@lingxia/elements 0.15.0 → 0.16.0

package/dist/inline-native/errors.d.ts

@@ -0,0 +1,8 @@
+import { type NativeError, type RootRef } from "./types.js";
+import type { NativeErrorCode } from "./schema.js";
+export declare function nativeError(code: NativeErrorCode, message: string, options?: {
+    scope?: "node" | "root";
+    recoverable?: boolean;
+    root?: RootRef;
+}): NativeError;
+export declare function isNativeErrorCode(value: unknown): value is NativeErrorCode;

package/dist/inline-native/errors.js

@@ -0,0 +1,23 @@
+import { EMPTY_ROOT_REF } from "./types.js";
+export function nativeError(code, message, options = {}) {
+    var _a, _b, _c;
+    return {
+        code,
+        scope: (_a = options.scope) !== null && _a !== void 0 ? _a : "root",
+        recoverable: (_b = options.recoverable) !== null && _b !== void 0 ? _b : false,
+        root: (_c = options.root) !== null && _c !== void 0 ? _c : EMPTY_ROOT_REF,
+        message,
+    };
+}
+export function isNativeErrorCode(value) {
+    return (value === "NATIVE_ROOT_UNAVAILABLE" ||
+        value === "NATIVE_ROOT_INCOMPATIBLE" ||
+        value === "NATIVE_ROOT_INVALID_STRUCTURE" ||
+        value === "NATIVE_ROOT_FAILED" ||
+        value === "NATIVE_ROOT_UNSUPPORTED_LAYOUT" ||
+        value === "NATIVE_COMPONENT_INVALID_PROPS" ||
+        value === "NATIVE_COMPONENT_MOUNT_FAILED" ||
+        value === "NATIVE_COMPONENT_COMMAND_FAILED" ||
+        value === "NATIVE_ROOT_UNSUPPORTED_STYLE" ||
+        value === "NATIVE_ROOT_DESTROYED");
+}

package/dist/inline-native/events.d.ts

@@ -0,0 +1,10 @@
+export type IslandHostMessage = {
+    event?: string;
+    action?: string;
+    detail?: unknown;
+};
+export type IslandEventTarget = {
+    dispatchEvent(event: Event): boolean;
+};
+/** Dispatch native interaction payloads onto the author element. */
+export declare function applyIslandHostEvent(target: IslandEventTarget, message: IslandHostMessage): boolean;

package/dist/inline-native/events.js

@@ -0,0 +1,16 @@
+const HOST_EVENTS = new Set(["press", "focus", "blur", "pointerenter", "pointerleave", "pointerwithinchange"]);
+/** Dispatch native interaction payloads onto the author element. */
+export function applyIslandHostEvent(target, message) {
+    var _a, _b, _c;
+    const name = String((_b = (_a = message.event) !== null && _a !== void 0 ? _a : message.action) !== null && _b !== void 0 ? _b : "").toLowerCase();
+    if (!HOST_EVENTS.has(name)) {
+        return false;
+    }
+    const detail = (_c = message.detail) !== null && _c !== void 0 ? _c : {};
+    target.dispatchEvent(new CustomEvent(name, {
+        detail,
+        bubbles: false,
+        cancelable: false,
+    }));
+    return true;
+}

package/dist/inline-native/geometry.d.ts

@@ -0,0 +1,78 @@
+import type { IdentifiedRoot } from "./identity.js";
+import type { RootRef } from "./types.js";
+export interface NativeGeometrySnapshotJson {
+    action: "geometry.snapshot";
+    surfaceInstanceId: string;
+    pageInstanceId: string;
+    documentInstanceId: string;
+    revision: number;
+    coordinateSpace: "page-unscrolled-css-px";
+    viewportOffset: {
+        x: number;
+        y: number;
+    };
+    roots: Array<{
+        ref: RootRef;
+        basisTreeRevision: number;
+        rootOrder: number;
+        chainKey: string;
+        contentRect: {
+            x: number;
+            y: number;
+            width: number;
+            height: number;
+        };
+        visible: boolean;
+    }>;
+    nodes: Array<{
+        ref: IdentifiedRoot["children"][number]["nodeRef"];
+        chainKey: string;
+        contentRect: {
+            x: number;
+            y: number;
+            width: number;
+            height: number;
+        };
+        clipStack: unknown[];
+        visible: boolean;
+    }>;
+    chains: Array<{
+        chainKey: string;
+        ancestors: Array<{
+            key: string;
+            viewportRect: {
+                x: number;
+                y: number;
+                width: number;
+                height: number;
+            };
+            offsetX: number;
+            offsetY: number;
+        }>;
+    }>;
+}
+export declare function buildGeometrySnapshot(options: {
+    identified: IdentifiedRoot;
+    basisTreeRevision: number;
+    geometryRevision: number;
+    rootOrder: number;
+    rootRect: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    nodeRects: Record<string, {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    }>;
+    nodeVisibility?: Record<string, boolean>;
+    nodeClipStacks?: Record<string, unknown[]>;
+    rootVisible?: boolean;
+    viewportOffset?: {
+        x: number;
+        y: number;
+    };
+}): NativeGeometrySnapshotJson;

package/dist/inline-native/geometry.js

@@ -0,0 +1,40 @@
+export function buildGeometrySnapshot(options) {
+    var _a, _b;
+    const root = options.identified.rootRef;
+    const nodes = [];
+    const walk = (list) => {
+        var _a, _b, _c, _d, _e;
+        for (const node of list) {
+            nodes.push({
+                ref: node.nodeRef,
+                chainKey: "page",
+                contentRect: (_a = options.nodeRects[node.nodeRef.nodeKey]) !== null && _a !== void 0 ? _a : options.rootRect,
+                clipStack: (_c = (_b = options.nodeClipStacks) === null || _b === void 0 ? void 0 : _b[node.nodeRef.nodeKey]) !== null && _c !== void 0 ? _c : [],
+                visible: (_e = (_d = options.nodeVisibility) === null || _d === void 0 ? void 0 : _d[node.nodeRef.nodeKey]) !== null && _e !== void 0 ? _e : true,
+            });
+            walk(node.children);
+        }
+    };
+    walk(options.identified.children);
+    return {
+        action: "geometry.snapshot",
+        surfaceInstanceId: root.surfaceInstanceId,
+        pageInstanceId: root.pageInstanceId,
+        documentInstanceId: root.documentInstanceId,
+        revision: options.geometryRevision,
+        coordinateSpace: "page-unscrolled-css-px",
+        viewportOffset: (_a = options.viewportOffset) !== null && _a !== void 0 ? _a : { x: 0, y: 0 },
+        roots: [
+            {
+                ref: root,
+                basisTreeRevision: options.basisTreeRevision,
+                rootOrder: options.rootOrder,
+                chainKey: "page",
+                contentRect: options.rootRect,
+                visible: (_b = options.rootVisible) !== null && _b !== void 0 ? _b : true,
+            },
+        ],
+        nodes,
+        chains: [{ chainKey: "page", ancestors: [] }],
+    };
+}

package/dist/inline-native/identity.d.ts

@@ -0,0 +1,28 @@
+import type { CompiledNativeRoot, CoreNode, NodeRef, RootRef } from "./types.js";
+export interface IdentityRecord {
+    nodeKey: string;
+    nodeEpoch: number;
+    kind: CoreNode["kind"];
+    authorId?: string;
+    path: string;
+}
+export interface IdentityTable {
+    byPath: Record<string, IdentityRecord>;
+    byAuthorId: Record<string, IdentityRecord>;
+}
+export interface IdentifiedNode {
+    node: CoreNode;
+    nodeRef: NodeRef;
+    parentRef: NodeRef | null;
+    order: number;
+    path: string;
+    children: IdentifiedNode[];
+}
+export interface IdentifiedRoot {
+    rootRef: RootRef;
+    children: IdentifiedNode[];
+    table: IdentityTable;
+}
+export declare function nextOpaqueKey(prefix: string): string;
+export declare function identifyCompiledRoot(compiled: CompiledNativeRoot, rootRef: RootRef, previous?: IdentifiedRoot | null): IdentifiedRoot;
+export declare function remountIdentity(previous: IdentityRecord): IdentityRecord;

package/dist/inline-native/identity.js

@@ -0,0 +1,51 @@
+let autoKey = 0;
+export function nextOpaqueKey(prefix) {
+    autoKey += 1;
+    return `${prefix}-${autoKey.toString(36)}`;
+}
+export function identifyCompiledRoot(compiled, rootRef, previous = null) {
+    const table = { byPath: Object.create(null), byAuthorId: Object.create(null) };
+    const livePrev = previous ? liveNodeKeys(previous) : new Set();
+    const children = compiled.children.map((child, index) => identifyNode(child, rootRef, null, index, String(index), previous, livePrev, table));
+    return { rootRef, children, table };
+}
+function liveNodeKeys(root) {
+    const keys = new Set();
+    const walk = (nodes) => {
+        for (const node of nodes) {
+            keys.add(node.nodeRef.nodeKey);
+            walk(node.children);
+        }
+    };
+    walk(root.children);
+    return keys;
+}
+function identifyNode(node, rootRef, parentRef, order, path, previous, livePrev, table) {
+    const authorId = node.authorId;
+    const prev = authorId ? previous === null || previous === void 0 ? void 0 : previous.table.byAuthorId[authorId] : previous === null || previous === void 0 ? void 0 : previous.table.byPath[path];
+    let nodeKey;
+    let nodeEpoch;
+    if (prev && prev.kind === node.kind && prev.authorId === authorId && livePrev.delete(prev.nodeKey)) {
+        nodeKey = prev.nodeKey;
+        nodeEpoch = prev.nodeEpoch;
+    }
+    else {
+        nodeKey = nextOpaqueKey("n");
+        nodeEpoch = 1;
+    }
+    const record = { nodeKey, nodeEpoch, kind: node.kind, authorId, path };
+    table.byPath[path] = record;
+    if (authorId) {
+        table.byAuthorId[authorId] = record;
+    }
+    const nodeRef = {
+        ...rootRef,
+        nodeKey,
+        nodeEpoch,
+    };
+    const children = node.children.map((child, index) => identifyNode(child, rootRef, nodeRef, index, `${path}/${index}`, previous, livePrev, table));
+    return { node, nodeRef, parentRef, order, path, children };
+}
+export function remountIdentity(previous) {
+    return { ...previous, nodeEpoch: previous.nodeEpoch + 1 };
+}

package/dist/inline-native/index.d.ts

@@ -0,0 +1,14 @@
+export { INLINE_NATIVE_SCHEMA, NATIVE_ERROR_CODES, PUBLIC_COMPONENT_NAMES, PUBLIC_ELEMENT_TAGS, CORE_KINDS, HOST_FACTORY_KINDS, AUTHOR_COMPONENT_TO_TAG, TAG_TO_AUTHOR_COMPONENT, NATIVE_ACTION_ICONS, POINTER_EVENTS_VALUES, COVER_SCRIM_VALUES, type NativeErrorCode, type PublicComponentName, type PublicElementTag, type CoreKind, type HostFactoryKind, type NativeActionIcon, type NativeStyleProperty, } from "./schema.js";
+export { compileInlineNativeRoot, compileInlineNativeForest, collectAuthorTreeFromElement, normalizeAuthorType, parseBooleanAttr, isFallbackElement, findInlineNativeRoot, } from "./structure.js";
+export { unwrapNativeEventPayload, bindPayloadHandler, isDomEvent } from "./unwrap.js";
+export { applyIslandHostEvent, type IslandHostMessage } from "./events.js";
+export { identifyCompiledRoot, nextOpaqueKey, type IdentifiedRoot, type IdentifiedNode } from "./identity.js";
+export { buildRootCommit, type NativeRootCommitJson } from "./commit.js";
+export { emptyViewLease, viewApplyGrant, viewAcceptLease, viewMarkActive, viewCanShowFallback, type ViewLeaseState, } from "./lease.js";
+export { buildGeometrySnapshot, type NativeGeometrySnapshotJson } from "./geometry.js";
+export { createRootRuntimeState, publishCompiledRoot, applyHostLeaseMessage, type RootRuntimeState, type RootHostMessages, } from "./runtime.js";
+export { VIDEO_COMMANDS, buildVideoCommandRequest, collectVideoResourceUrls, videoCommandUrls, validateControlsSnapshot, type VideoCommand, type VideoCommandRequest, type VideoControlsSemanticSnapshot, } from "./video.js";
+export { nativeError, isNativeErrorCode } from "./errors.js";
+export { EMPTY_ROOT_REF, type RootRef, type NodeRef, type NativeError, type AuthorNode, type AuthorChild, type CoreNode, type CompiledNativeRoot, type CompileInlineNativeResult, type CompileInlineNativeOptions, type PressPayload, type ValuePayload, type FocusPayload, type PointerPayload, type NativeHandler, } from "./types.js";
+export { LxNativeRootElement, LxNativeViewElement, LxNativeCoverElement, LxNativeTextElement, LxNativeButtonElement, registerNativeRootComponent, registerNativeViewComponent, registerNativeCoverComponent, registerNativeTextComponent, registerNativeButtonComponent, registerInlineNativeAuthorComponents, } from "./elements.js";
+export declare function registerInlineNativeComponents(): void;

package/dist/inline-native/index.js

@@ -0,0 +1,19 @@
+export { INLINE_NATIVE_SCHEMA, NATIVE_ERROR_CODES, PUBLIC_COMPONENT_NAMES, PUBLIC_ELEMENT_TAGS, CORE_KINDS, HOST_FACTORY_KINDS, AUTHOR_COMPONENT_TO_TAG, TAG_TO_AUTHOR_COMPONENT, NATIVE_ACTION_ICONS, POINTER_EVENTS_VALUES, COVER_SCRIM_VALUES, } from "./schema.js";
+export { compileInlineNativeRoot, compileInlineNativeForest, collectAuthorTreeFromElement, normalizeAuthorType, parseBooleanAttr, isFallbackElement, findInlineNativeRoot, } from "./structure.js";
+export { unwrapNativeEventPayload, bindPayloadHandler, isDomEvent } from "./unwrap.js";
+export { applyIslandHostEvent } from "./events.js";
+export { identifyCompiledRoot, nextOpaqueKey } from "./identity.js";
+export { buildRootCommit } from "./commit.js";
+export { emptyViewLease, viewApplyGrant, viewAcceptLease, viewMarkActive, viewCanShowFallback, } from "./lease.js";
+export { buildGeometrySnapshot } from "./geometry.js";
+export { createRootRuntimeState, publishCompiledRoot, applyHostLeaseMessage, } from "./runtime.js";
+export { VIDEO_COMMANDS, buildVideoCommandRequest, collectVideoResourceUrls, videoCommandUrls, validateControlsSnapshot, } from "./video.js";
+export { nativeError, isNativeErrorCode } from "./errors.js";
+export { EMPTY_ROOT_REF, } from "./types.js";
+export { LxNativeRootElement, LxNativeViewElement, LxNativeCoverElement, LxNativeTextElement, LxNativeButtonElement, registerNativeRootComponent, registerNativeViewComponent, registerNativeCoverComponent, registerNativeTextComponent, registerNativeButtonComponent, registerInlineNativeAuthorComponents, } from "./elements.js";
+import { registerInlineNativeAuthorComponents } from "./elements.js";
+import { registerVideoComponent } from "../video.js";
+export function registerInlineNativeComponents() {
+    registerInlineNativeAuthorComponents();
+    registerVideoComponent();
+}

package/dist/inline-native/layout.d.ts

@@ -0,0 +1,2 @@
+/** ResizeObserver misses position-only changes (siblings, fonts and ancestor layout). */
+export declare function observeNativeLayout(root: HTMLElement, invalidate: () => void): () => void;

package/dist/inline-native/layout.js

@@ -0,0 +1,58 @@
+import { OBSERVED_STYLE_FIELDS } from "./style.js";
+const NODE_SELECTOR = "lx-native-view,lx-native-cover,lx-native-text,lx-native-button,lx-video";
+const subscriptions = new Set();
+let frame = null;
+let observer;
+let stylesDirty = false;
+function sample() {
+    frame = null;
+    for (const entry of subscriptions) {
+        if (!entry.root.isConnected)
+            continue;
+        const elements = [entry.root, ...Array.from(entry.root.querySelectorAll(NODE_SELECTOR))];
+        for (let ancestor = entry.root.parentElement; ancestor; ancestor = ancestor.parentElement)
+            elements.push(ancestor);
+        const geometry = elements
+            .map((element) => {
+            const rect = element.getBoundingClientRect();
+            const style = getComputedStyle(element);
+            // CSSOM, pseudo-classes and media queries can change paint without a DOM mutation.
+            const paint = OBSERVED_STYLE_FIELDS.map(field => style[field]).join(",");
+            return `${rect.x},${rect.y},${rect.width},${rect.height},${element.clientWidth},${element.clientHeight}:${paint}`;
+        }).join(";");
+        if (stylesDirty || geometry !== entry.geometry) {
+            entry.geometry = geometry;
+            entry.invalidate();
+        }
+    }
+    stylesDirty = false;
+    if (subscriptions.size)
+        frame = requestAnimationFrame(sample);
+}
+/** ResizeObserver misses position-only changes (siblings, fonts and ancestor layout). */
+export function observeNativeLayout(root, invalidate) {
+    const entry = { root, invalidate, geometry: "" };
+    subscriptions.add(entry);
+    if (!observer) {
+        observer = new MutationObserver((records) => {
+            // Root already observes its own subtree. External changes may alter inherited styles.
+            if (records.some((record) => !Array.from(subscriptions).some(({ root }) => root.contains(record.target)))) {
+                stylesDirty = true;
+            }
+        });
+        observer.observe(document.documentElement, { attributes: true, childList: true, characterData: true, subtree: true });
+    }
+    if (frame === null)
+        frame = requestAnimationFrame(sample);
+    return () => {
+        subscriptions.delete(entry);
+        if (!subscriptions.size) {
+            observer === null || observer === void 0 ? void 0 : observer.disconnect();
+            observer = undefined;
+            if (frame !== null)
+                cancelAnimationFrame(frame);
+            frame = null;
+            stylesDirty = false;
+        }
+    };
+}

package/dist/inline-native/lease.d.ts

@@ -0,0 +1,13 @@
+export type ViewLeasePhase = "none" | "granted" | "accept-sent" | "active" | "revoked" | "expired";
+export interface ViewLeaseState {
+    phase: ViewLeasePhase;
+    leaseId?: string;
+    sequence: number;
+    durationMs: number;
+    deadlineTickMs?: number;
+}
+export declare function emptyViewLease(): ViewLeaseState;
+export declare function viewApplyGrant(leaseId: string, sequence: number, durationMs: number, nowMs: number): ViewLeaseState;
+export declare function viewAcceptLease(state: ViewLeaseState): ViewLeaseState | null;
+export declare function viewMarkActive(state: ViewLeaseState): ViewLeaseState;
+export declare function viewCanShowFallback(state: ViewLeaseState, nowMs: number): boolean;

package/dist/inline-native/lease.js

@@ -0,0 +1,31 @@
+export function emptyViewLease() {
+    return { phase: "none", sequence: 0, durationMs: 0 };
+}
+export function viewApplyGrant(leaseId, sequence, durationMs, nowMs) {
+    return {
+        phase: "granted",
+        leaseId,
+        sequence,
+        durationMs,
+        deadlineTickMs: nowMs + durationMs,
+    };
+}
+export function viewAcceptLease(state) {
+    if (state.phase !== "granted" || !state.leaseId)
+        return null;
+    return { ...state, phase: "accept-sent" };
+}
+export function viewMarkActive(state) {
+    return { ...state, phase: "active", deadlineTickMs: undefined };
+}
+export function viewCanShowFallback(state, nowMs) {
+    if (state.phase === "none" || state.phase === "granted" || state.phase === "revoked" || state.phase === "expired") {
+        return true;
+    }
+    if (state.phase === "accept-sent") {
+        return state.deadlineTickMs !== undefined && nowMs >= state.deadlineTickMs;
+    }
+    if (state.phase === "active")
+        return false;
+    return false;
+}

package/dist/inline-native/runtime.d.ts

@@ -0,0 +1,64 @@
+import { type NativeRootCommitJson } from "./commit.js";
+import { type NativeGeometrySnapshotJson } from "./geometry.js";
+import { type IdentifiedRoot } from "./identity.js";
+import { type ViewLeaseState } from "./lease.js";
+import type { CompiledNativeRoot, RootRef } from "./types.js";
+export interface RootRuntimeState {
+    identified: IdentifiedRoot | null;
+    treeRevision: number;
+    geometryRevision: number;
+    lease: ViewLeaseState;
+}
+export interface RootHostMessages {
+    commit?: NativeRootCommitJson;
+    geometry: NativeGeometrySnapshotJson;
+    leaseAccept?: {
+        action: "root.leaseAccept";
+        id: string;
+        root: RootRef;
+        leaseId: string;
+        sequence: number;
+    };
+    ready: boolean;
+}
+export declare function createRootRuntimeState(): RootRuntimeState;
+export declare function publishCompiledRoot(options: {
+    compiled: CompiledNativeRoot;
+    rootRef: RootRef;
+    state: RootRuntimeState;
+    rootRect: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    nodeRects: Record<string, {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    }>;
+    nodeVisibility?: Record<string, boolean>;
+    nodeClipStacks?: Record<string, unknown[]>;
+    rootVisible?: boolean;
+    rootOrder?: number;
+    viewportOffset?: {
+        x: number;
+        y: number;
+    };
+    nowMs?: number;
+}): {
+    state: RootRuntimeState;
+    messages: RootHostMessages;
+};
+export declare function applyHostLeaseMessage(state: RootRuntimeState, message: {
+    action?: string;
+    leaseId?: string;
+    sequence?: number;
+    leaseDurationMs?: number;
+}, nowMs: number): {
+    state: RootRuntimeState;
+    leaseAccept?: RootHostMessages["leaseAccept"];
+    ready: boolean;
+};
+export declare function rootFallbackAllowed(state: RootRuntimeState, nowMs: number): boolean;

package/dist/inline-native/runtime.js

@@ -0,0 +1,119 @@
+import { buildRootCommit } from "./commit.js";
+import { buildGeometrySnapshot } from "./geometry.js";
+import { identifyCompiledRoot } from "./identity.js";
+import { emptyViewLease, viewAcceptLease, viewApplyGrant, viewCanShowFallback, viewMarkActive, } from "./lease.js";
+export function createRootRuntimeState() {
+    return {
+        identified: null,
+        treeRevision: 0,
+        geometryRevision: 0,
+        lease: emptyViewLease(),
+    };
+}
+export function publishCompiledRoot(options) {
+    var _a, _b, _c;
+    const identified = identifyCompiledRoot(options.compiled, options.rootRef, options.state.identified);
+    const first = options.state.identified === null;
+    let treeRevision = options.state.treeRevision;
+    let commit;
+    if (first) {
+        treeRevision = 1;
+        commit = buildRootCommit(identified, null, 1);
+    }
+    else {
+        const next = buildRootCommit(identified, options.state.identified, options.state.treeRevision + 1);
+        if (next.operations.length > 0) {
+            treeRevision = options.state.treeRevision + 1;
+            commit = next;
+        }
+    }
+    const geometryRevision = options.state.geometryRevision + 1;
+    const nodeRects = mapRectsToNodeKeys(identified, options.nodeRects);
+    const nodeVisibility = mapValuesToNodeKeys(identified, (_a = options.nodeVisibility) !== null && _a !== void 0 ? _a : {});
+    const nodeClipStacks = mapValuesToNodeKeys(identified, (_b = options.nodeClipStacks) !== null && _b !== void 0 ? _b : {});
+    const geometry = buildGeometrySnapshot({
+        identified,
+        basisTreeRevision: Math.max(treeRevision, 1),
+        geometryRevision,
+        rootOrder: (_c = options.rootOrder) !== null && _c !== void 0 ? _c : 0,
+        rootRect: options.rootRect,
+        nodeRects,
+        nodeVisibility,
+        nodeClipStacks,
+        rootVisible: options.rootVisible,
+        viewportOffset: options.viewportOffset,
+    });
+    const state = {
+        identified,
+        treeRevision,
+        geometryRevision,
+        lease: options.state.lease,
+    };
+    return {
+        state,
+        messages: {
+            commit,
+            geometry,
+            ready: state.lease.phase === "active",
+        },
+    };
+}
+function mapValuesToNodeKeys(identified, values) {
+    const mapped = { ...values };
+    const walk = (nodes) => {
+        for (const node of nodes) {
+            const authorId = node.node.authorId;
+            if (authorId && values[authorId] !== undefined) {
+                mapped[node.nodeRef.nodeKey] = values[authorId];
+            }
+            walk(node.children);
+        }
+    };
+    walk(identified.children);
+    return mapped;
+}
+export function applyHostLeaseMessage(state, message, nowMs) {
+    var _a, _b;
+    if (message.action === "root.leaseGranted" && message.leaseId) {
+        const granted = viewApplyGrant(message.leaseId, (_a = message.sequence) !== null && _a !== void 0 ? _a : 1, (_b = message.leaseDurationMs) !== null && _b !== void 0 ? _b : 8000, nowMs);
+        const accepted = viewAcceptLease(granted);
+        if (!accepted || !accepted.leaseId || !state.identified) {
+            return { state: { ...state, lease: granted }, ready: false };
+        }
+        return {
+            state: { ...state, lease: accepted },
+            leaseAccept: {
+                action: "root.leaseAccept",
+                id: state.identified.rootRef.rootKey,
+                root: state.identified.rootRef,
+                leaseId: accepted.leaseId,
+                sequence: accepted.sequence,
+            },
+            ready: false,
+        };
+    }
+    if (message.action === "root.leaseActive") {
+        const lease = viewMarkActive(state.lease);
+        return { state: { ...state, lease }, ready: lease.phase === "active" };
+    }
+    return { state, ready: state.lease.phase === "active" };
+}
+export function rootFallbackAllowed(state, nowMs) {
+    return viewCanShowFallback(state.lease, nowMs);
+}
+function mapRectsToNodeKeys(identified, rects) {
+    const mapped = {
+        ...rects,
+    };
+    const walk = (nodes) => {
+        for (const node of nodes) {
+            const authorId = node.node.authorId;
+            if (authorId && rects[authorId]) {
+                mapped[node.nodeRef.nodeKey] = rects[authorId];
+            }
+            walk(node.children);
+        }
+    };
+    walk(identified.children);
+    return mapped;
+}