@vmz/core 0.0.1 → 0.0.3

package/dist/dom.js

@@ -0,0 +1,3059 @@
+// @ts-nocheck
+/**
+ * VMZ DOM / SSR runtime — precise patches, no VDOM diff.
+ *
+ *
+ * Direct components expose `__vmzCreate` / `__vmzSerialize` / `__vmzPlan`.
+ * Mount, SSR, hydrate, and resume all run that same schedule.
+ * Field writes only run registered dep patches — never re-create structure.
+ */
+/** @type {Record<string, new (props?: object) => any>} */
+const components = Object.create(null);
+/**
+ * Precision lab counters (test / MCP / benchmarks — not a user API).
+ * Primary keys: BindingId (IR). `*ByDep` is transitional stable-string adapter.
+ */
+const precision = {
+    enabled: false,
+    writes: 0,
+    bindingEvals: 0,
+    patchExecs: 0,
+    domCreates: 0,
+    domMoves: 0,
+    domRemoves: 0,
+    componentExecs: 0,
+    /** @type {Record<string, number>} */
+    writesByRoot: Object.create(null),
+    /** @type {Record<string, number>} */
+    bindingEvalsByDep: Object.create(null),
+    /** @type {Record<string, number>} */
+    patchesByDep: Object.create(null),
+    /** @type {Record<string, number>} BindingId → count */
+    bindingEvalsByBinding: Object.create(null),
+    /** @type {Record<string, number>} BindingId → count */
+    patchesByBinding: Object.create(null),
+};
+/** optional StableId event ring (enabled with precision or __vmzTraceEnable). */
+const TRACE_CAP = 256;
+/** @type {{ enabled: boolean, events: Array<{ kind: string, stableId: { kind: string, id: string }, dep?: string|null, t?: number, chunkId?: string|null }> }} */
+const traceBuf = {
+    enabled: false,
+    events: [],
+};
+function pushTrace(kind, stableKind, stableId, dep = null) {
+    if (!traceBuf.enabled && !precision.enabled)
+        return;
+    traceBuf.events.push({
+        kind,
+        stableId: { kind: stableKind, id: String(stableId) },
+        dep: dep == null ? undefined : String(dep),
+        t: Date.now(),
+    });
+    if (traceBuf.events.length > TRACE_CAP) {
+        traceBuf.events.splice(0, traceBuf.events.length - TRACE_CAP);
+    }
+}
+function bumpMap(map, key, n = 1) {
+    if (key == null || key === '')
+        return;
+    map[key] = (map[key] || 0) + n;
+}
+/** @param {boolean} [on] */
+export function __vmzPrecisionEnable(on = true) {
+    precision.enabled = !!on;
+}
+/** @param {boolean} [on] */
+export function __vmzTraceEnable(on = true) {
+    traceBuf.enabled = !!on;
+}
+export function __vmzPrecisionReset() {
+    precision.writes = 0;
+    precision.bindingEvals = 0;
+    precision.patchExecs = 0;
+    precision.domCreates = 0;
+    precision.domMoves = 0;
+    precision.domRemoves = 0;
+    precision.componentExecs = 0;
+    precision.writesByRoot = Object.create(null);
+    precision.bindingEvalsByDep = Object.create(null);
+    precision.patchesByDep = Object.create(null);
+    precision.bindingEvalsByBinding = Object.create(null);
+    precision.patchesByBinding = Object.create(null);
+}
+export function __vmzTraceReset() {
+    traceBuf.events = [];
+}
+/**
+ * StableId event snapshot (`vmz.dx.trace.v0` shape without schema stamp —
+ * host may wrap via ingestRuntimeTrace).
+ * @returns {{ schema: string, events: typeof traceBuf.events, status: string }}
+ */
+export function __vmzTraceSnapshot() {
+    const events = traceBuf.events.map((e) => ({ ...e, stableId: { ...e.stableId } }));
+    return {
+        schema: 'vmz.dx.trace.v0',
+        events,
+        status: events.length ? 'ready' : 'empty',
+    };
+}
+/** @returns {typeof precision} */
+export function __vmzPrecisionSnapshot() {
+    return {
+        enabled: precision.enabled,
+        writes: precision.writes,
+        bindingEvals: precision.bindingEvals,
+        patchExecs: precision.patchExecs,
+        domCreates: precision.domCreates,
+        domMoves: precision.domMoves,
+        domRemoves: precision.domRemoves,
+        componentExecs: precision.componentExecs,
+        writesByRoot: { ...precision.writesByRoot },
+        bindingEvalsByDep: { ...precision.bindingEvalsByDep },
+        patchesByDep: { ...precision.patchesByDep },
+        bindingEvalsByBinding: { ...precision.bindingEvalsByBinding },
+        patchesByBinding: { ...precision.patchesByBinding },
+    };
+}
+/**
+ * @param { => any} fn
+ * @param {string | null} [depKey]
+ * @param {number | string | null} [bindingId]
+ */
+function runPatch(fn, depKey = null, bindingId = null) {
+    if (precision.enabled) {
+        precision.patchExecs++;
+        if (depKey)
+            bumpMap(precision.patchesByDep, depKey);
+        if (bindingId != null)
+            bumpMap(precision.patchesByBinding, String(bindingId));
+    }
+    if (bindingId != null) {
+        pushTrace('patch', 'binding', bindingId, depKey);
+    }
+    return fn();
+}
+function noteDomCreate() {
+    if (precision.enabled)
+        precision.domCreates++;
+}
+function noteDomRemove() {
+    if (precision.enabled)
+        precision.domRemoves++;
+}
+function noteDomMove() {
+    if (precision.enabled)
+        precision.domMoves++;
+}
+/** @param {Record<string, any>} map */
+export function registerComponents(map) {
+    Object.assign(components, map);
+}
+/**
+ * Lazy component loader for EventEntry mixed packs (set by entry-client / entry-event).
+ * @param {string} name
+ * @returns {Promise<any>}
+ */
+async function resolveComponent(name) {
+    let Ctor = components[name];
+    if (!Ctor && typeof globalThis.__vmzLoadComponent === 'function') {
+        Ctor = await globalThis.__vmzLoadComponent(name);
+        if (Ctor)
+            registerComponents({ [name]: Ctor });
+    }
+    return Ctor || null;
+}
+/**
+ * @param {new (props?: object) => any} Component
+ * @param {object} [props]
+ */
+export async function renderToString(Component, props = {}) {
+    const inst = createInstance(Component, props);
+    if (typeof inst.onMount === 'function') {
+        await inst.onMount();
+    }
+    // production Direct emit: SSR only via Direct serialize schedule — never `render`.
+    if (!(Component && Component.__vmzDirect && typeof Component.__vmzCreate === 'function')) {
+        throw new Error(`vmz:dom renderToString() requires __vmzCreate (Direct); blueprint render() removed (production Direct emit)`);
+    }
+    const root = await runDirectSerializeTreeWithMounts(Component, inst);
+    return flattenSerializeNode(root);
+}
+/**
+ * Stream SSR via the same Direct serialize schedule as `renderToString`.
+ * Yields HTML chunks (open tag → children → close). Joining chunks equals `renderToString`.
+ * Supports AbortSignal for cancel; consumers should respect backpressure (await between chunks).
+ * @param {new (props?: object) => any} Component
+ * @param {object} [props]
+ * @param {{ signal?: AbortSignal }} [opts]
+ * @returns {AsyncGenerator<string, void, void>}
+ */
+export async function* renderToStream(Component, props = {}, opts = {}) {
+    const signal = opts && opts.signal;
+    const aborted = () => Boolean(signal && signal.aborted);
+    if (aborted())
+        return;
+    const inst = createInstance(Component, props);
+    try {
+        if (typeof inst.onMount === 'function') {
+            await inst.onMount();
+        }
+        if (aborted())
+            return;
+        if (!(Component && Component.__vmzDirect && typeof Component.__vmzCreate === 'function')) {
+            throw new Error(`vmz:dom renderToStream() requires __vmzCreate (Direct); blueprint render() removed (production Direct emit)`);
+        }
+        const root = await runDirectSerializeTreeWithMounts(Component, inst);
+        if (aborted())
+            return;
+        for (const chunk of streamSerializeChunks(root)) {
+            if (aborted())
+                return;
+            yield chunk;
+            // Allow consumers / HTTP hosts to flush between chunks (backpressure point).
+            await Promise.resolve();
+        }
+    }
+    finally {
+        // Abort and normal completion both dispose the SSR instance (lifetime).
+        destroy(inst);
+    }
+}
+/**
+ * Mount once; later updates are dep patches only (never re-run structure).
+ * Requires compiler `__vmzCreate` (production Direct emit — no blueprint fallback).
+ * @param {new (props?: object) => any} Component
+ * @param {Element} container
+ * @param {object} [props]
+ */
+export async function mount(Component, container, props = {}) {
+    if (container.__vmzInst) {
+        destroy(container.__vmzInst);
+        container.__vmzInst = null;
+    }
+    const inst = createInstance(Component, props);
+    inst.__vmzBinders = Object.create(null);
+    inst.__vmzBindings = Object.create(null);
+    inst.__vmzDepToBindings = Object.create(null);
+    container.replaceChildren();
+    const node = await createFromComponent(Component, inst);
+    if (node) {
+        inst.__vmzDomRoot = node;
+        container.appendChild(node);
+    }
+    if (typeof inst.onMount === 'function') {
+        await inst.onMount();
+    }
+    await settlePendingChildMounts(inst);
+    container.__vmzInst = inst;
+    return inst;
+}
+/**
+ * Nested Direct `component` schedules child onMount asynchronously; drain before return
+ * so SSR/hydrate callers see post-mount DOM (e.g. UserCard Ada, not Loading…).
+ * @param {object} inst
+ */
+async function settlePendingChildMounts(inst) {
+    if (!inst || !Array.isArray(inst.__vmzPendingChildMounts) || !inst.__vmzPendingChildMounts.length)
+        return;
+    await Promise.all(inst.__vmzPendingChildMounts);
+    inst.__vmzPendingChildMounts = [];
+    const hosts = [];
+    const root = inst.__vmzDomRoot;
+    if (root && root.nodeType === 1) {
+        if (root.__vmzInst)
+            hosts.push(root.__vmzInst);
+        for (const el of root.querySelectorAll('[data-vmz]')) {
+            if (el.__vmzInst)
+                hosts.push(el.__vmzInst);
+        }
+    }
+    for (const child of hosts) {
+        await flushPending(child);
+        await settlePendingChildMounts(child);
+    }
+}
+/**
+ * Direct create only (production Direct emit).
+ * @param {new (props?: object) => any} Component
+ * @param {object} inst
+ */
+async function createFromComponent(Component, inst) {
+    if (Component && Component.__vmzDirect && typeof Component.__vmzCreate === 'function') {
+        return runDirectCreate(Component, inst);
+    }
+    throw new Error(`vmz:dom mount requires __vmzCreate (Direct); blueprint render() removed (production Direct emit)`);
+}
+/**
+ * @param {new (props?: object) => any} Component
+ * @param {object} inst
+ */
+function runDirectCreate(Component, inst) {
+    directApi._inst = inst;
+    try {
+        return Component.__vmzCreate.call(inst, directApi);
+    }
+    finally {
+        directApi._inst = null;
+    }
+}
+/**
+ * SSR: run the same __vmzCreate schedule against a serialize host (no render).
+ * @param {new (props?: object) => any} Component
+ * @param {object} inst
+ */
+function runDirectSerializeTree(Component, inst) {
+    serializeApi._inst = inst;
+    try {
+        return Component.__vmzCreate.call(inst, serializeApi);
+    }
+    finally {
+        serializeApi._inst = null;
+    }
+}
+/**
+ * SSR child onMount: sync `__vmzCreate` cannot await nested mounts.
+ * Expand rounds — reuse prior child instances, await newly discovered onMounts, re-emit.
+ * @param {new (props?: object) => any} Component
+ * @param {object} inst
+ */
+async function runDirectSerializeTreeWithMounts(Component, inst) {
+    /** @type {object[]} */
+    let preMounted = [];
+    /** @type {any} */
+    let tree = null;
+    for (let round = 0; round < 32; round++) {
+        serializeApi._ssrPreMounted = preMounted;
+        serializeApi._ssrPreIdx = 0;
+        serializeApi._ssrCollected = [];
+        tree = runDirectSerializeTree(Component, inst);
+        if (serializeApi._ssrPreIdx !== preMounted.length) {
+            throw new Error(`vmz:dom SSR child mount queue desync (used ${serializeApi._ssrPreIdx}, had ${preMounted.length})`);
+        }
+        const collected = serializeApi._ssrCollected;
+        serializeApi._ssrPreMounted = null;
+        serializeApi._ssrCollected = null;
+        if (!collected.length)
+            return tree;
+        for (const child of collected) {
+            if (typeof child.onMount === 'function') {
+                await child.onMount();
+            }
+        }
+        preMounted = preMounted.concat(collected);
+    }
+    throw new Error('vmz:dom SSR child onMount expansion exceeded 32 rounds');
+}
+function serializeOpenTag(node) {
+    const tag = node.tag || 'div';
+    let attrs = '';
+    for (const [k, v] of Object.entries(node.attrs || {})) {
+        if (v == null || v === false)
+            continue;
+        if (k === 'className')
+            attrs += ` class="${escapeHtml(v)}"`;
+        else
+            attrs += ` ${k}="${escapeHtml(v)}"`;
+    }
+    return { tag, open: `<${tag}${attrs}>` };
+}
+function flattenSerializeNode(node) {
+    if (node == null || node === false)
+        return '';
+    if (typeof node === 'string' || typeof node === 'number')
+        return escapeHtml(node);
+    if (node.__kind === 'text')
+        return escapeHtml(node.value);
+    if (node.__kind === 'frag') {
+        return (node.children || []).map(flattenSerializeNode).join('');
+    }
+    if (node.__kind === 'el') {
+        const tag = node.tag || 'div';
+        if (tag === 'slot') {
+            return (node.children || []).map(flattenSerializeNode).join('');
+        }
+        const { open } = serializeOpenTag(node);
+        if (node.__rawHtml != null) {
+            return `${open}${String(node.__rawHtml)}</${tag}>`;
+        }
+        const inner = (node.children || []).map(flattenSerializeNode).join('');
+        return `${open}${inner}</${tag}>`;
+    }
+    return '';
+}
+/**
+ * Progressive HTML chunks from a serialize tree (same nodes as flattenSerializeNode).
+ * @param {any} node
+ * @returns {Generator<string, void, void>}
+ */
+function* streamSerializeChunks(node) {
+    if (node == null || node === false)
+        return;
+    if (typeof node === 'string' || typeof node === 'number') {
+        yield escapeHtml(node);
+        return;
+    }
+    if (node.__kind === 'text') {
+        yield escapeHtml(node.value);
+        return;
+    }
+    if (node.__kind === 'frag') {
+        for (const c of node.children || [])
+            yield* streamSerializeChunks(c);
+        return;
+    }
+    if (node.__kind === 'el') {
+        const tag = node.tag || 'div';
+        if (tag === 'slot') {
+            for (const c of node.children || [])
+                yield* streamSerializeChunks(c);
+            return;
+        }
+        const { open } = serializeOpenTag(node);
+        yield open;
+        if (node.__rawHtml != null) {
+            yield String(node.__rawHtml);
+        }
+        else {
+            for (const c of node.children || [])
+                yield* streamSerializeChunks(c);
+        }
+        yield `</${tag}>`;
+    }
+}
+/** Serialize host mirroring directApi — returns virtual nodes, not DOM. */
+const serializeApi = {
+    /** @type {object | null} */
+    _inst: null,
+    /** @type {null} */
+    _branchBinds: null,
+    /** @type {null} */
+    _itemPatches: null,
+    /** @type {object[] | null} reused child instances from prior SSR mount rounds */
+    _ssrPreMounted: null,
+    /** @type {number} */
+    _ssrPreIdx: 0,
+    /** @type {object[] | null} newly created child instances this round */
+    _ssrCollected: null,
+    /**
+     * @param {new (props?: object) => any} Ctor
+     * @param {object} resolved
+     */
+    _ssrChildInstance(Ctor, resolved) {
+        const pre = serializeApi._ssrPreMounted;
+        if (pre && serializeApi._ssrPreIdx < pre.length) {
+            return pre[serializeApi._ssrPreIdx++];
+        }
+        const child = createInstance(Ctor, resolved);
+        if (serializeApi._ssrCollected)
+            serializeApi._ssrCollected.push(child);
+        return child;
+    },
+    el(tag) {
+        return {
+            __kind: 'el',
+            tag: tag || 'div',
+            attrs: {},
+            children: [],
+            appendChild(c) {
+                if (c != null)
+                    this.children.push(c);
+            },
+        };
+    },
+    text(value) {
+        return { __kind: 'text', value: value == null ? '' : String(value) };
+    },
+    frag() {
+        return {
+            __kind: 'frag',
+            children: [],
+            appendChild(c) {
+                if (c != null)
+                    this.children.push(c);
+            },
+        };
+    },
+    attr(el, name, value) {
+        if (!el || el.__kind !== 'el')
+            return;
+        if (value == null)
+            delete el.attrs[name];
+        else
+            el.attrs[name] = String(value);
+    },
+    on() {
+        /* events are no-ops during SSR */
+    },
+    bindText(inst, bindingId, deps, get, textNode) {
+        let raw = '';
+        try {
+            raw = get.call(inst);
+        }
+        catch {
+            raw = '';
+        }
+        textNode.value = String(raw ?? '');
+    },
+    bindAttr(inst, bindingId, deps, get, el, name) {
+        let raw;
+        try {
+            raw = get.call(inst);
+        }
+        catch {
+            raw = null;
+        }
+        const key = name === 'className' ? 'class' : name;
+        if (raw == null)
+            delete el.attrs[key];
+        else
+            el.attrs[key] = String(raw);
+    },
+    setHtml(el, value) {
+        if (!el || el.__kind !== 'el')
+            return;
+        el.__rawHtml = value == null ? '' : String(value);
+        el.children = [];
+    },
+    bindHtml(inst, bindingId, deps, get, el) {
+        let raw = '';
+        try {
+            raw = get.call(inst);
+        }
+        catch {
+            raw = '';
+        }
+        el.__rawHtml = raw == null ? '' : String(raw);
+        el.children = [];
+    },
+    ifBlock(inst, bindingId, deps, branches) {
+        const host = {
+            __kind: 'el',
+            tag: 'span',
+            attrs: { 'data-vmz-if': '' },
+            children: [],
+            appendChild(c) {
+                if (c != null)
+                    this.children.push(c);
+            },
+        };
+        let idx = -1;
+        for (let i = 0; i < branches.length; i++) {
+            const b = branches[i];
+            if (!b.cond) {
+                idx = i;
+                break;
+            }
+            try {
+                if (b.cond.call(inst)) {
+                    idx = i;
+                    break;
+                }
+            }
+            catch {
+                /* continue */
+            }
+        }
+        if (idx >= 0 && branches[idx].create) {
+            const created = branches[idx].create.call(inst, serializeApi);
+            if (created)
+                host.children.push(created);
+        }
+        return host;
+    },
+    eachBlock(inst, bindingId, deps, spec) {
+        const frag = serializeApi.frag();
+        let list = [];
+        try {
+            list = spec.list.call(inst) || [];
+        }
+        catch {
+            list = [];
+        }
+        if (!Array.isArray(list))
+            list = [...list];
+        for (let i = 0; i < list.length; i++) {
+            const box = { item: list[i], index: i };
+            let k = i;
+            if (typeof spec.key === 'function') {
+                try {
+                    k = spec.key.call(inst, box);
+                }
+                catch {
+                    k = i;
+                }
+            }
+            const dom = spec.createItem.call(inst, serializeApi, box);
+            if (dom) {
+                // Parity with Direct eachBlock: keyed items expose data-vmz-key for hydrate/tests.
+                if (dom.__kind === 'el')
+                    serializeApi.attr(dom, 'data-vmz-key', String(k));
+                frag.appendChild(dom);
+            }
+        }
+        return frag;
+    },
+    component(hostInst, name, props, client) {
+        const Ctor = components[name];
+        if (!Ctor)
+            throw new Error(`vmz:dom unknown component <${name} />`);
+        /** @type {Record<string, any>} */
+        const resolved = {};
+        for (const [k, v] of Object.entries(props || {})) {
+            if (typeof v === 'function' && isEventPropName(k))
+                continue;
+            else if (typeof v === 'function')
+                resolved[k] = v.call(hostInst);
+            else
+                resolved[k] = v;
+        }
+        if (client) {
+            // resume: Island SSR includes body + ResumeEntry slice (same Direct schedule).
+            const child = serializeApi._ssrChildInstance(Ctor, resolved);
+            let body = null;
+            if (Ctor.__vmzDirect && typeof Ctor.__vmzCreate === 'function') {
+                const prev = serializeApi._inst;
+                serializeApi._inst = child;
+                try {
+                    body = Ctor.__vmzCreate.call(child, serializeApi);
+                }
+                finally {
+                    serializeApi._inst = prev;
+                }
+            }
+            const state = snapshotInstanceState(child) || {};
+            const plan = Ctor.__vmzPlan || null;
+            const resume = {
+                schema: 'vmz.resume.v0',
+                component: name,
+                strategy: String(client),
+                props: stripFns(resolved),
+                state,
+                planSchema: plan?.schema || null,
+                planRootIds: plan?.root_ids || [],
+            };
+            /** @type {Record<string, string>} */
+            const attrs = {
+                'data-vmz': name,
+                'data-vmz-island': name,
+                'data-vmz-client': String(client),
+                'data-vmz-props': JSON.stringify(stripFns(resolved)),
+                'data-vmz-resume': JSON.stringify(resume),
+            };
+            if (isEventEntryStrategy(String(client))) {
+                attrs['data-vmz-entry'] = 'event';
+            }
+            return {
+                __kind: 'el',
+                tag: 'div',
+                attrs,
+                children: body ? [body] : [],
+                appendChild(c) {
+                    if (c != null)
+                        this.children.push(c);
+                },
+            };
+        }
+        const child = serializeApi._ssrChildInstance(Ctor, resolved);
+        if (Ctor.__vmzDirect && typeof Ctor.__vmzCreate === 'function') {
+            const prev = serializeApi._inst;
+            serializeApi._inst = child;
+            try {
+                const node = Ctor.__vmzCreate.call(child, serializeApi);
+                return {
+                    __kind: 'el',
+                    tag: 'div',
+                    attrs: { 'data-vmz': name },
+                    children: node ? [node] : [],
+                    appendChild(c) {
+                        if (c != null)
+                            this.children.push(c);
+                    },
+                };
+            }
+            finally {
+                serializeApi._inst = prev;
+            }
+        }
+        throw new Error(`vmz:dom serialize component <${name}> requires __vmzCreate (rebuild child with Direct)`);
+    },
+};
+/** Host API for compiler-emitted `__vmzCreate` (direct path, Program IR B). */
+const directApi = {
+    /** @type {object | null} */
+    _inst: null,
+    /** @type {Array<{ deps: string[], fn: => any, bindingId?: number|string|null }> | null} */
+    _branchBinds: null,
+    /** @type {Array< => void> | null} */
+    _itemPatches: null,
+    /**
+     * Active keyed-each context (/): item binds + event delegation.
+     * @type {null | {
+     * noteItemBind: (bindingId: number|string|null, deps: string[], fn: => void) => void,
+     * needDelegate: (type: string) => void,
+     * }}
+     */
+    _eachCtx: null,
+    el(tag) {
+        noteDomCreate();
+        return document.createElement(tag || 'div');
+    },
+    text(value) {
+        noteDomCreate();
+        return document.createTextNode(value == null ? '' : String(value));
+    },
+    frag() {
+        noteDomCreate();
+        return document.createDocumentFragment();
+    },
+    attr(el, name, value) {
+        if (value == null)
+            el.removeAttribute(name);
+        else
+            el.setAttribute(name, String(value));
+    },
+    on(el, type, handler) {
+        const inst = directApi._inst;
+        if (directApi._eachCtx && typeof handler === 'function') {
+            /** @type {Record<string, Function>} */
+            const bag = el.__vmzEvt || (el.__vmzEvt = Object.create(null));
+            bag[type] = handler;
+            directApi._eachCtx.needDelegate(type);
+            return;
+        }
+        el.addEventListener(type, (ev) => {
+            // Belt-and-suspenders: form submit must not navigate before handler runs.
+            if (type === 'submit' && ev && typeof ev.preventDefault === 'function') {
+                ev.preventDefault();
+            }
+            if (typeof handler === 'function')
+                handler.call(inst, ev);
+        });
+    },
+    /**
+     * @param {object} inst
+     * @param {number|string|null} bindingId
+     * @param {string[]} deps
+     * @param { => any} get
+     * @param {Text} textNode
+     * @param {{ stable: string[], branches: Array<{ cond?: => any, deps: string[] }> } | null | undefined} [cf]
+     */
+    bindText(inst, bindingId, deps, get, textNode, cf) {
+        wireDirectBind(inst, bindingId, deps, get, (raw) => {
+            textNode.textContent = String(raw ?? '');
+        }, cf);
+    },
+    /**
+     * @param {object} inst
+     * @param {number|string|null} bindingId
+     * @param {string[]} deps
+     * @param { => any} get
+     * @param {Element} el
+     * @param {string} name
+     * @param {{ stable: string[], branches: Array<{ cond?: => any, deps: string[] }> } | null | undefined} [cf]
+     */
+    bindAttr(inst, bindingId, deps, get, el, name, cf) {
+        wireDirectBind(inst, bindingId, deps, get, (raw) => {
+            if (name === 'class' || name === 'className') {
+                el.setAttribute('class', String(raw ?? ''));
+            }
+            else if (raw == null) {
+                el.removeAttribute(name);
+            }
+            else {
+                el.setAttribute(name, String(raw));
+            }
+        }, cf);
+    },
+    setHtml(el, value) {
+        el.innerHTML = value == null ? '' : String(value);
+    },
+    /**
+     * Trusted HTML binding (`html={expr}`). Author/plugin responsibility.
+     * @param {object} inst
+     * @param {number|string|null} bindingId
+     * @param {string[]} deps
+     * @param { => any} get
+     * @param {Element} el
+     * @param {{ stable: string[], branches: Array<{ cond?: => any, deps: string[] }> } | null | undefined} [cf]
+     */
+    bindHtml(inst, bindingId, deps, get, el, cf) {
+        wireDirectBind(inst, bindingId, deps, get, (raw) => {
+            el.innerHTML = raw == null ? '' : String(raw);
+        }, cf);
+    },
+    /**
+     * Nested component (sync Direct child or island schedule).
+     * @param {object} hostInst
+     * @param {string} name
+     * @param {Record<string, any>} props
+     * @param {string | null} client
+     */
+    component(hostInst, name, props, client) {
+        noteDomCreate();
+        const host = document.createElement('div');
+        host.setAttribute('data-vmz', name);
+        /** @type {Record<string, any>} */
+        const resolved = {};
+        for (const [k, v] of Object.entries(props || {})) {
+            if (typeof v === 'function' && isEventPropName(k))
+                resolved[k] = v;
+            else if (typeof v === 'function')
+                resolved[k] = v.call(hostInst);
+            else
+                resolved[k] = v;
+        }
+        if (client) {
+            host.setAttribute('data-vmz-island', name);
+            host.setAttribute('data-vmz-client', String(client));
+            host.setAttribute('data-vmz-props', JSON.stringify(stripFns(resolved)));
+            if (isEventEntryStrategy(String(client))) {
+                host.setAttribute('data-vmz-entry', 'event');
+            }
+            // resume: resume on schedule; EventEntry may lazy-load chunk via __vmzLoadComponent.
+            scheduleClientOn(host, String(client), async () => {
+                const Ctor = await resolveComponent(name);
+                if (!Ctor)
+                    throw new Error(`vmz:dom unknown component <${name} />`);
+                await resume(Ctor, host, { props: resolved, state: {} });
+            });
+            return host;
+        }
+        const Ctor = components[name];
+        if (!Ctor)
+            throw new Error(`vmz:dom unknown component <${name} />`);
+        const child = createInstance(Ctor, resolved);
+        if (!(Ctor.__vmzDirect && typeof Ctor.__vmzCreate === 'function')) {
+            throw new Error(`vmz:dom direct component <${name}> requires __vmzCreate (rebuild child with Direct)`);
+        }
+        const node = runDirectCreate(Ctor, child);
+        if (node) {
+            child.__vmzDomRoot = node;
+            host.appendChild(node);
+        }
+        host.__vmzInst = child;
+        if (typeof child.onMount === 'function') {
+            const pending = Promise.resolve().then(() => {
+                if (!child.__vmzDestroyed)
+                    return child.onMount();
+            });
+            const bag = hostInst.__vmzPendingChildMounts || (hostInst.__vmzPendingChildMounts = []);
+            bag.push(pending);
+        }
+        return host;
+    },
+    /**
+     * Direct if/else — no blueprint `kind: "if"` dispatch.
+     * @param {object} inst
+     * @param {number|string|null} bindingId
+     * @param {string[]} deps
+     * @param {Array<{ cond?: => any, create: (api: typeof directApi) => Node }>} branches
+     * @param {number|string|null} [regionId]
+     */
+    ifBlock(inst, bindingId, deps, branches, regionId = null) {
+        noteDomCreate();
+        const host = document.createElement('span');
+        host.setAttribute('data-vmz-if', '');
+        if (regionId != null)
+            host.setAttribute('data-vmz-region', String(regionId));
+        /** @type {Array<Node | null>} */
+        const cached = branches.map(() => null);
+        /** @type {Array<Array<{ deps: string[], fn: => any, bindingId?: number|string|null }>>} */
+        const branchBinds = branches.map(() => []);
+        let active = -1;
+        let gen = 0;
+        const pick = () => {
+            for (let i = 0; i < branches.length; i++) {
+                const b = branches[i];
+                if (!b.cond)
+                    return i;
+                try {
+                    if (b.cond.call(inst))
+                        return i;
+                }
+                catch {
+                    /* continue */
+                }
+            }
+            return -1;
+        };
+        const wireBranch = (idx) => {
+            if (idx < 0)
+                return;
+            for (const { deps: d, fn, bindingId: bid } of branchBinds[idx]) {
+                registerBind(inst, d, fn, bid);
+                try {
+                    runPatch(fn, (d && d[0]) || null, bid ?? null);
+                }
+                catch (err) {
+                    console.error('vmz:dom if branch', err);
+                }
+            }
+        };
+        const unwireBranch = (idx) => {
+            if (idx < 0)
+                return;
+            for (const { deps: d, fn, bindingId: bid } of branchBinds[idx]) {
+                unregisterBind(inst, d, fn, bid);
+            }
+        };
+        const apply = () => {
+            if (inst.__vmzDestroyed)
+                return;
+            const applied = ++gen;
+            const next = pick();
+            if (next === active)
+                return;
+            if (next >= 0 && !cached[next]) {
+                const binds = [];
+                const prevSink = directApi._branchBinds;
+                const prevInst = directApi._inst;
+                directApi._branchBinds = binds;
+                directApi._inst = inst;
+                let created = null;
+                try {
+                    created = branches[next].create.call(inst, directApi);
+                }
+                finally {
+                    directApi._branchBinds = prevSink;
+                    directApi._inst = prevInst;
+                }
+                if (applied !== gen || inst.__vmzDestroyed)
+                    return;
+                if (!cached[next]) {
+                    cached[next] = created;
+                    branchBinds[next] = binds;
+                }
+            }
+            if (applied !== gen || inst.__vmzDestroyed)
+                return;
+            if (active >= 0) {
+                unwireBranch(active);
+                if (cached[active] && cached[active].parentNode) {
+                    noteDomRemove();
+                    cached[active].remove();
+                }
+            }
+            active = next;
+            if (next < 0)
+                return;
+            wireBranch(next);
+            if (cached[next])
+                host.appendChild(cached[next]);
+        };
+        registerBind(inst, deps || [], apply, bindingId);
+        if (directApi._itemPatches)
+            directApi._itemPatches.push(apply);
+        // parent destroy disposes all cached branch trees (pause ≠ destroy on switch).
+        host.__vmzDispose = () => {
+            for (let i = 0; i < cached.length; i++) {
+                unwireBranch(i);
+                if (cached[i])
+                    disposeDomTree(cached[i]);
+                cached[i] = null;
+            }
+            active = -1;
+        };
+        apply();
+        return host;
+    },
+    /**
+     * Direct keyed each — no blueprint `kind: "each"` dispatch.
+     * /: Set/Map + Fragment batch insert; item-local binds; host selected; event delegate.
+     * @param {object} inst
+     * @param {number|string|null} bindingId
+     * @param {string[]} deps
+     * @param {{ as?: string, list: => any, key?: (box: {item:any,index:number}) => any, createItem: (api: typeof directApi, box: {item:any,index:number}) => Node }} spec
+     * @param {number|string|null} [regionId]
+     */
+    eachBlock(inst, bindingId, deps, spec, regionId = null) {
+        const start = document.createComment(`vmz-each:${spec.as || ''}`);
+        const end = document.createComment('/vmz-each');
+        if (regionId != null)
+            start.__vmzRegion = regionId;
+        const frag = document.createDocumentFragment();
+        frag.appendChild(start);
+        frag.appendChild(end);
+        /** @type {Map<any, { box: { item: any, index: number }, dom: Node, patches: Array< => void> }>} */
+        const keyed = new Map();
+        let gen = 0;
+        /** @type {Map<string, => void>} */
+        const listDispatchers = new Map();
+        /** @type {Set<string>} */
+        const hostDispatchers = new Set();
+        /** @type {Record<string, any>} */
+        const hostPrev = Object.create(null);
+        /** @type {Set<string>} */
+        const delegateTypes = new Set();
+        /** @type {Record<string, EventListener>} */
+        const delegateListeners = Object.create(null);
+        /** @type {Element | null} */
+        let delegateRoot = null;
+        const itemKey = (box) => {
+            if (typeof spec.key === 'function') {
+                try {
+                    return spec.key.call(inst, box);
+                }
+                catch {
+                    return box.index;
+                }
+            }
+            return box.index;
+        };
+        const readList = () => {
+            let list = [];
+            try {
+                list = spec.list.call(inst) || [];
+            }
+            catch {
+                list = [];
+            }
+            if (!Array.isArray(list))
+                list = [...list];
+            return list;
+        };
+        const runEntryPatches = (entry, depKey, onlyBindingId) => {
+            if (!entry || !entry.patches)
+                return;
+            for (const p of entry.patches) {
+                if (onlyBindingId != null && p.__vmzBindingId != null && String(p.__vmzBindingId) !== String(onlyBindingId)) {
+                    continue;
+                }
+                try {
+                    runPatch(p, depKey, onlyBindingId);
+                }
+                catch (err) {
+                    console.error('vmz:dom each item', err);
+                }
+            }
+        };
+        const refreshByListIndex = (onlyBindingId, leafDeps, trie) => {
+            const list = readList();
+            const allowIdx = itemIndicesAllowedForDeps(trie, leafDeps);
+            const runAt = (i) => {
+                if (i < 0 || i >= list.length)
+                    return;
+                const box = { item: list[i], index: i };
+                const k = itemKey(box);
+                const entry = keyed.get(k);
+                if (!entry)
+                    return;
+                entry.box.item = list[i];
+                entry.box.index = i;
+                tagItemPatches(entry.patches, i);
+                runEntryPatches(entry, (leafDeps && leafDeps[0]) || null, onlyBindingId);
+            };
+            if (allowIdx) {
+                for (const idx of allowIdx)
+                    runAt(Number(idx));
+                return;
+            }
+            for (let i = 0; i < list.length; i++)
+                runAt(i);
+        };
+        const refreshHostKeyed = (fields, onlyBindingId) => {
+            for (const field of fields) {
+                const next = inst[field];
+                const prev = hostPrev[field];
+                hostPrev[field] = next;
+                const todo = [];
+                if (prev !== undefined && prev !== null)
+                    todo.push(prev);
+                if (next !== undefined && next !== null && next !== prev)
+                    todo.push(next);
+                for (const k of todo) {
+                    const entry = keyed.get(k);
+                    if (!entry)
+                        continue;
+                    runEntryPatches(entry, field, onlyBindingId);
+                }
+            }
+        };
+        const ensureListDispatcher = (bId, leafDeps) => {
+            if (bId == null)
+                return;
+            const idKey = String(bId);
+            if (listDispatchers.has(idKey))
+                return;
+            const dispatch = () => {
+                if (inst.__vmzDestroyed)
+                    return;
+                const trie = inst.__vmzFlushTrie;
+                const hostFields = [];
+                for (const d of leafDeps || []) {
+                    if (!d)
+                        continue;
+                    if (d.includes('.*') || (d.includes('[') && d.includes(']')))
+                        continue;
+                    hostFields.push(depRootField(d) || d);
+                }
+                const hostDirty = !!trie &&
+                    hostFields.some((f) => {
+                        const n = trie[f];
+                        return n && (n.replace || n.dirty);
+                    });
+                if (hostDirty && hostFields.length) {
+                    refreshHostKeyed(hostFields, bId);
+                    return;
+                }
+                refreshByListIndex(bId, leafDeps, trie);
+            };
+            listDispatchers.set(idKey, dispatch);
+            registerBind(inst, leafDeps || [], dispatch, bId);
+        };
+        const ensureHostDispatcher = (field) => {
+            if (!field || hostDispatchers.has(field))
+                return;
+            hostDispatchers.add(field);
+            const dispatch = () => {
+                if (inst.__vmzDestroyed)
+                    return;
+                refreshHostKeyed([field], null);
+            };
+            registerBind(inst, [field], dispatch, null);
+        };
+        const noteItemBind = (bId, bindDeps, fn) => {
+            fn.__vmzItemDeps = Array.isArray(bindDeps) ? bindDeps.slice() : [];
+            fn.__vmzBindingId = bId;
+            const leaf = fn.__vmzItemDeps;
+            if (bId != null) {
+                // One dispatcher per BindingId also covers bare host fields (e.g. selected).
+                ensureListDispatcher(bId, leaf);
+                return;
+            }
+            for (const d of leaf) {
+                if (!d)
+                    continue;
+                if (d.includes('.*') || (d.includes('[') && d.includes(']')))
+                    continue;
+                const root = depRootField(d) || d;
+                if (root && root.indexOf('.') < 0)
+                    ensureHostDispatcher(root);
+            }
+        };
+        const teardownDelegate = () => {
+            if (!delegateRoot)
+                return;
+            for (const type of Object.keys(delegateListeners)) {
+                delegateRoot.removeEventListener(type, delegateListeners[type]);
+                delete delegateListeners[type];
+            }
+            delegateRoot = null;
+        };
+        const ensureDelegateAttached = () => {
+            const parent = end.parentNode;
+            if (!parent || parent.nodeType !== 1)
+                return;
+            if (delegateRoot && delegateRoot !== parent)
+                teardownDelegate();
+            delegateRoot = /** @type {Element} */ (parent);
+            for (const type of delegateTypes) {
+                if (delegateListeners[type])
+                    continue;
+                const listener = (ev) => {
+                    if (type === 'submit' && ev && typeof ev.preventDefault === 'function') {
+                        ev.preventDefault();
+                    }
+                    let n = /** @type {Node | null} */ (ev.target);
+                    while (n && n !== delegateRoot) {
+                        if (n.nodeType === 1) {
+                            const bag = /** @type {Element} */ (n).__vmzEvt;
+                            if (bag && typeof bag[type] === 'function') {
+                                bag[type].call(inst, ev);
+                                return;
+                            }
+                        }
+                        n = n.parentNode;
+                    }
+                };
+                delegateListeners[type] = listener;
+                delegateRoot.addEventListener(type, listener);
+            }
+        };
+        const needDelegate = (type) => {
+            if (!type)
+                return;
+            delegateTypes.add(type);
+            ensureDelegateAttached();
+        };
+        const eachCtx = { noteItemBind, needDelegate };
+        const clearDomEvt = (root) => {
+            if (!root || root.nodeType !== 1)
+                return;
+            const walk = (node) => {
+                if (node.nodeType === 1) {
+                    if (node.__vmzEvt)
+                        node.__vmzEvt = null;
+                    for (let c = node.firstChild; c; c = c.nextSibling)
+                        walk(c);
+                }
+            };
+            walk(root);
+        };
+        const reconcileDomOrder = (nextNodes) => {
+            const parent = end.parentNode;
+            if (!parent)
+                return;
+            let ok = true;
+            let n = start.nextSibling;
+            for (let i = 0; i < nextNodes.length; i++) {
+                if (n !== nextNodes[i]) {
+                    ok = false;
+                    break;
+                }
+                n = n.nextSibling;
+            }
+            if (ok && n === end)
+                return;
+            const batch = document.createDocumentFragment();
+            for (const dom of nextNodes) {
+                if (dom.parentNode)
+                    noteDomMove();
+                batch.appendChild(dom);
+            }
+            parent.insertBefore(batch, end);
+        };
+        const apply = () => {
+            if (inst.__vmzDestroyed)
+                return;
+            const applied = ++gen;
+            const list = readList();
+            const seen = new Set();
+            const nextNodes = [];
+            for (let i = 0; i < list.length; i++) {
+                if (applied !== gen || inst.__vmzDestroyed)
+                    return;
+                const box = { item: list[i], index: i };
+                const k = itemKey(box);
+                if (seen.has(k)) {
+                }
+                seen.add(k);
+                let entry = keyed.get(k);
+                if (!entry) {
+                    const patches = [];
+                    const prevPatches = directApi._itemPatches;
+                    const prevCtx = directApi._eachCtx;
+                    directApi._itemPatches = patches;
+                    directApi._eachCtx = eachCtx;
+                    let dom = null;
+                    try {
+                        dom = spec.createItem.call(inst, directApi, box);
+                    }
+                    finally {
+                        directApi._itemPatches = prevPatches;
+                        directApi._eachCtx = prevCtx;
+                    }
+                    if (applied !== gen || inst.__vmzDestroyed)
+                        return;
+                    tagItemPatches(patches, i);
+                    if (dom) {
+                        if (dom.nodeType === 1) {
+                            dom.setAttribute('data-vmz-key', String(k));
+                        }
+                        entry = { box, dom, patches };
+                        keyed.set(k, entry);
+                    }
+                }
+                else {
+                    entry.box.item = list[i];
+                    entry.box.index = i;
+                    tagItemPatches(entry.patches, i);
+                    for (const p of entry.patches)
+                        runPatch(p, null);
+                }
+                if (entry)
+                    nextNodes.push(entry.dom);
+            }
+            if (applied !== gen || inst.__vmzDestroyed)
+                return;
+            for (const [k, entry] of [...keyed.entries()]) {
+                if (seen.has(k))
+                    continue;
+                noteDomRemove();
+                clearDomEvt(entry.dom);
+                disposeDomTree(entry.dom);
+                if (entry.dom && entry.dom.parentNode)
+                    entry.dom.remove();
+                keyed.delete(k);
+            }
+            reconcileDomOrder(nextNodes);
+            // First apply may run while start/end still sit in a DocumentFragment
+            // (before mount appends). Defer until connected so clicks work.
+            if (end.isConnected)
+                ensureDelegateAttached();
+            else
+                queueMicrotask(() => {
+                    if (!inst.__vmzDestroyed)
+                        ensureDelegateAttached();
+                });
+        };
+        registerBind(inst, deps || [], apply, bindingId);
+        if (directApi._itemPatches)
+            directApi._itemPatches.push(apply);
+        start.__vmzDispose = () => {
+            teardownDelegate();
+            for (const [, entry] of [...keyed.entries()]) {
+                clearDomEvt(entry.dom);
+                disposeDomTree(entry.dom);
+                if (entry.dom && entry.dom.parentNode)
+                    entry.dom.remove();
+            }
+            keyed.clear();
+        };
+        const softDeps = [...new Set((deps || []).map((d) => `${depRootField(d)}.*`))];
+        const softRefresh = () => {
+            if (inst.__vmzDestroyed)
+                return;
+            const list = readList();
+            const softKey = softDeps[0] || `${depRootField((deps && deps[0]) || '')}.*`;
+            for (let i = 0; i < list.length; i++) {
+                const box = { item: list[i], index: i };
+                const k = itemKey(box);
+                const entry = keyed.get(k);
+                if (!entry)
+                    continue;
+                entry.box.item = list[i];
+                entry.box.index = i;
+                tagItemPatches(entry.patches, i);
+                for (const p of entry.patches) {
+                    // Leaf BindingId patches are owned by list/host dispatchers .
+                    if (p.__vmzBindingId != null)
+                        continue;
+                    if (patchHasBindingId(inst, p))
+                        continue;
+                    try {
+                        runPatch(p, softKey, null);
+                    }
+                    catch (err) {
+                        console.error('vmz:dom each soft', err);
+                    }
+                }
+            }
+        };
+        registerBind(inst, softDeps, softRefresh, null);
+        apply();
+        return frag;
+    },
+};
+/**
+ * @param {object} inst
+ * @param {string[]} deps
+ * @param { => any} fn
+ * @param {number|string|null|undefined} bindingId
+ */
+function trackDirectBind(inst, deps, fn, bindingId = null) {
+    if (directApi._branchBinds) {
+        directApi._branchBinds.push({ deps, fn, bindingId });
+        if (directApi._itemPatches)
+            directApi._itemPatches.push(fn);
+        return;
+    }
+    // item binds stay on entry.patches; eachBlock registers one dispatcher per BindingId.
+    if (directApi._itemPatches) {
+        fn.__vmzItemLocal = true;
+        directApi._itemPatches.push(fn);
+        if (directApi._eachCtx) {
+            directApi._eachCtx.noteItemBind(bindingId, deps || [], fn);
+        }
+        return;
+    }
+    registerBind(inst, deps, fn, bindingId);
+}
+/**
+ * @param {object} inst
+ * @param {number|string|null} bindingId
+ * @param {string[]} deps
+ * @param { => any} get
+ * @param {(raw: any) => void} write
+ * @param {{ stable: string[], branches: Array<{ cond?: => any, deps: string[] }> } | null | undefined} [cf]
+ */
+function wireDirectBind(inst, bindingId, deps, get, write, cf) {
+    let activeBranch = -1;
+    /** @type {string[]} */
+    let liveDeps = Array.isArray(deps) ? [...deps] : [];
+    const pickCf = () => {
+        if (!cf || !Array.isArray(cf.branches))
+            return -1;
+        for (let i = 0; i < cf.branches.length; i++) {
+            const b = cf.branches[i];
+            if (!b.cond)
+                return i;
+            try {
+                if (b.cond.call(inst))
+                    return i;
+            }
+            catch {
+                /* continue */
+            }
+        }
+        return cf.branches.length - 1;
+    };
+    const apply = () => {
+        if (precision.enabled) {
+            precision.bindingEvals++;
+            for (const d of liveDeps || [])
+                bumpMap(precision.bindingEvalsByDep, d);
+            if (bindingId != null) {
+                bumpMap(precision.bindingEvalsByBinding, String(bindingId));
+            }
+        }
+        let raw;
+        try {
+            raw = get.call(inst);
+        }
+        catch {
+            raw = null;
+        }
+        write(raw);
+        if (!cf || !Array.isArray(cf.branches))
+            return;
+        const next = pickCf();
+        if (next === activeBranch)
+            return;
+        activeBranch = next;
+        const branch = cf.branches[next];
+        const nextDeps = [...(cf.stable || []), ...((branch && branch.deps) || [])];
+        const uniq = [...new Set(nextDeps)];
+        // Item-local binds must never enter the global binder table ( / jfb select).
+        if (apply.__vmzItemLocal) {
+            liveDeps = uniq;
+            return;
+        }
+        unregisterBind(inst, liveDeps, apply, bindingId);
+        liveDeps = uniq;
+        registerBind(inst, liveDeps, apply, bindingId);
+    };
+    if (cf && Array.isArray(cf.branches)) {
+        activeBranch = pickCf();
+        const branch = cf.branches[activeBranch];
+        liveDeps = [...(cf.stable || []), ...((branch && branch.deps) || [])];
+        liveDeps = [...new Set(liveDeps)];
+    }
+    // Mark before first apply so CF branch switches never hit global registerBind.
+    if (directApi._itemPatches)
+        apply.__vmzItemLocal = true;
+    apply();
+    trackDirectBind(inst, liveDeps, apply, bindingId);
+}
+function isEventPropName(name) {
+    return typeof name === 'string' && /^on[A-Z]/.test(name);
+}
+function stripFns(obj) {
+    /** @type {Record<string, unknown>} */
+    const out = {};
+    for (const [k, v] of Object.entries(obj || {})) {
+        if (typeof v === 'function')
+            continue;
+        out[k] = v;
+    }
+    return out;
+}
+/**
+ * Marker range host for Direct eachBlock (insert before end comment).
+ * @param {Comment} start
+ * @param {Comment} end
+ */
+function eachHostApi(start, end) {
+    return {
+        insert(dom) {
+            if (dom.parentNode)
+                noteDomMove();
+            end.parentNode.insertBefore(dom, end);
+        },
+        childrenBetween() {
+            const out = [];
+            let n = start.nextSibling;
+            while (n && n !== end) {
+                if (n.nodeType === 1)
+                    out.push(n);
+                n = n.nextSibling;
+            }
+            return out;
+        },
+    };
+}
+/**
+ * Snapshot plain state/prop field values for Island HMR (session).
+ * @param {object} inst
+ * @returns {Record<string, unknown> | null}
+ */
+export function snapshotInstanceState(inst) {
+    if (!inst || inst.__vmzDestroyed)
+        return null;
+    const Ctor = inst.constructor;
+    const keys = [...(Ctor.__vmzState || []), ...(Ctor.__vmzProps || [])];
+    /** @type {Record<string, unknown>} */
+    const out = {};
+    for (const key of keys) {
+        if (!key || String(key).startsWith('__'))
+            continue;
+        try {
+            out[key] = inst[key];
+        }
+        catch {
+            /* ignore accessors that throw */
+        }
+    }
+    return out;
+}
+/**
+ * @param {object} inst
+ * @param {Record<string, unknown> | null | undefined} state
+ */
+export function applyPreservedState(inst, state) {
+    if (!inst || !state)
+        return;
+    for (const [key, value] of Object.entries(state)) {
+        try {
+            inst[key] = value;
+        }
+        catch {
+            /* ignore */
+        }
+    }
+}
+/**
+ * resume: attach to existing Island DOM without re-running construct structure or onMount.
+ * Consumes ResumeEntry product (`data-vmz-resume`) derived from the same Execution Plan.
+ * @param {new (props?: object) => any} Component
+ * @param {HTMLElement} container
+ * @param {{ props?: object, state?: Record<string, unknown>, strategy?: string } | null} [slice]
+ */
+export async function resume(Component, container, slice = null) {
+    if (typeof document === 'undefined') {
+        throw new Error('vmz:dom resume() requires a document (browser)');
+    }
+    let parsed = slice;
+    if (!parsed) {
+        const raw = container.getAttribute('data-vmz-resume');
+        if (raw) {
+            try {
+                parsed = JSON.parse(raw);
+            }
+            catch {
+                parsed = null;
+            }
+        }
+    }
+    if (!parsed) {
+        let props = {};
+        try {
+            props = JSON.parse(container.getAttribute('data-vmz-props') || '{}');
+        }
+        catch {
+            props = {};
+        }
+        parsed = { props, state: {} };
+    }
+    if (container.__vmzInst) {
+        destroy(container.__vmzInst);
+        container.__vmzInst = null;
+    }
+    const props = parsed.props || {};
+    const inst = createInstance(Component, props);
+    if (parsed.state)
+        applyPreservedState(inst, parsed.state);
+    // Intentionally never call onMount — SSR already completed that work.
+    if (Component.__vmzDirect && typeof Component.__vmzCreate === 'function') {
+        if (!hasMeaningfulChild(container)) {
+            const node = runDirectCreate(Component, inst);
+            if (node) {
+                inst.__vmzDomRoot = node;
+                container.appendChild(node);
+            }
+        }
+        else {
+            // Island leaf adopt: preserve Element identity (resume nodeIdentity).
+            const node = runDirectResume(Component, inst, container);
+            if (node)
+                inst.__vmzDomRoot = node;
+        }
+    }
+    else {
+        throw new Error(`vmz:dom resume() requires __vmzCreate (Direct); blueprint render() removed (production Direct emit)`);
+    }
+    container.__vmzInst = inst;
+    container.__vmzResumed = true;
+    return inst;
+}
+/**
+ * Resume all `[data-vmz-island]` hosts (prefer ResumeEntry / EventEntry over mount).
+ * Event strategy islands wait for the DOM event before attach (lazy EventEntry).
+ * @param {ParentNode} [root]
+ */
+export function resumeIslands(root = globalThis.document) {
+    if (!root || typeof root.querySelectorAll !== 'function') {
+        throw new Error('vmz:dom resumeIslands() requires a DOM root');
+    }
+    const nodes = [...root.querySelectorAll('[data-vmz-island]')];
+    for (const el of nodes) {
+        const name = el.getAttribute('data-vmz-island');
+        const strategy = el.getAttribute('data-vmz-client') || 'load';
+        scheduleClientOn(el, strategy, async () => {
+            const Ctor = await resolveComponent(name);
+            if (!Ctor) {
+                console.error(`vmz:dom resume: unknown component ${name}`);
+                return;
+            }
+            await resume(Ctor, el);
+        });
+    }
+}
+/**
+ * EventEntry attach: only wire `client:event` / `client:event:*` islands.
+ * Idle/load/visible ResumeEntries are left alone (static shell can defer framework work).
+ * @param {ParentNode} [root]
+ */
+export function attachEventEntries(root = globalThis.document) {
+    if (!root || typeof root.querySelectorAll !== 'function') {
+        throw new Error('vmz:dom attachEventEntries() requires a DOM root');
+    }
+    const nodes = [...root.querySelectorAll('[data-vmz-island]')];
+    for (const el of nodes) {
+        const strategy = el.getAttribute('data-vmz-client') || '';
+        if (!isEventEntryStrategy(strategy))
+            continue;
+        const name = el.getAttribute('data-vmz-island');
+        el.setAttribute('data-vmz-entry', 'event');
+        scheduleClientOn(el, strategy, async () => {
+            const Ctor = await resolveComponent(name);
+            if (!Ctor) {
+                console.error(`vmz:dom EventEntry: unknown component ${name}`);
+                return;
+            }
+            await resume(Ctor, el);
+        });
+    }
+}
+/**
+ * Adopt existing Island DOM while running the same `__vmzCreate` schedule (resume).
+ * @param {new (props?: object) => any} Component
+ * @param {object} inst
+ * @param {Element} container
+ */
+function runDirectResume(Component, inst, container) {
+    const rootEl = [...container.childNodes].find((n) => n.nodeType === 1 || (n.nodeType === 3 && String(n.textContent).trim() !== ''));
+    if (!rootEl || rootEl.nodeType !== 1) {
+        return runDirectCreate(Component, inst);
+    }
+    let textI = 0;
+    const api = {
+        _inst: inst,
+        _branchBinds: null,
+        _itemPatches: null,
+        el(tag) {
+            if (String(rootEl.tagName).toLowerCase() !== String(tag).toLowerCase()) {
+                noteDomCreate();
+                return document.createElement(tag);
+            }
+            return rootEl;
+        },
+        frag() {
+            return document.createDocumentFragment();
+        },
+        text(s) {
+            while (textI < rootEl.childNodes.length) {
+                const n = rootEl.childNodes[textI++];
+                if (n.nodeType === 3) {
+                    if (s != null && s !== '')
+                        n.textContent = String(s);
+                    return n;
+                }
+            }
+            noteDomCreate();
+            return document.createTextNode(String(s ?? ''));
+        },
+        attr(el, name, value) {
+            if (name === 'className')
+                el.setAttribute('class', String(value ?? ''));
+            else if (value == null || value === false)
+                el.removeAttribute(name);
+            else
+                el.setAttribute(name, value === true ? '' : String(value));
+        },
+        on(el, type, handler) {
+            el.addEventListener(type, handler);
+        },
+        bindText: directApi.bindText,
+        bindAttr: directApi.bindAttr,
+        setHtml: directApi.setHtml,
+        bindHtml: directApi.bindHtml,
+        ifBlock: directApi.ifBlock,
+        eachBlock: directApi.eachBlock,
+        component: directApi.component,
+    };
+    return Component.__vmzCreate.call(inst, api);
+}
+/**
+ * @param {new (props?: object) => any} Component
+ * @param {HTMLElement} container
+ * @param {object} [props]
+ * @param {{ preserveState?: boolean | Record<string, unknown>, skipOnMount?: boolean }} [opts]
+ */
+export async function hydrate(Component, container, props = {}, opts = {}) {
+    if (typeof document === 'undefined') {
+        throw new Error('vmz:dom hydrate() requires a document (browser)');
+    }
+    /** @type {Record<string, unknown> | null} */
+    let preserved = null;
+    if (opts.preserveState && typeof opts.preserveState === 'object') {
+        preserved = opts.preserveState;
+    }
+    else if (opts.preserveState === true && container.__vmzInst) {
+        preserved = snapshotInstanceState(container.__vmzInst);
+    }
+    if (container.__vmzInst) {
+        destroy(container.__vmzInst);
+        container.__vmzInst = null;
+    }
+    const inst = createInstance(Component, props);
+    if (preserved) {
+        applyPreservedState(inst, preserved);
+    }
+    // production Direct emit: hydrate uses the same Direct schedule as resume (no render).
+    if (!(Component && Component.__vmzDirect && typeof Component.__vmzCreate === 'function')) {
+        throw new Error(`vmz:dom hydrate() requires __vmzCreate (Direct); blueprint render() removed (production Direct emit)`);
+    }
+    // Wire DOM + events BEFORE awaiting onMount. SSR shell is already visible; if we
+    // wait on RPC/bootstrap first, buttons look real but have no listeners (dead UI).
+    // onMount may still patch state / redirect afterwards (same end state as SSR order).
+    if (!hasMeaningfulChild(container)) {
+        const node = runDirectCreate(Component, inst);
+        if (node) {
+            inst.__vmzDomRoot = node;
+            container.appendChild(node);
+        }
+    }
+    else {
+        // Interim: shallow resume leaves if/each binders unbound. Recreate against live
+        // DOM so patches attach. Leaf nodeIdentity (same Element) remains TODO for deep adopt.
+        container.replaceChildren();
+        const node = runDirectCreate(Component, inst);
+        if (node) {
+            inst.__vmzDomRoot = node;
+            container.appendChild(node);
+        }
+    }
+    await settlePendingChildMounts(inst);
+    container.__vmzInst = inst;
+    const runMount = opts.skipOnMount !== true && !preserved && typeof inst.onMount === 'function';
+    if (runMount) {
+        await inst.onMount();
+    }
+    return inst;
+}
+/**
+ * Tear down binders and stop patches. Safe to call more than once.
+ * Field writes after destroy no longer update DOM (values may still change).
+ *: also dispose owned DOM trees (child __vmzInst / region __vmzDispose).
+ * @param {object} inst
+ */
+export function destroy(inst) {
+    if (!inst || inst.__vmzDestroyed)
+        return;
+    inst.__vmzDestroyed = true;
+    inst.__vmzFlushScheduled = false;
+    // async cancel: abort in-flight tasks before tearing down DOM.
+    __vmzCancelTasks(inst);
+    if (inst.__vmzDomRoot) {
+        disposeDomTree(inst.__vmzDomRoot);
+        inst.__vmzDomRoot = null;
+    }
+    if (inst.__vmzDirtyNotices)
+        inst.__vmzDirtyNotices.length = 0;
+    if (inst.__vmzDirtyTrie)
+        inst.__vmzDirtyTrie = Object.create(null);
+    if (inst.__vmzDirty)
+        inst.__vmzDirty.clear();
+    inst.__vmzBinders = Object.create(null);
+    inst.__vmzBindings = Object.create(null);
+    inst.__vmzDepToBindings = Object.create(null);
+    if (typeof inst.onDestroy === 'function') {
+        try {
+            inst.onDestroy();
+        }
+        catch (err) {
+            console.error('vmz:dom onDestroy', err);
+        }
+    }
+}
+/**
+ *: walk a DOM subtree and run lifetime dispose hooks + nested instance destroy.
+ * Does not mark the *calling* parent destroyed; safe from destroy(inst).
+ * @param {Node | null | undefined} root
+ */
+export function disposeDomTree(root) {
+    if (!root)
+        return;
+    const seen = new Set();
+    const visit = (node) => {
+        if (!node || seen.has(node))
+            return;
+        seen.add(node);
+        if (typeof node.__vmzDispose === 'function') {
+            try {
+                node.__vmzDispose();
+            }
+            catch (err) {
+                console.error('vmz:dom __vmzDispose', err);
+            }
+            node.__vmzDispose = null;
+        }
+        if (node.__vmzInst) {
+            const child = node.__vmzInst;
+            node.__vmzInst = null;
+            destroy(child);
+        }
+        let child = node.firstChild;
+        while (child) {
+            const next = child.nextSibling;
+            visit(child);
+            child = next;
+        }
+    };
+    visit(root);
+}
+/**
+ * @param {ParentNode} [root]
+ */
+export function hydrateIslands(root = globalThis.document) {
+    // resume: hydrateIslands is an alias for resumeIslands (same Plan attach).
+    return resumeIslands(root);
+}
+export function scheduleClient(strategy, fn) {
+    scheduleClientOn(null, strategy, fn);
+}
+/** @param {string} strategy */
+function isEventEntryStrategy(strategy) {
+    const s = String(strategy || '');
+    return s === 'event' || s.startsWith('event:') || s === 'click';
+}
+/** @param {string} strategy */
+function eventEntryType(strategy) {
+    const s = String(strategy || 'event');
+    if (s.startsWith('event:'))
+        return s.slice(6) || 'click';
+    if (s === 'click')
+        return 'click';
+    return 'click';
+}
+function scheduleClientOn(el, strategy, fn) {
+    const run = () => {
+        Promise.resolve(fn).catch((err) => console.error('vmz:dom island', err));
+    };
+    if (isEventEntryStrategy(strategy)) {
+        if (!el || typeof el.addEventListener !== 'function') {
+            run();
+            return;
+        }
+        const type = eventEntryType(strategy);
+        const once = () => {
+            el.removeEventListener(type, once);
+            run();
+        };
+        el.addEventListener(type, once);
+        return;
+    }
+    if (strategy === 'idle') {
+        if (typeof requestIdleCallback === 'function') {
+            requestIdleCallback(() => run(), { timeout: 2000 });
+        }
+        else {
+            setTimeout(run, 1);
+        }
+        return;
+    }
+    if (strategy === 'visible' && el && typeof IntersectionObserver === 'function') {
+        const io = new IntersectionObserver((entries) => {
+            if (entries.some((e) => e.isIntersecting)) {
+                io.disconnect();
+                run();
+            }
+        });
+        io.observe(el);
+        return;
+    }
+    run();
+}
+/**
+ * AsyncTask cancel protocol (first slice): keyed generation + AbortSignal.
+ * Superseded runs and `destroy(inst)` abort prior work; stale results must not apply.
+ * @param {object} inst
+ * @param {string} key
+ * @param {(signal: AbortSignal, meta: { generation: number }) => any | Promise<any>} fn
+ * @returns {Promise<any>}
+ */
+export function __vmzRunTask(inst, key, fn) {
+    if (!inst)
+        throw new Error('vmz:dom __vmzRunTask requires inst');
+    const k = String(key || 'default');
+    if (!inst.__vmzTasks)
+        inst.__vmzTasks = Object.create(null);
+    const prev = inst.__vmzTasks[k];
+    if (prev) {
+        prev.generation += 1;
+        try {
+            prev.controller.abort();
+        }
+        catch {
+            /* ignore */
+        }
+        prev.status = 'cancelled';
+    }
+    const controller = typeof AbortController !== 'undefined'
+        ? new AbortController()
+        : {
+            signal: { aborted: false },
+            abort() {
+                this.signal.aborted = true;
+            },
+        };
+    const generation = (prev?.generation || 0) + 1;
+    /** @type {{ generation: number, controller: any, status: string, result?: any, error?: any, promise?: Promise<any> }} */
+    const entry = {
+        generation,
+        controller,
+        status: 'pending',
+    };
+    inst.__vmzTasks[k] = entry;
+    // Invoke synchronously so event handlers can call preventDefault before
+    // the browser continues the default action (form submit → native navigation).
+    // Async work still continues via the returned Promise.
+    let syncResult;
+    let syncErr;
+    let threw = false;
+    try {
+        syncResult = fn(controller.signal, { generation });
+    }
+    catch (err) {
+        threw = true;
+        syncErr = err;
+    }
+    const settleOk = (result) => {
+        if (inst.__vmzDestroyed || controller.signal.aborted || inst.__vmzTasks[k] !== entry) {
+            entry.status = 'cancelled';
+            return undefined;
+        }
+        entry.status = 'success';
+        entry.result = result;
+        return result;
+    };
+    const settleErr = (err) => {
+        if (inst.__vmzDestroyed || controller.signal.aborted || inst.__vmzTasks[k] !== entry) {
+            entry.status = 'cancelled';
+            return undefined;
+        }
+        entry.status = 'error';
+        entry.error = err;
+        throw err;
+    };
+    if (threw) {
+        const promise = Promise.resolve().then(() => settleErr(syncErr));
+        entry.promise = promise;
+        return promise;
+    }
+    const promise = Promise.resolve(syncResult).then(settleOk, settleErr);
+    entry.promise = promise;
+    return promise;
+}
+/** Abort all keyed tasks on an instance (also called from destroy). */
+export function __vmzCancelTasks(inst) {
+    const tasks = inst?.__vmzTasks;
+    if (!tasks)
+        return;
+    for (const key of Object.keys(tasks)) {
+        const t = tasks[key];
+        t.generation += 1;
+        try {
+            t.controller.abort();
+        }
+        catch {
+            /* ignore */
+        }
+        t.status = 'cancelled';
+    }
+}
+/** @returns {'pending'|'success'|'error'|'cancelled'|null} */
+export function __vmzTaskStatus(inst, key) {
+    const t = inst?.__vmzTasks?.[String(key || 'default')];
+    return t ? t.status : null;
+}
+function createInstance(Component, props = {}) {
+    if (precision.enabled)
+        precision.componentExecs++;
+    const inst = new Component(props || {});
+    if (typeof inst.__vmzApplyProps === 'function' && !Component.__vmzCtorAppliesProps) {
+        inst.__vmzApplyProps(props || {});
+    }
+    inst.__vmzBinders = Object.create(null);
+    inst.__vmzBindings = Object.create(null);
+    inst.__vmzDepToBindings = Object.create(null);
+    makeReactive(inst, Component.__vmzState || []);
+    makeReactive(inst, Component.__vmzProps || []);
+    // WriteBarrier: path / array writes call Component helpers (no import needed).
+    Component.__vmzWritePath = __vmzWritePath;
+    Component.__vmzWritePathLogical = __vmzWritePathLogical;
+    Component.__vmzReadPath = __vmzReadPath;
+    Component.__vmzArrayMutate = __vmzArrayMutate;
+    Component.__vmzAllowShared = __vmzAllowShared;
+    Component.__vmzTakeShared = __vmzTakeShared;
+    return inst;
+}
+/** Shared plain-object owners under WriteBarrier (no Proxy). */
+const wbSharedOwners = new WeakMap();
+/** Objects explicitly marked OK to share across component instances (13 ). */
+const wbAllowShared = new WeakSet();
+/** @type {Array<{ kind: string, message: string }>} */
+const wbCrossComponentDiags = [];
+/**
+ * Mark a plain object as intentionally shared across ownership boundaries.
+ * @param {any} value
+ */
+export function __vmzAllowShared(value) {
+    if (value != null && typeof value === 'object')
+        wbAllowShared.add(value);
+    return value;
+}
+/**
+ * Take exclusive ownership intent: clear multi-owner registry for this object.
+ * Subsequent field assigns re-register from the assigning instance only.
+ * @param {any} value
+ */
+export function __vmzTakeShared(value) {
+    if (value != null && typeof value === 'object') {
+        wbSharedOwners.delete(value);
+        wbAllowShared.delete(value);
+    }
+    return value;
+}
+/**
+ * @returns {Array<{ kind: string, message: string }>}
+ */
+export function __vmzSharedCrossComponentDiagnostics() {
+    return wbCrossComponentDiags.slice();
+}
+export function __vmzSharedCrossComponentDiagnosticsReset() {
+    wbCrossComponentDiags.length = 0;
+}
+/**
+ * @param {any} value
+ * @param {(segs: string[] | null) => void} report
+ * @param {string[]} baseSegs
+ * @param {any} [inst]
+ */
+function registerWbOwner(value, report, baseSegs = [], inst = null) {
+    if (value == null || typeof value !== 'object')
+        return;
+    let entry = wbSharedOwners.get(value);
+    if (!entry) {
+        entry = { owners: [] };
+        wbSharedOwners.set(value, entry);
+    }
+    if (entry.owners.some((o) => o.report === report && sameSegs(o.baseSegs, baseSegs))) {
+        return;
+    }
+    entry.owners.push({ report, baseSegs: baseSegs.slice(), inst });
+    // Cross-component share without explicit allow → diagnose (13 ).
+    if (!wbAllowShared.has(value) && inst) {
+        const other = entry.owners.find((o) => o.inst && o.inst !== inst);
+        if (other) {
+            if (!wbCrossComponentDiags.some((d) => d.message === msg)) {
+                wbCrossComponentDiags.push({ kind: 'shared_cross_component', message: msg });
+            }
+        }
+    }
+}
+/**
+ * Notify all registered owners of a shared plain object after a barrier write.
+ * @param {any} rootObj field-root value that was written under
+ * @param {string[] | null} localSegs path under that object (null = replace)
+ * @returns {boolean} true when at least one owner was notified
+ */
+function notifyWbShared(rootObj, localSegs) {
+    const entry = rootObj && typeof rootObj === 'object' ? wbSharedOwners.get(rootObj) : null;
+    if (!entry || !entry.owners.length)
+        return false;
+    for (const o of entry.owners) {
+        if (localSegs == null) {
+            o.report(o.baseSegs.length ? o.baseSegs.slice() : null);
+        }
+        else {
+            o.report([...o.baseSegs, ...localSegs]);
+        }
+    }
+    return true;
+}
+/**
+ * Read a nested path under a field root (for compound / update expansion).
+ * @param {any} inst
+ * @param {string} root
+ * @param {string[]} segs
+ */
+export function __vmzReadPath(inst, root, segs) {
+    if (!inst || !root)
+        return undefined;
+    let obj = inst[root];
+    if (!Array.isArray(segs) || segs.length === 0)
+        return obj;
+    for (let i = 0; i < segs.length; i++) {
+        if (obj == null || typeof obj !== 'object')
+            return undefined;
+        obj = obj[segs[i]];
+    }
+    return obj;
+}
+/**
+ * Short-circuit logical path assign (`||=` / `&&=` / `??=`).
+ * @param {any} inst
+ * @param {string} root
+ * @param {string[]} segs
+ * @param {'||'|'&&'|'??'} kind
+ * @param {any} rhs
+ */
+export function __vmzWritePathLogical(inst, root, segs, kind, rhs) {
+    const cur = __vmzReadPath(inst, root, segs);
+    if (kind === '||') {
+        if (cur)
+            return cur;
+    }
+    else if (kind === '&&') {
+        if (!cur)
+            return cur;
+    }
+    else if (kind === '??') {
+        if (cur != null)
+            return cur;
+    }
+    else {
+        return cur;
+    }
+    return __vmzWritePath(inst, root, segs, rhs);
+}
+/**
+ * Mutates a plain owned object/array and schedules the same path notice Proxy would.
+ *
+ * Root-array index assigns (`tags[0] = x`) notify as field replace (structural),
+ * matching the transitional Proxy wrapArray behavior.
+ * Shared multi-owner: writing through one field notifies all owners of the same raw object.
+ *
+ * @param {any} inst
+ * @param {string} root field root
+ * @param {string[]} segs path under root (non-empty); dynamic indices already String(...)'d
+ * @param {any} value
+ */
+export function __vmzWritePath(inst, root, segs, value) {
+    if (!inst || inst.__vmzDestroyed)
+        return value;
+    if (!root || !Array.isArray(segs) || segs.length === 0)
+        return value;
+    const normSegs = segs.map((s) => String(s));
+    let obj = inst[root];
+    if (obj == null || typeof obj !== 'object')
+        return value;
+    for (let i = 0; i < normSegs.length - 1; i++) {
+        obj = obj[normSegs[i]];
+        if (obj == null || typeof obj !== 'object')
+            return value;
+    }
+    const leaf = normSegs[normSegs.length - 1];
+    if (Object.is(obj[leaf], value))
+        return value;
+    obj[leaf] = value;
+    // Register newly assigned nested objects under this field for future shared writes.
+    if (value != null && typeof value === 'object') {
+        const report = (local) => {
+            if (!local || local.length === 0) {
+                scheduleRefresh(inst, { type: 'replace', root });
+            }
+            else {
+                scheduleRefresh(inst, { type: 'path', root, segs: local });
+            }
+        };
+        registerWbOwner(value, report, normSegs.slice(), inst);
+    }
+    const rootObj = inst[root];
+    const rootArr = rootObj;
+    const isRootIndex = normSegs.length === 1 && Array.isArray(rootArr) && leaf !== 'length' && String(Number(leaf)) === leaf;
+    if (isRootIndex) {
+        if (!notifyWbShared(rootObj, null)) {
+            scheduleRefresh(inst, { type: 'replace', root });
+        }
+    }
+    else if (!notifyWbShared(rootObj, normSegs)) {
+        scheduleRefresh(inst, { type: 'path', root, segs: normSegs.slice() });
+    }
+    return value;
+}
+/**
+ * Compiler-inserted array mutator barrier (push/pop/splice/…).
+ * Applies the mutator on the plain array and schedules a structural notice
+ * at `root` + `baseSegs` (empty baseSegs → field replace).
+ *
+ * @param {any} inst
+ * @param {string} root
+ * @param {string[]} baseSegs
+ * @param {string} method
+ * @param {any[]} args
+ */
+export function __vmzArrayMutate(inst, root, baseSegs, method, args) {
+    if (!inst || inst.__vmzDestroyed)
+        return undefined;
+    if (!root || typeof method !== 'string')
+        return undefined;
+    const segs = Array.isArray(baseSegs) ? baseSegs.map((s) => String(s)) : [];
+    let arr = inst[root];
+    if (arr == null || typeof arr !== 'object')
+        return undefined;
+    for (let i = 0; i < segs.length; i++) {
+        arr = arr[segs[i]];
+        if (arr == null || typeof arr !== 'object')
+            return undefined;
+    }
+    if (!Array.isArray(arr) || typeof arr[method] !== 'function')
+        return undefined;
+    const list = Array.isArray(args) ? args : [];
+    const ret = arr[method](...list);
+    const rootObj = inst[root];
+    if (segs.length === 0) {
+        if (!notifyWbShared(rootObj, null)) {
+            scheduleRefresh(inst, { type: 'replace', root });
+        }
+    }
+    else if (!notifyWbShared(rootObj, segs)) {
+        scheduleRefresh(inst, { type: 'path', root, segs: segs.slice() });
+    }
+    return ret;
+}
+function makeReactive(inst, stateKeys) {
+    const barrier = !!inst.constructor.__vmzWriteBarrier;
+    for (const key of stateKeys) {
+        if (!key || key.startsWith('#'))
+            continue;
+        const desc = Object.getOwnPropertyDescriptor(inst, key);
+        if (desc && desc.set && desc.get && !desc.writable)
+            continue;
+        /** @param {string[] | null} segs null/empty → replace field */
+        const report = (segs) => {
+            if (!segs || segs.length === 0) {
+                scheduleRefresh(inst, { type: 'replace', root: key });
+            }
+            else {
+                scheduleRefresh(inst, { type: 'path', root: key, segs });
+            }
+        };
+        // WriteBarrier components keep plain objects — nested writes go through __vmzWritePath.
+        let value = barrier ? inst[key] : wrapReactive(inst[key], report, []);
+        if (barrier)
+            registerWbOwner(value, report, [], inst);
+        Object.defineProperty(inst, key, {
+            configurable: true,
+            enumerable: true,
+            get() {
+                return value;
+            },
+            set(next) {
+                const wrapped = barrier ? next : wrapReactive(next, report, []);
+                if (Object.is(value, wrapped))
+                    return;
+                value = wrapped;
+                if (barrier)
+                    registerWbOwner(value, report, [], inst);
+                report(null);
+            },
+        });
+    }
+}
+/** Targets already wrapped: raw|proxy|barrier → { proxy, owners[], kind }. */
+const reactiveProxies = new WeakMap();
+/** Plain objects using defineProperty write barriers (not Proxy). */
+const writeBarrierOwned = new WeakSet();
+/**
+ * WriteBarrier: true when value is an owned plain object with path barriers (no Proxy).
+ * @param {any} value
+ */
+export function __vmzIsWriteBarrierOwned(value) {
+    return writeBarrierOwned.has(value);
+}
+/**
+ * True when value is the Proxy wrapper from array (or residual) reactive wrap.
+ * @param {any} value
+ */
+export function __vmzIsReactiveProxy(value) {
+    const e = reactiveProxies.get(value);
+    return !!(e && e.kind === 'proxy' && e.proxy === value);
+}
+const ARRAY_MUTATORS = new Set(['push', 'pop', 'shift', 'unshift', 'splice', 'sort', 'reverse', 'fill', 'copyWithin']);
+/**
+ * @typedef {{ report: (segs: string[] | null) => void, baseSegs: string[] }} ReactiveOwner
+ * @typedef {{ proxy: object, owners: ReactiveOwner[], kind: 'barrier'|'proxy' }} ReactiveEntry
+ */
+function sameSegs(a, b) {
+    if (a.length !== b.length)
+        return false;
+    for (let i = 0; i < a.length; i++) {
+        if (a[i] !== b[i])
+            return false;
+    }
+    return true;
+}
+/**
+ * @param {ReactiveEntry} entry
+ * @param {(segs: string[] | null) => void} report
+ * @param {string[]} baseSegs
+ */
+function addOwner(entry, report, baseSegs) {
+    if (entry.owners.some((o) => o.report === report && sameSegs(o.baseSegs, baseSegs))) {
+        return;
+    }
+    entry.owners.push({
+        report,
+        baseSegs: baseSegs.slice(),
+    });
+}
+/**
+ * @param {ReactiveOwner[]} owners
+ * @param {string[] | null} localSegs null = structural replace of this node
+ */
+function notifyOwners(owners, localSegs) {
+    for (const o of owners) {
+        if (localSegs == null) {
+            o.report(o.baseSegs.length ? o.baseSegs.slice() : null);
+        }
+        else {
+            o.report([...o.baseSegs, ...localSegs]);
+        }
+    }
+}
+/**
+ * Field-owned write traps for plain objects / arrays on state fields.
+ * Plain objects: WriteBarrier via defineProperty (no Proxy) — .
+ * Arrays: transitional Proxy until keyed collection barriers land.
+ * Shared raw objects notify **all** current owners.
+ *
+ * @param {any} value
+ * @param {(segs: string[] | null) => void} report
+ * @param {string[]} pathSegs path under the field root to this value
+ */
+function wrapReactive(value, report, pathSegs = []) {
+    if (value == null || typeof value !== 'object')
+        return value;
+    const existing = reactiveProxies.get(value);
+    if (existing) {
+        addOwner(existing, report, pathSegs);
+        return existing.proxy;
+    }
+    if (Array.isArray(value))
+        return wrapArray(value, report, pathSegs);
+    if (isPlainObject(value))
+        return wrapOwnedObject(value, report, pathSegs);
+    return value;
+}
+function isPlainObject(value) {
+    const proto = Object.getPrototypeOf(value);
+    return proto === Object.prototype || proto === null;
+}
+/**
+ * Path-level write barrier for owned plain objects (no Proxy).
+ */
+function wrapOwnedObject(obj, report, pathSegs) {
+    const existing = reactiveProxies.get(obj);
+    if (existing) {
+        addOwner(existing, report, pathSegs);
+        return existing.proxy;
+    }
+    /** @type {ReactiveEntry} */
+    const entry = {
+        proxy: obj,
+        owners: [],
+        kind: 'barrier',
+    };
+    addOwner(entry, report, pathSegs);
+    writeBarrierOwned.add(obj);
+    reactiveProxies.set(obj, entry);
+    for (const prop of Object.keys(obj)) {
+        installOwnedProp(obj, prop, entry);
+    }
+    return obj;
+}
+/**
+ * @param {object} obj
+ * @param {string} prop
+ * @param {ReactiveEntry} entry
+ */
+function installOwnedProp(obj, prop, entry) {
+    const desc = Object.getOwnPropertyDescriptor(obj, prop);
+    if (!desc || !desc.configurable)
+        return;
+    if (desc.get || desc.set)
+        return;
+    let current = obj[prop];
+    for (const o of entry.owners) {
+        current = wrapReactive(current, o.report, [...o.baseSegs, prop]);
+    }
+    Object.defineProperty(obj, prop, {
+        configurable: true,
+        enumerable: desc.enumerable !== false,
+        get() {
+            return current;
+        },
+        set(next) {
+            const local = [prop];
+            let wrapped = next;
+            for (const o of entry.owners) {
+                wrapped = wrapReactive(next, o.report, [...o.baseSegs, ...local]);
+            }
+            if (Object.is(current, wrapped))
+                return;
+            current = wrapped;
+            notifyOwners(entry.owners, local);
+        },
+    });
+}
+function wrapArray(arr, report, pathSegs) {
+    const existing = reactiveProxies.get(arr);
+    if (existing) {
+        addOwner(existing, report, pathSegs);
+        return existing.proxy;
+    }
+    /** @type {ReactiveEntry} */
+    const entry = {
+        proxy: null,
+        owners: [],
+        kind: 'proxy',
+    };
+    addOwner(entry, report, pathSegs);
+    for (let i = 0; i < arr.length; i++) {
+        const item = arr[i];
+        for (const o of entry.owners) {
+            arr[i] = wrapReactive(item, o.report, [...o.baseSegs, String(i)]);
+        }
+    }
+    const proxy = new Proxy(arr, {
+        get(target, prop, receiver) {
+            if (typeof prop === 'string' && ARRAY_MUTATORS.has(prop)) {
+                const fn = target[prop];
+                return (...args) => {
+                    const wrappedArgs = args.map((a, idx) => {
+                        if (prop === 'splice' && idx >= 2) {
+                            let w = a;
+                            for (const o of entry.owners) {
+                                w = wrapReactive(a, o.report, o.baseSegs.slice());
+                            }
+                            return w;
+                        }
+                        if ((prop === 'push' || prop === 'unshift') && typeof a === 'object') {
+                            let w = a;
+                            for (const o of entry.owners) {
+                                w = wrapReactive(a, o.report, o.baseSegs.slice());
+                            }
+                            return w;
+                        }
+                        if (prop === 'fill') {
+                            let w = a;
+                            for (const o of entry.owners) {
+                                w = wrapReactive(a, o.report, o.baseSegs.slice());
+                            }
+                            return w;
+                        }
+                        return a;
+                    });
+                    const ret = fn.apply(target, wrappedArgs);
+                    notifyOwners(entry.owners, null);
+                    return ret;
+                };
+            }
+            const v = Reflect.get(target, prop, receiver);
+            if (v && typeof v === 'object' && typeof prop === 'string') {
+                let nested = null;
+                for (const o of entry.owners) {
+                    nested = wrapReactive(v, o.report, [...o.baseSegs, prop]);
+                }
+                return nested;
+            }
+            return v;
+        },
+        set(target, prop, next, receiver) {
+            const isIndex = typeof prop === 'string' && prop !== 'length' && String(Number(prop)) === prop;
+            const allRoot = entry.owners.every((o) => o.baseSegs.length === 0);
+            if (isIndex && allRoot) {
+                let wrapped = next;
+                for (const o of entry.owners) {
+                    wrapped = wrapReactive(next, o.report, [...o.baseSegs, prop]);
+                }
+                const prev = target[prop];
+                if (Object.is(prev, wrapped))
+                    return true;
+                const ok = Reflect.set(target, prop, wrapped, receiver);
+                if (ok)
+                    notifyOwners(entry.owners, null);
+                return ok;
+            }
+            const local = prop === 'length' || typeof prop !== 'string' ? [] : [prop];
+            let wrapped = next;
+            if (prop !== 'length') {
+                for (const o of entry.owners) {
+                    wrapped = wrapReactive(next, o.report, [...o.baseSegs, ...local]);
+                }
+            }
+            const prev = target[prop];
+            if (Object.is(prev, wrapped))
+                return true;
+            const ok = Reflect.set(target, prop, wrapped, receiver);
+            if (ok) {
+                if (prop === 'length')
+                    notifyOwners(entry.owners, null);
+                else
+                    notifyOwners(entry.owners, local);
+            }
+            return ok;
+        },
+        deleteProperty(target, prop) {
+            if (!(prop in target))
+                return true;
+            const ok = Reflect.deleteProperty(target, prop);
+            if (ok) {
+                notifyOwners(entry.owners, typeof prop === 'string' ? [prop] : null);
+            }
+            return ok;
+        },
+    });
+    entry.proxy = proxy;
+    reactiveProxies.set(arr, entry);
+    reactiveProxies.set(proxy, entry);
+    return proxy;
+}
+/**
+ * Coalesce field/path patches in the same turn via a dirty path trie.
+ * Still precise deps — never a full-tree re-render. Flush runs as a microtask;
+ * call `await flushPending(inst)` to apply synchronously (tests / immediate UI).
+ *
+ *
+ * @param {object} inst
+ * @param {{ type: 'replace', root: string } | { type: 'path', root: string, segs: string[] } | string} notice
+ * string form is transitional field-root alias for replace.
+ */
+function scheduleRefresh(inst, notice) {
+    if (!inst || inst.__vmzDestroyed)
+        return;
+    const n = typeof notice === 'string' ? { type: 'replace', root: notice } : notice;
+    if (!n || !n.root)
+        return;
+    if (precision.enabled) {
+        precision.writes++;
+        bumpMap(precision.writesByRoot, n.root);
+    }
+    pushTrace('write', 'field', n.root, n.root);
+    if (!inst.__vmzDirtyTrie)
+        inst.__vmzDirtyTrie = Object.create(null);
+    insertDirtyNotice(inst.__vmzDirtyTrie, n);
+    // Transitional: keep notice list for flush loop emptiness check / compat.
+    if (!inst.__vmzDirtyNotices)
+        inst.__vmzDirtyNotices = [];
+    inst.__vmzDirtyNotices.push(n);
+    if (inst.__vmzFlushScheduled)
+        return;
+    inst.__vmzFlushScheduled = true;
+    queueMicrotask(() => {
+        inst.__vmzFlushScheduled = false;
+        Promise.resolve(flushPending(inst)).catch((err) => console.error('vmz:dom flush', err));
+    });
+}
+/**
+ * @param {Record<string, any>} trie
+ * @param {{ type: string, root: string, segs?: string[] }} notice
+ */
+function insertDirtyNotice(trie, notice) {
+    if (notice.type === 'replace') {
+        trie[notice.root] = { replace: true };
+        return;
+    }
+    const segs = notice.segs || [];
+    let node = trie[notice.root];
+    if (node && node.replace)
+        return;
+    if (!node) {
+        node = { children: Object.create(null) };
+        trie[notice.root] = node;
+    }
+    if (!segs.length) {
+        trie[notice.root] = { replace: true };
+        return;
+    }
+    if (!node.children)
+        node.children = Object.create(null);
+    let cur = node;
+    for (let i = 0; i < segs.length; i++) {
+        const seg = segs[i];
+        if (cur.dirty)
+            return; // ancestor already dirty
+        if (!cur.children)
+            cur.children = Object.create(null);
+        if (i === segs.length - 1) {
+            cur.children[seg] = { dirty: true };
+            return;
+        }
+        let next = cur.children[seg];
+        if (!next) {
+            next = { children: Object.create(null) };
+            cur.children[seg] = next;
+        }
+        else if (next.dirty) {
+            return;
+        }
+        else if (!next.children) {
+            next.children = Object.create(null);
+        }
+        cur = next;
+    }
+}
+/** @param {object} inst */
+export async function flushPending(inst) {
+    if (!inst || inst.__vmzDestroyed)
+        return;
+    inst.__vmzFlushScheduled = false;
+    let guard = 0;
+    while (!inst.__vmzDestroyed &&
+        ((inst.__vmzDirtyTrie && Object.keys(inst.__vmzDirtyTrie).length > 0) ||
+            (inst.__vmzDirtyNotices && inst.__vmzDirtyNotices.length > 0)) &&
+        guard++ < 64) {
+        const trie = inst.__vmzDirtyTrie || Object.create(null);
+        inst.__vmzDirtyTrie = Object.create(null);
+        if (inst.__vmzDirtyNotices)
+            inst.__vmzDirtyNotices.length = 0;
+        inst.__vmzFlushTrie = trie;
+        const jobs = [];
+        // Prefer BindingId scheduling (IR). String `__vmzBinders` is adapter-only.
+        // Pass `trie` into refresh — dirty map is cleared above before patches run.
+        try {
+            const bindingIds = bindingIdsMatchingTrie(inst, trie);
+            const coveredDeps = Object.create(null);
+            for (const id of bindingIds) {
+                const entry = inst.__vmzBindings && inst.__vmzBindings[id];
+                if (entry) {
+                    for (const d of entry.deps || [])
+                        coveredDeps[d] = true;
+                }
+                jobs.push(...refreshBinding(inst, id, trie));
+            }
+            for (const key of binderKeysMatchingTrie(inst, trie)) {
+                if (coveredDeps[key])
+                    continue;
+                if (inst.__vmzDepToBindings && inst.__vmzDepToBindings[key]?.length) {
+                    continue;
+                }
+                jobs.push(...refreshField(inst, key));
+            }
+            if (jobs.length)
+                await Promise.all(jobs);
+        }
+        finally {
+            inst.__vmzFlushTrie = null;
+        }
+    }
+}
+/**
+ * @param {object} inst
+ * @param {Record<string, any>} trie
+ * @returns {Array<number|string>}
+ */
+function bindingIdsMatchingTrie(inst, trie) {
+    const index = inst.__vmzDepToBindings;
+    if (!index)
+        return [];
+    const out = [];
+    const seen = Object.create(null);
+    for (const key of Object.keys(index)) {
+        if (!depMatchesTrie(trie, key))
+            continue;
+        for (const id of index[key]) {
+            const k = String(id);
+            if (seen[k])
+                continue;
+            seen[k] = true;
+            out.push(id);
+        }
+    }
+    return out;
+}
+/**
+ * @param {object} inst
+ * @param {Record<string, any>} trie
+ * @returns {string[]}
+ */
+function binderKeysMatchingTrie(inst, trie) {
+    const binders = inst.__vmzBinders;
+    if (!binders)
+        return [];
+    const out = [];
+    for (const key of Object.keys(binders)) {
+        if (depMatchesTrie(trie, key))
+            out.push(key);
+    }
+    return out;
+}
+/**
+ * @param {Record<string, any>} trie
+ * @param {string} key
+ */
+function depMatchesTrie(trie, key) {
+    const root = depRootField(key);
+    const node = trie[root];
+    if (!node)
+        return false;
+    if (node.replace) {
+        return key === root || key === `${root}.*` || key.startsWith(`${root}.`) || key.startsWith(`${root}[`);
+    }
+    if (key === `${root}.*`) {
+        // Bare `field.*` soft/structure channel: item replace / array structure only —
+        // NOT deep leaf writes (`tags.0.label`); those use `tags.*.label` BindingId.
+        return structureStarMatches(node);
+    }
+    // Bare field: replace-only.
+    if (key === root)
+        return false;
+    // Path channel: `tags.*.label` — wildcard index under list root.
+    const starPrefix = `${root}.*`;
+    if (key === starPrefix || key.startsWith(`${starPrefix}.`)) {
+        const rest = key === starPrefix
+            ? []
+            : key
+                .slice(starPrefix.length + 1)
+                .split('.')
+                .filter(Boolean);
+        return wildcardIndexDirtyCovers(node, rest);
+    }
+    // Stable ListItem form `tags[key=…].label` — treat `[key=…]` as wildcard index.
+    if (key.startsWith(`${root}[`)) {
+        const afterBracket = key.indexOf(']');
+        if (afterBracket > root.length) {
+            const rest = key.length > afterBracket + 1 && key[afterBracket + 1] === '.'
+                ? key
+                    .slice(afterBracket + 2)
+                    .split('.')
+                    .filter(Boolean)
+                : [];
+            return wildcardIndexDirtyCovers(node, rest);
+        }
+    }
+    const segs = key
+        .slice(root.length + 1)
+        .split('.')
+        .filter(Boolean);
+    return pathDirtyCovers(node, segs);
+}
+/** `tags.*` structure soft-refresh: replace or index-level dirty, not leaf-only. */
+function structureStarMatches(node) {
+    if (!node)
+        return false;
+    if (node.replace || node.dirty)
+        return true;
+    if (!node.children)
+        return false;
+    for (const idx of Object.keys(node.children)) {
+        const child = node.children[idx];
+        // Index node dirty/replace → item identity changed.
+        if (child && (child.replace || child.dirty))
+            return true;
+    }
+    return false;
+}
+/** `tags.*.label` / `tags[key=x].label` vs dirty trie under `tags`. */
+function wildcardIndexDirtyCovers(node, restSegs) {
+    if (!node || node.replace)
+        return !!node?.replace;
+    if (node.dirty)
+        return true;
+    if (!node.children)
+        return false;
+    for (const idx of Object.keys(node.children)) {
+        const child = node.children[idx];
+        if (restSegs.length === 0) {
+            if (trieHasAnyDirty(child))
+                return true;
+        }
+        else if (pathDirtyCovers(child, restSegs)) {
+            return true;
+        }
+    }
+    return false;
+}
+function trieHasAnyDirty(node) {
+    if (!node || node.replace)
+        return !!node;
+    if (node.dirty)
+        return true;
+    if (!node.children)
+        return false;
+    for (const k of Object.keys(node.children)) {
+        if (trieHasAnyDirty(node.children[k]))
+            return true;
+    }
+    return false;
+}
+/**
+ * Wake if write is at/under dep, or dep is under write (parent covers children).
+ * @param {any} node root trie node for field
+ * @param {string[]} depSegs
+ */
+function pathDirtyCovers(node, depSegs) {
+    let cur = node;
+    for (let i = 0; i < depSegs.length; i++) {
+        if (!cur || cur.replace)
+            return !!cur?.replace;
+        if (cur.dirty)
+            return true; // write parent covers this dep
+        if (!cur.children)
+            return false;
+        const next = cur.children[depSegs[i]];
+        if (!next) {
+            // No write along this dep path — but a write under a prefix?
+            return false;
+        }
+        cur = next;
+    }
+    // Reached dep node: wake if dirty here or any dirty descendant (write under dep).
+    return trieHasAnyDirty(cur);
+}
+/**
+ * Dual-track match retained for tests / tooling.
+ * @param {{ type: string, root: string, segs?: string[] }} notice
+ * @param {string} key
+ */
+function noticeMatchesDepKey(notice, key) {
+    const trie = Object.create(null);
+    insertDirtyNotice(trie, notice);
+    return depMatchesTrie(trie, key);
+}
+/** Root field name from a dep key string (`user.name` → `user`, `tags.*` → `tags`). */
+function depRootField(dep) {
+    if (!dep)
+        return '';
+    const star = dep.indexOf('.*');
+    if (star >= 0)
+        return dep.slice(0, star);
+    const dot = dep.indexOf('.');
+    if (dot >= 0)
+        return dep.slice(0, dot);
+    const bracket = dep.indexOf('[');
+    if (bracket >= 0)
+        return dep.slice(0, bracket);
+    return dep;
+}
+/** Precise patches only — no full-tree fallback. @returns {Promise[]} */
+function refreshBinding(inst, bindingId, dirtyTrie = null) {
+    const entry = inst.__vmzBindings && inst.__vmzBindings[bindingId];
+    const jobs = [];
+    if (!inst || inst.__vmzDestroyed || bindingId == null || !entry) {
+        return jobs;
+    }
+    const depKey = (entry.deps && entry.deps[0]) || null;
+    const trie = dirtyTrie || inst.__vmzDirtyTrie;
+    const allowIdx = itemIndicesAllowedForDeps(trie, entry.deps);
+    for (const fn of entry.patches) {
+        if (allowIdx && !patchMatchesDirtyIndex(fn, allowIdx))
+            continue;
+        try {
+            const ret = runPatch(fn, depKey, bindingId);
+            if (ret && typeof ret.then === 'function')
+                jobs.push(ret);
+        }
+        catch (err) {
+            console.error('vmz:dom patch', err);
+        }
+    }
+    return jobs;
+}
+/**
+ * For ListItem path-channel deps (`tags.*.label`), restrict to dirty indices.
+ * @param {Record<string, any>|null|undefined} trie
+ * @param {string[]|null|undefined} deps
+ * @returns {Set<string>|null} null = run all patches (replace / non-list deps)
+ */
+function itemIndicesAllowedForDeps(trie, deps) {
+    if (!trie || !deps || !deps.length)
+        return null;
+    let sawListChannel = false;
+    /** @type {Set<string>|null} */
+    let allow = null;
+    for (const dep of deps) {
+        const root = depRootField(dep);
+        if (!root)
+            continue;
+        const starPrefix = `${root}.*`;
+        const isListChannel = dep === starPrefix || dep.startsWith(`${starPrefix}.`) || (dep.startsWith(`${root}[`) && dep.includes(']'));
+        if (!isListChannel)
+            return null;
+        sawListChannel = true;
+        const node = trie[root];
+        if (!node)
+            continue;
+        if (node.replace || node.dirty)
+            return null; // whole list
+        if (!node.children)
+            continue;
+        if (!allow)
+            allow = new Set();
+        for (const idx of Object.keys(node.children)) {
+            const child = node.children[idx];
+            if (!child)
+                continue;
+            if (child.replace || child.dirty || trieHasAnyDirty(child)) {
+                allow.add(String(idx));
+            }
+        }
+    }
+    if (!sawListChannel)
+        return null;
+    return allow && allow.size ? allow : null;
+}
+function patchMatchesDirtyIndex(fn, allowIdx) {
+    const idx = fn && fn.__vmzItemIndex;
+    if (idx == null || idx === '')
+        return true;
+    return allowIdx.has(String(idx));
+}
+/** Legacy string-key patches (hand blueprints without BindingId). @returns {Promise[]} */
+function refreshField(inst, field) {
+    const binders = inst.__vmzBinders;
+    const jobs = [];
+    if (!inst || inst.__vmzDestroyed || !field || !binders || !binders[field]) {
+        return jobs;
+    }
+    for (const fn of binders[field]) {
+        try {
+            const ret = runPatch(fn, field, null);
+            if (ret && typeof ret.then === 'function')
+                jobs.push(ret);
+        }
+        catch (err) {
+            console.error('vmz:dom patch', err);
+        }
+    }
+    return jobs;
+}
+/**
+ * @param {object} inst
+ * @param {number|string} bindingId
+ * @param {string[]} deps
+ */
+function reindexBindingDeps(inst, bindingId, deps) {
+    if (!inst.__vmzDepToBindings)
+        inst.__vmzDepToBindings = Object.create(null);
+    const entry = inst.__vmzBindings[bindingId];
+    if (!entry)
+        return;
+    for (const dep of entry.deps || []) {
+        const list = inst.__vmzDepToBindings[dep];
+        if (!list)
+            continue;
+        const j = list.indexOf(bindingId);
+        if (j >= 0)
+            list.splice(j, 1);
+        if (list.length === 0)
+            delete inst.__vmzDepToBindings[dep];
+    }
+    entry.deps = [...(deps || [])];
+    for (const dep of entry.deps) {
+        if (!inst.__vmzDepToBindings[dep])
+            inst.__vmzDepToBindings[dep] = [];
+        if (!inst.__vmzDepToBindings[dep].includes(bindingId)) {
+            inst.__vmzDepToBindings[dep].push(bindingId);
+        }
+    }
+}
+/**
+ * @param {object} inst
+ * @param {string[]} deps
+ * @param { => any} fn
+ * @param {number|string|null|undefined} [bindingId]
+ */
+function registerBind(inst, deps, fn, bindingId = null) {
+    if (!inst.__vmzBinders)
+        inst.__vmzBinders = Object.create(null);
+    for (const dep of deps || []) {
+        if (!inst.__vmzBinders[dep])
+            inst.__vmzBinders[dep] = [];
+        inst.__vmzBinders[dep].push(fn);
+    }
+    if (bindingId == null)
+        return;
+    if (!inst.__vmzBindings)
+        inst.__vmzBindings = Object.create(null);
+    let entry = inst.__vmzBindings[bindingId];
+    if (!entry) {
+        entry = { id: bindingId, deps: [], patches: [] };
+        inst.__vmzBindings[bindingId] = entry;
+    }
+    if (!entry.patches.includes(fn))
+        entry.patches.push(fn);
+    reindexBindingDeps(inst, bindingId, deps || []);
+}
+/**
+ * @param {object} inst
+ * @param {string[]} deps
+ * @param { => any} fn
+ * @param {number|string|null|undefined} [bindingId]
+ */
+function unregisterBind(inst, deps, fn, bindingId = null) {
+    const binders = inst.__vmzBinders;
+    if (binders) {
+        for (const dep of deps || []) {
+            const list = binders[dep];
+            if (!list)
+                continue;
+            const i = list.indexOf(fn);
+            if (i >= 0)
+                list.splice(i, 1);
+            if (list.length === 0)
+                delete binders[dep];
+        }
+    }
+    if (bindingId == null || !inst.__vmzBindings)
+        return;
+    const entry = inst.__vmzBindings[bindingId];
+    if (!entry)
+        return;
+    const i = entry.patches.indexOf(fn);
+    if (i >= 0)
+        entry.patches.splice(i, 1);
+    if (entry.patches.length === 0) {
+        reindexBindingDeps(inst, bindingId, []);
+        delete inst.__vmzBindings[bindingId];
+    }
+}
+/**
+ * True when the container already has meaningful DOM (SSR / resume shell).
+ * @param {Element} el
+ */
+function hasMeaningfulChild(el) {
+    for (const n of el.childNodes) {
+        if (n.nodeType === 1)
+            return true;
+        if (n.nodeType === 3 && String(n.textContent).trim() !== '')
+            return true;
+    }
+    return false;
+}
+function patchHasBindingId(inst, fn) {
+    const bindings = inst && inst.__vmzBindings;
+    if (!bindings)
+        return false;
+    for (const id of Object.keys(bindings)) {
+        const patches = bindings[id].patches;
+        if (patches && patches.includes(fn))
+            return true;
+    }
+    return false;
+}
+/** Tag each-item patches with list index for ListItem path-channel filtering. */
+function tagItemPatches(patches, index) {
+    if (!patches)
+        return;
+    const idx = String(index);
+    for (const p of patches) {
+        if (typeof p === 'function')
+            p.__vmzItemIndex = idx;
+    }
+}
+function escapeHtml(s) {
+    return s.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
+}