@microsoft/webui-framework 0.0.19 → 0.0.20

package/dist/streaming-coordinator.js

@@ -0,0 +1,367 @@
+import { abortStreamingGate, markBoundaryCommitted, markBoundaryPending, } from './lifecycle.js';
+import { activateRootsBetween, } from './streaming-activation.js';
+import { applyBoundaryBootstrap } from './streaming-bootstrap.js';
+import { abandonDeferredDocumentRoots, abandonDeferredRange, } from './streaming-cleanup.js';
+import { abandonPendingWaiters, configureStreamingFailureHandler, elementHasPendingStateForTests, pendingTagWaiterCountForTests, pendingUndefinedRootCountForTests, resetDeferredActivationForTests, } from './streaming-deferred.js';
+import { findBoundaryScript, findEndMarkerByPrefix, findStartMarkerByPrefix, removeBoundaryScaffolding, resolveBoundaryRange, streamingErrorMessage, } from './streaming-dom.js';
+import { parseBoundaryEnvelope, RECORD_KIND_STATE_UPDATE, RECORD_KIND_TERMINAL, RECORD_KIND_UPDATABLE_CHECKPOINT, } from './streaming-protocol.js';
+const MAX_QUEUED_BOUNDARIES = 512;
+const MAX_UPDATABLE_BOUNDARIES = 128;
+const MAX_RETAINED_UPDATE_ROOTS = 50_000;
+const BOUNDARY_HYDRATED_EVENT = 'webui:boundary-hydrated';
+const BOUNDARY_MARK_PREFIX = 'webui:boundary:';
+const UPDATE_MARK_SUFFIX = ':update';
+const TERMINAL_MARK = 'webui:streaming:terminal';
+const perf = globalThis.performance;
+const queue = [];
+let queueHead = 0;
+let pumpScheduled = false;
+let slicedDrainActive = false;
+let halted = false;
+let nextExpectedRecordSequence = 0;
+let nextExpectedBoundaryId = 0;
+let terminalCommitted = false;
+let pendingTerminalSequence = null;
+let terminalValidationScheduled = false;
+let coordinatorGeneration = 0;
+let retainedUpdateRoots = 0;
+const updatableBoundaries = new Map();
+configureStreamingFailureHandler(fail);
+export function enqueueStreamingSentinel(sentinel) {
+    if (halted) {
+        discardRejectedBoundary(sentinel);
+        abandonDeferredDocumentRoots();
+        return;
+    }
+    if (queue.length - queueHead >= MAX_QUEUED_BOUNDARIES) {
+        failBoundary(sentinel, `queued boundary count exceeds ${MAX_QUEUED_BOUNDARIES}`);
+        return;
+    }
+    queue.push(sentinel);
+    if (!pumpScheduled) {
+        pumpScheduled = true;
+        queueMicrotask(drainQueue);
+    }
+}
+function drainQueue() {
+    const budget = sliceBudgetMs();
+    if (budget > 0) {
+        void drainSliced(budget);
+        return;
+    }
+    pumpScheduled = false;
+    while (queueHead < queue.length) {
+        const sentinel = queue[queueHead];
+        queueHead++;
+        if (!halted)
+            processSentinel(sentinel);
+    }
+    queue.length = 0;
+    queueHead = 0;
+    scheduleTerminalValidation();
+}
+function sliceBudgetMs() {
+    const raw = window
+        .__WEBUI_STREAMING_SLICE_MS__;
+    return typeof raw === 'number' && raw > 0 ? raw : 0;
+}
+function nowMs() {
+    return perf ? perf.now() : Date.now();
+}
+async function drainSliced(budget) {
+    const generation = coordinatorGeneration;
+    slicedDrainActive = true;
+    let deadline = nowMs() + budget;
+    while (queueHead < queue.length) {
+        const sentinel = queue[queueHead];
+        queueHead++;
+        if (!halted)
+            processSentinel(sentinel);
+        if (nowMs() >= deadline) {
+            await yieldToRenderer();
+            if (generation !== coordinatorGeneration) {
+                slicedDrainActive = false;
+                return;
+            }
+            deadline = nowMs() + budget;
+        }
+    }
+    slicedDrainActive = false;
+    pumpScheduled = false;
+    queue.length = 0;
+    queueHead = 0;
+    scheduleTerminalValidation();
+}
+function yieldToRenderer() {
+    const scheduler = globalThis.scheduler;
+    if (scheduler?.yield)
+        return scheduler.yield();
+    return new Promise((resolve) => {
+        setTimeout(resolve, 0);
+    });
+}
+function fail(reason) {
+    halted = true;
+    console.error(`[WebUI] streaming hydration halted: ${reason}.`);
+    abortStreamingGate();
+    abandonPendingWaiters();
+    clearUpdatableBoundaries();
+    settlePendingTerminal(false);
+    for (let i = queueHead; i < queue.length; i++) {
+        discardRejectedBoundary(queue[i]);
+    }
+    queue.length = 0;
+    queueHead = 0;
+    abandonDeferredDocumentRoots();
+}
+function failBoundary(sentinel, reason) {
+    discardRejectedBoundary(sentinel);
+    fail(reason);
+}
+function discardRejectedBoundary(sentinel) {
+    const scriptEl = findBoundaryScript(sentinel);
+    let endMarker = null;
+    let startMarker = null;
+    if (scriptEl) {
+        endMarker = findEndMarkerByPrefix(scriptEl);
+        if (endMarker)
+            startMarker = findStartMarkerByPrefix(endMarker);
+    }
+    if (startMarker && endMarker) {
+        abandonDeferredRange(startMarker, endMarker);
+    }
+    removeBoundaryScaffolding(sentinel, scriptEl, startMarker, endMarker);
+}
+function processSentinel(sentinel) {
+    if (terminalCommitted) {
+        failBoundary(sentinel, 'boundary arrived after the terminal streaming record');
+        return;
+    }
+    const scriptEl = findBoundaryScript(sentinel);
+    if (!scriptEl) {
+        failBoundary(sentinel, 'missing boundary payload script before <webui-hydrate>');
+        return;
+    }
+    const parsed = parseBoundaryEnvelope(scriptEl.textContent ?? '');
+    if (!parsed.ok) {
+        failBoundary(sentinel, parsed.reason);
+        return;
+    }
+    const [, sequence, kind, target, payload] = parsed.envelope;
+    if (sequence !== nextExpectedRecordSequence) {
+        failBoundary(sentinel, `expected streaming record sequence ${nextExpectedRecordSequence}, received ${sequence}`);
+        return;
+    }
+    if (kind === RECORD_KIND_STATE_UPDATE) {
+        const boundary = updatableBoundaries.get(target);
+        if (!boundary) {
+            failBoundary(sentinel, `state update targets boundary ${target}, which is not committed as updatable`);
+            return;
+        }
+        nextExpectedRecordSequence++;
+        commitStateUpdate(boundary, payload, target, sequence, sentinel, scriptEl);
+        return;
+    }
+    if (kind === RECORD_KIND_TERMINAL) {
+        const resolved = resolveBoundaryRange(scriptEl, 0, true);
+        if (!resolved.ok) {
+            failBoundary(sentinel, resolved.reason);
+            return;
+        }
+        nextExpectedRecordSequence++;
+        commitTerminal(sequence, sentinel, scriptEl);
+        return;
+    }
+    if (target !== nextExpectedBoundaryId) {
+        failBoundary(sentinel, `expected boundary ID ${nextExpectedBoundaryId}, received ${target}`);
+        return;
+    }
+    const resolved = resolveBoundaryRange(scriptEl, target, false);
+    if (!resolved.ok) {
+        if (resolved.truncated) {
+            if (resolved.start) {
+                abandonDeferredRange(resolved.start, scriptEl);
+            }
+            removeBoundaryScaffolding(sentinel, scriptEl, resolved.start, null);
+            fail(resolved.reason);
+        }
+        else {
+            failBoundary(sentinel, resolved.reason);
+        }
+        return;
+    }
+    nextExpectedRecordSequence++;
+    nextExpectedBoundaryId++;
+    commitCheckpoint(payload, resolved.range, sequence, target, kind === RECORD_KIND_UPDATABLE_CHECKPOINT, sentinel, scriptEl);
+}
+function commitCheckpoint(bootstrap, range, sequence, target, updatable, sentinel, scriptEl) {
+    markBoundaryPending();
+    let committed = false;
+    try {
+        applyBoundaryBootstrap(bootstrap);
+        if (range.start && range.end) {
+            const boundary = updatable
+                ? { roots: [], pendingRoots: 0 }
+                : undefined;
+            activateRootsBetween(range.start, range.end, bootstrap.state, boundary);
+            if (boundary)
+                retainUpdatableBoundary(target, boundary);
+        }
+        else if (updatable) {
+            retainUpdatableBoundary(target, { roots: [], pendingRoots: 0 });
+        }
+        committed = true;
+    }
+    catch (error) {
+        fail(`error committing boundary ${sequence}: ${streamingErrorMessage(error)}`);
+    }
+    finally {
+        removeBoundaryScaffolding(sentinel, scriptEl, range.start, range.end);
+        if (committed) {
+            notifyCommit(`${BOUNDARY_MARK_PREFIX}${target}`, sequence, 'checkpoint');
+        }
+        markBoundaryCommitted(false);
+    }
+}
+function retainUpdatableBoundary(target, boundary) {
+    if (updatableBoundaries.size >= MAX_UPDATABLE_BOUNDARIES) {
+        throw new Error(`updatable boundary count exceeds ${MAX_UPDATABLE_BOUNDARIES}`);
+    }
+    if (retainedUpdateRoots + boundary.roots.length >
+        MAX_RETAINED_UPDATE_ROOTS) {
+        throw new Error(`retained update root count exceeds ${MAX_RETAINED_UPDATE_ROOTS}`);
+    }
+    retainedUpdateRoots += boundary.roots.length;
+    updatableBoundaries.set(target, boundary);
+}
+function commitStateUpdate(boundary, patch, target, sequence, sentinel, scriptEl) {
+    try {
+        if (boundary.pendingRoots > 0) {
+            if (boundary.patch) {
+                Object.assign(boundary.patch, patch);
+            }
+            else {
+                boundary.patch = Object.assign(Object.create(null), patch);
+            }
+        }
+        for (let i = 0; i < boundary.roots.length; i++) {
+            const root = boundary.roots[i];
+            if (root.hasAttribute('data-ws'))
+                continue;
+            try {
+                if (typeof root.setState !== 'function') {
+                    throw new Error('no setState() method');
+                }
+                root.setState(patch);
+            }
+            catch (error) {
+                console.error(`[WebUI] streaming: state update failed for <${root.tagName.toLowerCase()}>: ${streamingErrorMessage(error)}`);
+            }
+        }
+        notifyCommit(`${BOUNDARY_MARK_PREFIX}${target}${UPDATE_MARK_SUFFIX}`, sequence, 'update');
+    }
+    catch (error) {
+        fail(`error applying state update to boundary ${target}: ${streamingErrorMessage(error)}`);
+    }
+    finally {
+        removeBoundaryScaffolding(sentinel, scriptEl, null, null);
+    }
+}
+function commitTerminal(sequence, sentinel, scriptEl) {
+    markBoundaryPending();
+    removeBoundaryScaffolding(sentinel, scriptEl, null, null);
+    terminalCommitted = true;
+    pendingTerminalSequence = sequence;
+    clearUpdatableBoundaries();
+    scheduleTerminalValidation();
+}
+function clearUpdatableBoundaries() {
+    updatableBoundaries.clear();
+    retainedUpdateRoots = 0;
+}
+function notifyCommit(mark, sequence, kind) {
+    perf?.mark(mark);
+    if (window
+        .__WEBUI_STREAMING_DEBUG__ !== true) {
+        return;
+    }
+    window.dispatchEvent(new CustomEvent(BOUNDARY_HYDRATED_EVENT, {
+        detail: { sequence, terminal: kind === 'terminal', kind },
+    }));
+}
+function scheduleTerminalValidation() {
+    if (pendingTerminalSequence === null ||
+        terminalValidationScheduled ||
+        slicedDrainActive) {
+        return;
+    }
+    terminalValidationScheduled = true;
+    const generation = coordinatorGeneration;
+    queueMicrotask(() => validatePendingTerminal(generation));
+}
+function validatePendingTerminal(generation) {
+    if (generation !== coordinatorGeneration)
+        return;
+    terminalValidationScheduled = false;
+    if (pendingTerminalSequence === null)
+        return;
+    if (pumpScheduled || queueHead < queue.length) {
+        scheduleTerminalValidation();
+        return;
+    }
+    settlePendingTerminal(!halted);
+}
+function settlePendingTerminal(success) {
+    const sequence = pendingTerminalSequence;
+    if (sequence === null)
+        return;
+    pendingTerminalSequence = null;
+    if (success)
+        notifyCommit(TERMINAL_MARK, sequence, 'terminal');
+    markBoundaryCommitted(success);
+}
+export function installStreamingTruncationGuard() {
+    if (typeof document === 'undefined')
+        return;
+    const generation = coordinatorGeneration;
+    if (document.readyState === 'loading') {
+        document.addEventListener('DOMContentLoaded', () => onDomContentLoaded(generation), { once: true });
+    }
+    else {
+        queueMicrotask(() => onDomContentLoaded(generation));
+    }
+}
+function onDomContentLoaded(generation) {
+    if (generation !== coordinatorGeneration)
+        return;
+    if (halted) {
+        abandonDeferredDocumentRoots();
+        return;
+    }
+    if (terminalCommitted)
+        return;
+    fail('response ended at DOMContentLoaded before the terminal streaming boundary committed (truncated stream)');
+}
+export function resetStreamingCoordinatorStateForTests() {
+    resetDeferredActivationForTests();
+    settlePendingTerminal(false);
+    clearUpdatableBoundaries();
+    coordinatorGeneration++;
+    queue.length = 0;
+    queueHead = 0;
+    pumpScheduled = false;
+    slicedDrainActive = false;
+    halted = false;
+    nextExpectedRecordSequence = 0;
+    nextExpectedBoundaryId = 0;
+    terminalCommitted = false;
+    pendingTerminalSequence = null;
+    terminalValidationScheduled = false;
+}
+export function isStreamingHaltedForTests() {
+    return halted;
+}
+export function streamingRetentionStateForTests() {
+    return [updatableBoundaries.size, retainedUpdateRoots];
+}
+export { elementHasPendingStateForTests, pendingTagWaiterCountForTests, pendingUndefinedRootCountForTests, };

package/dist/streaming-deferred.d.ts

@@ -0,0 +1,22 @@
+export declare const ACTIVATION_MISSING_TEMPLATE = 3;
+export declare const ELEMENT_IGNORED = 0;
+export declare const ELEMENT_DEFERRED = 4;
+export declare const ELEMENT_LIMIT_FAILURE = 5;
+export declare const MAX_PENDING_UNDEFINED_ROOTS = 50000;
+export interface PendingBoundaryUpdates {
+    readonly roots: Element[];
+    pendingRoots: number;
+    patch?: Record<string, unknown>;
+}
+export interface DeferredActivationOptions {
+    updates?: PendingBoundaryUpdates;
+    retainedRoots?: Element[];
+}
+export declare function configureStreamingFailureHandler(handler: (reason: string) => void): void;
+export declare function activateElement(el: Element, state: Record<string, unknown> | undefined, updates?: PendingBoundaryUpdates): number;
+export declare function activateDeferredTree(first: Node | null, root: Node, end: Node | null, state: Record<string, unknown> | undefined, options?: DeferredActivationOptions): string | null;
+export declare function abandonPendingWaiters(): void;
+export declare function resetDeferredActivationForTests(): void;
+export declare function pendingTagWaiterCountForTests(): number;
+export declare function pendingUndefinedRootCountForTests(): number;
+export declare function elementHasPendingStateForTests(el: Element): boolean;

package/dist/streaming-deferred.js

@@ -0,0 +1,273 @@
+import { markLateActivationPending, settleLateActivation, } from './lifecycle.js';
+import { abandonDeferredDescendants, abandonDeferredElement, } from './streaming-cleanup.js';
+import { firstNodeWithin, MAX_ELEMENTS_PER_BOUNDARY, MAX_MARKER_SCAN_NODES, nextAfterSubtreeWithin, nextWithinRoot, safeRemoveAttribute, streamingErrorMessage, } from './streaming-dom.js';
+import { PENDING_ROOT_CONNECTED, STREAMED_HOST_ATTR, STREAMING_BOUNDARY_ACTIVATE, } from './streaming-mode.js';
+const ACTIVATION_ACTIVATED = 1;
+const ACTIVATION_STATIC_HOST_OPT_OUT = 2;
+export const ACTIVATION_MISSING_TEMPLATE = 3;
+export const ELEMENT_IGNORED = 0;
+export const ELEMENT_DEFERRED = 4;
+export const ELEMENT_LIMIT_FAILURE = 5;
+export const MAX_PENDING_UNDEFINED_ROOTS = 50_000;
+const pendingTagWaiters = new Map();
+let pendingUndefinedRoots = 0;
+let activationGeneration = 0;
+let failureHandler = null;
+const PENDING_BOUNDARY_STATE = Symbol();
+const PENDING_BOUNDARY_UPDATES = Symbol();
+const NO_BOUNDARY_STATE = Symbol();
+export function configureStreamingFailureHandler(handler) {
+    failureHandler = handler;
+}
+function fail(reason) {
+    if (!failureHandler) {
+        throw new Error('streaming failure handler is not installed');
+    }
+    failureHandler(reason);
+}
+export function activateElement(el, state, updates) {
+    if (!el.hasAttribute(STREAMED_HOST_ATTR))
+        return ELEMENT_IGNORED;
+    const tag = el.tagName.toLowerCase();
+    if (tag.indexOf('-') === -1)
+        return ELEMENT_IGNORED;
+    if (customElements.get(tag))
+        return invokeActivationHook(el, state);
+    if (!hasPendingState(el) &&
+        pendingUndefinedRoots >= MAX_PENDING_UNDEFINED_ROOTS) {
+        return ELEMENT_LIMIT_FAILURE;
+    }
+    stashPendingState(el, state, updates);
+    let waiter = pendingTagWaiters.get(tag);
+    if (!waiter) {
+        waiter = { generation: activationGeneration, roots: new Set() };
+        pendingTagWaiters.set(tag, waiter);
+        markLateActivationPending();
+        const generation = activationGeneration;
+        customElements
+            .whenDefined(tag)
+            .then(() => onTagDefined(tag, generation));
+    }
+    if (!waiter.roots.has(el)) {
+        waiter.roots.add(el);
+        pendingUndefinedRoots++;
+    }
+    el[PENDING_ROOT_CONNECTED] = resumePendingRoot;
+    return ELEMENT_DEFERRED;
+}
+function onTagDefined(tag, generation) {
+    if (generation !== activationGeneration)
+        return;
+    const waiter = pendingTagWaiters.get(tag);
+    if (!waiter || waiter.generation !== generation)
+        return;
+    for (const el of waiter.roots) {
+        if (!el.isConnected) {
+            try {
+                customElements.upgrade(el);
+            }
+            catch (error) {
+                fail(`failed to upgrade detached <${tag}>: ${streamingErrorMessage(error)}`);
+                return;
+            }
+            const hook = el[STREAMING_BOUNDARY_ACTIVATE];
+            if (el.hasAttribute(STREAMED_HOST_ATTR) &&
+                typeof hook !== 'function') {
+                fail(`upgrading detached <${tag}> did not install its streaming activation hook`);
+                return;
+            }
+        }
+        activatePendingRoot(tag, waiter, el);
+    }
+}
+function resumePendingRoot() {
+    const tag = this.tagName.toLowerCase();
+    const waiter = pendingTagWaiters.get(tag);
+    if (!waiter ||
+        waiter.generation !== activationGeneration ||
+        !waiter.roots.has(this)) {
+        delete this[PENDING_ROOT_CONNECTED];
+        return;
+    }
+    activatePendingRoot(tag, waiter, this);
+}
+function activatePendingRoot(tag, waiter, el) {
+    if (!waiter.roots.delete(el))
+        return;
+    pendingUndefinedRoots--;
+    delete el[PENDING_ROOT_CONNECTED];
+    let updates;
+    try {
+        updates = takePendingUpdates(el);
+        const state = mergePendingUpdates(takePendingState(el), updates);
+        const outcome = invokeActivationHook(el, state);
+        if (outcome === ACTIVATION_MISSING_TEMPLATE) {
+            abandonDeferredDescendants(el);
+            abandonDeferredElement(el);
+            fail(`template metadata missing while activating <${tag}>`);
+            return;
+        }
+        const failure = activateDeferredTree(firstNodeWithin(el), el, null, state, updates ? { updates } : undefined);
+        if (failure)
+            fail(failure);
+    }
+    catch (error) {
+        abandonDeferredDescendants(el);
+        reportActivationFailure(tag, error);
+    }
+    finally {
+        if (updates?.pendingRoots === 0)
+            updates.patch = undefined;
+        if (waiter.roots.size === 0 &&
+            pendingTagWaiters.get(tag) === waiter) {
+            pendingTagWaiters.delete(tag);
+            settleLateActivation();
+        }
+    }
+}
+export function activateDeferredTree(first, root, end, state, options) {
+    let node = first;
+    let resumeAfterDeferred = null;
+    let skippingDeferredDescendants = false;
+    let visited = 0;
+    let elements = 0;
+    while (node && node !== end) {
+        if (visited >= MAX_MARKER_SCAN_NODES) {
+            return `streaming boundary walk exceeds ${MAX_MARKER_SCAN_NODES} nodes`;
+        }
+        visited++;
+        if (node.nodeType === 1) {
+            const el = node;
+            if (options?.retainedRoots &&
+                el.hasAttribute(STREAMED_HOST_ATTR)) {
+                if (options.retainedRoots.length >= MAX_ELEMENTS_PER_BOUNDARY) {
+                    return `updatable streaming boundary exceeds ${MAX_ELEMENTS_PER_BOUNDARY} roots`;
+                }
+                options.retainedRoots.push(el);
+            }
+        }
+        if (skippingDeferredDescendants &&
+            node !== resumeAfterDeferred) {
+            node = nextWithinRoot(node, root);
+            continue;
+        }
+        skippingDeferredDescendants = false;
+        if (node.nodeType === 1) {
+            if (elements >= MAX_ELEMENTS_PER_BOUNDARY) {
+                return `streaming boundary exceeds ${MAX_ELEMENTS_PER_BOUNDARY} elements`;
+            }
+            elements++;
+            try {
+                const outcome = activateElement(node, state, options?.updates);
+                if (outcome === ACTIVATION_MISSING_TEMPLATE) {
+                    return `template metadata missing while activating <${node.tagName.toLowerCase()}>`;
+                }
+                if (outcome === ELEMENT_LIMIT_FAILURE) {
+                    return `pending undefined root count exceeds ${MAX_PENDING_UNDEFINED_ROOTS}`;
+                }
+                if (outcome === ELEMENT_DEFERRED) {
+                    resumeAfterDeferred = nextAfterSubtreeWithin(node, root);
+                    skippingDeferredDescendants = true;
+                }
+            }
+            catch (error) {
+                reportActivationFailure(node.tagName.toLowerCase(), error);
+            }
+        }
+        node = nextWithinRoot(node, root);
+    }
+    return end && node !== end
+        ? 'streaming boundary end marker became unreachable during activation'
+        : null;
+}
+function reportActivationFailure(tag, error) {
+    console.error(`[WebUI] streaming: late activation failed for <${tag}>: ${streamingErrorMessage(error)}`);
+}
+export function abandonPendingWaiters() {
+    if (pendingTagWaiters.size === 0) {
+        pendingUndefinedRoots = 0;
+        return;
+    }
+    for (const waiter of pendingTagWaiters.values()) {
+        for (const el of waiter.roots)
+            clearPendingRoot(el);
+        settleLateActivation();
+    }
+    pendingTagWaiters.clear();
+    pendingUndefinedRoots = 0;
+}
+function clearPendingRoot(el) {
+    if (hasPendingState(el))
+        takePendingState(el);
+    takePendingUpdates(el);
+    delete el[PENDING_ROOT_CONNECTED];
+    abandonDeferredDescendants(el);
+    abandonDeferredElement(el);
+}
+function stashPendingState(el, state, updates) {
+    const store = el;
+    store[PENDING_BOUNDARY_STATE] =
+        state === undefined ? NO_BOUNDARY_STATE : state;
+    if (updates) {
+        store[PENDING_BOUNDARY_UPDATES] = updates;
+        updates.pendingRoots++;
+    }
+}
+function hasPendingState(el) {
+    return Object.prototype.hasOwnProperty.call(el, PENDING_BOUNDARY_STATE);
+}
+function takePendingState(el) {
+    const store = el;
+    const stored = store[PENDING_BOUNDARY_STATE];
+    delete store[PENDING_BOUNDARY_STATE];
+    return stored === NO_BOUNDARY_STATE
+        ? undefined
+        : stored;
+}
+function takePendingUpdates(el) {
+    const store = el;
+    const updates = store[PENDING_BOUNDARY_UPDATES];
+    delete store[PENDING_BOUNDARY_UPDATES];
+    if (updates)
+        updates.pendingRoots--;
+    return updates;
+}
+function mergePendingUpdates(state, updates) {
+    if (!updates?.patch)
+        return state;
+    return state
+        ? { ...state, ...updates.patch }
+        : { ...updates.patch };
+}
+function invokeActivationHook(el, state) {
+    const hook = el[STREAMING_BOUNDARY_ACTIVATE];
+    if (typeof hook !== 'function')
+        return ACTIVATION_MISSING_TEMPLATE;
+    let outcome;
+    try {
+        outcome = hook.call(el, state);
+    }
+    catch (error) {
+        safeRemoveAttribute(el, STREAMED_HOST_ATTR);
+        throw error;
+    }
+    if (outcome !== ACTIVATION_ACTIVATED &&
+        outcome !== ACTIVATION_STATIC_HOST_OPT_OUT) {
+        return ACTIVATION_MISSING_TEMPLATE;
+    }
+    safeRemoveAttribute(el, STREAMED_HOST_ATTR);
+    return outcome;
+}
+export function resetDeferredActivationForTests() {
+    abandonPendingWaiters();
+    activationGeneration++;
+}
+export function pendingTagWaiterCountForTests() {
+    return pendingTagWaiters.size;
+}
+export function pendingUndefinedRootCountForTests() {
+    return pendingUndefinedRoots;
+}
+export function elementHasPendingStateForTests(el) {
+    return hasPendingState(el);
+}

package/dist/streaming-dom.d.ts

@@ -0,0 +1,32 @@
+export declare const BOUNDARY_SCRIPT_ATTR = "data-webui-boundary";
+export declare const MAX_ELEMENTS_PER_BOUNDARY = 10000;
+export declare const MAX_MARKER_SCAN_NODES = 50000;
+export declare const MAX_BOUNDARY_SCRIPT_SCAN = 8;
+export declare function streamingErrorMessage(error: unknown): string;
+export interface HydrationRange {
+    readonly start: Comment | null;
+    readonly end: Comment | null;
+}
+export type RangeResolution = {
+    readonly ok: true;
+    readonly range: HydrationRange;
+} | {
+    readonly ok: false;
+    readonly reason: string;
+    readonly truncated: false;
+} | {
+    readonly ok: false;
+    readonly reason: string;
+    readonly truncated: true;
+    readonly start: Comment | null;
+};
+export declare function resolveBoundaryRange(scriptEl: Element, sequence: number, terminal: boolean): RangeResolution;
+export declare function findBoundaryScript(sentinel: Element): Element | null;
+export declare function findEndMarkerByPrefix(scriptEl: Element): Comment | null;
+export declare function findStartMarkerByPrefix(endMarker: Comment): Comment | null;
+export declare function safeRemove(node: Node | null | undefined): void;
+export declare function safeRemoveAttribute(el: Element, name: string): void;
+export declare function removeBoundaryScaffolding(sentinel: Element, scriptEl: Element | null, startMarker: Comment | null, endMarker: Comment | null): void;
+export declare function firstNodeWithin(root: Element): Node | null;
+export declare function nextWithinRoot(node: Node, root: Node): Node | null;
+export declare function nextAfterSubtreeWithin(node: Node, root: Node): Node | null;