@vidact/runtime 0.2.0-beta.0

package/dist/compiled/core.js

@@ -0,0 +1,3170 @@
+import { currentIntrinsicNamespace, withIntrinsicNamespace, } from '../dom/intrinsic.js';
+import { HydrationMismatch, beginHydration, borrowHydrationSlotRange, claimHydrationArrayRange, claimHydrationComponentMount, claimHydrationComponentRange, claimHydrationNode, claimHydrationSlotRange, claimHydrationSuspenseFallback, claimHydrationText, claimHydrationTextRange, hydrationRangeParent, hydrationRootMarkers, finishHydration, finishHydrationArrayRange, hydrationCursor, hydrationFragmentChildren, hydrationInsertionPoint, isHydrating, isHydrationMismatch, noteHydrationStructuralParent, withoutHydration, withHydrationComponentRange, withHydrationInsertion, withHydrationCursor, } from '../hydration-bridge.js';
+import { createIndexedList } from '../indexed-list.js';
+import { createKeyedList } from '../keyed-list.js';
+import { isRenderableProtocol, materializeRenderable } from '../renderable-protocol.js';
+import { scheduleDeferredTask, scheduleTask } from '../scheduler.js';
+import { intersectsSources, isEmptySources, unionSources } from '../source-mask.js';
+import { createStateSlot } from '../state-slot.js';
+import { isSuspension, subscribeResource, useAsync } from './async-resource.js';
+import { BINDING, COMPONENT_SPREAD_SOURCE as componentSpreadSourceSymbol, CONTEXT, STRUCTURAL, } from './types.js';
+import { hasInvalidChild } from './validation.js';
+export const COMPONENT_SPREAD_SOURCE = componentSpreadSourceSymbol;
+const MAX_FLUSH_PASSES = 100;
+export const DEV = typeof __VIDACT_DEV__ === 'undefined' || __VIDACT_DEV__;
+let retainedUiEnabled = typeof __VIDACT_RETAINED_UI__ !== 'undefined' && __VIDACT_RETAINED_UI__;
+let profilingEnabled = false;
+let activeOwnerCount = 0;
+let createdOwnerCount = 0;
+const noop = () => { };
+const wideSourceOperations = [isEmptySources, intersectsSources, unionSources];
+const narrowSourceOperations = [
+    (mask) => mask === 0,
+    (left, right) => (left & right) !== 0,
+    (left, right) => (left | right) >>> 0,
+];
+export function deferred(render) {
+    noteHydrationStructuralParent();
+    return [
+        STRUCTURAL,
+        (parent, before) => {
+            const hydrated = claimHydrationSlotRange(parent);
+            if (hydrated === undefined)
+                insertValue(parent, render(), before);
+            else
+                insertValue(parent, render(), hydrated[1]);
+        },
+        'slot',
+    ];
+}
+/** @internal */
+export function retainedActivity(modeInput, render) {
+    noteHydrationStructuralParent();
+    const context = activeContextFrame ?? activeOwner?.[2] ?? null;
+    const rootIdentity = activeOwner?.[3] ?? activeRootIdentity;
+    if (rootIdentity === null) {
+        throw new Error(DEV ? 'Activity must run during compiled root construction' : 'V033');
+    }
+    const parentErrorBoundary = activeOwner?.[4] ?? null;
+    const parentConnection = activeOwner?.[5] ?? null;
+    let mounted = false;
+    return [
+        STRUCTURAL,
+        (parent, before) => {
+            if (mounted)
+                throw new Error(DEV ? 'compiled Activity is already mounted' : 'V008');
+            mounted = true;
+            const lifetimeOwner = activeOwner;
+            if (lifetimeOwner === null) {
+                throw new Error(DEV ? 'Activity must mount inside an owned compiled root' : 'V033');
+            }
+            const readMode = () => validateActivityMode(isCompiledBinding(modeInput) ? modeInput[1]() : modeInput);
+            let currentMode = readMode();
+            const connection = createRetainedConnection(parentConnection, currentMode === 'visible');
+            const childOwner = createOwner(context, rootIdentity, parentErrorBoundary, connection);
+            const hydratedRange = claimHydrationSlotRange(parent);
+            const start = hydratedRange?.[0] ?? document.createComment(DEV ? 'vidact:activity' : '');
+            const end = hydratedRange?.[1] ?? document.createComment(DEV ? '/vidact:activity' : '');
+            if (hydratedRange === undefined) {
+                parent.insertBefore(start, before);
+                parent.insertBefore(end, before);
+            }
+            const currentParent = rangeParent(start, end, 'Activity boundary');
+            const hiddenDisplays = new Map();
+            const hiddenTexts = new Map();
+            const heldText = document.createDocumentFragment();
+            let restoreHydratedDisplays = hydratedRange !== undefined && currentMode === 'hidden';
+            const conceal = () => {
+                for (const node of nodesBetween(start, end)) {
+                    if (node instanceof Element && 'style' in node) {
+                        const styled = node;
+                        const previous = hiddenDisplays.get(node);
+                        const hydratedDisplay = restoreHydratedDisplays
+                            ? readServerHiddenDisplay(node)
+                            : undefined;
+                        if (previous === undefined && hydratedDisplay !== undefined) {
+                            hiddenDisplays.set(node, hydratedDisplay);
+                        }
+                        else if (previous === undefined ||
+                            styled.style.display !== 'none' ||
+                            styled.style.getPropertyPriority('display') !== 'important') {
+                            hiddenDisplays.set(node, [
+                                styled.style.display,
+                                styled.style.getPropertyPriority('display'),
+                            ]);
+                        }
+                        styled.style.setProperty('display', 'none', 'important');
+                    }
+                    else if (node instanceof Text && !hiddenTexts.has(node)) {
+                        const placeholder = document.createComment(DEV ? 'vidact:activity-text' : '');
+                        node.replaceWith(placeholder);
+                        heldText.append(node);
+                        hiddenTexts.set(node, placeholder);
+                    }
+                }
+                restoreHydratedDisplays = false;
+            };
+            const reveal = () => {
+                for (const [element, [display, priority]] of hiddenDisplays) {
+                    const styled = element;
+                    if (display === '')
+                        styled.style.removeProperty('display');
+                    else
+                        styled.style.setProperty('display', display, priority);
+                }
+                hiddenDisplays.clear();
+                for (const [text, placeholder] of hiddenTexts) {
+                    if (placeholder.parentNode !== null)
+                        placeholder.replaceWith(text);
+                }
+                hiddenTexts.clear();
+            };
+            const setMode = (nextMode) => {
+                if (nextMode === currentMode)
+                    return;
+                currentMode = nextMode;
+                if (nextMode === 'hidden') {
+                    connection.visible = false;
+                    updateRetainedConnection(connection);
+                    conceal();
+                }
+                else {
+                    reveal();
+                    connection.visible = true;
+                    updateRetainedConnection(connection);
+                    concealDisconnectedDescendants(connection);
+                }
+            };
+            connection.afterFlush.add(conceal);
+            let stagedNodes = [];
+            try {
+                const [fragment, nodes] = hydratedRange === undefined
+                    ? stageRender(render, childOwner)
+                    : withHydrationInsertion(currentParent, end, () => stageRender(render, childOwner));
+                stagedNodes = nodes;
+                currentParent.insertBefore(fragment, end);
+                if (currentMode === 'hidden')
+                    conceal();
+                commitPublishedNodes(nodes);
+            }
+            catch (error) {
+                disposePublished(childOwner, stagedNodes);
+                disposeRetainedConnection(connection);
+                throw error;
+            }
+            const removeModeUpdater = isCompiledBinding(modeInput)
+                ? subscribeBinding(modeInput, () => setMode(readMode()))
+                : noop;
+            onCleanup(() => {
+                removeModeUpdater();
+                reveal();
+                try {
+                    disposeRange(childOwner, start, end);
+                }
+                finally {
+                    disposeRetainedConnection(connection);
+                    start.remove();
+                    end.remove();
+                }
+            });
+        },
+        'slot',
+    ];
+}
+/** @internal */
+export function enableRetainedUi() {
+    retainedUiEnabled = true;
+}
+/** @internal */
+export function enableProfiling() {
+    profilingEnabled = DEV;
+}
+/** @internal */
+export function profiled(idInput, onRenderInput, render) {
+    if (!DEV)
+        return deferred(render);
+    noteHydrationStructuralParent();
+    const context = activeContextFrame ?? activeOwner?.[2] ?? null;
+    const rootIdentity = activeOwner?.[3] ?? activeRootIdentity;
+    if (rootIdentity === null) {
+        throw new Error(DEV ? 'Profiler must run during compiled root construction' : 'V035');
+    }
+    const parentErrorBoundary = activeOwner?.[4] ?? null;
+    const parentConnection = activeOwner?.[5] ?? null;
+    const parentProfile = activeOwner?.[6] ?? null;
+    let mounted = false;
+    return [
+        STRUCTURAL,
+        (parent, before) => {
+            if (mounted)
+                throw new Error(DEV ? 'compiled Profiler is already mounted' : 'V008');
+            mounted = true;
+            const readId = () => {
+                const id = isCompiledBinding(idInput) ? idInput[1]() : idInput;
+                if (typeof id !== 'string')
+                    throw new TypeError('Profiler id must be a string');
+                return id;
+            };
+            const readOnRender = () => {
+                const onRender = isCompiledBinding(onRenderInput) ? onRenderInput[1]() : onRenderInput;
+                if (typeof onRender !== 'function') {
+                    throw new TypeError('Profiler onRender must be a function');
+                }
+                return onRender;
+            };
+            const boundary = {
+                parent: parentProfile?.boundary ?? null,
+                id: readId(),
+                onRender: readOnRender(),
+                baseDuration: 0,
+                mounted: false,
+                pendingDuration: 0,
+                pendingStart: 0,
+                scheduled: false,
+            };
+            const childOwner = createOwner(context, rootIdentity, parentErrorBoundary, parentConnection, {
+                frame: parentProfile?.frame ?? null,
+                boundary,
+            });
+            const hydratedRange = claimHydrationSlotRange(parent);
+            const start = hydratedRange?.[0] ?? document.createComment(DEV ? 'vidact:profiler' : '');
+            const end = hydratedRange?.[1] ?? document.createComment(DEV ? '/vidact:profiler' : '');
+            if (hydratedRange === undefined) {
+                parent.insertBefore(start, before);
+                parent.insertBefore(end, before);
+            }
+            const currentParent = rangeParent(start, end, 'Profiler boundary');
+            let stagedNodes = [];
+            const started = profileNow();
+            try {
+                const [fragment, nodes] = hydratedRange === undefined
+                    ? stageRender(render, childOwner)
+                    : withHydrationInsertion(currentParent, end, () => stageRender(render, childOwner));
+                stagedNodes = nodes;
+                currentParent.insertBefore(fragment, end);
+                commitPublishedNodes(nodes);
+            }
+            catch (error) {
+                disposePublished(childOwner, stagedNodes);
+                throw error;
+            }
+            const finished = profileNow();
+            boundary.baseDuration = finished - started;
+            boundary.mounted = true;
+            emitProfileMeasure(childOwner, 'range', started, finished);
+            runOwnerTask(childOwner, () => boundary.onRender(boundary.id, 'mount', boundary.baseDuration, boundary.baseDuration, started, finished));
+            const removeIdUpdater = isCompiledBinding(idInput)
+                ? subscribeBinding(idInput, () => {
+                    boundary.id = readId();
+                })
+                : noop;
+            const removeCallbackUpdater = isCompiledBinding(onRenderInput)
+                ? subscribeBinding(onRenderInput, () => {
+                    boundary.onRender = readOnRender();
+                })
+                : noop;
+            onCleanup(() => {
+                removeCallbackUpdater();
+                removeIdUpdater();
+                disposeRange(childOwner, start, end);
+            });
+        },
+        'slot',
+    ];
+}
+/** @internal */
+export function recordCompiledDebugValue(valueInput, format) {
+    if (!profilingEnabled)
+        return;
+    const owner = activeConstructionOwner ?? activeOwner;
+    if (owner === null) {
+        throw new Error(DEV ? 'useDebugValue must run inside a compiled component' : 'V036');
+    }
+    const frame = ensureProfileContext(owner).frame;
+    if (frame === null) {
+        throw new Error(DEV ? 'useDebugValue must run inside a compiled component' : 'V036');
+    }
+    const read = () => {
+        const value = isCompiledBinding(valueInput) ? valueInput[1]() : valueInput;
+        return format === undefined ? value : format(value);
+    };
+    const index = frame.values.length;
+    frame.values.push(read());
+    if (isCompiledBinding(valueInput)) {
+        const remove = subscribeBinding(valueInput, () => {
+            frame.values[index] = read();
+        });
+        owner[1].add(remove);
+    }
+}
+/** @internal */
+export function captureCompiledOwnerStack() {
+    if (!profilingEnabled)
+        return null;
+    const owner = activeConstructionOwner ?? activeOwner;
+    let frame = owner === null ? null : ensureProfileContext(owner).frame;
+    if (frame === null)
+        return null;
+    const lines = [];
+    while (frame !== null) {
+        const values = frame.values.length === 0 ? '' : ` [${frame.values.map(String).join(', ')}]`;
+        lines.push(`\n    at ${frame.name}${values}`);
+        frame = frame.parent;
+    }
+    return lines.join('');
+}
+function validateActivityMode(mode) {
+    if (mode === 'visible' || mode === 'hidden')
+        return mode;
+    throw new TypeError(DEV ? 'Activity mode must be "visible" or "hidden"' : 'V034');
+}
+function readServerHiddenDisplay(element) {
+    const cssText = element.getAttribute('style');
+    const hiddenDeclaration = 'display:none!important';
+    if (cssText === null || !cssText.endsWith(hiddenDeclaration))
+        return undefined;
+    let authoredCssText = cssText.slice(0, -hiddenDeclaration.length);
+    if (authoredCssText.endsWith(';'))
+        authoredCssText = authoredCssText.slice(0, -1);
+    const style = document.createElement('div').style;
+    style.cssText = authoredCssText;
+    return [style.display, style.getPropertyPriority('display')];
+}
+export function errorBoundary(render, fallback, onError) {
+    noteHydrationStructuralParent();
+    const context = activeContextFrame ?? activeOwner?.[2] ?? null;
+    const rootIdentity = activeOwner?.[3] ?? activeRootIdentity;
+    if (rootIdentity === null) {
+        throw new Error(DEV ? 'errorBoundary must run during compiled root construction' : 'V028');
+    }
+    const parentBoundary = activeOwner?.[4] ?? null;
+    let mounted = false;
+    return [
+        STRUCTURAL,
+        (parent, before) => {
+            if (mounted)
+                throw new Error(DEV ? 'compiled error boundary is already mounted' : 'V008');
+            mounted = true;
+            const hydratedRange = claimHydrationSlotRange(parent);
+            const start = hydratedRange?.[0] ?? document.createComment(DEV ? 'vidact:error' : '');
+            const end = hydratedRange?.[1] ?? document.createComment(DEV ? '/vidact:error' : '');
+            if (hydratedRange === undefined) {
+                parent.insertBefore(start, before);
+                parent.insertBefore(end, before);
+            }
+            let currentOwner = null;
+            let currentNodes = [];
+            let failed = false;
+            const publish = (read, boundary) => {
+                const currentParent = rangeParent(start, end, 'error boundary');
+                const nextOwner = createOwner(context, rootIdentity, boundary);
+                const [fragment, nodes] = hydratedRange === undefined
+                    ? stageRender(read, nextOwner)
+                    : withHydrationInsertion(currentParent, end, () => stageRender(read, nextOwner));
+                try {
+                    currentParent.insertBefore(fragment, end);
+                    commitPublishedNodes(nodes);
+                }
+                catch (error) {
+                    disposePublished(nextOwner, nodes);
+                    throw error;
+                }
+                const previousOwner = currentOwner;
+                const previousNodes = currentNodes;
+                currentOwner = nextOwner;
+                currentNodes = nodes;
+                disposePublished(previousOwner, previousNodes);
+            };
+            const reset = () => {
+                if (!failed)
+                    return;
+                try {
+                    failed = false;
+                    publish(render, boundary);
+                }
+                catch (error) {
+                    recover(error);
+                }
+            };
+            const recover = (error) => {
+                failed = true;
+                publish(() => fallback(error, reset), parentBoundary);
+                onError?.(error);
+                rootIdentity.onCaughtError?.(error);
+            };
+            const boundary = { handle: recover, parent: parentBoundary };
+            try {
+                publish(render, boundary);
+            }
+            catch (error) {
+                recover(error);
+            }
+            onCleanup(() => {
+                try {
+                    disposePublished(currentOwner, currentNodes);
+                }
+                finally {
+                    start.remove();
+                    end.remove();
+                }
+            });
+        },
+        'slot',
+    ];
+}
+export function suspense(render, fallback) {
+    noteHydrationStructuralParent();
+    const context = activeContextFrame ?? activeOwner?.[2] ?? null;
+    const rootIdentity = activeOwner?.[3] ?? activeRootIdentity;
+    if (rootIdentity === null) {
+        throw new Error(DEV ? 'Suspense must run during compiled root construction' : 'V032');
+    }
+    const parentErrorBoundary = activeOwner?.[4] ?? null;
+    let mounted = false;
+    return [
+        STRUCTURAL,
+        (parent, before) => {
+            if (mounted)
+                throw new Error(DEV ? 'compiled Suspense boundary is already mounted' : 'V008');
+            mounted = true;
+            const lifetimeOwner = activeOwner;
+            if (lifetimeOwner === null) {
+                throw new Error(DEV ? 'Suspense must mount inside an owned compiled root' : 'V032');
+            }
+            const hydratedRange = claimHydrationSlotRange(parent);
+            const start = hydratedRange?.[0] ?? document.createComment(DEV ? 'vidact:suspense' : '');
+            const end = hydratedRange?.[1] ?? document.createComment(DEV ? '/vidact:suspense' : '');
+            if (hydratedRange === undefined) {
+                parent.insertBefore(start, before);
+                parent.insertBefore(end, before);
+            }
+            const pendingMarker = hydratedRange === undefined ? undefined : claimHydrationSuspenseFallback(parent);
+            let currentOwner = null;
+            let currentNodes = [];
+            let currentKind = null;
+            let removeResourceListener = noop;
+            let generation = 0;
+            let boundary;
+            const publish = (read, kind, detachedHydrationProbe = false) => {
+                const currentParent = rangeParent(start, end, 'Suspense boundary');
+                const nextOwner = createOwner(context, rootIdentity, kind === 'content' ? boundary : parentErrorBoundary);
+                const serverNodes = detachedHydrationProbe ? nodesBetween(start, end) : [];
+                const [fragment, nodes] = detachedHydrationProbe
+                    ? withoutHydration(() => stageRender(read, nextOwner))
+                    : hydratedRange === undefined || currentKind !== null
+                        ? stageRender(read, nextOwner)
+                        : withHydrationInsertion(currentParent, end, () => stageRender(read, nextOwner));
+                try {
+                    currentParent.insertBefore(fragment, end);
+                    commitPublishedNodes(nodes);
+                }
+                catch (error) {
+                    disposePublished(nextOwner, nodes);
+                    throw error;
+                }
+                const previousOwner = currentOwner;
+                const previousNodes = currentNodes;
+                currentOwner = nextOwner;
+                currentNodes = nodes;
+                currentKind = kind;
+                disposePublished(previousOwner, previousNodes);
+                for (const node of serverNodes)
+                    node.parentNode?.removeChild(node);
+            };
+            const beginAttempt = () => {
+                const attemptGeneration = ++generation;
+                removeResourceListener();
+                removeResourceListener = noop;
+                return attemptGeneration;
+            };
+            const suspend = (failure, attemptGeneration) => {
+                if (!isSuspension(failure))
+                    throw failure;
+                const retry = () => {
+                    if (lifetimeOwner[0] || attemptGeneration !== generation)
+                        return;
+                    runOwnerTask(lifetimeOwner, () => attempt(false));
+                };
+                removeResourceListener = subscribeResource(failure.resource, retry);
+                if (currentKind !== 'fallback') {
+                    try {
+                        publish(fallback, 'fallback');
+                        if (pendingMarker !== undefined) {
+                            currentNodes = [pendingMarker, ...currentNodes];
+                        }
+                    }
+                    catch (fallbackError) {
+                        removeResourceListener();
+                        removeResourceListener = noop;
+                        throw fallbackError;
+                    }
+                }
+            };
+            const attempt = (initial) => {
+                const attemptGeneration = beginAttempt();
+                try {
+                    publish(render, 'content', initial && pendingMarker !== undefined);
+                }
+                catch (error) {
+                    if (!isSuspension(error)) {
+                        if (initial || !routeOwnerError(lifetimeOwner, error))
+                            throw error;
+                        return;
+                    }
+                    suspend(error, attemptGeneration);
+                }
+            };
+            boundary = {
+                handle: (error) => suspend(error, beginAttempt()),
+                parent: parentErrorBoundary,
+            };
+            attempt(true);
+            onCleanup(() => {
+                generation += 1;
+                removeResourceListener();
+                try {
+                    disposePublished(currentOwner, currentNodes);
+                }
+                finally {
+                    start.remove();
+                    end.remove();
+                }
+            });
+        },
+        'slot',
+    ];
+}
+export function createPortal(children, container, _key) {
+    if (!(container instanceof Node) || typeof container.insertBefore !== 'function') {
+        throw new TypeError(DEV ? 'createPortal requires a DOM container' : 'V026');
+    }
+    const context = activeContextFrame ?? activeOwner?.[2] ?? null;
+    const rootIdentity = activeOwner?.[3] ?? activeRootIdentity;
+    if (rootIdentity === null) {
+        throw new Error(DEV ? 'createPortal must run during compiled root construction' : 'V027');
+    }
+    let mounted = false;
+    return [
+        STRUCTURAL,
+        (logicalParent, before) => {
+            if (mounted)
+                throw new Error(DEV ? 'compiled portal is already mounted' : 'V008');
+            mounted = true;
+            const logicalMarker = document.createComment(DEV ? 'vidact:portal' : '');
+            logicalParent.insertBefore(logicalMarker, before);
+            const start = document.createComment(DEV ? 'vidact:portal:start' : '');
+            const end = document.createComment(DEV ? 'vidact:portal:end' : '');
+            const fragment = document.createDocumentFragment();
+            fragment.append(start, end);
+            const portalOwner = withRootIdentity(rootIdentity, () => withContextFrame(context, createOwner));
+            try {
+                withOwner(portalOwner, () => insertValue(fragment, children, end));
+            }
+            catch (error) {
+                disposeOwner(portalOwner);
+                logicalMarker.remove();
+                throw error;
+            }
+            const rollback = () => {
+                removeBetween(start, end);
+                start.remove();
+                end.remove();
+            };
+            const publication = [
+                () => {
+                    container.insertBefore(fragment, null);
+                    try {
+                        commitRangeRefs(start, end);
+                    }
+                    catch (error) {
+                        rollback();
+                        throw error;
+                    }
+                },
+                rollback,
+            ];
+            if (rootIdentity.mounted) {
+                stagePublication([publication[0], publication[1], () => disposeOwner(portalOwner)]);
+            }
+            else {
+                let pending = pendingRootPortals.get(rootIdentity);
+                if (pending === undefined) {
+                    pending = new Set();
+                    pendingRootPortals.set(rootIdentity, pending);
+                }
+                pending.add(publication);
+            }
+            onCleanup(() => {
+                pendingRootPortals.get(rootIdentity)?.delete(publication);
+                try {
+                    disposeOwner(portalOwner);
+                }
+                finally {
+                    publication[1]();
+                    logicalMarker.remove();
+                }
+            });
+        },
+    ];
+}
+let activeOwner = null;
+let activeContextFrame = null;
+let activeRootIdentity = null;
+let nextClientRoot = 0;
+let activeScopeCollector = null;
+let activeConstructionOwner = null;
+let activeProfileName = null;
+let activeErrorOwner = null;
+let failedOwner = null;
+let transactionDepth = 0;
+let drainingFlushes = false;
+let activePublication = null;
+const scheduledFlushes = new Set();
+const scopeOwners = new WeakMap();
+const scopeNamespaces = new WeakMap();
+const componentRanges = new WeakMap();
+const pendingRefs = new WeakMap();
+const componentCommitOwners = new WeakMap();
+const pendingInsertionCommits = new WeakMap();
+const pendingOwnerCommits = new WeakMap();
+const pendingRootPortals = new WeakMap();
+export function createCompiledScope() {
+    return createScope(wideSourceOperations);
+}
+export function createNarrowCompiledScope() {
+    return createScope(narrowSourceOperations);
+}
+export function runCompiledTransaction(operation) {
+    transactionDepth += 1;
+    try {
+        return operation();
+    }
+    finally {
+        transactionDepth -= 1;
+        if (transactionDepth === 0)
+            drainFlushes();
+    }
+}
+function createScope(operations) {
+    const namespace = currentIntrinsicNamespace();
+    const owner = createOwner();
+    const updaters = [];
+    const freeUpdaterIndexes = [];
+    const addedDuringFlush = new Set();
+    let batchDepth = 0;
+    let flushing = false;
+    let pending = 0;
+    const flush = () => {
+        if (owner[0] || flushing)
+            return;
+        const operation = () => {
+            flushing = true;
+            try {
+                let pass = 0;
+                while (!operations[0](pending)) {
+                    pass += 1;
+                    if (pass > MAX_FLUSH_PASSES) {
+                        pending = 0;
+                        throw new Error(DEV ? 'Vidact compiled scope did not stabilize' : 'V001');
+                    }
+                    let active = pending;
+                    pending = 0;
+                    const updaterCount = updaters.length;
+                    for (let index = 0; index < updaterCount; index += 1) {
+                        const updater = updaters[index];
+                        if (updater === undefined ||
+                            addedDuringFlush.has(updater) ||
+                            !updater[3] ||
+                            !operations[1](active, updater[0])) {
+                            continue;
+                        }
+                        if (profilingEnabled) {
+                            measureProfileWork(owner, 'updater', () => updater[2](active));
+                        }
+                        else {
+                            updater[2](active);
+                        }
+                        if (updater[1] !== undefined)
+                            active = operations[2](active, updater[1]);
+                    }
+                    addedDuringFlush.clear();
+                }
+            }
+            finally {
+                addedDuringFlush.clear();
+                flushing = false;
+            }
+            if (retainedUiEnabled)
+                notifyRetainedFlush(owner[5] ?? null);
+        };
+        if (profilingEnabled)
+            measureProfileWork(owner, 'scheduler', operation, true);
+        else
+            operation();
+    };
+    const scope = [
+        (reads, run, writes) => {
+            if (owner[0]) {
+                throw new Error(DEV ? 'cannot add an updater to a disposed scope' : 'V002');
+            }
+            const errorOwner = activeOwner ?? owner;
+            const context = activeContextFrame ?? errorOwner[2];
+            const entry = [
+                reads,
+                writes,
+                (active) => {
+                    try {
+                        withOwner(errorOwner, () => withContextFrame(context, () => withScopeNamespace(scope, () => run(active))));
+                    }
+                    catch (error) {
+                        if (!routeOwnerError(errorOwner, error)) {
+                            failedOwner = errorOwner;
+                            throw error;
+                        }
+                    }
+                },
+                true,
+            ];
+            const reusableIndex = freeUpdaterIndexes.pop();
+            const index = reusableIndex ?? updaters.length;
+            updaters[index] = entry;
+            if (flushing)
+                addedDuringFlush.add(entry);
+            const remove = () => {
+                if (updaters[index] !== entry)
+                    return;
+                entry[3] = false;
+                updaters[index] = undefined;
+                freeUpdaterIndexes.push(index);
+            };
+            if (activeOwner !== null && activeOwner !== owner)
+                activeOwner[1].add(remove);
+            return remove;
+        },
+        (sources) => {
+            if (owner[0] || operations[0](sources))
+                return;
+            pending = operations[2](pending, sources);
+            if (batchDepth === 0) {
+                if (retainedUiEnabled)
+                    scheduleOwnerFlush(owner, flush);
+                else
+                    scheduleFlush(flush);
+            }
+        },
+        (operation) => {
+            batchDepth += 1;
+            transactionDepth += 1;
+            try {
+                return operation();
+            }
+            finally {
+                batchDepth -= 1;
+                if (batchDepth === 0 && !operations[0](pending)) {
+                    if (retainedUiEnabled)
+                        scheduleOwnerFlush(owner, flush);
+                    else
+                        scheduleFlush(flush);
+                }
+                transactionDepth -= 1;
+                if (transactionDepth === 0)
+                    drainFlushes();
+            }
+        },
+        () => {
+            if (owner[0])
+                return;
+            try {
+                disposeOwner(owner);
+            }
+            finally {
+                pending = 0;
+                for (const updater of updaters) {
+                    if (updater !== undefined)
+                        updater[3] = false;
+                }
+                updaters.length = 0;
+                freeUpdaterIndexes.length = 0;
+                addedDuringFlush.clear();
+            }
+        },
+    ];
+    scopeOwners.set(scope, owner);
+    scopeNamespaces.set(scope, namespace);
+    activeScopeCollector?.add(scope);
+    if (activeScopeCollector !== null)
+        activeConstructionOwner = owner;
+    return scope;
+}
+export function createCompiledState(scope, sourceMask, initialValue) {
+    const assertWritable = stateWriteGuard(scope);
+    const value = typeof initialValue === 'function' ? initialValue() : initialValue;
+    return createStateSlot(scope[1], sourceMask, value, assertWritable);
+}
+export function createCompiledReducer(scope, sourceMask, reducer, initialArg, initialize) {
+    const state = createStateSlot(scope[1], sourceMask, initialize === undefined ? initialArg : initialize(initialArg), stateWriteGuard(scope));
+    return {
+        get: state.get,
+        set: (action) => state.set((previous) => reducer(previous, action)),
+    };
+}
+export function createCompiledMemo(scope, reads, writes, evaluate, readDependencies) {
+    let currentDependencies = readDependencies();
+    const slot = createStateSlot(scope[1], writes, evaluate(), stateWriteGuard(scope));
+    const removeUpdater = scope[0](reads, () => {
+        const nextDependencies = readDependencies();
+        if (equalDependencies(nextDependencies, currentDependencies))
+            return;
+        slot.replace(evaluate());
+        currentDependencies = nextDependencies;
+    });
+    const owner = scopeOwners.get(scope);
+    if (owner === undefined) {
+        removeUpdater();
+        throw new Error(DEV ? 'createCompiledMemo received an unknown scope' : 'V003');
+    }
+    owner[1].add(removeUpdater);
+    return slot;
+}
+export function createContext(defaultValue) {
+    let context;
+    const provider = ((props) => provideContext(context, props.value, props.children));
+    context = provider;
+    context.Provider = provider;
+    Object.defineProperty(context, CONTEXT, { value: defaultValue });
+    return context;
+}
+/** @internal */
+export function runWithCompiledContext(context, value, operation) {
+    const parent = activeContextFrame ?? activeOwner?.[2] ?? null;
+    return withContextFrame({ context: context, input: value, parent }, operation);
+}
+export function createCompiledContext(scope, sourceMask, context) {
+    const input = contextInput(scope, context);
+    return createCompiledProp(scope, sourceMask, input);
+}
+export function createCompiledExternalStore(scope, sourceMask, storeSubscribe, getSnapshot, _getServerSnapshot) {
+    const owner = scopeOwners.get(scope);
+    if (owner === undefined) {
+        throw new Error(DEV ? 'createCompiledExternalStore received an unknown scope' : 'V003');
+    }
+    const slot = createStateSlot(scope[1], sourceMask, getSnapshot(), stateWriteGuard(scope));
+    if (!retainedUiEnabled) {
+        let active = true;
+        const checkSnapshot = () => {
+            if (!active)
+                return;
+            scope[2](() => slot.replace(getSnapshot()));
+        };
+        const unsubscribe = storeSubscribe(() => runOwnerTask(owner, checkSnapshot));
+        if (typeof unsubscribe !== 'function') {
+            active = false;
+            throw new TypeError(DEV ? 'external store subscribe must return an unsubscribe function' : 'V020');
+        }
+        try {
+            checkSnapshot();
+        }
+        catch (error) {
+            active = false;
+            unsubscribe();
+            throw error;
+        }
+        owner[1].add(() => {
+            active = false;
+            unsubscribe();
+        });
+        return slot;
+    }
+    let active = false;
+    let unsubscribe = noop;
+    const checkSnapshot = () => {
+        if (!active)
+            return;
+        scope[2](() => slot.replace(getSnapshot()));
+    };
+    const [activate, disposeResource] = createRetainedResource(owner, () => {
+        active = true;
+        try {
+            const remove = storeSubscribe(() => runOwnerTask(owner, checkSnapshot));
+            if (typeof remove !== 'function') {
+                throw new TypeError(DEV ? 'external store subscribe must return an unsubscribe function' : 'V020');
+            }
+            unsubscribe = remove;
+            checkSnapshot();
+        }
+        catch (error) {
+            active = false;
+            unsubscribe();
+            unsubscribe = noop;
+            throw error;
+        }
+    }, () => {
+        active = false;
+        unsubscribe();
+        unsubscribe = noop;
+    }, 0);
+    try {
+        activate();
+    }
+    catch (error) {
+        disposeResource();
+        throw error;
+    }
+    owner[1].add(() => {
+        disposeResource();
+    });
+    return slot;
+}
+export function createCompiledEffectEvent(scope, callback) {
+    const owner = scopeOwners.get(scope);
+    if (owner === undefined) {
+        throw new Error(DEV ? 'createCompiledEffectEvent received an unknown scope' : 'V003');
+    }
+    return (...arguments_) => {
+        if (owner[0])
+            throw new Error(DEV ? 'cannot call an effect event after disposal' : 'V022');
+        return callback(...arguments_);
+    };
+}
+export function createCompiledId(scope) {
+    const owner = scopeOwners.get(scope);
+    if (owner === undefined) {
+        throw new Error(DEV ? 'createCompiledId received an unknown scope' : 'V003');
+    }
+    const id = `:${owner[3].prefix}r${owner[3].nextId}:`;
+    owner[3].nextId += 1;
+    return id;
+}
+export function useContext(context) {
+    if (activeConstructionOwner === null) {
+        throw new Error(DEV ? 'useContext must run during compiled component construction' : 'V019');
+    }
+    const input = contextInputFromFrame(activeConstructionOwner[2], context);
+    return isCompiledBinding(input) ? input[1]() : input;
+}
+export function use(context) {
+    return useContext(context);
+}
+export function createCompiledAsync(scope, reads, writes, evaluate) {
+    const input = evaluate();
+    if (isCompiledContext(input))
+        return createCompiledContext(scope, writes, input);
+    const slot = createCompiledState(scope, writes, useAsync(input));
+    scope[0](reads, () => slot.replace(useAsync(evaluate())));
+    return slot;
+}
+export function Suspense(props) {
+    const render = Array.isArray(props.children) ? props.children[0] : props.children;
+    if (typeof render !== 'function' || typeof props.fallback !== 'function') {
+        throw new TypeError(DEV
+            ? `Suspense children and fallback must be compiler-generated render functions; received ${typeof render} and ${typeof props.fallback}`
+            : 'V031');
+    }
+    return suspense(render, props.fallback);
+}
+export function useSyncExternalStore(_subscribe, _getSnapshot, _getServerSnapshot) {
+    throw new Error(DEV ? 'useSyncExternalStore requires compiler lowering' : 'V021');
+}
+export function useEffectEvent(callback) {
+    return callback;
+}
+export function useId() {
+    if (activeConstructionOwner === null) {
+        throw new Error(DEV ? 'useId must run during compiled component construction' : 'V023');
+    }
+    const id = `:${activeConstructionOwner[3].prefix}r${activeConstructionOwner[3].nextId}:`;
+    activeConstructionOwner[3].nextId += 1;
+    return id;
+}
+export function useMemo(factory, _dependencies) {
+    return factory();
+}
+export function useCallback(callback, _dependencies) {
+    return callback;
+}
+export function createCompiledProp(scope, sourceMask, input, fallback) {
+    const assertWritable = stateWriteGuard(scope);
+    const upstream = isCompiledBinding(input) ? input : undefined;
+    const read = () => {
+        const value = upstream === undefined ? input : upstream[1]();
+        return value === undefined && fallback !== undefined ? fallback() : value;
+    };
+    const slot = createStateSlot(scope[1], sourceMask, read(), assertWritable);
+    if (upstream !== undefined) {
+        const remove = subscribeBinding(upstream, () => slot.replace(read()));
+        const owner = scopeOwners.get(scope);
+        if (owner === undefined) {
+            throw new Error(DEV ? 'createCompiledProp received an unknown scope' : 'V003');
+        }
+        owner[1].add(remove);
+    }
+    return slot;
+}
+export function createCompiledRestProp(scope, sourceMask, input, excludedNames) {
+    const excluded = new Set(excludedNames);
+    const entries = () => Object.entries(input).filter(([name]) => !excluded.has(name));
+    const read = () => Object.fromEntries(entries().map(([name, value]) => [name, isCompiledBinding(value) ? value[1]() : value]));
+    const slot = createStateSlot(scope[1], sourceMask, read(), stateWriteGuard(scope));
+    const componentSpreadSource = input[COMPONENT_SPREAD_SOURCE];
+    const upstreams = new Set(entries()
+        .map(([, value]) => value)
+        .filter(isCompiledBinding));
+    if (isCompiledBinding(componentSpreadSource))
+        upstreams.add(componentSpreadSource);
+    const removers = [...upstreams].map((upstream) => subscribeBinding(upstream, () => slot.replace(read())));
+    const owner = scopeOwners.get(scope);
+    if (owner === undefined) {
+        throw new Error(DEV ? 'createCompiledRestProp received an unknown scope' : 'V003');
+    }
+    owner[1].add(() => {
+        for (const remove of removers)
+            remove();
+    });
+    return slot;
+}
+function stateWriteGuard(scope) {
+    const owner = scopeOwners.get(scope);
+    if (owner === undefined) {
+        throw new Error(DEV ? 'compiled state received an unknown scope' : 'V003');
+    }
+    return () => {
+        if (owner[0])
+            throw new Error(DEV ? 'cannot update state after disposal' : 'V012');
+    };
+}
+export function binding(scope, reads, evaluate, additionalScope, additionalReads) {
+    return [BINDING, evaluate, scope, reads, additionalScope, additionalReads];
+}
+export function compiledEvent(scope, handler) {
+    const owner = scopeOwners.get(scope);
+    if (owner === undefined) {
+        throw new Error(DEV ? 'compiledEvent received an unknown scope' : 'V003');
+    }
+    const errorOwner = activeOwner ?? owner;
+    return (...arguments_) => runOwnerTask(errorOwner, () => withOwner(errorOwner, () => scope[2](() => handler(...arguments_))));
+}
+export function captureCompiledTask(scope) {
+    const owner = scope === undefined ? activeOwner : scopeOwners.get(scope);
+    if (owner === null || owner === undefined) {
+        throw new Error(DEV ? 'compiled task must be captured during owned construction' : 'V034');
+    }
+    return {
+        disposed: () => owner[0],
+        report: (error) => runOwnerTask(owner, () => {
+            throw error;
+        }),
+    };
+}
+export function when(scope, reads, condition, render, additionalScope, additionalReads) {
+    return structural(scope, (parent, before) => {
+        const [start, end, hydrated] = structuralRange(parent, before, 'when');
+        let branchOwner = null;
+        let mounted = false;
+        let hydrationPending = hydrated;
+        const update = () => {
+            const next = Boolean(condition());
+            if (hydrationPending && !next) {
+                claimHydrationText(parent, '');
+                hydrationPending = false;
+                return;
+            }
+            if (next === mounted)
+                return;
+            const currentParent = rangeParent(start, end, 'conditional block');
+            if (!next) {
+                const owner = branchOwner;
+                branchOwner = null;
+                mounted = false;
+                disposeRange(owner, start, end);
+                return;
+            }
+            const nextOwner = createOwner();
+            const [fragment, staged] = hydrationPending
+                ? withHydrationInsertion(currentParent, end, () => stageRender(render, nextOwner))
+                : stageRender(render, nextOwner);
+            hydrationPending = false;
+            currentParent.insertBefore(fragment, end);
+            commitPublishedNodes(staged);
+            branchOwner = nextOwner;
+            mounted = true;
+        };
+        const removeUpdater = subscribe(scope, reads, update, additionalScope, additionalReads);
+        try {
+            update();
+        }
+        catch (error) {
+            removeUpdater();
+            throw error;
+        }
+        onCleanup(() => {
+            removeUpdater();
+            try {
+                disposeRange(branchOwner, start, end);
+            }
+            finally {
+                start.remove();
+                end.remove();
+            }
+        });
+    }, 'slot');
+}
+export function choose(scope, reads, mode, select, consequent, alternate, additionalScope, additionalReads) {
+    return structural(scope, (parent, before) => {
+        const [start, end, hydrated] = structuralRange(parent, before, 'choice');
+        let selected = -1;
+        let branchOwner = null;
+        let branchNodes = [];
+        const update = () => {
+            const value = select();
+            const next = mode === 'not-nullish' ? (value === null || value === undefined ? 1 : 0) : value ? 0 : 1;
+            if (next === selected)
+                return;
+            const currentParent = rangeParent(start, end, 'choice block');
+            const nextOwner = createOwner();
+            const [fragment, nodes] = hydrated && selected === -1
+                ? withHydrationInsertion(currentParent, end, () => stageRender(next === 0 ? consequent : alternate, nextOwner))
+                : stageRender(next === 0 ? consequent : alternate, nextOwner);
+            currentParent.insertBefore(fragment, end);
+            try {
+                commitPublishedNodes(nodes);
+            }
+            catch (error) {
+                disposePublished(nextOwner, nodes);
+                throw error;
+            }
+            const previousOwner = branchOwner;
+            const previousNodes = branchNodes;
+            branchOwner = nextOwner;
+            branchNodes = nodes;
+            selected = next;
+            disposePublished(previousOwner, previousNodes);
+        };
+        const removeUpdater = subscribe(scope, reads, update, additionalScope, additionalReads);
+        try {
+            update();
+        }
+        catch (error) {
+            removeUpdater();
+            throw error;
+        }
+        onCleanup(() => {
+            removeUpdater();
+            try {
+                disposePublished(branchOwner, branchNodes);
+            }
+            finally {
+                start.remove();
+                end.remove();
+            }
+        });
+    }, 'slot');
+}
+export function dispatch(scope, reads, type, key, render, additionalScope, additionalReads) {
+    return structural(scope, (parent, before) => {
+        const [start, end, hydrated] = structuralRange(parent, before, 'dispatch');
+        const unset = Symbol('Vidact.UnsetIdentity');
+        let currentType = unset;
+        let currentKey = unset;
+        let currentOwner = null;
+        let currentNodes = [];
+        const update = () => {
+            const nextType = type();
+            const nextKey = key();
+            if (currentType !== unset &&
+                Object.is(nextType, currentType) &&
+                Object.is(nextKey, currentKey)) {
+                return;
+            }
+            const currentParent = rangeParent(start, end, 'dispatch block');
+            const nextOwner = createOwner();
+            const [fragment, nodes] = hydrated && currentType === unset
+                ? withHydrationInsertion(currentParent, end, () => stageRender(render, nextOwner))
+                : stageRender(render, nextOwner);
+            currentParent.insertBefore(fragment, end);
+            try {
+                commitPublishedNodes(nodes);
+            }
+            catch (error) {
+                disposePublished(nextOwner, nodes);
+                throw error;
+            }
+            const previousOwner = currentOwner;
+            const previousNodes = currentNodes;
+            currentType = nextType;
+            currentKey = nextKey;
+            currentOwner = nextOwner;
+            currentNodes = nodes;
+            disposePublished(previousOwner, previousNodes);
+        };
+        const removeUpdater = subscribe(scope, reads, update, additionalScope, additionalReads);
+        try {
+            update();
+        }
+        catch (error) {
+            removeUpdater();
+            throw error;
+        }
+        onCleanup(() => {
+            removeUpdater();
+            try {
+                disposePublished(currentOwner, currentNodes);
+            }
+            finally {
+                start.remove();
+                end.remove();
+            }
+        });
+    }, 'slot');
+}
+export function keyed(scope, reads, values, key, render, additionalScope, additionalReads) {
+    return structural(scope, (parent, before) => {
+        const itemSource = 1;
+        const indexSource = 2;
+        const list = createKeyedList(parent, {
+            key,
+            render(value, index) {
+                const owner = createOwner();
+                const itemScope = createNarrowCompiledScope();
+                const valueSlot = createCompiledState(itemScope, itemSource, value);
+                const indexSlot = createCompiledState(itemScope, indexSource, index);
+                try {
+                    const nodes = withOwner(owner, () => {
+                        onCleanup(itemScope[3]);
+                        return materialize(render(valueSlot, indexSlot, itemScope));
+                    });
+                    return [
+                        nodes,
+                        (nextValue, nextIndex) => {
+                            itemScope[2](() => {
+                                valueSlot.set(nextValue);
+                                indexSlot.set(nextIndex);
+                            });
+                        },
+                        () => disposeOwner(owner),
+                    ];
+                }
+                catch (error) {
+                    disposeOwner(owner);
+                    throw error;
+                }
+            },
+        }, before);
+        const update = () => {
+            try {
+                commitPublishedNodes(list.update(values()));
+            }
+            catch (error) {
+                const currentParent = list.parent();
+                if (currentParent !== null)
+                    commitPendingRefs(currentParent);
+                throw error;
+            }
+        };
+        update();
+        const removeUpdater = subscribe(scope, reads, update, additionalScope, additionalReads);
+        onCleanup(() => {
+            removeUpdater();
+            list.dispose();
+        });
+    }, 'array');
+}
+export function indexed(scope, reads, values, render, additionalScope, additionalReads) {
+    return structural(scope, (parent, before) => {
+        const itemSource = 1;
+        const indexSource = 2;
+        const list = createIndexedList(parent, {
+            render(value, index) {
+                const owner = createOwner();
+                const itemScope = createNarrowCompiledScope();
+                const valueSlot = createCompiledState(itemScope, itemSource, value);
+                const indexSlot = createCompiledState(itemScope, indexSource, index);
+                try {
+                    const nodes = withOwner(owner, () => {
+                        onCleanup(itemScope[3]);
+                        return materialize(render(valueSlot, indexSlot, itemScope));
+                    });
+                    return [
+                        nodes,
+                        (nextValue, nextIndex) => {
+                            itemScope[2](() => {
+                                valueSlot.set(nextValue);
+                                indexSlot.set(nextIndex);
+                            });
+                        },
+                        () => disposeOwner(owner),
+                    ];
+                }
+                catch (error) {
+                    disposeOwner(owner);
+                    throw error;
+                }
+            },
+        }, before);
+        const update = () => {
+            try {
+                commitPublishedNodes(list.update(values()));
+            }
+            catch (error) {
+                const currentParent = list.parent();
+                if (currentParent !== null)
+                    commitPendingRefs(currentParent);
+                throw error;
+            }
+        };
+        update();
+        const removeUpdater = subscribe(scope, reads, update, additionalScope, additionalReads);
+        onCleanup(() => {
+            removeUpdater();
+            list.dispose();
+        });
+    }, 'array');
+}
+export function compiledRoot(scope, render) {
+    const owner = scopeOwners.get(scope);
+    if (owner === undefined) {
+        throw new Error(DEV ? 'compiledRoot received an unknown scope' : 'V004');
+    }
+    const hydratedRange = claimHydrationComponentRange();
+    const start = hydratedRange?.[0] ?? document.createComment(DEV ? 'vidact:component' : '');
+    const end = hydratedRange?.[1] ?? document.createComment(DEV ? '/vidact:component' : '');
+    componentCommitOwners.set(end, owner);
+    const fragment = document.createDocumentFragment();
+    if (hydratedRange === undefined)
+        fragment.append(start, end);
+    owner[1].add(() => {
+        try {
+            removeBetween(start, end);
+        }
+        finally {
+            start.remove();
+            end.remove();
+        }
+    });
+    try {
+        const renderParent = hydrationRangeParent(start, end) ?? fragment;
+        const insertRender = () => withOwner(owner, () => withScopeNamespace(scope, () => insertValue(renderParent, render(), end)));
+        const insert = () => {
+            if (hydratedRange === undefined)
+                insertRender();
+            else
+                withHydrationComponentRange(hydratedRange, () => withHydrationCursor(renderParent, start.nextSibling, insertRender));
+        };
+        if (profilingEnabled)
+            measureProfileWork(owner, 'range', insert);
+        else
+            insert();
+    }
+    catch (error) {
+        try {
+            scope[3]();
+        }
+        catch {
+            // Preserve the render error that made this component unmountable.
+        }
+        throw error;
+    }
+    let mounted = false;
+    const component = [
+        STRUCTURAL,
+        (parent, before) => {
+            if (mounted)
+                throw new Error(DEV ? 'compiled component is already mounted' : 'V005');
+            mounted = true;
+            adoptCompiledRoot(component);
+            try {
+                if (!claimHydrationComponentMount(parent, start, end)) {
+                    parent.insertBefore(fragment, before);
+                }
+            }
+            catch (error) {
+                try {
+                    scope[3]();
+                }
+                catch {
+                    // Preserve the insertion error that made this component unmountable.
+                }
+                throw error;
+            }
+        },
+    ];
+    componentRanges.set(component, [start, end, scope]);
+    return component;
+}
+export function adoptCompiledRoot(root) {
+    if (!isCompiledComponentResult(root))
+        return;
+    const range = componentRanges.get(root);
+    if (range === undefined)
+        return;
+    const owner = scopeOwners.get(range[2]);
+    if (activeOwner !== null && owner !== undefined && activeOwner !== owner) {
+        activeOwner[1].add(range[2][3]);
+    }
+}
+export function constructCompiledComponent(component, componentType) {
+    const previousCollector = activeScopeCollector;
+    const previousConstructionOwner = activeConstructionOwner;
+    const previousProfileName = activeProfileName;
+    const scopes = new Set();
+    activeScopeCollector = scopes;
+    activeConstructionOwner = null;
+    const profileType = componentType;
+    if (DEV)
+        activeProfileName = profileType?.displayName ?? profileType?.name ?? 'Anonymous';
+    try {
+        return component();
+    }
+    catch (error) {
+        // oxlint-disable-next-line unicorn/no-array-reverse - scopes is already copied to avoid mutation during iteration
+        for (const scope of [...scopes].reverse()) {
+            try {
+                scope[3]();
+            }
+            catch {
+                // Preserve the construction error that made this component unmountable.
+            }
+        }
+        throw error;
+    }
+    finally {
+        activeScopeCollector = previousCollector;
+        activeConstructionOwner = previousConstructionOwner;
+        if (DEV)
+            activeProfileName = previousProfileName;
+    }
+}
+export function queueElementRef(element, value) {
+    if (!isRefValue(value)) {
+        throw new TypeError(DEV ? 'ref must be a callback or an object with current' : 'V006');
+    }
+    pendingRefs.set(element, [activeOwner, value]);
+}
+export function useImperativeHandle(ref, create, dependencies) {
+    const owner = activeConstructionOwner;
+    if (owner === null) {
+        throw new Error(DEV ? 'useImperativeHandle must run during compiled component construction' : 'V013');
+    }
+    if (!isRefValue(ref)) {
+        throw new TypeError(DEV ? 'imperative ref must be null, a callback, or an object with current' : 'V006');
+    }
+    if (dependencies !== undefined && dependencies.length !== 0) {
+        throw new Error(DEV ? 'reactive useImperativeHandle dependencies are not supported yet' : 'V014');
+    }
+    queueOwnerCommit(owner, () => owner[1].add(attachRef(ref, create())));
+}
+export function useLayoutEffect(create, dependencies) {
+    registerEffect(create, dependencies, false);
+}
+export function useInsertionEffect(create, dependencies) {
+    const owner = activeConstructionOwner;
+    if (owner === null) {
+        throw new Error(DEV ? 'insertion effects must run during compiled component construction' : 'V016');
+    }
+    if (dependencies !== undefined && dependencies.length !== 0) {
+        throw new Error(DEV ? 'reactive insertion effect dependencies require compiler lowering' : 'V017');
+    }
+    const lifetimeOwner = activeOwner ?? owner;
+    if (!retainedUiEnabled) {
+        let cleanup = noop;
+        queueInsertionCommit(owner, () => {
+            if (lifetimeOwner[0])
+                return;
+            cleanup();
+            cleanup = profilingEnabled
+                ? readProfiledEffectCleanup(owner, create)
+                : readEffectCleanup(create());
+        });
+        lifetimeOwner[1].add(() => cleanup());
+        return;
+    }
+    let cleanup = noop;
+    const [activate, disposeResource] = createRetainedResource(lifetimeOwner, () => {
+        stagePublication([
+            noop,
+            noop,
+            undefined,
+            () => {
+                cleanup = profilingEnabled
+                    ? readProfiledEffectCleanup(owner, create)
+                    : readEffectCleanup(create());
+            },
+            -20,
+        ]);
+    }, () => {
+        cleanup();
+        cleanup = noop;
+    });
+    queueInsertionCommit(owner, () => {
+        if (!lifetimeOwner[0])
+            activate();
+    });
+    lifetimeOwner[1].add(disposeResource);
+}
+export function useEffect(create, dependencies) {
+    registerEffect(create, dependencies, true);
+}
+function registerEffect(create, dependencies, passive) {
+    const owner = activeConstructionOwner;
+    if (owner === null) {
+        throw new Error(DEV ? 'effects must run during compiled component construction' : 'V016');
+    }
+    if (dependencies !== undefined && dependencies.length !== 0) {
+        throw new Error(DEV ? 'reactive effect dependencies require compiler lowering' : 'V017');
+    }
+    const lifetimeOwner = activeOwner ?? owner;
+    if (!retainedUiEnabled) {
+        let cleanup = noop;
+        let generation = 0;
+        const run = () => {
+            cleanup();
+            cleanup = profilingEnabled
+                ? readProfiledEffectCleanup(owner, create)
+                : readEffectCleanup(create());
+        };
+        queueOwnerCommit(owner, () => {
+            if (lifetimeOwner[0])
+                return;
+            if (passive) {
+                const scheduled = ++generation;
+                (DEV ? scheduleTask : queueMicrotask)(() => {
+                    if (!lifetimeOwner[0] && scheduled === generation)
+                        runOwnerTask(lifetimeOwner, run);
+                });
+            }
+            else {
+                run();
+            }
+        });
+        lifetimeOwner[1].add(() => {
+            generation += 1;
+            if (passive)
+                (DEV ? scheduleTask : queueMicrotask)(() => runOwnerTask(lifetimeOwner, cleanup));
+            else
+                cleanup();
+        });
+        return;
+    }
+    let cleanup = noop;
+    let generation = 0;
+    const [activate, disposeResource] = createRetainedResource(lifetimeOwner, () => {
+        stagePublication([
+            noop,
+            noop,
+            undefined,
+            () => {
+                if (passive) {
+                    const scheduled = ++generation;
+                    (DEV ? scheduleTask : queueMicrotask)(() => {
+                        if (!lifetimeOwner[0] && scheduled === generation) {
+                            runOwnerTask(lifetimeOwner, () => {
+                                cleanup = profilingEnabled
+                                    ? readProfiledEffectCleanup(owner, create)
+                                    : readEffectCleanup(create());
+                            });
+                        }
+                    });
+                }
+                else {
+                    cleanup = profilingEnabled
+                        ? readProfiledEffectCleanup(owner, create)
+                        : readEffectCleanup(create());
+                }
+            },
+            passive ? 40 : 20,
+        ]);
+    }, () => {
+        generation += 1;
+        const previousCleanup = cleanup;
+        cleanup = noop;
+        if (passive)
+            (DEV ? scheduleTask : queueMicrotask)(() => runOwnerTask(lifetimeOwner, previousCleanup));
+        else
+            previousCleanup();
+    });
+    queueOwnerCommit(owner, () => {
+        if (!lifetimeOwner[0])
+            activate();
+    });
+    lifetimeOwner[1].add(disposeResource);
+}
+export function compiledLayoutEffect(scope, reads, readCreate, readDependencies) {
+    compiledEffect(scope, reads, readCreate, readDependencies, false);
+}
+export function compiledInsertionEffect(scope, reads, readCreate, readDependencies) {
+    const owner = activeConstructionOwner;
+    if (owner === null || scopeOwners.get(scope) !== owner) {
+        throw new Error(DEV ? 'compiled insertion effects must run in their component scope' : 'V016');
+    }
+    const lifetimeOwner = activeOwner ?? owner;
+    if (!retainedUiEnabled) {
+        let mounted = false;
+        let currentDependencies;
+        let cleanup = noop;
+        const run = () => {
+            const nextDependencies = readDependencies?.();
+            if (mounted &&
+                readDependencies !== undefined &&
+                equalDependencies(nextDependencies, currentDependencies)) {
+                return;
+            }
+            cleanup();
+            cleanup = profilingEnabled
+                ? readProfiledEffectCleanup(owner, () => readCreate()())
+                : readEffectCleanup(readCreate()());
+            currentDependencies = nextDependencies;
+            mounted = true;
+        };
+        queueInsertionCommit(owner, () => {
+            if (!lifetimeOwner[0])
+                run();
+        });
+        const removeUpdater = subscribe(scope, reads, () => stagePublication([noop, noop, undefined, run, -20]));
+        lifetimeOwner[1].add(() => {
+            removeUpdater();
+            cleanup();
+        });
+        return;
+    }
+    let mounted = false;
+    let connected = false;
+    let currentDependencies;
+    let cleanup = noop;
+    const run = () => {
+        const nextDependencies = readDependencies?.();
+        if (mounted &&
+            readDependencies !== undefined &&
+            equalDependencies(nextDependencies, currentDependencies)) {
+            return;
+        }
+        cleanup();
+        cleanup = profilingEnabled
+            ? readProfiledEffectCleanup(owner, () => readCreate()())
+            : readEffectCleanup(readCreate()());
+        currentDependencies = nextDependencies;
+        mounted = true;
+    };
+    const [activate, disposeResource] = createRetainedResource(lifetimeOwner, () => {
+        stagePublication([
+            noop,
+            noop,
+            undefined,
+            () => {
+                connected = true;
+                run();
+            },
+            -20,
+        ]);
+    }, () => {
+        connected = false;
+        cleanup();
+        cleanup = noop;
+        mounted = false;
+    });
+    queueInsertionCommit(owner, () => {
+        if (!lifetimeOwner[0])
+            activate();
+    });
+    const removeUpdater = subscribe(scope, reads, () => {
+        if (connected)
+            stagePublication([noop, noop, undefined, run, -20]);
+    });
+    lifetimeOwner[1].add(() => {
+        removeUpdater();
+        disposeResource();
+    });
+}
+export function compiledEffect(scope, reads, readCreate, readDependencies, passive = true) {
+    const owner = activeConstructionOwner;
+    if (owner === null || scopeOwners.get(scope) !== owner) {
+        throw new Error(DEV ? 'compiled effects must run in their component scope' : 'V016');
+    }
+    const lifetimeOwner = activeOwner ?? owner;
+    if (!retainedUiEnabled) {
+        let mounted = false;
+        let generation = 0;
+        let currentDependencies;
+        let cleanup = noop;
+        const run = () => {
+            const nextDependencies = readDependencies?.();
+            if (mounted &&
+                readDependencies !== undefined &&
+                equalDependencies(nextDependencies, currentDependencies)) {
+                return;
+            }
+            cleanup();
+            cleanup = profilingEnabled
+                ? readProfiledEffectCleanup(owner, () => readCreate()())
+                : readEffectCleanup(readCreate()());
+            currentDependencies = nextDependencies;
+            mounted = true;
+        };
+        const schedule = () => {
+            if (!passive) {
+                run();
+                return;
+            }
+            const scheduled = ++generation;
+            (DEV ? scheduleTask : queueMicrotask)(() => {
+                if (!lifetimeOwner[0] && scheduled === generation)
+                    runOwnerTask(lifetimeOwner, run);
+            });
+        };
+        queueOwnerCommit(owner, () => {
+            if (!lifetimeOwner[0])
+                schedule();
+        });
+        const removeUpdater = subscribe(scope, reads, () => {
+            if (passive)
+                schedule();
+            else
+                stagePublication([noop, noop, undefined, run, 20]);
+        });
+        lifetimeOwner[1].add(() => {
+            generation += 1;
+            removeUpdater();
+            if (passive)
+                (DEV ? scheduleTask : queueMicrotask)(() => runOwnerTask(lifetimeOwner, cleanup));
+            else
+                cleanup();
+        });
+        return;
+    }
+    let mounted = false;
+    let connected = false;
+    let generation = 0;
+    let currentDependencies;
+    let cleanup = noop;
+    const run = () => {
+        const nextDependencies = readDependencies?.();
+        if (mounted &&
+            readDependencies !== undefined &&
+            equalDependencies(nextDependencies, currentDependencies)) {
+            return;
+        }
+        cleanup();
+        cleanup = profilingEnabled
+            ? readProfiledEffectCleanup(owner, () => readCreate()())
+            : readEffectCleanup(readCreate()());
+        currentDependencies = nextDependencies;
+        mounted = true;
+    };
+    const schedule = () => {
+        if (!connected)
+            return;
+        if (!passive) {
+            run();
+            return;
+        }
+        const scheduled = ++generation;
+        (DEV ? scheduleTask : queueMicrotask)(() => {
+            if (!lifetimeOwner[0] && scheduled === generation)
+                runOwnerTask(lifetimeOwner, run);
+        });
+    };
+    const [activate, disposeResource] = createRetainedResource(lifetimeOwner, () => {
+        stagePublication([
+            noop,
+            noop,
+            undefined,
+            () => {
+                connected = true;
+                schedule();
+            },
+            passive ? 40 : 20,
+        ]);
+    }, () => {
+        connected = false;
+        generation += 1;
+        const previousCleanup = cleanup;
+        cleanup = noop;
+        mounted = false;
+        if (passive)
+            (DEV ? scheduleTask : queueMicrotask)(() => runOwnerTask(lifetimeOwner, previousCleanup));
+        else
+            previousCleanup();
+    });
+    queueOwnerCommit(owner, () => {
+        if (!lifetimeOwner[0])
+            activate();
+    });
+    const removeUpdater = subscribe(scope, reads, () => {
+        if (!connected)
+            return;
+        if (passive)
+            schedule();
+        else
+            stagePublication([noop, noop, undefined, run, 20]);
+    });
+    lifetimeOwner[1].add(() => {
+        removeUpdater();
+        disposeResource();
+    });
+}
+function readEffectCleanup(result) {
+    if (result === undefined)
+        return noop;
+    if (typeof result === 'function')
+        return result;
+    throw new TypeError(DEV ? 'an effect must return a cleanup function or undefined' : 'V018');
+}
+export function compiledImperativeHandle(scope, reads, readRef, create, readDependencies) {
+    const owner = activeConstructionOwner;
+    if (owner === null || scopeOwners.get(scope) !== owner) {
+        throw new Error(DEV ? 'compiledImperativeHandle must run in its compiled component scope' : 'V013');
+    }
+    let mounted = false;
+    let currentRef;
+    let currentHandle;
+    let currentDependencies;
+    // oxlint-disable-next-line unicorn/consistent-function-scoping -- This placeholder is replaced by the committed resource cleanup.
+    let cleanup = noop;
+    const commitInitial = () => {
+        currentRef = readImperativeRef(readRef());
+        currentDependencies = readDependencies?.();
+        currentHandle = create();
+        cleanup = attachRef(currentRef, currentHandle);
+        mounted = true;
+    };
+    queueOwnerCommit(owner, commitInitial);
+    const update = () => {
+        if (!mounted)
+            return;
+        const nextRef = readImperativeRef(readRef());
+        const nextDependencies = readDependencies?.();
+        if (Object.is(nextRef, currentRef) &&
+            readDependencies !== undefined &&
+            equalDependencies(nextDependencies, currentDependencies)) {
+            return;
+        }
+        const previousRef = currentRef;
+        const previousHandle = currentHandle;
+        const previousDependencies = currentDependencies;
+        const previousCleanup = cleanup;
+        let nextCleanup;
+        let finalized = false;
+        stagePublication([
+            noop,
+            () => {
+                if (!finalized)
+                    return;
+                nextCleanup?.();
+                cleanup = attachRef(previousRef, previousHandle);
+                currentRef = previousRef;
+                currentHandle = previousHandle;
+                currentDependencies = previousDependencies;
+                finalized = false;
+            },
+            undefined,
+            () => {
+                const nextHandle = create();
+                if (Object.is(nextRef, previousRef)) {
+                    try {
+                        previousCleanup();
+                    }
+                    catch (error) {
+                        try {
+                            cleanup = attachRef(previousRef, previousHandle);
+                        }
+                        catch {
+                            // Preserve the cleanup error that aborted publication.
+                        }
+                        throw error;
+                    }
+                    try {
+                        nextCleanup = attachRef(nextRef, nextHandle);
+                    }
+                    catch (error) {
+                        try {
+                            cleanup = attachRef(previousRef, previousHandle);
+                        }
+                        catch {
+                            // Preserve the next-ref attachment error.
+                        }
+                        throw error;
+                    }
+                }
+                else {
+                    nextCleanup = attachRef(nextRef, nextHandle);
+                    try {
+                        previousCleanup();
+                    }
+                    catch (error) {
+                        nextCleanup();
+                        try {
+                            cleanup = attachRef(previousRef, previousHandle);
+                        }
+                        catch {
+                            // Preserve the previous-ref cleanup error.
+                        }
+                        throw error;
+                    }
+                }
+                cleanup = nextCleanup;
+                currentRef = nextRef;
+                currentHandle = nextHandle;
+                currentDependencies = nextDependencies;
+                finalized = true;
+            },
+            10,
+        ]);
+    };
+    const removeUpdater = subscribe(scope, reads, update);
+    owner[1].add(() => {
+        removeUpdater();
+        cleanup();
+    });
+}
+function queueOwnerCommit(owner, commit) {
+    let commits = pendingOwnerCommits.get(owner);
+    if (commits === undefined) {
+        commits = new Set();
+        pendingOwnerCommits.set(owner, commits);
+    }
+    commits.add(commit);
+}
+function queueInsertionCommit(owner, commit) {
+    let commits = pendingInsertionCommits.get(owner);
+    if (commits === undefined) {
+        commits = new Set();
+        pendingInsertionCommits.set(owner, commits);
+    }
+    commits.add(commit);
+}
+function readImperativeRef(ref) {
+    if (!isRefValue(ref)) {
+        throw new TypeError(DEV ? 'imperative ref must be null, a callback, or an object with current' : 'V006');
+    }
+    return ref;
+}
+function equalDependencies(next, previous) {
+    if (next === undefined || previous === undefined || next.length !== previous.length)
+        return false;
+    return next.every((value, index) => Object.is(value, previous[index]));
+}
+export function mountCompiledRef(element, value) {
+    const initial = value[1]();
+    if (!isRefValue(initial)) {
+        throw new TypeError(DEV ? 'ref must be null, a callback, or an object with current' : 'V006');
+    }
+    let current = initial;
+    // oxlint-disable-next-line unicorn/consistent-function-scoping -- This placeholder is replaced when the ref attaches.
+    let cleanup = noop;
+    const pending = [activeOwner, current, (attached) => (cleanup = attached)];
+    pendingRefs.set(element, pending);
+    const removeUpdater = subscribeBinding(value, () => {
+        const next = value[1]();
+        if (Object.is(next, current))
+            return;
+        if (!isRefValue(next)) {
+            throw new TypeError(DEV ? 'ref must be null, a callback, or an object with current' : 'V006');
+        }
+        const previous = current;
+        let nextCleanup;
+        let committed = false;
+        stagePublication([
+            () => {
+                nextCleanup = attachRef(next, element);
+                cleanup();
+                cleanup = nextCleanup;
+                current = next;
+                committed = true;
+            },
+            () => {
+                if (!committed) {
+                    nextCleanup?.();
+                    return;
+                }
+                cleanup();
+                cleanup = attachRef(previous, element);
+                current = previous;
+                committed = false;
+            },
+        ]);
+    });
+    onCleanup(() => {
+        removeUpdater();
+        if (pendingRefs.get(element) === pending)
+            pendingRefs.delete(element);
+        cleanup();
+    });
+}
+export function registerCompiledCleanup(cleanup) {
+    onCleanup(cleanup);
+}
+export function hydrateCompiled(component, host, options) {
+    let endHydration;
+    let hydratedMount;
+    try {
+        endHydration = beginHydration(host);
+        hydratedMount = mountCompiled(component, host, options);
+        finishHydration();
+        const rootMarkers = hydrationRootMarkers();
+        return {
+            dispose: () => {
+                try {
+                    hydratedMount?.dispose();
+                }
+                finally {
+                    removeBetween(rootMarkers[0], rootMarkers[1]);
+                    rootMarkers[0].remove();
+                    rootMarkers[1].remove();
+                }
+            },
+        };
+    }
+    catch (error) {
+        if (!isHydrationMismatch(error))
+            throw error;
+        try {
+            hydratedMount?.dispose();
+        }
+        catch {
+            // Preserve and report the mismatch that forced recovery.
+        }
+        hydratedMount = undefined;
+        endHydration?.();
+        endHydration = undefined;
+        options?.onRecoverableError?.(error);
+        return mountCompiled(component, host, options);
+    }
+    finally {
+        endHydration?.();
+    }
+}
+export function mountCompiled(component, host, options) {
+    const hydrating = isHydrating();
+    const previousRootIdentity = activeRootIdentity;
+    const rootIdentity = createRootIdentity(options?.identifierPrefix, options?.onCaughtError, options?.onUncaughtError);
+    activeRootIdentity = rootIdentity;
+    let root;
+    try {
+        root = constructCompiledComponent(component);
+    }
+    catch (error) {
+        if (isHydrationMismatch(error))
+            throw error;
+        if (rootIdentity.onUncaughtError === undefined)
+            throw error;
+        rootIdentity.onUncaughtError(error);
+        return { dispose: noop };
+    }
+    finally {
+        activeRootIdentity = previousRootIdentity;
+    }
+    const range = componentRanges.get(root);
+    if (range === undefined) {
+        throw new Error(DEV ? 'mountCompiled received an unknown component result' : 'V007');
+    }
+    const previous = [...host.childNodes];
+    try {
+        root[1](host, previous[0] ?? null);
+        const rootOwner = scopeOwners.get(range[2]);
+        const mountedRootIdentity = rootOwner?.[3];
+        if (mountedRootIdentity !== undefined) {
+            mountedRootIdentity.mounted = true;
+            commitRootPortals(mountedRootIdentity);
+        }
+        commitOwnerInsertions(rootOwner);
+        commitRangeRefs(range[0], range[1]);
+        commitOwnerResources(rootOwner);
+        if (!hydrating) {
+            for (const node of previous)
+                host.removeChild(node);
+        }
+    }
+    catch (error) {
+        try {
+            range[2][3]();
+        }
+        catch {
+            // Preserve the mount error while still running every component cleanup.
+        }
+        if (isHydrationMismatch(error) || rootIdentity.onUncaughtError === undefined)
+            throw error;
+        rootIdentity.onUncaughtError(error);
+        return { dispose: noop };
+    }
+    return {
+        dispose: range[2][3],
+    };
+}
+export function isCompiledBinding(value) {
+    return Array.isArray(value) && value[0] === BINDING;
+}
+export function isStructuralBinding(value) {
+    return Array.isArray(value) && value[0] === STRUCTURAL;
+}
+export function isCompiledComponentResult(value) {
+    return isStructuralBinding(value) && componentRanges.has(value);
+}
+export function mountCompiledBinding(parent, value) {
+    mountCompiledBindingBefore(parent, value, null);
+}
+export function mountCompiledProp(value, apply) {
+    let current = value[1]();
+    let cleanup = apply(current);
+    const removeUpdater = subscribeBinding(value, () => {
+        const next = value[1]();
+        if (Object.is(next, current))
+            return;
+        const previous = current;
+        let nextCleanup;
+        let committedNext = false;
+        stagePublication([
+            () => {
+                try {
+                    nextCleanup = apply(next);
+                }
+                catch (error) {
+                    try {
+                        apply(previous);
+                    }
+                    catch {
+                        // Preserve the setter error that aborted publication.
+                    }
+                    throw error;
+                }
+                committedNext = true;
+                cleanup?.();
+                cleanup = nextCleanup;
+                current = next;
+            },
+            () => {
+                if (!committedNext)
+                    return;
+                nextCleanup?.();
+                cleanup = apply(previous);
+                current = previous;
+                committedNext = false;
+            },
+        ]);
+    });
+    onCleanup(() => {
+        removeUpdater();
+        cleanup?.();
+    });
+}
+export function mountCompiledPropTransition(value, initialize, prepare) {
+    let current = value[1]();
+    initialize(current);
+    const removeUpdater = subscribeBinding(value, () => {
+        const next = value[1]();
+        if (Object.is(next, current))
+            return;
+        const previous = current;
+        const transition = prepare(next, previous);
+        let attempted = false;
+        stagePublication([
+            () => {
+                attempted = true;
+                transition?.[0]();
+                current = next;
+            },
+            () => {
+                if (!attempted)
+                    return;
+                try {
+                    transition?.[1]();
+                }
+                finally {
+                    current = previous;
+                    attempted = false;
+                }
+            },
+            transition?.[2],
+            transition?.[3],
+            transition?.[4],
+        ]);
+    });
+    onCleanup(removeUpdater);
+}
+function structural(scope, mount, hydrationKind) {
+    if (hydrationKind !== undefined)
+        noteHydrationStructuralParent();
+    let mounted = false;
+    const owner = activeOwner ?? scopeOwners.get(scope);
+    const context = activeContextFrame ?? owner[2];
+    const mountOnce = (parent, before) => {
+        if (mounted)
+            throw new Error(DEV ? 'compiled block is already mounted' : 'V008');
+        mounted = true;
+        const operation = () => withOwner(owner, () => withContextFrame(context, () => withScopeNamespace(scope, () => mount(parent, before))));
+        if (profilingEnabled)
+            measureProfileWork(owner, 'range', operation);
+        else
+            operation();
+    };
+    return hydrationKind === undefined
+        ? [STRUCTURAL, mountOnce]
+        : [STRUCTURAL, mountOnce, hydrationKind];
+}
+function structuralRange(parent, before, label) {
+    const hydrated = claimHydrationSlotRange(parent);
+    if (hydrated !== undefined)
+        return [hydrated[0], hydrated[1], true];
+    const start = document.createComment(DEV ? `vidact:${label}` : '');
+    const end = document.createComment(DEV ? `/vidact:${label}` : '');
+    parent.insertBefore(start, before);
+    parent.insertBefore(end, before);
+    return [start, end, false];
+}
+function subscribe(scope, reads, run, additionalScope, additionalReads) {
+    const removers = [scope[0](reads, run)];
+    if (additionalScope !== undefined && additionalReads !== undefined) {
+        removers.push(additionalScope[0](additionalReads, () => withScopeNamespace(scope, run)));
+    }
+    return () => {
+        for (const remove of removers)
+            remove();
+    };
+}
+function subscribeBinding(compiledBinding, run) {
+    return subscribe(compiledBinding[2], compiledBinding[3], run, compiledBinding[4], compiledBinding[5]);
+}
+function withScopeNamespace(scope, operation) {
+    return withIntrinsicNamespace(scopeNamespaces.get(scope), operation);
+}
+function createOwner(context = activeContextFrame ?? activeOwner?.[2] ?? null, rootIdentity = activeOwner?.[3] ?? activeRootIdentity ?? createRootIdentity(), boundary = activeOwner?.[4] ?? null, retainedConnection = activeOwner?.[5] ?? null, profileContext = activeOwner?.[6] ?? activeConstructionOwner?.[6] ?? null) {
+    if (DEV) {
+        activeOwnerCount += 1;
+        createdOwnerCount += 1;
+    }
+    let nextProfile = profileContext;
+    if (profilingEnabled && activeProfileName !== null && activeConstructionOwner === null) {
+        nextProfile = {
+            frame: {
+                name: activeProfileName,
+                parent: profileContext?.frame ?? null,
+                values: [],
+            },
+            boundary: profileContext?.boundary ?? null,
+        };
+    }
+    if (profilingEnabled) {
+        const owner = [
+            false,
+            new Set(),
+            context,
+            rootIdentity,
+            boundary,
+            retainedUiEnabled ? retainedConnection : null,
+            nextProfile,
+        ];
+        if (DEV)
+            owner[7] = activeConstructionOwner?.[7] ?? activeProfileName;
+        return owner;
+    }
+    const owner = retainedUiEnabled
+        ? [false, new Set(), context, rootIdentity, boundary, retainedConnection]
+        : [false, new Set(), context, rootIdentity, boundary];
+    if (DEV)
+        owner[7] = activeConstructionOwner?.[7] ?? activeProfileName;
+    return owner;
+}
+function ensureProfileContext(owner) {
+    const current = owner[6];
+    if (current?.frame !== null && current?.frame !== undefined)
+        return current;
+    const parent = current ?? (activeOwner !== null && activeOwner !== owner ? (activeOwner[6] ?? null) : null);
+    const next = {
+        frame: {
+            name: owner[7] ?? activeProfileName ?? 'Anonymous',
+            parent: parent?.frame ?? null,
+            values: [],
+        },
+        boundary: parent?.boundary ?? null,
+    };
+    owner[6] = next;
+    return next;
+}
+function profileNow() {
+    return typeof performance === 'undefined' ? Date.now() : performance.now();
+}
+function measureProfileWork(owner, kind, operation, contribute = false) {
+    const started = profileNow();
+    try {
+        return operation();
+    }
+    finally {
+        const finished = profileNow();
+        emitProfileMeasure(owner, kind, started, finished);
+        if (contribute)
+            recordProfileCommit(owner, started, finished);
+    }
+}
+function emitProfileMeasure(owner, kind, started, finished) {
+    if (typeof performance === 'undefined' || typeof performance.measure !== 'function')
+        return;
+    const component = owner[6]?.frame?.name ?? 'Anonymous';
+    performance.measure(`vidact.${kind}:${component}`, { start: started, end: finished });
+}
+function recordProfileCommit(owner, started, finished) {
+    let boundary = owner[6]?.boundary ?? null;
+    while (boundary !== null) {
+        queueProfileBoundaryCommit(boundary, owner, started, finished);
+        boundary = boundary.parent;
+    }
+}
+function queueProfileBoundaryCommit(boundary, owner, started, finished) {
+    if (!boundary.mounted)
+        return;
+    boundary.pendingDuration += finished - started;
+    boundary.pendingStart =
+        boundary.pendingStart === 0 ? started : Math.min(boundary.pendingStart, started);
+    if (boundary.scheduled)
+        return;
+    boundary.scheduled = true;
+    stagePublication([
+        noop,
+        noop,
+        undefined,
+        () => {
+            const actualDuration = boundary.pendingDuration;
+            const startTime = boundary.pendingStart;
+            boundary.pendingDuration = 0;
+            boundary.pendingStart = 0;
+            boundary.scheduled = false;
+            boundary.onRender(boundary.id, 'update', actualDuration, boundary.baseDuration, startTime, profileNow());
+        },
+        100,
+        owner,
+    ]);
+}
+function readProfiledEffectCleanup(owner, evaluate) {
+    const cleanup = measureProfileWork(owner, 'effect', () => readEffectCleanup(evaluate()));
+    if (cleanup === noop)
+        return cleanup;
+    return () => measureProfileWork(owner, 'effect', cleanup);
+}
+function createRetainedConnection(parent, visible) {
+    const connection = {
+        parent,
+        children: new Set(),
+        resources: new Set(),
+        deferredFlushes: new Map(),
+        afterFlush: new Set(),
+        visible,
+        connected: visible && (parent?.connected ?? true),
+        disposed: false,
+    };
+    parent?.children.add(connection);
+    return connection;
+}
+function createRetainedResource(owner, connect, disconnect, phase = 1) {
+    const connection = owner[5];
+    const resource = {
+        owner,
+        connect,
+        disconnect,
+        active: false,
+        connected: false,
+        disposed: false,
+        phase,
+    };
+    connection?.resources.add(resource);
+    const activate = () => {
+        if (resource.disposed)
+            return;
+        resource.active = true;
+        reconcileRetainedResource(resource, connection?.connected ?? true);
+    };
+    const dispose = () => {
+        if (resource.disposed)
+            return;
+        resource.disposed = true;
+        resource.active = false;
+        connection?.resources.delete(resource);
+        reconcileRetainedResource(resource, false);
+    };
+    return [activate, dispose];
+}
+function reconcileRetainedResource(resource, connected) {
+    const nextConnected = !resource.disposed && resource.active && connected;
+    if (resource.connected === nextConnected)
+        return;
+    resource.connected = nextConnected;
+    try {
+        runOwnerTask(resource.owner, nextConnected ? resource.connect : resource.disconnect);
+    }
+    catch (error) {
+        resource.connected = false;
+        throw error;
+    }
+}
+function updateRetainedConnection(connection) {
+    if (connection.disposed)
+        return;
+    const nextConnected = connection.visible && (connection.parent?.connected ?? true);
+    if (connection.connected === nextConnected)
+        return;
+    connection.connected = nextConnected;
+    if (nextConnected) {
+        for (const [flush, cancel] of connection.deferredFlushes) {
+            cancel();
+            scheduleFlush(flush);
+        }
+        connection.deferredFlushes.clear();
+        for (const resource of [...connection.resources].toSorted((left, right) => left.phase - right.phase)) {
+            reconcileRetainedResource(resource, true);
+        }
+    }
+    else {
+        for (const resource of [...connection.resources].toReversed()) {
+            reconcileRetainedResource(resource, false);
+        }
+    }
+    for (const child of connection.children)
+        updateRetainedConnection(child);
+}
+function concealDisconnectedDescendants(connection) {
+    for (const child of connection.children) {
+        if (!child.connected) {
+            for (const conceal of child.afterFlush)
+                conceal();
+        }
+        concealDisconnectedDescendants(child);
+    }
+}
+function disposeRetainedConnection(connection) {
+    if (connection.disposed)
+        return;
+    connection.disposed = true;
+    connection.parent?.children.delete(connection);
+    for (const cancel of connection.deferredFlushes.values())
+        cancel();
+    connection.deferredFlushes.clear();
+    connection.afterFlush.clear();
+    for (const child of connection.children)
+        disposeRetainedConnection(child);
+    connection.children.clear();
+    for (const resource of [...connection.resources].toReversed()) {
+        resource.disposed = true;
+        resource.active = false;
+        reconcileRetainedResource(resource, false);
+    }
+    connection.resources.clear();
+}
+function notifyRetainedFlush(connection) {
+    for (let current = connection; current !== null; current = current.parent) {
+        if (!current.connected) {
+            for (const notify of current.afterFlush)
+                notify();
+        }
+    }
+}
+function createRootIdentity(identifierPrefix, onCaughtError, onUncaughtError) {
+    return {
+        mounted: false,
+        nextId: 0,
+        prefix: identifierPrefix ?? `v${nextClientRoot++}-`,
+        onCaughtError,
+        onUncaughtError,
+    };
+}
+function commitRootPortals(rootIdentity) {
+    const pending = pendingRootPortals.get(rootIdentity);
+    if (pending === undefined)
+        return;
+    pendingRootPortals.delete(rootIdentity);
+    const committed = [];
+    try {
+        for (const publication of pending) {
+            publication[0]();
+            committed.push(publication);
+        }
+    }
+    catch (error) {
+        for (const publication of committed.toReversed())
+            publication[1]();
+        throw error;
+    }
+}
+function provideContext(context, input, children) {
+    const parentContext = activeContextFrame ?? activeOwner?.[2] ?? null;
+    let mounted = false;
+    return [
+        STRUCTURAL,
+        (parent, before) => {
+            if (mounted)
+                throw new Error(DEV ? 'context provider is already mounted' : 'V008');
+            mounted = true;
+            withContextFrame({ context: context, input, parent: parentContext }, () => insertValue(parent, children, before));
+        },
+        'transparent',
+    ];
+}
+function contextInput(scope, context) {
+    const owner = scopeOwners.get(scope);
+    if (owner === undefined) {
+        throw new Error(DEV ? 'createCompiledContext received an unknown scope' : 'V003');
+    }
+    return contextInputFromFrame(owner[2], context);
+}
+function contextInputFromFrame(frame, context) {
+    if (typeof context !== 'function' || !(CONTEXT in context)) {
+        throw new TypeError(DEV ? 'useContext requires a context created by createContext' : 'V018');
+    }
+    for (let current = frame; current !== null; current = current.parent) {
+        if (current.context === context)
+            return current.input;
+    }
+    return context[CONTEXT];
+}
+function withOwner(owner, operation) {
+    const previous = activeOwner;
+    const previousContext = activeContextFrame;
+    const previousRootIdentity = activeRootIdentity;
+    const previousErrorOwner = activeErrorOwner;
+    activeOwner = owner;
+    activeContextFrame = owner[2];
+    activeRootIdentity = owner[3];
+    activeErrorOwner = owner;
+    try {
+        return operation();
+    }
+    finally {
+        activeOwner = previous;
+        activeContextFrame = previousContext;
+        activeRootIdentity = previousRootIdentity;
+        activeErrorOwner = previousErrorOwner;
+    }
+}
+function withContextFrame(frame, operation) {
+    const previous = activeContextFrame;
+    activeContextFrame = frame;
+    try {
+        return operation();
+    }
+    finally {
+        activeContextFrame = previous;
+    }
+}
+function withRootIdentity(rootIdentity, operation) {
+    const previous = activeRootIdentity;
+    activeRootIdentity = rootIdentity;
+    try {
+        return operation();
+    }
+    finally {
+        activeRootIdentity = previous;
+    }
+}
+function onCleanup(cleanup) {
+    activeOwner?.[1].add(cleanup);
+}
+function disposeOwner(owner) {
+    if (owner[0])
+        return;
+    owner[0] = true;
+    if (DEV)
+        activeOwnerCount -= 1;
+    pendingInsertionCommits.delete(owner);
+    pendingOwnerCommits.delete(owner);
+    const cleanups = [...owner[1]];
+    owner[1].clear();
+    let firstError;
+    let hasError = false;
+    for (let index = cleanups.length - 1; index >= 0; index -= 1) {
+        try {
+            cleanups[index]?.();
+        }
+        catch (error) {
+            if (!hasError)
+                firstError = error;
+            hasError = true;
+        }
+    }
+    if (hasError)
+        throw firstError;
+}
+/** @internal Test-only allocation and retention evidence. */
+export function readCompiledOwnerMetrics() {
+    return { active: activeOwnerCount, created: createdOwnerCount };
+}
+function mountCompiledBindingBefore(parent, value, before) {
+    const unset = Symbol(DEV ? 'Vidact.UnsetBinding' : undefined);
+    const initial = value[1]();
+    const scalarInitial = isScalarRenderValue(initial);
+    const hydratedTextRange = scalarInitial
+        ? claimHydrationTextRange(parent, toText(initial))
+        : undefined;
+    const borrowedHydrationRange = isHydrating() && !scalarInitial
+        ? borrowHydrationSlotRange(parent, isStructuralBinding(initial) && initial[2] === 'slot')
+        : undefined;
+    const hydratedStructuralRange = isHydrating() && !scalarInitial
+        ? (borrowedHydrationRange ?? claimHydrationSlotRange(parent))
+        : undefined;
+    const hydratedRange = hydratedTextRange ?? hydratedStructuralRange;
+    const start = hydratedRange?.[0] ?? document.createComment(DEV ? 'vidact:binding' : '');
+    const end = hydratedRange?.[1] ?? document.createComment(DEV ? '/vidact:binding' : '');
+    if (hydratedRange === undefined) {
+        parent.insertBefore(start, before);
+        parent.insertBefore(end, before);
+    }
+    let current = hydratedTextRange === undefined ? unset : initial;
+    let currentOwner = null;
+    let text = hydratedTextRange?.[2] ?? null;
+    const clear = () => {
+        const owner = currentOwner;
+        currentOwner = null;
+        text = null;
+        disposeRange(owner, start, end);
+    };
+    const update = () => {
+        const next = value[1]();
+        if (current !== unset && Object.is(next, current))
+            return;
+        const currentParent = rangeParent(start, end, 'binding range');
+        if (isScalarRenderValue(next)) {
+            const content = toText(next);
+            if (text !== null) {
+                const target = text;
+                const previousContent = target.data;
+                const previous = current;
+                stagePublication([
+                    () => {
+                        if (target.data !== content)
+                            target.data = content;
+                        current = next;
+                    },
+                    () => {
+                        if (target.data !== previousContent)
+                            target.data = previousContent;
+                        current = previous;
+                    },
+                ]);
+                return;
+            }
+            clear();
+            text = document.createTextNode(content);
+            currentParent.insertBefore(text, end);
+            current = next;
+            return;
+        }
+        const nextOwner = createOwner();
+        const [fragment, staged] = stageValue(next, nextOwner);
+        try {
+            clear();
+        }
+        catch (error) {
+            disposeOwner(nextOwner);
+            throw error;
+        }
+        currentOwner = nextOwner;
+        currentParent.insertBefore(fragment, end);
+        commitPublishedNodes(staged);
+        current = next;
+    };
+    if (hydratedStructuralRange !== undefined) {
+        const nextOwner = createOwner();
+        const [fragment, staged] = withHydrationInsertion(parent, end, () => stageRender(() => initial, nextOwner));
+        parent.insertBefore(fragment, end);
+        commitPublishedNodes(staged);
+        currentOwner = nextOwner;
+        current = initial;
+    }
+    else if (hydratedRange === undefined) {
+        update();
+    }
+    const removeUpdater = subscribeBinding(value, update);
+    onCleanup(() => {
+        removeUpdater();
+        clear();
+        if (borrowedHydrationRange === undefined) {
+            start.remove();
+            end.remove();
+        }
+    });
+}
+function materialize(value) {
+    const insertionPoint = hydrationInsertionPoint();
+    if (insertionPoint !== undefined) {
+        const [parent, before] = insertionPoint;
+        const first = hydrationCursor(parent);
+        if (first === undefined)
+            throw new Error('hydration insertion point requires active hydration');
+        insertValue(parent, value, before);
+        const after = hydrationCursor(parent);
+        const nodes = [];
+        for (let node = first; node !== null && node !== after; node = node.nextSibling) {
+            nodes.push(node);
+        }
+        return nodes;
+    }
+    const fragment = document.createDocumentFragment();
+    const moves = [];
+    try {
+        insertValue(fragment, value, null, moves);
+    }
+    catch (error) {
+        restoreNodePositions(moves);
+        throw error;
+    }
+    return [...fragment.childNodes];
+}
+function stageValue(value, owner) {
+    const insertionPoint = hydrationInsertionPoint();
+    if (insertionPoint !== undefined) {
+        const [parent, before] = insertionPoint;
+        const first = hydrationCursor(parent);
+        if (first === undefined)
+            throw new Error('hydration insertion point requires active hydration');
+        withOwner(owner, () => insertValue(parent, value, before));
+        const nodes = [];
+        for (let node = first; node !== null && node !== before; node = node.nextSibling) {
+            nodes.push(node);
+        }
+        return [document.createDocumentFragment(), nodes];
+    }
+    const fragment = document.createDocumentFragment();
+    const moves = [];
+    try {
+        withOwner(owner, () => insertValue(fragment, value, null, moves));
+    }
+    catch (error) {
+        restoreNodePositions(moves);
+        try {
+            disposeOwner(owner);
+        }
+        catch {
+            // Preserve the staging error; cleanup still ran every registered disposer.
+        }
+        throw error;
+    }
+    return [fragment, [...fragment.childNodes]];
+}
+function stageRender(render, owner) {
+    try {
+        return stageValue(withOwner(owner, render), owner);
+    }
+    catch (error) {
+        try {
+            disposeOwner(owner);
+        }
+        catch {
+            // Preserve the render or staging error after every registered cleanup ran.
+        }
+        throw error;
+    }
+}
+function insertValue(parent, value, before, moves) {
+    if (value === null || value === undefined || typeof value === 'boolean') {
+        claimHydrationText(parent, '');
+        return;
+    }
+    if (isStructuralBinding(value)) {
+        if (isHydrating() && !isCompiledComponentResult(value) && value[2] === undefined) {
+            throw new HydrationMismatch('structural binding hydration markers are not available');
+        }
+        adoptCompiledRoot(value);
+        value[1](parent, before);
+        return;
+    }
+    if (isCompiledBinding(value)) {
+        mountCompiledBindingBefore(parent, value, before);
+        return;
+    }
+    if (isRenderableProtocol(value)) {
+        insertValue(parent, materializeRenderable(value), before, moves);
+        return;
+    }
+    if (Array.isArray(value)) {
+        if (hasInvalidChild(value)) {
+            throw new TypeError(DEV ? 'unsupported compiled child value; expected a DOM node or owned block' : 'V009');
+        }
+        const hydratedRange = claimHydrationArrayRange(parent);
+        for (const item of value)
+            insertValue(parent, item, before, moves);
+        if (hydratedRange !== undefined)
+            finishHydrationArrayRange(parent, hydratedRange[1]);
+        return;
+    }
+    if (value instanceof DocumentFragment) {
+        const hydrationChildren = hydrationFragmentChildren(value);
+        if (hydrationChildren !== undefined) {
+            for (const child of hydrationChildren) {
+                insertValue(parent, child, before, moves);
+            }
+            return;
+        }
+        // oxlint-disable-next-line unicorn/no-useless-spread -- Snapshot the live NodeList before moving nodes.
+        for (const child of [...value.childNodes])
+            insertValue(parent, child, before, moves);
+        return;
+    }
+    if (value instanceof Node) {
+        moves?.push([value, value.parentNode, value.nextSibling]);
+        adoptCompiledRoot(value);
+        claimPendingRefOwners(value);
+        if (!claimHydrationNode(parent, value))
+            parent.insertBefore(value, before);
+        if (!(parent instanceof DocumentFragment))
+            commitPendingRefs(value);
+        return;
+    }
+    if (typeof value === 'object' || typeof value === 'function' || typeof value === 'symbol') {
+        throw new TypeError(DEV ? 'unsupported compiled child value; expected a DOM node or owned block' : 'V009');
+    }
+    const content = String(value);
+    if (claimHydrationText(parent, content) === undefined) {
+        parent.insertBefore(document.createTextNode(content), before);
+    }
+}
+function restoreNodePositions(positions) {
+    for (let index = positions.length - 1; index >= 0; index -= 1) {
+        const position = positions[index];
+        if (position === undefined)
+            continue;
+        if (position[1] === null) {
+            position[0].parentNode?.removeChild(position[0]);
+            continue;
+        }
+        const before = position[2]?.parentNode === position[1] ? position[2] : null;
+        position[1].insertBefore(position[0], before);
+    }
+}
+function removeBetween(start, end) {
+    let node = start.nextSibling;
+    while (node !== null && node !== end) {
+        const next = node.nextSibling;
+        node.parentNode?.removeChild(node);
+        node = next;
+    }
+}
+function nodesBetween(start, end) {
+    const nodes = [];
+    for (let node = start.nextSibling; node !== null && node !== end; node = node.nextSibling) {
+        nodes.push(node);
+    }
+    return nodes;
+}
+function rangeParent(start, end, description) {
+    const parent = end.parentNode;
+    if (parent === null || start.parentNode !== parent) {
+        throw new Error(DEV ? `cannot update a detached ${description}` : 'V010');
+    }
+    return parent;
+}
+function disposeRange(owner, start, end) {
+    try {
+        if (owner !== null)
+            disposeOwner(owner);
+    }
+    finally {
+        removeBetween(start, end);
+    }
+}
+function disposePublished(owner, nodes) {
+    try {
+        if (owner !== null)
+            disposeOwner(owner);
+    }
+    finally {
+        for (const node of nodes)
+            node.parentNode?.removeChild(node);
+    }
+}
+function toText(value) {
+    return value === null || value === undefined || typeof value === 'boolean' ? '' : String(value);
+}
+function isScalarRenderValue(value) {
+    return (value === null ||
+        value === undefined ||
+        typeof value === 'string' ||
+        typeof value === 'number' ||
+        typeof value === 'bigint' ||
+        typeof value === 'boolean');
+}
+function isRefValue(value) {
+    return (value === null ||
+        value === undefined ||
+        typeof value === 'function' ||
+        (typeof value === 'object' && value !== null && 'current' in value));
+}
+function claimPendingRefOwners(root) {
+    visitNodes(root, (node) => {
+        if (!(node instanceof Element))
+            return;
+        const pending = pendingRefs.get(node);
+        if (pending !== undefined && pending[0] === null)
+            pending[0] = activeOwner;
+    });
+}
+function commitPendingRefs(root) {
+    if (!isHydrating())
+        commitPublishedNodesNow([root]);
+}
+function commitPublishedNodes(nodes) {
+    if (isHydrating())
+        return;
+    commitPublishedNodesNow(nodes);
+}
+function commitPublishedNodesNow(nodes) {
+    const publicationRoot = nodes[0]?.getRootNode();
+    if (publicationRoot instanceof DocumentFragment && !(publicationRoot instanceof ShadowRoot)) {
+        return;
+    }
+    for (const node of nodes)
+        commitNodeInsertions(node);
+    for (const node of nodes)
+        commitNodeRefs(node);
+    for (const node of nodes)
+        commitNodeResources(node);
+}
+function commitNodeInsertions(root) {
+    visitNodes(root, (node) => {
+        if (node instanceof Comment)
+            commitOwnerInsertions(componentCommitOwners.get(node));
+    });
+}
+function commitNodeRefs(root) {
+    visitNodes(root, (node) => {
+        if (node instanceof Element) {
+            const pending = pendingRefs.get(node);
+            if (pending !== undefined) {
+                pendingRefs.delete(node);
+                const owner = pending[0] ?? activeOwner;
+                const cleanup = attachRef(pending[1], node);
+                if (pending[2] === undefined)
+                    owner?.[1].add(cleanup);
+                else
+                    pending[2](cleanup);
+            }
+        }
+    });
+}
+function commitNodeResources(root) {
+    visitNodes(root, (node) => {
+        if (node instanceof Comment)
+            commitOwnerResources(componentCommitOwners.get(node));
+    });
+}
+function commitOwnerInsertions(owner) {
+    if (owner === undefined || owner[0])
+        return;
+    const commits = pendingInsertionCommits.get(owner);
+    if (commits === undefined)
+        return;
+    pendingInsertionCommits.delete(owner);
+    for (const commit of commits)
+        commit();
+}
+function commitOwnerResources(owner) {
+    if (owner === undefined || owner[0])
+        return;
+    const commits = pendingOwnerCommits.get(owner);
+    if (commits === undefined)
+        return;
+    pendingOwnerCommits.delete(owner);
+    for (const commit of commits)
+        commit();
+}
+function commitRangeRefs(start, end) {
+    const nodes = [];
+    let node = start.nextSibling;
+    while (node !== null && node !== end) {
+        nodes.push(node);
+        node = node.nextSibling;
+    }
+    commitPublishedNodesNow(nodes);
+}
+function visitNodes(root, visit) {
+    visit(root);
+    for (const child of root.childNodes)
+        visitNodes(child, visit);
+}
+function attachRef(value, target) {
+    if (value === null || value === undefined)
+        return noop;
+    if (typeof value === 'function') {
+        const cleanup = value(target);
+        return typeof cleanup === 'function' ? cleanup : () => value(null);
+    }
+    value.current = target;
+    return () => {
+        if (value.current === target)
+            value.current = null;
+    };
+}
+function scheduleFlush(flush) {
+    scheduledFlushes.add(flush);
+    if (transactionDepth === 0)
+        drainFlushes();
+}
+function scheduleOwnerFlush(owner, flush) {
+    const connection = owner[5];
+    if (connection === null || connection === undefined || connection.connected) {
+        scheduleFlush(flush);
+        return;
+    }
+    if (connection.deferredFlushes.has(flush))
+        return;
+    const cancel = scheduleDeferredTask(() => {
+        connection.deferredFlushes.delete(flush);
+        scheduleFlush(flush);
+    });
+    connection.deferredFlushes.set(flush, cancel);
+}
+function drainFlushes() {
+    if (drainingFlushes || transactionDepth > 0)
+        return;
+    drainingFlushes = true;
+    const publication = [];
+    activePublication = publication;
+    const runs = new Map();
+    let committing = false;
+    let failure;
+    let failed = false;
+    try {
+        while (scheduledFlushes.size > 0) {
+            const flush = scheduledFlushes.values().next().value;
+            if (flush === undefined)
+                break;
+            scheduledFlushes.delete(flush);
+            const runCount = (runs.get(flush) ?? 0) + 1;
+            if (runCount > MAX_FLUSH_PASSES) {
+                scheduledFlushes.clear();
+                throw new Error(DEV ? 'Vidact compiled scopes did not stabilize' : 'V011');
+            }
+            runs.set(flush, runCount);
+            flush();
+        }
+        activePublication = null;
+        committing = true;
+        commitPublication(publication);
+    }
+    catch (error) {
+        activePublication = null;
+        if (!committing)
+            abortPublication(publication);
+        failure = error;
+        failed = true;
+    }
+    finally {
+        activePublication = null;
+        drainingFlushes = false;
+    }
+    if (failed) {
+        const owner = failedOwner;
+        failedOwner = null;
+        if (!routeOwnerError(owner, failure))
+            throw failure;
+    }
+    if (scheduledFlushes.size > 0)
+        drainFlushes();
+}
+function stagePublication(operation) {
+    if (activePublication === null) {
+        operation[0]();
+        try {
+            operation[3]?.();
+        }
+        catch (error) {
+            operation[1]();
+            throw error;
+        }
+        return;
+    }
+    activePublication.push([
+        operation[0],
+        operation[1],
+        operation[2],
+        operation[3],
+        operation[4],
+        operation[5] ?? activeErrorOwner,
+    ]);
+}
+function commitPublication(operations) {
+    const ordered = operations.some((operation) => operation[4] !== undefined)
+        ? operations.toSorted((left, right) => (left[4] ?? 0) - (right[4] ?? 0))
+        : operations;
+    const applied = [];
+    let current;
+    try {
+        for (const operation of ordered) {
+            current = operation;
+            applied.push(operation);
+            operation[0]();
+        }
+    }
+    catch (error) {
+        for (let index = applied.length - 1; index >= 0; index -= 1) {
+            try {
+                applied[index]?.[1]();
+            }
+            catch {
+                // Preserve the publication error while attempting every inverse.
+            }
+        }
+        for (const operation of ordered.slice(applied.length)) {
+            try {
+                operation[2]?.();
+            }
+            catch {
+                // Preserve the publication error while disposing every staged value.
+            }
+        }
+        failedOwner = current?.[5] ?? null;
+        throw error;
+    }
+    try {
+        for (const operation of ordered) {
+            current = operation;
+            operation[3]?.();
+        }
+    }
+    catch (error) {
+        for (let index = applied.length - 1; index >= 0; index -= 1) {
+            try {
+                applied[index]?.[1]();
+            }
+            catch {
+                // Preserve the finalization error while attempting every inverse.
+            }
+        }
+        failedOwner = current?.[5] ?? null;
+        throw error;
+    }
+}
+function runOwnerTask(owner, operation) {
+    try {
+        operation();
+    }
+    catch (error) {
+        if (!routeOwnerError(owner, error))
+            throw error;
+    }
+}
+function routeOwnerError(owner, failure) {
+    let error = failure;
+    let boundary = owner?.[4] ?? null;
+    while (boundary !== null) {
+        try {
+            boundary.handle(error);
+            return true;
+        }
+        catch (nextError) {
+            error = nextError;
+            boundary = boundary.parent;
+        }
+    }
+    const onUncaughtError = owner?.[3].onUncaughtError;
+    if (onUncaughtError === undefined)
+        return false;
+    onUncaughtError(error);
+    return true;
+}
+export function isCompiledContext(value) {
+    return typeof value === 'function' && CONTEXT in value;
+}
+function abortPublication(operations) {
+    for (let index = operations.length - 1; index >= 0; index -= 1) {
+        try {
+            operations[index]?.[2]?.();
+        }
+        catch {
+            // Preserve the computation error while disposing every staged value.
+        }
+    }
+}
+//# sourceMappingURL=core.js.map