Backtestsvuerun-20261007-145226#15153
Custom elements: async components nested ≥3 levels crash with TypeError: Cannot read properties of null (reading 'provides') — chained child resolve races its parent's mount
Our patch was judged better than the merged fix.
In this judgment, Patch A = our agent, Patch B = the merged fix.
Both patches fix the root cause the issue identifies. The bug is that the chain promise settles when the child's `_resolveDef()` returns, which is when its async load starts, not when it mounts. Each patch makes the chained callback return the element's own loader promise, so deeper descendants wait until the intermediate ancestor has actually mounted. **Patch A** returns `this._pendingResolve` after calling `_resolveDef()`. It also goes further in two ways: - **Resolved elements:** it restructures `connectedCallback` so an already-resolved element attached under a pending async parent also waits. Before, that element would call `_mount` → `_inheritParentContext` while `parent._instance` was null, which is the same crash class. - **Moved elements:** it detects a superseded chain when an element is moved between two pending parents, so the element waits for its new parent instead of mounting early. A's tests are thorough and would fail before the change: - 3-level nesting with the middle level slowest (the exact repro). - 4-level nesting where each level settles before its parent. - Dynamic insertion. - Moving an element between pending parents. - A resolved element moved under a pending parent. They also verify that `provide`/`inject` propagates across all levels. **Patch B** achieves the core fix by having `_resolveDef` return its pending promise. It also adds an `isConnected` guard. Its 3-level test uses controlled resolvers and directly reproduces the race. Its second test covers the disconnect case. B is minimal and correct for the reported scenario, but it leaves the resolved-element-under-pending-parent path still crashing, and it does not handle re-chaining when an element moves. On correctness, A covers more of the same race at the edges the issue implies, and it has stronger test coverage. B's `isConnected` guard is a small plus that A lacks, but it does not outweigh A's broader handling of the crash path.
The judge saw only the two patches, labelled A and B in random order, with issue links and version numbers removed. The reasoning above is shown verbatim.
Solve
10m 18s
Wall-clock time in the container
Full test suite
No new failures
3,635 passed · 6 skipped · 3,641 total
Contamination audit
Clean
No sign the agent saw the real fix
Patch size
256vs 119 merged
Changed lines, ours vs merged
The issue
View on GitHubVue version
3.5.40 (latest at the time of writing — the inline repro pins it; also reproduced on 3.5.13, 3.5.17, 3.5.30 and 3.6.0-rc.2; 3.4.38 — before the nested-async chaining existed — crashes with the same null dereference in the older _setParent provides copy inside vnode.ce)
Link to minimal reproduction
Steps to reproduce
- Open the reproduction link and watch the console:
mounted x-innernever appears — the element crashes with an unhandledTypeError: Cannot read properties of null (reading 'provides')and never mounts. (The playground variant inserts the nested markup dynamically after thedefine()calls; dynamic and parser-created markup crash identically.) - Parser-created (static server-HTML-style) variant — self-contained single file, no build step (save as
repro.html, serve statically, open in any browser; Chromium, Firefox and WebKit all reproduce):
<!doctype html>
<meta charset="utf-8" />
<title>nested async custom elements repro</title>
<x-outer>
<x-middle>
<div>
<x-inner>inner light dom</x-inner>
</div>
</x-middle>
</x-outer>
<script type="module">
import {
defineCustomElement,
defineAsyncComponent,
h,
} from "https://unpkg.com/vue@3.5.40/dist/vue.esm-browser.js";
// Delays chosen so the middle level settles AFTER its child: outer fast,
// middle slow, inner fast. This crashes on 100% of loads.
const delays = { "x-outer": 50, "x-middle": 300, "x-inner": 10 };
const makeComponent = (name) => ({
name,
mounted() {
console.log(`mounted ${name}`);
},
render() {
return h("div", { style: "display:block;padding:6px;border:1px solid #888" }, [name, h("slot")]);
},
});
const makeLoader = (tag) => () =>
new Promise((resolve) => setTimeout(() => resolve(makeComponent(tag)), delays[tag]));
// Define the three tags parent-first.
for (const tag of ["x-outer", "x-middle", "x-inner"]) {
customElements.define(tag, defineCustomElement(defineAsyncComponent(makeLoader(tag))));
}
window.addEventListener("error", (e) => console.error("UNCAUGHT:", e.message));
window.addEventListener("unhandledrejection", (e) =>
console.error("UNHANDLED REJECTION:", e.reason?.message ?? e.reason),
);
</script>
What is expected?
All three elements mount ancestor-first: mounted x-outer, mounted x-middle, mounted x-inner. The nested-async chaining added in 3.5.0 (37ccb9b, "delay mounting of custom elements with async parent", closing #9341 / #8127 / #9351) exists to guarantee exactly this.
What is actually happening?
mounted x-outer
UNHANDLED REJECTION: Cannot read properties of null (reading 'provides')
mounted x-middle
x-inner crashes in VueElement._mount → _inheritParentContext (runtime-dom — parent._instance.provides is dereferenced guarded only by parent && this._app), never mounts, and is left permanently half-resolved: _resolved: true, _instance: null, shadow root empty. Nothing ever retries it, no error surfaces through app.config.errorHandler, and any provide/inject inheritance it should have received is lost. Its own descendants (at deeper nesting) then crash against it in cascade.
Any additional comments?
Analysis (why depth ≥ 3 is the trigger)
connectedCallback of a child under a pending async parent chains:
this._pendingResolve = parent._pendingResolve.then(() => {
this._pendingResolve = undefined;
this._resolveDef();
});
- For an unchained parent (depth 2),
parent._pendingResolveis the parent's own_resolveDef()flow, which settles after the parent has mounted → 2-level nesting is safe. The variants table below confirms: 2 levels never crash. - For a chained parent (depth ≥ 3),
parent._pendingResolveis itself a chain promise — and that promise settles when the parent's_resolveDef()returns (i.e. when the parent's async load starts), not when the parent mounts.
So once the first unchained ancestor mounts, the whole chain unwinds within a few microtasks: every deeper level's loader fires nearly simultaneously and mount order degenerates to network settlement order. Any child whose async definition settles before its parent has mounted hits _inheritParentContext while parent._instance === null and throws. With real-network chunk timings the victim set varies per load, so in an app this presents as a flaky, page-dependent breakage; with the fixed delays above it is 100% deterministic.
Variants checked (each re-run in a real browser):
| Variant | Result |
|---|---|
| 3 levels, middle slowest | crashes every load |
| 3 levels, inner slowest | clean (race direction confirmed) |
| 2 levels | clean (chained parent required) |
plain <div> between levels | still crashes (structure-independent) |
markup inserted dynamically after all define() calls | still crashes |
| all loaders instant | clean (microtask FIFO protects when nothing is pending) |
_inheritParentContext (#13219, ~3.5.14) did not introduce the race — it converted a pre-existing silent misordering into a hard crash. 3.4.38 (no chaining) and 3.5.13 (chaining, pre-#13219) fail with the same null dereference in the older _setParent provides-copy path.
Suggested direction — either (or both):
- Chain the child to the parent's actual mount, not to
_resolveDef()returning — e.g. resolve the parent's_pendingResolveonly after_mount()has run, so the guarantee the chaining was built for ("ancestor mounts before descendant") holds at any depth. - Guard
_inheritParentContextagainstparent._instance === nulland defer context inheritance until the parent instance exists, instead of throwing away the child permanently on an unhandled rejection.
The two patches
packages/runtime-dom/__tests__/customElement.spec.tsindex a5bea20b8..07124136e 100644@@ -2210,6 +2210,233 @@ describe('defineCustomElement', () => { expect(barVal).toBe('bar') }) + describe('async & deeply nested custom elements', () => {+ const delay = (ms: number) => new Promise(r => setTimeout(r, ms))++ function defineNestedAsync(+ prefix: string,+ delays: number[],+ mounted: string[],+ injected: Record<string, unknown>,+ ) {+ const tags = delays.map((_, i) => `${prefix}-${i}`)+ tags.forEach((tag, i) => {+ customElements.define(+ tag,+ defineCustomElement(+ defineAsyncComponent(async () => {+ await delay(delays[i])+ return {+ setup() {+ provide(`level-${i}`, tag)+ for (let j = 0; j < i; j++) {+ injected[`${tag}:level-${j}`] = inject(`level-${j}`)+ }+ onMounted(() => mounted.push(tag))+ },+ render(this: any) {+ return h('div', null, [renderSlot(this.$slots, 'default')])+ },+ }+ }),+ ),+ )+ })+ return tags+ }++ const nestedMarkup = (tags: string[]) =>+ tags.map(t => `<${t}><div>`).join('') ++ tags+ .slice()+ .reverse()+ .map(t => `</div></${t}>`)+ .join('')++ test('3 levels, middle level settles after its child', async () => {+ const mounted: string[] = []+ const injected: Record<string, unknown> = {}+ const tags = defineNestedAsync(+ 'my-el-deep-async-a',+ [5, 40, 1],+ mounted,+ injected,+ )+ container.innerHTML = nestedMarkup(tags)++ await delay(100)+ expect(mounted).toEqual(tags)+ tags.forEach(tag => {+ const el = container.querySelector(tag) as VueElement+ expect(el.shadowRoot!.innerHTML).toBe(`<div><slot></slot></div>`)+ })+ expect(injected).toEqual({+ 'my-el-deep-async-a-1:level-0': 'my-el-deep-async-a-0',+ 'my-el-deep-async-a-2:level-0': 'my-el-deep-async-a-0',+ 'my-el-deep-async-a-2:level-1': 'my-el-deep-async-a-1',+ })+ })++ test('4 levels, each level settles before its parent', async () => {+ const mounted: string[] = []+ const injected: Record<string, unknown> = {}+ const tags = defineNestedAsync(+ 'my-el-deep-async-b',+ [1, 40, 20, 5],+ mounted,+ injected,+ )+ container.innerHTML = nestedMarkup(tags)++ await delay(120)+ expect(mounted).toEqual(tags)+ expect(injected['my-el-deep-async-b-3:level-0']).toBe(+ 'my-el-deep-async-b-0',+ )+ expect(injected['my-el-deep-async-b-3:level-1']).toBe(+ 'my-el-deep-async-b-1',+ )+ expect(injected['my-el-deep-async-b-3:level-2']).toBe(+ 'my-el-deep-async-b-2',+ )+ })++ test('nested markup inserted dynamically under a pending async parent', async () => {+ const mounted: string[] = []+ const injected: Record<string, unknown> = {}+ const tags = defineNestedAsync(+ 'my-el-deep-async-c',+ [5, 40, 1],+ mounted,+ injected,+ )+ const outer = document.createElement(tags[0])+ container.appendChild(outer)+ const middle = document.createElement(tags[1])+ outer.appendChild(middle)+ const wrapper = document.createElement('div')+ wrapper.appendChild(document.createElement(tags[2]))+ middle.appendChild(wrapper)++ await delay(100)+ expect(mounted).toEqual(tags)+ expect(injected['my-el-deep-async-c-2:level-1']).toBe(+ 'my-el-deep-async-c-1',+ )+ })++ test('element moved between two pending async parents waits for the new one', async () => {+ const mounted: string[] = []+ let childInjected: unknown+ const defineParent = (tag: string, ms: number) =>+ customElements.define(+ tag,+ defineCustomElement(+ defineAsyncComponent(async () => {+ await delay(ms)+ return {+ setup() {+ provide('from-parent', tag)+ onMounted(() => mounted.push(tag))+ },+ render(this: any) {+ return h('div', null, [renderSlot(this.$slots, 'default')])+ },+ }+ }),+ ),+ )+ defineParent('my-el-deep-async-e-first', 5)+ defineParent('my-el-deep-async-e-second', 40)+ customElements.define(+ 'my-el-deep-async-e-child',+ defineCustomElement(+ defineAsyncComponent(async () => {+ await delay(1)+ return {+ setup() {+ childInjected = inject('from-parent', 'none')+ onMounted(() => mounted.push('my-el-deep-async-e-child'))+ },+ render: () => h('div', 'child'),+ }+ }),+ ),+ )+ const first = document.createElement('my-el-deep-async-e-first')+ const second = document.createElement('my-el-deep-async-e-second')+ container.appendChild(first)+ container.appendChild(second)+ const child = document.createElement(+ 'my-el-deep-async-e-child',+ ) as VueElement+ first.appendChild(child)+ second.appendChild(child)++ await delay(100)+ expect(mounted).toEqual([+ 'my-el-deep-async-e-first',+ 'my-el-deep-async-e-second',+ 'my-el-deep-async-e-child',+ ])+ expect(child.shadowRoot!.innerHTML).toBe(`<div>child</div>`)+ expect(childInjected).toBe('my-el-deep-async-e-second')+ })++ test('resolved element moved under a pending async parent waits for it to mount', async () => {+ let parentMounted = false+ let childInjected: unknown+ customElements.define(+ 'my-el-deep-async-d-parent',+ defineCustomElement(+ defineAsyncComponent(async () => {+ await delay(20)+ return {+ setup() {+ provide('from-parent', 'parent')+ onMounted(() => (parentMounted = true))+ },+ render(this: any) {+ return h('div', null, [renderSlot(this.$slots, 'default')])+ },+ }+ }),+ ),+ )+ // a resolved child that injects from its parent+ customElements.define(+ 'my-el-deep-async-d-resolved',+ defineCustomElement({+ setup() {+ childInjected = inject('from-parent', 'none')+ },+ render: () => h('div', 'resolved'),+ }),+ )+ const resolvedChild = document.createElement(+ 'my-el-deep-async-d-resolved',+ ) as VueElement+ container.appendChild(resolvedChild)+ expect(childInjected).toBe('none')++ // detach so it unmounts, then move under a pending async parent+ resolvedChild.remove()+ await nextTick()+ expect(resolvedChild._instance).toBe(null)++ const parent = document.createElement('my-el-deep-async-d-parent')+ container.appendChild(parent)+ parent.appendChild(resolvedChild)+ expect(resolvedChild._instance).toBe(null)++ await delay(50)+ expect(parentMounted).toBe(true)+ expect(resolvedChild._instance).not.toBe(null)+ expect(resolvedChild.shadowRoot!.innerHTML).toBe(`<div>resolved</div>`)+ expect(childInjected).toBe('parent')+ })+ })+ describe('configureApp', () => { test('should work', () => { const E = defineCustomElement(packages/runtime-dom/src/apiCustomElement.tsindex 9e1f3a720..7ecfca45a 100644@@ -307,17 +307,28 @@ export class VueElement } if (!this._instance) {- if (this._resolved) {+ if (parent && parent._pendingResolve) {+ // delay until the async parent has mounted. The chained promise must+ // only settle after this element has mounted as well (including its+ // own async load), so that deeper descendants chained onto it never+ // mount before their parent instance exists.+ const chained: Promise<void> = (this._pendingResolve =+ parent._pendingResolve.then(() => {+ // superseded by a newer chain (element was moved under another+ // pending parent): defer to it instead of mounting too early+ if (this._pendingResolve !== chained) return this._pendingResolve+ this._pendingResolve = undefined+ if (this._resolved) {+ if (!this._instance) this._mount(this._def)+ } else {+ this._resolveDef()+ }+ return this._pendingResolve+ }))+ } else if (this._resolved) { this._mount(this._def) } else {- if (parent && parent._pendingResolve) {- this._pendingResolve = parent._pendingResolve.then(() => {- this._pendingResolve = undefined- this._resolveDef()- })- } else {- this._resolveDef()- }+ this._resolveDef() } } }
packages/runtime-dom/__tests__/customElement.spec.tsindex a5bea20b8..27c7121c2 100644@@ -2210,6 +2210,118 @@ describe('defineCustomElement', () => { expect(barVal).toBe('bar') }) + test('nested async custom elements should mount ancestor-first', async () => {+ const mounted: string[] = []+ const OuterComp = defineComponent({+ setup() {+ provide('foo', 'foo')+ },+ mounted() {+ mounted.push('outer')+ },+ render() {+ return h('slot')+ },+ })+ const MiddleComp = defineComponent({+ setup() {+ provide('bar', 'bar')+ },+ mounted() {+ mounted.push('middle')+ },+ render() {+ return h('slot')+ },+ })+ const InnerComp = defineComponent({+ setup() {+ const foo = inject('foo')+ const bar = inject('bar')+ return () => h('div', `${foo}/${bar}`)+ },+ mounted() {+ mounted.push('inner')+ },+ })+ let resolveOuter!: (comp: typeof OuterComp) => void+ let resolveMiddle!: (comp: typeof MiddleComp) => void+ let resolveInner!: (comp: typeof InnerComp) => void+ const outerReady = new Promise<typeof OuterComp>(resolve => {+ resolveOuter = resolve+ })+ const middleReady = new Promise<typeof MiddleComp>(resolve => {+ resolveMiddle = resolve+ })+ const innerReady = new Promise<typeof InnerComp>(resolve => {+ resolveInner = resolve+ })++ const Outer = defineCustomElement(defineAsyncComponent(() => outerReady))+ const Middle = defineCustomElement(defineAsyncComponent(() => middleReady))+ const Inner = defineCustomElement(defineAsyncComponent(() => innerReady))++ customElements.define('async-chain-outer', Outer)+ customElements.define('async-chain-middle', Middle)+ customElements.define('async-chain-inner', Inner)+ container.innerHTML =+ `<async-chain-outer>` ++ `<async-chain-middle>` ++ `<async-chain-inner></async-chain-inner>` ++ `</async-chain-middle>` ++ `</async-chain-outer>`++ resolveInner(InnerComp)+ resolveOuter(OuterComp)+ await new Promise(resolve => setTimeout(resolve))+ resolveMiddle(MiddleComp)+ await new Promise(resolve => setTimeout(resolve))++ const inner = container.querySelector('async-chain-inner') as VueElement+ expect(mounted).toEqual(['outer', 'middle', 'inner'])+ expect(inner.shadowRoot!.innerHTML).toBe('<div>foo/bar</div>')+ })++ test('should not resolve nested custom element after disconnect', async () => {+ const mounted = vi.fn()+ const ParentComp = defineComponent({+ render() {+ return h('slot')+ },+ })+ let resolveParent!: (comp: typeof ParentComp) => void+ const parentReady = new Promise<typeof ParentComp>(resolve => {+ resolveParent = resolve+ })+ const Parent = defineCustomElement(defineAsyncComponent(() => parentReady))+ const Child = defineCustomElement({+ mounted,+ render() {+ return h('div', 'child')+ },+ })++ customElements.define('async-disconnect-parent', Parent)+ customElements.define('async-disconnect-child', Child)+ container.innerHTML =+ `<async-disconnect-parent>` ++ `<async-disconnect-child></async-disconnect-child>` ++ `</async-disconnect-parent>`++ const parent = container.firstChild as VueElement+ const child = parent.firstChild as VueElement+ child.remove()+ resolveParent(ParentComp)+ await new Promise(resolve => setTimeout(resolve))++ expect(mounted).not.toHaveBeenCalled()+ expect(child.shadowRoot!.innerHTML).toBe('')++ parent.appendChild(child)+ expect(mounted).toHaveBeenCalledOnce()+ expect(child.shadowRoot!.innerHTML).toBe('<div>child</div>')+ })+ describe('configureApp', () => { test('should work', () => { const E = defineCustomElement(packages/runtime-dom/src/apiCustomElement.tsindex 9e1f3a720..9422f58d6 100644@@ -313,7 +313,9 @@ export class VueElement if (parent && parent._pendingResolve) { this._pendingResolve = parent._pendingResolve.then(() => { this._pendingResolve = undefined- this._resolveDef()+ if (this.isConnected) {+ return this._resolveDef()+ } }) } else { this._resolveDef()@@ -371,7 +373,7 @@ export class VueElement */ private _resolveDef() { if (this._pendingResolve) {- return+ return this._pendingResolve } // set initial attrs@@ -428,6 +430,7 @@ export class VueElement def.configureApp = this._def.configureApp resolve((this._def = def), true) })+ return this._pendingResolve } else { resolve(this._def) }