@microsoft/webui-framework 0.0.18 → 0.0.20

package/dist/lifecycle.js

@@ -1,6 +1,11 @@
 let pendingCount = 0;
 let started = false;
 let completed = false;
+let streamingGateActive = false;
+let terminalReached = false;
+let streamingGateAborted = false;
+let pendingBoundaries = 0;
+let pendingLateActivations = 0;
 export function hydrationStart() {
     if (!started) {
         performance.mark('webui:hydrate:total:start');
@@ -9,11 +14,69 @@ export function hydrationStart() {
     pendingCount++;
 }
 export function hydrationEnd() {
+    if (pendingCount === 0)
+        return;
     pendingCount--;
-    if (pendingCount <= 0 && !completed) {
-        completed = true;
+    tryComplete();
+}
+export function beginStreamingGate() {
+    streamingGateActive = true;
+}
+export function abortStreamingGate() {
+    streamingGateAborted = true;
+}
+export function markBoundaryPending() {
+    pendingBoundaries++;
+}
+export function markBoundaryCommitted(terminal) {
+    if (pendingBoundaries === 0)
+        return;
+    pendingBoundaries--;
+    if (terminal)
+        terminalReached = true;
+    tryComplete();
+}
+export function markLateActivationPending() {
+    pendingLateActivations++;
+}
+export function settleLateActivation() {
+    if (pendingLateActivations === 0)
+        return;
+    pendingLateActivations--;
+    tryComplete();
+}
+function tryComplete() {
+    if (completed || streamingGateAborted || pendingCount !== 0)
+        return;
+    if (streamingGateActive &&
+        (!terminalReached || pendingBoundaries !== 0 || pendingLateActivations !== 0))
+        return;
+    completed = true;
+    if (started) {
         performance.mark('webui:hydrate:total:end');
         performance.measure('webui:hydrate:total', 'webui:hydrate:total:start', 'webui:hydrate:total:end');
-        window.dispatchEvent(new Event('webui:hydration-complete'));
     }
+    window.dispatchEvent(new Event('webui:hydration-complete'));
+}
+export function __getLifecycleStateForTests() {
+    return {
+        pendingCount,
+        started,
+        completed,
+        streamingGateActive,
+        streamingGateAborted,
+        terminalReached,
+        pendingBoundaries,
+        pendingLateActivations,
+    };
+}
+export function __resetLifecycleForTests() {
+    pendingCount = 0;
+    started = false;
+    completed = false;
+    streamingGateActive = false;
+    streamingGateAborted = false;
+    terminalReached = false;
+    pendingBoundaries = 0;
+    pendingLateActivations = 0;
 }

package/dist/static-host.js

@@ -1,6 +1,6 @@
 import { TemplateElement } from './template-element.js';
 import { getTemplateRegistry } from './template.js';
-import { templateAttributeForRoot, templateNeedsStaticHost } from './template-roots.js';
+import { templateNeedsStaticHost } from './template-roots.js';
 import { TEMPLATES_REGISTERED_EVENT, templateRegistrationDetail, } from './template-events.js';
 let runtimeInstalled = false;
 function defineTemplateHost(tag, meta) {
@@ -12,16 +12,28 @@ function defineTemplateHost(tag, meta) {
     if (!w.__webui.templates[tag])
         w.__webui.templates[tag] = meta;
     class StaticTemplateHost extends TemplateElement {
-        $shouldApplyTemplateStateFromSSR(key) {
-            const attr = templateAttributeForRoot(meta, key);
-            return attr === undefined || !this.hasAttribute(attr);
+        $afterExternalStateWrite(applied) {
+            if (applied)
+                this.$activateDeferredSSR();
+        }
+        $shouldDeferSSRHydration() {
+            return true;
+        }
+        $shouldApplySSRBootstrapState() {
+            return false;
+        }
+        $shouldActivateOnBoundaryCommit() {
+            return false;
         }
     }
     StaticTemplateHost.define(tag);
 }
 function defineMissingTemplateHost(tag, meta) {
-    if (!templateNeedsStaticHost(meta) || customElements.get(tag))
+    if (!templateNeedsStaticHost(meta) ||
+        window.__webui?.templateHostExclusions?.has(tag) ||
+        customElements.get(tag)) {
         return;
+    }
     defineTemplateHost(tag, meta);
 }
 function defineTemplateHosts(templates = getTemplateRegistry()) {
@@ -45,14 +57,12 @@ export function installTemplateElementRuntime() {
     runtimeInstalled = true;
     window.addEventListener(TEMPLATES_REGISTERED_EVENT, (event) => {
         const detail = templateRegistrationDetail(event);
-        if (!detail)
+        if (!detail?.templates)
             return;
-        if (detail.templates)
-            defineTemplateHosts(detail.templates);
+        defineTemplateHosts(detail.templates);
     });
+    defineTemplateHosts();
     if (document.readyState === 'loading') {
         document.addEventListener('DOMContentLoaded', () => defineTemplateHosts(), { once: true });
-        return;
     }
-    defineTemplateHosts();
 }

package/dist/streaming-activation.d.ts

@@ -0,0 +1,2 @@
+import type { PendingBoundaryUpdates } from './streaming-deferred.js';
+export declare function activateRootsBetween(startMarker: Comment, endMarker: Comment, state: Record<string, unknown> | undefined, updates?: PendingBoundaryUpdates): void;

package/dist/streaming-activation.js

@@ -0,0 +1,13 @@
+import { abandonDeferredRange, } from './streaming-cleanup.js';
+import { activateDeferredTree, } from './streaming-deferred.js';
+export function activateRootsBetween(startMarker, endMarker, state, updates) {
+    const root = startMarker.parentNode;
+    if (!root) {
+        throw new Error('boundary start marker was detached before activation');
+    }
+    const failure = activateDeferredTree(startMarker.nextSibling, root, endMarker, state, updates ? { updates, retainedRoots: updates.roots } : undefined);
+    if (!failure)
+        return;
+    abandonDeferredRange(startMarker, endMarker);
+    throw new Error(failure);
+}

package/dist/streaming-bootstrap.d.ts

@@ -0,0 +1,2 @@
+import type { BoundaryBootstrap } from './streaming-protocol.js';
+export declare function applyBoundaryBootstrap(bootstrap: BoundaryBootstrap): void;

package/dist/streaming-bootstrap.js

@@ -0,0 +1,48 @@
+import { registerTemplateData } from './template.js';
+export function applyBoundaryBootstrap(bootstrap) {
+    if (bootstrap.templates)
+        registerTemplateData(bootstrap.templates);
+    const w = window;
+    if (!w.__webui)
+        w.__webui = {};
+    const keys = Object.keys(bootstrap);
+    for (let i = 0; i < keys.length; i++) {
+        const key = keys[i];
+        if (key === 'templates' || key === 'state')
+            continue;
+        if (key === 'inventory') {
+            w.__webui.inventory = mergeInventory(w.__webui.inventory, bootstrap.inventory);
+            continue;
+        }
+        if (key === 'css' || key === 'styles') {
+            appendUniqueStrings(w.__webui, key, bootstrap[key]);
+            continue;
+        }
+        w.__webui[key] = bootstrap[key];
+    }
+}
+function mergeInventory(existing, delta) {
+    const current = typeof existing === 'string' ? existing : '';
+    const next = delta ?? '';
+    const length = Math.max(current.length, next.length);
+    let merged = '';
+    for (let i = 0; i < length; i++) {
+        const a = i < current.length ? parseInt(current[i], 16) : 0;
+        const b = i < next.length ? parseInt(next[i], 16) : 0;
+        merged += (a | b).toString(16);
+    }
+    return merged;
+}
+function appendUniqueStrings(target, key, delta) {
+    if (!delta)
+        return;
+    const existing = target[key];
+    const cumulative = Array.isArray(existing) ? existing : [];
+    for (let i = 0; i < delta.length; i++) {
+        if (cumulative.indexOf(delta[i]) === -1) {
+            cumulative.push(delta[i]);
+        }
+    }
+    if (cumulative !== existing)
+        target[key] = cumulative;
+}

package/dist/streaming-cleanup.d.ts

@@ -0,0 +1,4 @@
+export declare function abandonDeferredElement(el: Element): void;
+export declare function abandonDeferredDescendants(root: Element): void;
+export declare function abandonDeferredRange(startMarker: Comment, endMarker: Node): void;
+export declare function abandonDeferredDocumentRoots(): void;

package/dist/streaming-cleanup.js

@@ -0,0 +1,66 @@
+import { firstNodeWithin, MAX_MARKER_SCAN_NODES, nextWithinRoot, safeRemoveAttribute, streamingErrorMessage, } from './streaming-dom.js';
+import { STREAMED_HOST_ATTR } from './streaming-mode.js';
+const STREAMING_BOUNDARY_ABANDON = Symbol.for('microsoft.webui.boundaryAbandon');
+export function abandonDeferredElement(el) {
+    try {
+        if (!el.hasAttribute(STREAMED_HOST_ATTR))
+            return;
+    }
+    catch {
+        safeRemoveAttribute(el, STREAMED_HOST_ATTR);
+        return;
+    }
+    try {
+        const hook = el[STREAMING_BOUNDARY_ABANDON];
+        if (typeof hook === 'function')
+            hook.call(el);
+    }
+    catch (error) {
+        console.error(`[WebUI] streaming: abandon failed for <${el.tagName?.toLowerCase?.() ?? '?'}>: ${streamingErrorMessage(error)}`);
+    }
+    finally {
+        safeRemoveAttribute(el, STREAMED_HOST_ATTR);
+    }
+}
+export function abandonDeferredDescendants(root) {
+    abandonDeferredNodes(firstNodeWithin(root), root, null);
+}
+export function abandonDeferredRange(startMarker, endMarker) {
+    const root = startMarker.parentNode;
+    if (root) {
+        abandonDeferredNodes(startMarker.nextSibling, root, endMarker);
+    }
+}
+function abandonDeferredNodes(first, root, end) {
+    let node = first;
+    let visited = 0;
+    while (node && node !== end && visited < MAX_MARKER_SCAN_NODES) {
+        visited++;
+        if (node.nodeType === 1) {
+            abandonDeferredElement(node);
+        }
+        node = nextWithinRoot(node, root);
+    }
+}
+export function abandonDeferredDocumentRoots() {
+    if (typeof document === 'undefined' ||
+        typeof document.getElementsByTagName !== 'function') {
+        return;
+    }
+    const elements = document.getElementsByTagName('*');
+    let visited = 0;
+    for (let i = 0; i < elements.length && visited < MAX_MARKER_SCAN_NODES; i++) {
+        const el = elements[i];
+        visited++;
+        abandonDeferredElement(el);
+        const shadowRoot = el.shadowRoot;
+        let node = shadowRoot?.firstChild ?? null;
+        while (node && visited < MAX_MARKER_SCAN_NODES) {
+            visited++;
+            if (node.nodeType === 1) {
+                abandonDeferredElement(node);
+            }
+            node = nextWithinRoot(node, shadowRoot);
+        }
+    }
+}

package/dist/streaming-coordinator.d.ts

@@ -0,0 +1,7 @@
+import { elementHasPendingStateForTests, pendingTagWaiterCountForTests, pendingUndefinedRootCountForTests } from './streaming-deferred.js';
+export declare function enqueueStreamingSentinel(sentinel: Element): void;
+export declare function installStreamingTruncationGuard(): void;
+export declare function resetStreamingCoordinatorStateForTests(): void;
+export declare function isStreamingHaltedForTests(): boolean;
+export declare function streamingRetentionStateForTests(): readonly [number, number];
+export { elementHasPendingStateForTests, pendingTagWaiterCountForTests, pendingUndefinedRootCountForTests, };

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;