@microsoft/webui-framework 0.0.18 → 0.0.20

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;

package/dist/streaming-dom.js

@@ -0,0 +1,148 @@
+export const BOUNDARY_SCRIPT_ATTR = 'data-webui-boundary';
+export const MAX_ELEMENTS_PER_BOUNDARY = 10_000;
+export const MAX_MARKER_SCAN_NODES = 50_000;
+export const MAX_BOUNDARY_SCRIPT_SCAN = 8;
+export function streamingErrorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+const BOUNDARY_START_PREFIX = 'wb:';
+const BOUNDARY_END_PREFIX = '/wb:';
+const MARKERLESS_RANGE = { start: null, end: null };
+export function resolveBoundaryRange(scriptEl, sequence, terminal) {
+    const end = findEndMarker(scriptEl, sequence);
+    if (end) {
+        if (terminal) {
+            return {
+                ok: false,
+                reason: `terminal boundary ${sequence} must be markerless`,
+                truncated: false,
+            };
+        }
+        const start = findStartMarkerBefore(end, sequence);
+        if (!start) {
+            return {
+                ok: false,
+                reason: `missing start marker for boundary ${sequence}`,
+                truncated: false,
+            };
+        }
+        return { ok: true, range: { start, end } };
+    }
+    if (terminal)
+        return { ok: true, range: MARKERLESS_RANGE };
+    return {
+        ok: false,
+        reason: `missing end marker for boundary ${sequence}`,
+        truncated: true,
+        start: findStartMarkerBefore(scriptEl, sequence),
+    };
+}
+export function findBoundaryScript(sentinel) {
+    let node = sentinel.previousElementSibling;
+    for (let hops = 0; node && hops < MAX_BOUNDARY_SCRIPT_SCAN; hops++) {
+        if (node.tagName === 'SCRIPT' &&
+            node.hasAttribute(BOUNDARY_SCRIPT_ATTR)) {
+            return node;
+        }
+        node = node.previousElementSibling;
+    }
+    return null;
+}
+function findEndMarker(scriptEl, sequence) {
+    const marker = previousComment(scriptEl);
+    return marker?.data === `${BOUNDARY_END_PREFIX}${sequence}`
+        ? marker
+        : null;
+}
+function findStartMarkerBefore(nodeBefore, sequence) {
+    return findCommentBefore(nodeBefore, `${BOUNDARY_START_PREFIX}${sequence}`);
+}
+export function findEndMarkerByPrefix(scriptEl) {
+    const marker = previousComment(scriptEl);
+    return marker?.data.startsWith(BOUNDARY_END_PREFIX) ? marker : null;
+}
+export function findStartMarkerByPrefix(endMarker) {
+    return findCommentBefore(endMarker, `${BOUNDARY_START_PREFIX}${endMarker.data.slice(BOUNDARY_END_PREFIX.length)}`);
+}
+function previousComment(node) {
+    const previous = node.previousSibling;
+    return previous?.nodeType === 8
+        ? previous
+        : null;
+}
+function findCommentBefore(nodeBefore, target) {
+    let node = nodeBefore.previousSibling;
+    for (let hops = 0; node && hops < MAX_MARKER_SCAN_NODES; hops++) {
+        if (node.nodeType === 8 &&
+            node.data === target) {
+            return node;
+        }
+        node = node.previousSibling;
+    }
+    return null;
+}
+export function safeRemove(node) {
+    try {
+        node?.remove?.();
+    }
+    catch {
+    }
+}
+export function safeRemoveAttribute(el, name) {
+    try {
+        el.removeAttribute?.(name);
+    }
+    catch {
+    }
+}
+export function removeBoundaryScaffolding(sentinel, scriptEl, startMarker, endMarker) {
+    if (!scriptEl) {
+        safeRemove(sentinel);
+        safeRemove(endMarker);
+        safeRemove(startMarker);
+        return;
+    }
+    let node = sentinel.previousElementSibling;
+    safeRemove(sentinel);
+    for (let hops = 0; node && hops <= MAX_BOUNDARY_SCRIPT_SCAN; hops++) {
+        const previous = node.previousElementSibling;
+        const wasBoundaryScript = node === scriptEl;
+        safeRemove(node);
+        if (wasBoundaryScript)
+            break;
+        node = previous;
+    }
+    safeRemove(endMarker);
+    safeRemove(startMarker);
+}
+export function firstNodeWithin(root) {
+    return root.shadowRoot?.firstChild ?? root.firstChild;
+}
+export function nextWithinRoot(node, root) {
+    if (node.nodeType === 1) {
+        const shadowRoot = node.shadowRoot;
+        if (shadowRoot?.firstChild)
+            return shadowRoot.firstChild;
+    }
+    if (node.firstChild)
+        return node.firstChild;
+    return nextAfterSubtreeWithin(node, root);
+}
+export function nextAfterSubtreeWithin(node, root) {
+    let current = node;
+    while (current && current !== root) {
+        if (current.nodeType === 11) {
+            const host = current.host ?? null;
+            if (host) {
+                if (host.firstChild)
+                    return host.firstChild;
+                current = host;
+                continue;
+            }
+        }
+        if (current.nextSibling)
+            return current.nextSibling;
+        current = current.parentNode;
+    }
+    return null;
+}

package/dist/streaming-entry.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/streaming-entry.js

@@ -0,0 +1,2 @@
+import { installStreamingCoordinator } from './streaming.js';
+installStreamingCoordinator();

package/dist/streaming-install.d.ts

@@ -0,0 +1,2 @@
+export declare function installStreamingCoordinator(): void;
+export declare function resetStreamingInstallForTests(): void;

package/dist/streaming-install.js

@@ -0,0 +1,25 @@
+import { beginStreamingGate } from './lifecycle.js';
+import { installTemplateElementRuntime } from './static-host.js';
+import { enqueueStreamingSentinel, installStreamingTruncationGuard, } from './streaming-coordinator.js';
+import { isStreamingHydrationMode } from './streaming-mode.js';
+const SENTINEL_TAG = 'webui-hydrate';
+let installed = false;
+class WebUiHydrateSentinel extends HTMLElement {
+    connectedCallback() {
+        enqueueStreamingSentinel(this);
+    }
+}
+export function installStreamingCoordinator() {
+    if (installed || !isStreamingHydrationMode())
+        return;
+    installed = true;
+    if (!customElements.get(SENTINEL_TAG)) {
+        customElements.define(SENTINEL_TAG, WebUiHydrateSentinel);
+    }
+    beginStreamingGate();
+    installStreamingTruncationGuard();
+    installTemplateElementRuntime();
+}
+export function resetStreamingInstallForTests() {
+    installed = false;
+}

package/dist/streaming-mode.d.ts

@@ -0,0 +1,5 @@
+export declare const STREAMING_BOUNDARY_ACTIVATE: unique symbol;
+export declare const PENDING_ROOT_CONNECTED: unique symbol;
+export declare const STREAMED_HOST_ATTR = "data-ws";
+export declare function isStreamingHydrationMode(): boolean;
+export declare function resetStreamingModeForTests(): void;

package/dist/streaming-mode.js

@@ -0,0 +1,14 @@
+let cached;
+export const STREAMING_BOUNDARY_ACTIVATE = Symbol.for('microsoft.webui.boundaryActivate');
+export const PENDING_ROOT_CONNECTED = Symbol.for('microsoft.webui.pendingRootConnected');
+export const STREAMED_HOST_ATTR = 'data-ws';
+export function isStreamingHydrationMode() {
+    if (cached !== undefined)
+        return cached;
+    cached = typeof document !== 'undefined' &&
+        !!document.querySelector('meta[name="webui-streaming"][content="1"]');
+    return cached;
+}
+export function resetStreamingModeForTests() {
+    cached = undefined;
+}

package/dist/streaming-protocol.d.ts

@@ -0,0 +1,32 @@
+import type { TemplateMeta } from './template.js';
+export interface BoundaryBootstrap {
+    state?: Record<string, unknown>;
+    templates?: Record<string, TemplateMeta>;
+    inventory?: string;
+    nonce?: string;
+    chain?: unknown[];
+    css?: string[];
+    styles?: string[];
+    [key: string]: unknown;
+}
+export declare const RECORD_KIND_FINAL_CHECKPOINT = 0;
+export declare const RECORD_KIND_UPDATABLE_CHECKPOINT = 1;
+export declare const RECORD_KIND_STATE_UPDATE = 2;
+export declare const RECORD_KIND_TERMINAL = 3;
+export type BoundaryRecordKind = typeof RECORD_KIND_FINAL_CHECKPOINT | typeof RECORD_KIND_UPDATABLE_CHECKPOINT | typeof RECORD_KIND_STATE_UPDATE | typeof RECORD_KIND_TERMINAL;
+export type BoundaryRecordPayload = BoundaryBootstrap | Record<string, unknown>;
+export type BoundaryEnvelope = readonly [
+    version: number,
+    recordSequence: number,
+    kind: BoundaryRecordKind,
+    target: number,
+    payload: BoundaryRecordPayload
+];
+export type ParseBoundaryEnvelopeResult = {
+    readonly ok: true;
+    readonly envelope: BoundaryEnvelope;
+} | {
+    readonly ok: false;
+    readonly reason: string;
+};
+export declare function parseBoundaryEnvelope(text: string): ParseBoundaryEnvelopeResult;

package/dist/streaming-protocol.js

@@ -0,0 +1,27 @@
+const SUPPORTED_VERSION = 1;
+export const RECORD_KIND_FINAL_CHECKPOINT = 0;
+export const RECORD_KIND_UPDATABLE_CHECKPOINT = 1;
+export const RECORD_KIND_STATE_UPDATE = 2;
+export const RECORD_KIND_TERMINAL = 3;
+function invalid(reason) {
+    return { ok: false, reason };
+}
+export function parseBoundaryEnvelope(text) {
+    let parsed;
+    try {
+        parsed = JSON.parse(text);
+    }
+    catch {
+        return invalid('boundary payload is not valid JSON');
+    }
+    if (!Array.isArray(parsed) || parsed.length !== 5) {
+        return invalid('boundary envelope must be a 5-element [version, recordSequence, kind, target, payload] array');
+    }
+    if (parsed[0] !== SUPPORTED_VERSION) {
+        return invalid(`unsupported boundary envelope version ${JSON.stringify(parsed[0])}`);
+    }
+    return {
+        ok: true,
+        envelope: parsed,
+    };
+}

package/dist/streaming.d.ts

@@ -0,0 +1,5 @@
+export { enqueueStreamingSentinel as __enqueueSentinelForTests, elementHasPendingStateForTests as __elementHasPendingStateForTests, installStreamingTruncationGuard as __installTruncationGuardForTests, isStreamingHaltedForTests as __isHaltedForTests, pendingTagWaiterCountForTests as __pendingTagWaiterCountForTests, pendingUndefinedRootCountForTests as __pendingUndefinedRootCountForTests, streamingRetentionStateForTests as __streamingRetentionStateForTests, } from './streaming-coordinator.js';
+export { installStreamingCoordinator } from './streaming-install.js';
+export { parseBoundaryEnvelope } from './streaming-protocol.js';
+export type { BoundaryBootstrap, BoundaryEnvelope, ParseBoundaryEnvelopeResult, } from './streaming-protocol.js';
+export declare function __resetStreamingCoordinatorForTests(): void;

package/dist/streaming.js

@@ -0,0 +1,9 @@
+import { resetStreamingCoordinatorStateForTests, } from './streaming-coordinator.js';
+import { resetStreamingInstallForTests } from './streaming-install.js';
+export { enqueueStreamingSentinel as __enqueueSentinelForTests, elementHasPendingStateForTests as __elementHasPendingStateForTests, installStreamingTruncationGuard as __installTruncationGuardForTests, isStreamingHaltedForTests as __isHaltedForTests, pendingTagWaiterCountForTests as __pendingTagWaiterCountForTests, pendingUndefinedRootCountForTests as __pendingUndefinedRootCountForTests, streamingRetentionStateForTests as __streamingRetentionStateForTests, } from './streaming-coordinator.js';
+export { installStreamingCoordinator } from './streaming-install.js';
+export { parseBoundaryEnvelope } from './streaming-protocol.js';
+export function __resetStreamingCoordinatorForTests() {
+    resetStreamingCoordinatorStateForTests();
+    resetStreamingInstallForTests();
+}

package/dist/template-element.d.ts

@@ -1,11 +1,17 @@
 import type { TemplateBlockMeta, TemplateNodePath } from './template.js';
+import { STREAMING_BOUNDARY_ACTIVATE } from './streaming-mode.js';
 import type { ScopeFrame, TemplateInstance } from './element/types.js';
 declare const WEBUI_SET_STATE_KEY: unique symbol;
+declare const STREAMING_BOUNDARY_ABANDON: unique symbol;
 export declare class TemplateElement extends HTMLElement {
     private $root;
     private $meta?;
     private $ready;
     private $hydrated;
+    private $hydratedCallbackCalled;
+    private $deferredSSR;
+    private $activatingDeferredSSR;
+    private $hasUnknownScopes;
     private $templateState;
     private $dirtyPaths;
     private $pendingFlush;
@@ -14,20 +20,30 @@ export declare class TemplateElement extends HTMLElement {
     private $pathIndex?;
     private $wildcardBindings?;
     [WEBUI_SET_STATE_KEY](key: string, value: unknown): boolean;
+    [STREAMING_BOUNDARY_ACTIVATE](state?: Record<string, unknown>): number;
+    [STREAMING_BOUNDARY_ABANDON](): void;
     static define(tagName: string): void;
     connectedCallback(): void;
     private $mount;
     disconnectedCallback(): void;
     $destroy(): void;
-    private $teardown;
-    private $teardownInstanceCleanups;
+    private $clearRepeatBinding;
+    private $clearInstance;
     attributeChangedCallback(name: string, oldValue: string | null, newValue: string | null): void;
     setState(state: Record<string, unknown>): void;
     protected $observableNames(): Set<string>;
+    protected $beforeExternalStateWrite(): void;
+    protected $afterExternalStateWrite(_applied: boolean): void;
+    protected $shouldDeferSSRHydration(): boolean;
+    protected $shouldActivateOnBoundaryCommit(): boolean;
+    protected $activateDeferredSSR(state?: Record<string, unknown>): void;
+    protected $shouldApplySSRBootstrapState(): boolean;
     protected $shouldApplySSRState(_key: string): boolean;
     protected $syncAuthoredAttributes(): void;
+    protected hydratedCallback(): void;
+    private $notifyHydrated;
     protected $shouldApplyTemplateStateFromSSR(_key: string): boolean;
-    protected $setTemplateState(key: string, value: unknown): void;
+    protected $setTemplateState(key: string, value: unknown): boolean;
     private $writeTemplateState;
     private $templateMeta;
     private $templateRootForAttribute;
@@ -44,33 +60,36 @@ export declare class TemplateElement extends HTMLElement {
     private $parseTemplate;
     private $createStagingRoot;
     private $appendStagedChildren;
-    private $releaseStagingRepeatContainers;
+    private $replaceInstanceContainer;
     private $wire;
     private $hydrate;
-    private $collectBetween;
+    private $collectConditionalRange;
+    private $hasRootStructuralSlot;
     private $hydrateCondContent;
     private $findMarker;
-    private $hasContentAfterMarker;
     private $findSSRText;
     private $findSSRSlotRef;
     private $rootTag;
     private $wireAttrs;
     protected $finalize(_instance: TemplateInstance, _root: Node, _meta: TemplateBlockMeta, _resolver: (root: Node, path: TemplateNodePath) => Node | null, _scope?: ScopeFrame): void;
     private $makeAttr;
-    private $repeatMaps;
     private $buildPathIndex;
     private $updateBindings;
+    private $scopeIsKnown;
     $updateInstance(instance: TemplateInstance): void;
     private $patchText;
     private $patchAttr;
     private $toggleCond;
     $resolveValue(path: string, scope?: ScopeFrame): unknown;
+    $hasStateRoot(path: string, scope?: ScopeFrame): boolean;
     private $resolveComponentRoot;
     private $resolveParts;
     $block(blockIndex: number): TemplateBlockMeta | undefined;
-    $createBlockInstance(blockIndex: number, scope?: ScopeFrame): TemplateInstance | null;
+    $createBlockInstance(blockIndex: number, scope?: ScopeFrame, parent?: TemplateInstance, container?: ParentNode & Node): TemplateInstance | null;
     $removeInstance(instance: TemplateInstance): void;
+    private $disposeInstance;
+    private $compactNodeArray;
+    $changeStructure(removedFrom?: TemplateInstance): void;
     $insertInstanceAfter(cursor: Node | null, container: ParentNode & Node, instance: TemplateInstance): Node | null;
-    private $singleDynamic;
 }
 export {};