@cyberart-io/engine 0.0.7 → 0.0.9

package/dist/index.d.ts

@@ -411,6 +411,80 @@ declare class IncompatibleCartStateError extends Error {
     constructor(message: string);
 }
 
+/**
+ * Copyright (c) 2026 Aaron Boyarsky
+ * SPDX-License-Identifier: LicenseRef-CyberArt-Engine
+ * See packages/engine/LICENSE
+ *
+ * Host-controlled time, input, and asset completion for deterministic replays.
+ * Production kaleidoscope / Art Blocks playback does not enable this mode.
+ * Logical asset URLs are resolved by the host preloader (`assetResolver.ts`);
+ * this module only times `ASSET_READY_EVENT` / `ASSET_FAILED_EVENT` delivery.
+ */
+
+declare const ASSET_READY_EVENT = "cyberart.asset.ready";
+declare const ASSET_FAILED_EVENT = "cyberart.asset.failed";
+type PointerKind = 'down' | 'move' | 'up';
+type ScriptedAction = {
+    atFrame: number;
+} & ({
+    type: 'pointer';
+    pointer: {
+        kind: PointerKind;
+        x: number;
+        y: number;
+    };
+} | {
+    type: 'key';
+    key: string;
+} | {
+    type: 'event';
+    event: HostEvent;
+} | {
+    type: 'asset';
+    id: string;
+    status: 'ready' | 'failed';
+    /** Optional structured failure or resolved resource. Envelope is unchanged. */
+    detail?: unknown;
+});
+type DeterministicRuntimeOptions = {
+    /** Virtual clock origin in ms. Default 0. */
+    origin?: number;
+    /** Actions applied at the start of `atFrame`, before `update`. */
+    actions?: ScriptedAction[];
+};
+type ClockSnapshot = {
+    now: number;
+    framesElapsed: number;
+    frameRate: number;
+};
+type ReplayMetadata = {
+    seed: string;
+    clock: ClockSnapshot;
+    rng: RandomState;
+    actions: ScriptedAction[];
+    applied: AppliedAction[];
+    events: HostEvent[];
+    state: unknown;
+};
+type AppliedAction = {
+    frame: number;
+    action: ScriptedAction;
+};
+/**
+ * Compare two replay captures. Empty array means identical; otherwise each
+ * string names the first disagreement on that field.
+ */
+declare function describeReplayMismatch(a: ReplayMetadata, b: ReplayMetadata): string[];
+
+type FrameTimingSample = {
+    frame: number;
+    updateMs: number;
+    renderMs: number;
+    drawMs: number;
+    totalMs: number;
+};
+
 /**
  * Copyright (c) 2026 Aaron Boyarsky
  * SPDX-License-Identifier: LicenseRef-CyberArt-Engine
@@ -466,9 +540,17 @@ type SnapshotIntegrity = {
     alg: string;
     hash: string;
 };
+type SnapshotSignatureRef = {
+    id: string;
+    alg: string;
+};
 type SnapshotProvenance = {
     source?: string;
     integrity?: SnapshotIntegrity;
+    publisher?: string;
+    version?: string;
+    signature?: SnapshotSignatureRef;
+    grants?: string[];
 };
 type SnapshotEnvelope = {
     schemaVersion: typeof SNAPSHOT_SCHEMA_VERSION;
@@ -558,75 +640,9 @@ declare function validateSnapshot(value: unknown): ValidateSnapshotResult;
 declare function snapshotErrorsToMessage(errors: SnapshotDiagnostic[]): string;
 declare function engineStateFromEnvelope(snapshot: SnapshotEnvelope): CartStateBundle;
 
-/**
- * Copyright (c) 2026 Aaron Boyarsky
- * SPDX-License-Identifier: LicenseRef-CyberArt-Engine
- * See packages/engine/LICENSE
- *
- * Host-controlled time, input, and asset completion for deterministic replays.
- * Production kaleidoscope / Art Blocks playback does not enable this mode.
- * Logical asset URLs are resolved by the host preloader (`assetResolver.ts`);
- * this module only times `ASSET_READY_EVENT` / `ASSET_FAILED_EVENT` delivery.
- */
-
-declare const ASSET_READY_EVENT = "cyberart.asset.ready";
-declare const ASSET_FAILED_EVENT = "cyberart.asset.failed";
-type PointerKind = 'down' | 'move' | 'up';
-type ScriptedAction = {
-    atFrame: number;
-} & ({
-    type: 'pointer';
-    pointer: {
-        kind: PointerKind;
-        x: number;
-        y: number;
-    };
-} | {
-    type: 'key';
-    key: string;
-} | {
-    type: 'event';
-    event: HostEvent;
-} | {
-    type: 'asset';
-    id: string;
-    status: 'ready' | 'failed';
-    /** Optional structured failure or resolved resource. Envelope is unchanged. */
-    detail?: unknown;
-});
-type DeterministicRuntimeOptions = {
-    /** Virtual clock origin in ms. Default 0. */
-    origin?: number;
-    /** Actions applied at the start of `atFrame`, before `update`. */
-    actions?: ScriptedAction[];
-};
-type ClockSnapshot = {
-    now: number;
-    framesElapsed: number;
-    frameRate: number;
-};
-type ReplayMetadata = {
-    seed: string;
-    clock: ClockSnapshot;
-    rng: RandomState;
-    actions: ScriptedAction[];
-    applied: AppliedAction[];
-    events: HostEvent[];
-    state: unknown;
-};
-type AppliedAction = {
-    frame: number;
-    action: ScriptedAction;
-};
-/**
- * Compare two replay captures. Empty array means identical; otherwise each
- * string names the first disagreement on that field.
- */
-declare function describeReplayMismatch(a: ReplayMetadata, b: ReplayMetadata): string[];
-
 declare const ASSET_KINDS: readonly ["image", "audio", "font", "spritesheet"];
 type AssetKind = (typeof ASSET_KINDS)[number];
-declare const ASSET_FAILURE_CODES: readonly ["timeout", "cors", "not-found", "invalid", "aborted", "resolver"];
+declare const ASSET_FAILURE_CODES: readonly ["timeout", "cors", "not-found", "invalid", "aborted", "resolver", "undeclared", "hash-mismatch", "unsigned"];
 type AssetFailureCode = (typeof ASSET_FAILURE_CODES)[number];
 type AssetCorsMode = 'anonymous' | 'use-credentials' | 'omit';
 /** Logical silent placeholder. Carts/hosts may treat it as “no media”. */
@@ -767,6 +783,26 @@ declare function assetStatusEvent(status: 'ready' | 'failed', payload: {
 declare function rewriteHostedAssetRef(ref: string, cdnBase: string): string;
 declare function createFixtureAssetResolver(catalog: FixtureAssetCatalog): AssetResolver;
 declare function createHostedAssetResolver(options: HostedAssetResolverOptions): AssetResolver;
+type DeclaredAssetBytes = {
+    url: string;
+    hash: string;
+    alg?: 'sha256';
+};
+type DeclaredAssetResolverOptions = {
+    /** Logical refs this cart may load. Unknown refs fail `undeclared`. */
+    declared: Readonly<Record<string, DeclaredAssetBytes>>;
+    /**
+     * Byte source keyed by declared URL. Tests inject a map. Missing bytes
+     * fail `unsigned`. The resolver does not call ambient `fetch`.
+     */
+    fetchBytes: (url: string) => Promise<Uint8Array | undefined>;
+    hashBytes?: (bytes: Uint8Array) => Promise<string>;
+};
+/**
+ * Resolve only declared asset refs. Bytes must match the declared hash.
+ * Unsigned or mismatched payloads fail closed.
+ */
+declare function createDeclaredAssetResolver(options: DeclaredAssetResolverOptions): AssetResolver;
 declare function createAssetPreloader(options: CreateAssetPreloaderOptions): AssetPreloader;
 
 declare const DEFAULT_DUCK_GAIN = 0.25;
@@ -860,6 +896,7 @@ type FrameErrorInfo = {
     consecutive: number;
     stopped: boolean;
 };
+
 type CreateRuntimeOptions = {
     /** Required mount point. The runtime creates or adopts a canvas inside this element. */
     container: HTMLElement;
@@ -909,6 +946,11 @@ type CreateRuntimeOptions = {
      * `update`, and host-channel events still run. Default `'render'`.
      */
     kind?: CartKind;
+    /**
+     * Optional per-frame update/render/draw timings. Can also be assigned later
+     * via `runtime.onFrameTiming`. Unset = no `performance.now` in the draw loop.
+     */
+    onFrameTiming?: (sample: FrameTimingSample) => void;
 };
 type MountOptions<T = unknown> = {
     /** Boot overrides passed as `customState` into `getDefaultState`. Not a live-state replay. */
@@ -990,6 +1032,11 @@ type CyberArtRuntime = {
     /** `'render'` (default) or `'calculation'` (no canvas / paint). */
     readonly kind: CartKind;
     onError?: (error: unknown, info: FrameErrorInfo) => void;
+    /**
+     * Optional per-frame update/render/draw timings. Unset = zero overhead in the
+     * draw loop (single null check). Same pattern as `onError`.
+     */
+    onFrameTiming?: (sample: FrameTimingSample) => void;
 };
 declare function createRuntime(options: CreateRuntimeOptions): CyberArtRuntime;
 
@@ -1575,6 +1622,9 @@ declare const CAPABILITY_CLEAR_POLICIES: readonly ["transparent", "opaque"];
 type CapabilityClearPolicy = (typeof CAPABILITY_CLEAR_POLICIES)[number];
 declare const CAPABILITY_CART_KINDS: readonly ["render", "calculation"];
 type CapabilityCartKind = (typeof CAPABILITY_CART_KINDS)[number];
+/** Device/host grants a remote cart may request. Omitted on existing manifests. */
+declare const CAPABILITY_DEVICE_GRANTS: readonly ["audio", "controller", "network", "persistence", "fullscreen"];
+type CapabilityDeviceGrant = (typeof CAPABILITY_DEVICE_GRANTS)[number];
 type CapabilityDiagnostic = {
     code: string;
     detail: string;
@@ -1631,6 +1681,8 @@ type CapabilityManifest = {
     modules?: CapabilityModuleRequirements;
     /** Omitted means `'render'`. `'calculation'` carts have no surface. */
     kind?: CapabilityCartKind;
+    /** Optional device grants (CYB-74). Omitted on existing manifests. */
+    grants?: CapabilityDeviceGrant[];
 };
 type CapabilityManifestInput = {
     version?: number;
@@ -1647,6 +1699,7 @@ type CapabilityManifestInput = {
     layers?: CapabilityLayerRequirements;
     modules?: CapabilityModuleRequirements;
     kind?: CapabilityCartKind;
+    grants?: CapabilityDeviceGrant[];
 };
 type HostCapabilities = {
     contractVersion: number;
@@ -1662,6 +1715,11 @@ type HostCapabilities = {
     modules?: CapabilityModuleRequirements;
     /** Cart kinds this host can run. Omitted: kind is not checked. */
     kinds?: CapabilityCartKind[];
+    /**
+     * Device grants this host is willing to give. Omitted is treated as an
+     * empty set (deny-by-default) when the cart listed `grants`.
+     */
+    grants?: CapabilityDeviceGrant[];
 };
 type DefineCapabilityManifestResult = {
     ok: true;
@@ -1856,6 +1914,8 @@ declare function validateGeometry(doc: GeometryDocument): GeometryValidation;
 declare function drawGeometryDebug(ctx: GeometryDebugContext, layout: PresentationLayout, doc: GeometryDocument, diagnostics?: readonly GeometryDiagnostic[]): DebugDrawCall[];
 declare function serializeGeometry(doc: GeometryDocument): string;
 declare function parseGeometry(json: string): GeometryDocument;
+/** True when the normalized point is inside the hitbox rect or polygon. */
+declare function pointInHitbox(region: GeometryHitbox, point: NormalizedPoint): boolean;
 
 /**
  * Copyright (c) 2026 Aaron Boyarsky
@@ -1926,10 +1986,14 @@ type RuntimeGroupParticipantInspect = {
     emit: string[];
     subscribe: string[];
     authoritative: boolean;
+    /** True when the group skips this slot on `step` (portal parent suspend). */
+    suspended: boolean;
 };
 type RuntimeGroupDiagnostics = {
     paused: boolean;
     participantIds: string[];
+    /** Participants skipped by `step` until `resumeParticipant`. Sorted. */
+    suspendedIds: string[];
     clocks: Record<string, ClockSnapshot>;
     rejections: unknown[];
 };
@@ -1961,6 +2025,13 @@ type RuntimeGroup = {
     resize(width: number, height: number): void;
     /** Tear down one participant without destroying the group or blanking siblings. */
     detach(id: string): void;
+    /**
+     * Pause this cart's live loop and skip it on group `step`. Snapshot-safe
+     * state is retained. Used by portal lifecycle; does not pause siblings.
+     */
+    suspendParticipant(id: string): void;
+    resumeParticipant(id: string): void;
+    isParticipantSuspended(id: string): boolean;
     dispatch(participantId: string, event: HostEvent): void;
     publish(event: EventInput, extras?: PublishExtras): EventEnvelope | undefined;
     inspectParticipants(): Array<RouterParticipantInspect & {
@@ -1971,78 +2042,1167 @@ type RuntimeGroup = {
 };
 declare function createRuntimeGroup(options: CreateRuntimeGroupOptions): RuntimeGroup;
 
-declare const REPLAY_INSPECTOR_SCHEMA_VERSION: 1;
-declare const DEFAULT_MAX_INSPECTOR_RECORDS = 512;
-declare const REDACTED_VALUE = "[REDACTED]";
-type ReplayTraceFilter = {
-    types?: string[];
-    sources?: string[];
-    outcomes?: RouterDecisionOutcome[];
-    correlationId?: string;
+/**
+ * Copyright (c) 2026 Aaron Boyarsky
+ * SPDX-License-Identifier: LicenseRef-CyberArt-Engine
+ * See packages/engine/LICENSE
+ *
+ * Trusted, versioned executable-module host. Factories are registered by
+ * exact id+version; the host allowlists which refs may load. Untrusted
+ * source strings are not compiled. Per-module failures do not stop siblings.
+ */
+declare const EXECUTABLE_MODULE_ERROR_CODES: readonly ["invalid-ref", "unknown-module", "version-mismatch", "not-allowlisted", "load-failed", "invoke-failed", "timeout", "rate-limited", "destroyed"];
+type ExecutableModuleErrorCode = (typeof EXECUTABLE_MODULE_ERROR_CODES)[number];
+type ExecutableModuleRef = {
+    id: string;
+    version: string;
 };
-type CreateReplayInspectorOptions = {
-    redactedKeys?: string[];
-    maxRecords?: number;
-    /** Optional contracts so records can include payload schema version. */
-    registry?: Pick<ContractRegistry, 'get'>;
+type ExecutableModuleError = {
+    code: ExecutableModuleErrorCode;
+    detail: string;
+    ref?: ExecutableModuleRef;
 };
-type InspectorRecord = {
-    index: number;
+type ExecutableModuleDiagnostic = ExecutableModuleError;
+type ExecutableModuleCapabilities = {
+    readonly [key: string]: unknown;
+};
+type ExecutableModuleInvokeContext = {
+    signal: AbortSignal;
     turn: number;
-    time: number;
-    outcome: RouterDecisionOutcome;
-    reason?: RouterDecisionReason;
-    detail?: string;
-    source: string;
-    target?: string;
-    type: string;
-    kind?: EventKind;
-    envelopeId?: string;
-    priorEnvelopeId?: string;
-    correlationId?: string;
-    causationId?: string;
-    hops?: number;
-    seq?: number;
-    idempotencyKey?: string;
-    schemaVersion?: number;
-    payloadSchemaVersion?: number;
-    deliveredTo: string[];
-    payload?: unknown;
 };
-type CausationTreeNode = {
-    envelopeId?: string;
-    type: string;
-    source: string;
-    outcome: RouterDecisionOutcome;
-    reason?: RouterDecisionReason;
-    children: CausationTreeNode[];
+type ExecutableModuleInstance = {
+    invoke(input: unknown, context: ExecutableModuleInvokeContext): unknown | Promise<unknown>;
+    destroy?: () => void;
 };
-type ReplayParticipantSummary = {
+type ExecutableModuleFactory = (capabilities: ExecutableModuleCapabilities) => ExecutableModuleInstance;
+type ExecutableModuleRegistration = {
     id: string;
-    kind?: RuntimeGroupKind;
-    emit: string[];
-    subscribe: string[];
-    authoritative: boolean;
-    seed?: string;
-    clock?: ClockSnapshot;
-    state?: unknown;
-    errorCount: number;
-    lastError?: string;
+    version: string;
+    create: ExecutableModuleFactory;
+    capabilities?: ExecutableModuleCapabilities;
 };
-type ReplayInspectorReport = {
-    schemaVersion: typeof REPLAY_INSPECTOR_SCHEMA_VERSION;
-    participants: ReplayParticipantSummary[];
-    records: InspectorRecord[];
-    trees: CausationTreeNode[];
-    dropped: number;
+type ExecutableModuleLimits = {
+    /** Cooperative timeout; the invoke AbortSignal aborts after this many ms. */
+    maxInvokeMs?: number;
+    maxInvokesPerTurn?: number;
 };
-type ReplayTapeAction = {
-    kind: 'publish';
-    event: EventInput;
-    extras?: PublishExtras;
-} | {
-    kind: 'dispatch';
-    participantId: string;
+type CreateExecutableModuleHostOptions = {
+    allowlist: readonly ExecutableModuleRef[];
+    modules: readonly ExecutableModuleRegistration[];
+    limits?: ExecutableModuleLimits;
+    /** Default capability bag. Frozen per module; class instances stay shared handles. */
+    capabilities?: ExecutableModuleCapabilities;
+};
+type ExecutableModuleInvokeResult = {
+    ok: true;
+    value: unknown;
+} | {
+    ok: false;
+    error: ExecutableModuleError;
+};
+type ExecutableModuleLoadResult = {
+    ok: true;
+    ref: ExecutableModuleRef;
+} | {
+    ok: false;
+    error: ExecutableModuleError;
+};
+type ExecutableModuleHostInspect = {
+    allowlist: ExecutableModuleRef[];
+    registered: ExecutableModuleRef[];
+    loaded: ExecutableModuleRef[];
+    turn: number;
+    invokesThisTurn: number;
+    diagnostics: ExecutableModuleDiagnostic[];
+};
+type ExecutableModuleHost = {
+    load(ref: ExecutableModuleRef): ExecutableModuleLoadResult;
+    invoke(ref: ExecutableModuleRef, input?: unknown): Promise<ExecutableModuleInvokeResult>;
+    beginTurn(): void;
+    inspect(): ExecutableModuleHostInspect;
+    destroy(): void;
+};
+/**
+ * Deep-freeze JSON-like values so modules cannot rewrite the bag. Class
+ * instances (and other non-plain objects) are passed through as host handles.
+ */
+declare function freezeCapabilityBag(value: unknown): unknown;
+declare function createExecutableModuleHost(options: CreateExecutableModuleHostOptions): ExecutableModuleHost;
+
+/**
+ * Copyright (c) 2026 Aaron Boyarsky
+ * SPDX-License-Identifier: LicenseRef-CyberArt-Engine
+ * See packages/engine/LICENSE
+ *
+ * Signed, versioned remote-cart manifests. HMAC signatures, declared-asset
+ * loads, and deny-by-default host grants. Trusted factories only — no eval.
+ */
+
+declare const REMOTE_CART_MANIFEST_VERSION: 1;
+declare const REMOTE_CART_SIGNATURE_ALG: "hmac-sha256";
+declare const HOST_GRANT_SNAPSHOT_SCHEMA_VERSION: 1;
+declare const REMOTE_CART_GRANTS: readonly ["audio", "controller", "network", "persistence", "fullscreen"];
+type RemoteCartGrant = CapabilityDeviceGrant;
+declare const REMOTE_CART_ERROR_CODES: readonly ["invalid-json", "invalid-manifest", "invalid-version", "invalid-signature", "unknown-publisher", "unknown-key", "undeclared-asset", "hash-mismatch", "unsigned-bytes", "capability-denied", "destroyed", "load-failed"];
+type RemoteCartErrorCode = (typeof REMOTE_CART_ERROR_CODES)[number];
+type RemoteCartDiagnostic = {
+    code: RemoteCartErrorCode | string;
+    detail: string;
+    path?: string;
+};
+type RemoteCartAsset = {
+    id: string;
+    kind: AssetKind;
+    url: string;
+    hash: string;
+    alg: 'sha256';
+};
+type RemoteCartManifestBody = {
+    version: typeof REMOTE_CART_MANIFEST_VERSION;
+    id: string;
+    cartVersion: string;
+    publisher: string;
+    assets: RemoteCartAsset[];
+    requestedGrants: RemoteCartGrant[];
+    module?: ExecutableModuleRef;
+    capabilities?: CapabilityManifest;
+};
+type RemoteCartSignature = {
+    alg: typeof REMOTE_CART_SIGNATURE_ALG;
+    keyId: string;
+    mac: string;
+};
+type SignedRemoteCartManifest = {
+    body: RemoteCartManifestBody;
+    signature: RemoteCartSignature;
+};
+type DefineRemoteCartResult = {
+    ok: true;
+    manifest: SignedRemoteCartManifest;
+} | {
+    ok: false;
+    errors: RemoteCartDiagnostic[];
+};
+type VerifyRemoteCartResult = {
+    ok: true;
+    manifest: SignedRemoteCartManifest;
+} | {
+    ok: false;
+    errors: RemoteCartDiagnostic[];
+};
+type RemoteCartLoadSource = {
+    kind: 'registry';
+    id: string;
+} | {
+    kind: 'url';
+    url: string;
+};
+type RemoteCartFetchAdapter = (url: string) => Promise<unknown>;
+type RemoteCartRegistry = {
+    get(id: string): SignedRemoteCartManifest | undefined;
+};
+type HostGrantSnapshot = {
+    schemaVersion: typeof HOST_GRANT_SNAPSHOT_SCHEMA_VERSION;
+    grants: RemoteCartGrant[];
+};
+type HostGrantRestoreResult = {
+    ok: true;
+    grants: RemoteCartGrant[];
+} | {
+    ok: false;
+    errors: RemoteCartDiagnostic[];
+};
+type HostGrantSet = {
+    grant(capability: RemoteCartGrant): HostGrantRestoreResult;
+    revoke(capability: RemoteCartGrant): HostGrantRestoreResult;
+    has(capability: RemoteCartGrant): boolean;
+    list(): RemoteCartGrant[];
+    inspect(): HostGrantSnapshot;
+    restore(input: unknown): HostGrantRestoreResult;
+};
+declare class RemoteCartCapabilityError extends Error {
+    readonly code: "capability-denied";
+    readonly grant: RemoteCartGrant;
+    constructor(grant: RemoteCartGrant, api: string);
+}
+type RemoteCartNetworkApi = {
+    fetch(url: string): Promise<Uint8Array>;
+};
+type RemoteCartStorageApi = {
+    getItem(key: string): string | null;
+    setItem(key: string, value: string): void;
+    removeItem(key: string): void;
+    clear(): void;
+};
+type RemoteCartDeviceApi = {
+    request(): {
+        ok: true;
+    };
+};
+type RemoteCartCapabilityBag = ExecutableModuleCapabilities & {
+    grants: readonly RemoteCartGrant[];
+    network: RemoteCartNetworkApi;
+    storage: RemoteCartStorageApi;
+    audio: RemoteCartDeviceApi;
+    controller: RemoteCartDeviceApi;
+    fullscreen: RemoteCartDeviceApi;
+};
+type RemoteCartInspect = {
+    id: string;
+    cartVersion: string;
+    publisher: string;
+    signature: {
+        id: string;
+        alg: string;
+    };
+    requestedGrants: RemoteCartGrant[];
+    grants: RemoteCartGrant[];
+    assets: Array<{
+        id: string;
+        url: string;
+        hash: string;
+    }>;
+    loaded: boolean;
+    destroyed: boolean;
+    diagnostics: RemoteCartDiagnostic[];
+};
+type RemoteCartSandbox = {
+    listRequestedGrants(): RemoteCartGrant[];
+    grants: HostGrantSet;
+    loadAssets(): Promise<{
+        ok: true;
+        snapshot: AssetPreloadSnapshot;
+    } | {
+        ok: false;
+        errors: RemoteCartDiagnostic[];
+    }>;
+    capabilities(): RemoteCartCapabilityBag | {
+        ok: false;
+        errors: RemoteCartDiagnostic[];
+    };
+    inspect(): RemoteCartInspect;
+    snapshotProvenance(): SnapshotProvenance;
+    destroy(): void;
+};
+type CreateRemoteCartSandboxOptions = {
+    manifest: SignedRemoteCartManifest;
+    /** Host HMAC secrets keyed by `signature.keyId`. Sandbox re-verifies before load. */
+    keys: Readonly<Record<string, string>>;
+    grants?: Iterable<RemoteCartGrant>;
+    bytesByUrl: Readonly<Record<string, Uint8Array>>;
+    modules?: readonly ExecutableModuleRegistration[];
+};
+type LoadRemoteCartOptions = {
+    source: RemoteCartLoadSource;
+    keys: Readonly<Record<string, string>>;
+    registry?: RemoteCartRegistry;
+    fetch?: RemoteCartFetchAdapter;
+    expectedVersion?: string;
+};
+declare function sha256Hex(data: Uint8Array | string): Promise<string>;
+declare function hmacSha256Hex(secret: string, message: string): Promise<string>;
+declare function canonicalizeRemoteCartBody(body: RemoteCartManifestBody): string;
+declare function defineRemoteCartManifest(input: unknown): DefineRemoteCartResult;
+declare function parseRemoteCartManifest(json: string | unknown): DefineRemoteCartResult;
+declare function signRemoteCartManifest(bodyInput: unknown, secret: string, keyId: string): Promise<DefineRemoteCartResult>;
+declare function verifyRemoteCartSignature(signed: unknown, keys: Readonly<Record<string, string>>, expectedVersion?: string): Promise<VerifyRemoteCartResult>;
+declare function createRemoteCartRegistry(entries: Readonly<Record<string, SignedRemoteCartManifest | string>>): RemoteCartRegistry;
+declare function loadRemoteCart(options: LoadRemoteCartOptions): Promise<VerifyRemoteCartResult>;
+declare function listRequestedRemoteCartGrants(manifest: SignedRemoteCartManifest): RemoteCartGrant[];
+declare function createHostGrantSet(initial?: Iterable<RemoteCartGrant>): HostGrantSet;
+declare function remoteCartProvenanceForSnapshot(manifest: SignedRemoteCartManifest, grants: readonly RemoteCartGrant[]): SnapshotProvenance;
+declare function createRemoteCartSandbox(options: CreateRemoteCartSandboxOptions): RemoteCartSandbox;
+
+/**
+ * Copyright (c) 2026 Aaron Boyarsky
+ * SPDX-License-Identifier: LicenseRef-CyberArt-Engine
+ * See packages/engine/LICENSE
+ *
+ * Universal portal/experience lifecycle: enter another cart exclusively,
+ * suspend the parent, transfer host grants, return a versioned outcome.
+ * Cabinet, painting, and other host metaphors are the same primitive.
+ */
+
+declare const PORTAL_LIFECYCLE_SNAPSHOT_SCHEMA_VERSION: 1;
+declare const PORTAL_OUTCOME_SCHEMA_VERSION: 1;
+declare const DEFAULT_PORTAL_MAX_DEPTH = 8;
+declare const PORTAL_METAPHORS: readonly ["cabinet", "painting", "dream", "wormhole", "book", "nested-world"];
+type PortalMetaphor = (typeof PORTAL_METAPHORS)[number];
+declare const PORTAL_OUTCOME_KINDS: readonly ["completed", "aborted"];
+type PortalOutcomeKind = (typeof PORTAL_OUTCOME_KINDS)[number];
+/** Exclusive device grants transferred for the child's lifetime. */
+declare const PORTAL_EXCLUSIVE_GRANTS: readonly ["audio", "controller", "fullscreen"];
+type PortalExclusiveGrant = (typeof PORTAL_EXCLUSIVE_GRANTS)[number];
+declare const PORTAL_ENTERED_EVENT = "portal.lifecycle.entered";
+declare const PORTAL_EXITED_EVENT = "portal.lifecycle.exited";
+declare const PORTAL_ABORTED_EVENT = "portal.lifecycle.aborted";
+declare const PORTAL_LIFECYCLE_EVENTS: readonly ["portal.lifecycle.entered", "portal.lifecycle.exited", "portal.lifecycle.aborted"];
+type PortalLifecycleEventType = (typeof PORTAL_LIFECYCLE_EVENTS)[number];
+type PortalDiagnostic = {
+    code: string;
+    detail: string;
+    path?: string;
+};
+type PortalOutcome = {
+    schemaVersion: typeof PORTAL_OUTCOME_SCHEMA_VERSION;
+    kind: PortalOutcomeKind;
+    payload?: unknown;
+};
+type PortalCartDeclaration = {
+    id: string;
+    /** Cart ids this cart may enter. */
+    targets: readonly string[];
+    acceptedOutcomeSchemaVersion?: number;
+    emittedOutcomeSchemaVersion?: number;
+};
+type PortalEnterRequest = {
+    from: string;
+    to: string;
+    metaphor?: PortalMetaphor;
+    seed?: string;
+    clock?: number;
+    /** Extra grants to give the child (exclusive ones are transferred from parent). */
+    grants?: readonly CapabilityDeviceGrant[];
+    state?: unknown;
+    persistence?: unknown;
+};
+type PortalFrameInspect = {
+    id: string;
+    parentId: string;
+    childId: string;
+    metaphor: PortalMetaphor;
+    seed: string | null;
+    clock: number | null;
+    parentState: unknown;
+    parentGrants: CapabilityDeviceGrant[];
+    /** Live child grants after transfer + extras. */
+    childGrants: CapabilityDeviceGrant[];
+    /** Child grants before enter, used to restore and revert extras. */
+    childGrantsBefore: CapabilityDeviceGrant[];
+    extraChildGrants: CapabilityDeviceGrant[];
+    persistence: unknown;
+    transferred: PortalExclusiveGrant[];
+    enterCue: typeof PORTAL_ENTERED_EVENT;
+    exitCue: typeof PORTAL_EXITED_EVENT | typeof PORTAL_ABORTED_EVENT | null;
+};
+type PortalLifecycleSnapshot = {
+    schemaVersion: typeof PORTAL_LIFECYCLE_SNAPSHOT_SCHEMA_VERSION;
+    activeId: string | null;
+    stack: PortalFrameInspect[];
+    lastOutcome: PortalOutcome | null;
+    cues: PortalLifecycleEventType[];
+};
+type PortalInspect = {
+    destroyed: boolean;
+    activeId: string | null;
+    stack: PortalFrameInspect[];
+    lastOutcome: PortalOutcome | null;
+    cues: PortalLifecycleEventType[];
+    grants: Record<string, CapabilityDeviceGrant[]>;
+};
+type PortalMutationResult = {
+    ok: true;
+    inspect: PortalInspect;
+    outcome?: PortalOutcome;
+} | {
+    ok: false;
+    errors: PortalDiagnostic[];
+};
+type RestorePortalResult = {
+    ok: true;
+    snapshot: PortalLifecycleSnapshot;
+} | {
+    ok: false;
+    errors: PortalDiagnostic[];
+};
+type CreatePortalLifecycleOptions = {
+    group?: RuntimeGroup;
+    /** Per-participant grant sets. Missing ids get an empty HostGrantSet. */
+    grants?: Readonly<Record<string, HostGrantSet>>;
+    audioBroker?: AudioBroker;
+    declarations?: readonly PortalCartDeclaration[];
+    rootId?: string;
+    maxDepth?: number;
+    createId?: () => string;
+};
+type PortalLifecycle = {
+    enter(request: PortalEnterRequest): PortalMutationResult;
+    exit(payload?: unknown): PortalMutationResult;
+    abort(payload?: unknown): PortalMutationResult;
+    stack(): PortalFrameInspect[];
+    activeId(): string | null;
+    inspect(): PortalInspect;
+    snapshot(): PortalLifecycleSnapshot;
+    restore(input: unknown): RestorePortalResult;
+    grantsOf(participantId: string): HostGrantSet;
+    destroy(): void;
+};
+/**
+ * Same `enter` / `exit` / `abort` as the session. Metaphor is fixed so cabinet
+ * and painting hosts share lifecycle code.
+ */
+declare function cabinetPortal(portal: PortalLifecycle): {
+    enter: (request: Omit<PortalEnterRequest, 'metaphor'>) => PortalMutationResult;
+    exit: (payload?: unknown) => PortalMutationResult;
+    abort: (payload?: unknown) => PortalMutationResult;
+};
+declare function paintingPortal(portal: PortalLifecycle): {
+    enter: (request: Omit<PortalEnterRequest, 'metaphor'>) => PortalMutationResult;
+    exit: (payload?: unknown) => PortalMutationResult;
+    abort: (payload?: unknown) => PortalMutationResult;
+};
+declare function createPortalLifecycle(options?: CreatePortalLifecycleOptions): PortalLifecycle;
+
+/**
+ * Copyright (c) 2026 Aaron Boyarsky
+ * SPDX-License-Identifier: LicenseRef-CyberArt-Engine
+ * See packages/engine/LICENSE
+ *
+ * Durable asynchronous job orchestration: lifecycle, persistence, worker
+ * boundary, evaluator feedback, and host-owned apply. Wall-clock completion
+ * never mutates authoritative host state.
+ */
+
+declare const JOB_ORCHESTRATION_SNAPSHOT_SCHEMA_VERSION: 1;
+declare const JOB_RESULT_REF_SCHEMA_VERSION: 1;
+declare const JOB_STATES: readonly ["queued", "claimed", "awaiting-evaluation", "retry-scheduled", "ready", "applied", "failed", "canceled", "superseded"];
+type JobState = (typeof JOB_STATES)[number];
+declare const JOB_RETRYABILITY: readonly ["retryable", "permanent", "unknown"];
+type JobRetryability = (typeof JOB_RETRYABILITY)[number];
+declare const JOB_EVALUATOR_DECISIONS: readonly ["accept", "reject", "revise"];
+type JobEvaluatorDecision = (typeof JOB_EVALUATOR_DECISIONS)[number];
+declare const JOB_SUBMITTED_EVENT = "job.intent.submitted";
+declare const JOB_QUEUED_EVENT = "job.state.queued";
+declare const JOB_CLAIMED_EVENT = "job.state.claimed";
+declare const JOB_PROGRESS_EVENT = "job.state.progress";
+declare const JOB_AWAITING_EVALUATION_EVENT = "job.state.awaiting-evaluation";
+declare const JOB_RETRY_SCHEDULED_EVENT = "job.state.retry-scheduled";
+declare const JOB_READY_EVENT = "job.state.ready";
+declare const JOB_APPLIED_EVENT = "job.state.applied";
+declare const JOB_FAILED_EVENT = "job.state.failed";
+declare const JOB_CANCELED_EVENT = "job.state.canceled";
+declare const JOB_SUPERSEDED_EVENT = "job.state.superseded";
+declare const JOB_DIAGNOSTIC_EVENT = "job.diagnostic.lifecycle";
+declare const JOB_LIFECYCLE_EVENTS: readonly ["job.intent.submitted", "job.state.queued", "job.state.claimed", "job.state.progress", "job.state.awaiting-evaluation", "job.state.retry-scheduled", "job.state.ready", "job.state.applied", "job.state.failed", "job.state.canceled", "job.state.superseded", "job.diagnostic.lifecycle"];
+type JobLifecycleEventType = (typeof JOB_LIFECYCLE_EVENTS)[number];
+/** Keys replaced with REDACTED_VALUE in exported traces. */
+declare const JOB_REDACTED_KEYS: readonly ["prompt", "credentials", "credential", "authorization", "apiKey", "secret"];
+type JobDiagnostic = {
+    code: string;
+    detail: string;
+    path?: string;
+};
+type JobResultRef = {
+    schemaVersion: typeof JOB_RESULT_REF_SCHEMA_VERSION;
+    kind: string;
+    uri: string;
+    contentType?: string;
+    bytes?: number;
+};
+type JobRetryPolicy = {
+    maxAttempts: number;
+    backoffMs: readonly number[];
+    retryableCodes: readonly string[];
+};
+type JobFallback = {
+    reasonCode: string;
+    resultRef?: JobResultRef;
+};
+type JobDefinition = {
+    id: string;
+    version: number;
+    requestSchema: PayloadSchema;
+    resultKind: string;
+    retry: JobRetryPolicy;
+    timeoutMs: number;
+    leaseMs: number;
+    fallback: JobFallback;
+};
+type JobProgress = {
+    value: number;
+    stage: string;
+    message?: string;
+};
+type JobFailureRecord = {
+    attempt: number;
+    code: string;
+    retryability: JobRetryability;
+    at: number;
+    detail?: string;
+};
+type JobEvaluatorRecord = {
+    decision: JobEvaluatorDecision;
+    at: number;
+    correction?: string;
+};
+type JobRecord = {
+    jobId: string;
+    definitionId: string;
+    definitionVersion: number;
+    idempotencyKey: string;
+    state: JobState;
+    request: unknown;
+    resultRef: JobResultRef | null;
+    progress: JobProgress;
+    attempt: number;
+    failureHistory: JobFailureRecord[];
+    evaluatorHistory: JobEvaluatorRecord[];
+    correlationId: string;
+    causationId?: string;
+    workerId: string | null;
+    leaseUntil: number | null;
+    createdAt: number;
+    updatedAt: number;
+    timeoutAt: number;
+    nextRetryAt: number | null;
+    supersededBy: string | null;
+    fallbackApplied: boolean;
+    fallback?: JobFallback;
+};
+type JobCoordinatorSnapshot = {
+    schemaVersion: typeof JOB_ORCHESTRATION_SNAPSHOT_SCHEMA_VERSION;
+    jobs: JobRecord[];
+    hostAcceptedJobIds: string[];
+};
+type JobInspect = {
+    destroyed: boolean;
+    jobs: JobRecord[];
+    events: JobLifecycleEventType[];
+};
+type JobMutationResult = {
+    ok: true;
+    job: JobRecord;
+} | {
+    ok: false;
+    errors: JobDiagnostic[];
+};
+type RestoreJobResult = {
+    ok: true;
+    snapshot: JobCoordinatorSnapshot;
+} | {
+    ok: false;
+    errors: JobDiagnostic[];
+};
+type JobSubmitRequest = {
+    definitionId: string;
+    idempotencyKey: string;
+    request: unknown;
+    correlationId: string;
+    causationId?: string;
+    supersedeJobId?: string;
+};
+type JobPersistenceAdapter = {
+    save(job: JobRecord): void;
+    get(jobId: string): JobRecord | undefined;
+    getByIdempotencyKey(key: string): JobRecord | undefined;
+    list(): JobRecord[];
+    replaceAll(jobs: JobRecord[]): void;
+};
+type JobWorkRequest = {
+    jobId: string;
+    workerId: string;
+    definitionId: string;
+    request: unknown;
+    attempt: number;
+};
+type JobWorkerCallbacks = {
+    reportProgress(jobId: string, progress: JobProgress): JobMutationResult;
+    complete(jobId: string, resultRef: JobResultRef): JobMutationResult;
+    fail(jobId: string, failure: {
+        code: string;
+        retryability: JobRetryability;
+        detail?: string;
+    }): JobMutationResult;
+    heartbeat(jobId: string): JobMutationResult;
+};
+type JobWorkerAdapter = {
+    bind(callbacks: JobWorkerCallbacks): void;
+    start(work: JobWorkRequest): void;
+    cancel?(jobId: string): void;
+};
+type HeadlessJobWorker = JobWorkerAdapter & {
+    complete(jobId: string, resultRef: JobResultRef): JobMutationResult;
+    fail(jobId: string, failure: {
+        code: string;
+        retryability: JobRetryability;
+        detail?: string;
+    }): JobMutationResult;
+    started(): string[];
+};
+type CreateJobCoordinatorOptions = {
+    definitions: readonly JobDefinition[];
+    persistence?: JobPersistenceAdapter;
+    worker?: JobWorkerAdapter;
+    router?: Pick<EventRouter, 'publish'>;
+    now?: () => number;
+    createId?: () => string;
+    maxCorrectionChars?: number;
+    maxFailureHistory?: number;
+};
+type JobCoordinator = {
+    submit(request: JobSubmitRequest): JobMutationResult;
+    claim(workerId: string): JobMutationResult;
+    reportProgress(jobId: string, progress: JobProgress): JobMutationResult;
+    heartbeat(jobId: string): JobMutationResult;
+    complete(jobId: string, resultRef: JobResultRef): JobMutationResult;
+    fail(jobId: string, failure: {
+        code: string;
+        retryability: JobRetryability;
+        detail?: string;
+    }): JobMutationResult;
+    evaluate(jobId: string, decision: JobEvaluatorDecision, correction?: string): JobMutationResult;
+    cancel(jobId: string): JobMutationResult;
+    recoverStale(): JobRecord[];
+    tick(): JobRecord[];
+    /** Host policy gate. Ready jobs become applied; never called from worker complete. */
+    accept(jobId: string): JobMutationResult;
+    get(jobId: string): JobRecord | undefined;
+    getByIdempotencyKey(key: string): JobRecord | undefined;
+    inspect(): JobInspect;
+    snapshot(): JobCoordinatorSnapshot;
+    restore(input: unknown): RestoreJobResult;
+    exportTrace(): {
+        jobs: unknown[];
+        events: JobLifecycleEventType[];
+    };
+    destroy(): void;
+};
+declare function jobEventContracts(): EventContract[];
+declare function createMemoryJobPersistence(): JobPersistenceAdapter;
+declare function createHeadlessJobWorker(): HeadlessJobWorker;
+declare function createJobCoordinator(options: CreateJobCoordinatorOptions): JobCoordinator;
+
+/**
+ * Copyright (c) 2026 Aaron Boyarsky
+ * SPDX-License-Identifier: LicenseRef-CyberArt-Engine
+ * See packages/engine/LICENSE
+ *
+ * Optional spatial world graph: nodes, edges, discovery projections, entity
+ * transit, and host-owned path policy. Semantic time and story rules stay
+ * with the host. No economy, combat, quest, or narrative.
+ */
+
+declare const WORLD_GRAPH_SNAPSHOT_SCHEMA_VERSION: 1;
+declare const WORLD_NODE_KINDS: readonly ["room", "region", "landmark", "frontier"];
+type WorldNodeKind = (typeof WORLD_NODE_KINDS)[number];
+declare const WORLD_MAP_LAYERS: readonly ["local", "regional"];
+type WorldMapLayer = (typeof WORLD_MAP_LAYERS)[number];
+declare const WORLD_EDGE_VISIBILITIES: readonly ["canonical", "discoverable", "hidden"];
+type WorldEdgeVisibility = (typeof WORLD_EDGE_VISIBILITIES)[number];
+declare const WORLD_EDGE_ACCESS: readonly ["open", "locked", "disabled"];
+type WorldEdgeAccess = (typeof WORLD_EDGE_ACCESS)[number];
+declare const WORLD_ENTITY_KINDS: readonly ["character", "party"];
+type WorldEntityKind = (typeof WORLD_ENTITY_KINDS)[number];
+declare const WORLD_ENTITY_STATUSES: readonly ["available", "busy", "traveling"];
+type WorldEntityStatus = (typeof WORLD_ENTITY_STATUSES)[number];
+declare const WORLD_NODE_ADDED_EVENT = "world.graph.state.node-added";
+declare const WORLD_EDGE_ADDED_EVENT = "world.graph.state.edge-added";
+declare const WORLD_DISCOVERED_EVENT = "world.graph.state.discovered";
+declare const WORLD_TRANSIT_EVENT = "world.graph.state.transit";
+declare const WORLD_GRAPH_DIAGNOSTIC_EVENT = "world.graph.diagnostic.lifecycle";
+declare const WORLD_GRAPH_EVENTS: readonly ["world.graph.state.node-added", "world.graph.state.edge-added", "world.graph.state.discovered", "world.graph.state.transit", "world.graph.diagnostic.lifecycle"];
+type WorldGraphEventType = (typeof WORLD_GRAPH_EVENTS)[number];
+type WorldGraphDiagnostic = {
+    code: string;
+    detail: string;
+    path?: string;
+};
+type WorldNode = {
+    id: string;
+    version: number;
+    kind: WorldNodeKind;
+    mapLayer: WorldMapLayer;
+    frontier?: boolean;
+    metadata?: Record<string, unknown>;
+};
+type WorldEdge = {
+    id: string;
+    version: number;
+    from: string;
+    to: string;
+    directed: boolean;
+    kind: string;
+    visibility: WorldEdgeVisibility;
+    access: WorldEdgeAccess;
+    requirements?: Record<string, unknown>;
+    cost?: Record<string, number>;
+    metadata?: Record<string, unknown>;
+};
+type WorldTransit = {
+    originNodeId: string;
+    destinationNodeId: string;
+    routeEdgeIds: readonly string[];
+    departedAt: number;
+    expectedArrival: number;
+};
+type WorldEntity = {
+    id: string;
+    kind: WorldEntityKind;
+    status: WorldEntityStatus;
+    locationNodeId: string | null;
+    transit: WorldTransit | null;
+    metadata?: Record<string, unknown>;
+};
+type WorldObserverDiscovery = {
+    observerId: string;
+    nodeIds: readonly string[];
+    edgeIds: readonly string[];
+};
+type WorldGraphSnapshot = {
+    schemaVersion: typeof WORLD_GRAPH_SNAPSHOT_SCHEMA_VERSION;
+    graphId: string;
+    nodes: WorldNode[];
+    edges: WorldEdge[];
+    entities: WorldEntity[];
+    discovery: WorldObserverDiscovery[];
+};
+type WorldGraphProjection = {
+    kind: 'canonical' | 'known' | 'local' | 'regional';
+    observerId?: string;
+    focusNodeId?: string;
+    nodes: WorldNode[];
+    edges: WorldEdge[];
+    frontiers: WorldNode[];
+    entities: WorldEntity[];
+};
+type WorldPathStep = {
+    edgeId: string;
+    from: string;
+    to: string;
+    cost: number;
+};
+type WorldPath = {
+    from: string;
+    to: string;
+    nodeIds: string[];
+    steps: WorldPathStep[];
+    totalCost: number;
+};
+type WorldTraversalContext = {
+    semanticTime: number;
+    observerId?: string;
+    hostState?: unknown;
+};
+type WorldTraversalPolicy = {
+    canTraverse(edge: WorldEdge, from: string, to: string, ctx: WorldTraversalContext): boolean;
+    cost(edge: WorldEdge, from: string, to: string, ctx: WorldTraversalContext): number;
+};
+type WorldQueryBounds = {
+    maxVisits?: number;
+};
+type WorldGraphInspect = {
+    destroyed: boolean;
+    graphId: string;
+    nodeCount: number;
+    edgeCount: number;
+    entityCount: number;
+    observerCount: number;
+    events: WorldGraphEventType[];
+};
+type WorldMutationResult = {
+    ok: true;
+} | {
+    ok: false;
+    errors: WorldGraphDiagnostic[];
+};
+type RestoreWorldGraphResult = {
+    ok: true;
+    snapshot: WorldGraphSnapshot;
+} | {
+    ok: false;
+    errors: WorldGraphDiagnostic[];
+};
+type WorldPathResult = {
+    ok: true;
+    path: WorldPath;
+} | {
+    ok: false;
+    errors: WorldGraphDiagnostic[];
+};
+type WorldReachabilityResult = {
+    nodeIds: string[];
+};
+type WorldGraphPatch = {
+    nodes?: readonly WorldNode[];
+    edges?: readonly WorldEdge[];
+};
+type CreateWorldGraphOptions = {
+    graphId?: string;
+    migrations?: readonly SnapshotMigration[];
+    router?: Pick<EventRouter, 'publish'>;
+    source?: string;
+    maxPathVisits?: number;
+};
+type WorldGraph = {
+    addNode(node: WorldNode): WorldMutationResult;
+    addEdge(edge: WorldEdge): WorldMutationResult;
+    applyPatch(patch: WorldGraphPatch): WorldMutationResult;
+    removeNode(nodeId: string): WorldMutationResult;
+    removeEdge(edgeId: string): WorldMutationResult;
+    setEdgeAccess(edgeId: string, access: WorldEdgeAccess): WorldMutationResult;
+    discover(observerId: string, known: {
+        nodeIds?: readonly string[];
+        edgeIds?: readonly string[];
+    }): WorldMutationResult;
+    upsertEntity(entity: WorldEntity): WorldMutationResult;
+    startTransit(entityId: string, transit: WorldTransit, status?: Exclude<WorldEntityStatus, 'available'>): WorldMutationResult;
+    completeTransit(entityId: string, semanticTime: number): WorldMutationResult;
+    setEntityStatus(entityId: string, status: WorldEntityStatus): WorldMutationResult;
+    getNode(nodeId: string): WorldNode | undefined;
+    getEdge(edgeId: string): WorldEdge | undefined;
+    getEntity(entityId: string): WorldEntity | undefined;
+    projectCanonical(): WorldGraphProjection;
+    projectKnown(observerId: string): WorldGraphProjection;
+    projectLocal(observerId: string, focusNodeId: string, hops?: number): WorldGraphProjection;
+    projectRegional(observerId: string): WorldGraphProjection;
+    findPath(from: string, to: string, policy: WorldTraversalPolicy, ctx: WorldTraversalContext, bounds?: WorldQueryBounds): WorldPathResult;
+    reachable(from: string, policy: WorldTraversalPolicy, ctx: WorldTraversalContext, bounds?: WorldQueryBounds): WorldReachabilityResult;
+    inspect(): WorldGraphInspect;
+    snapshot(): WorldGraphSnapshot;
+    restore(input: unknown): RestoreWorldGraphResult;
+    events(): readonly EventInput[];
+    destroy(): void;
+};
+declare function worldGraphEventContracts(): EventContract[];
+declare function createWorldGraph(options?: CreateWorldGraphOptions): WorldGraph;
+
+/**
+ * Copyright (c) 2026 Aaron Boyarsky
+ * SPDX-License-Identifier: LicenseRef-CyberArt-Engine
+ * See packages/engine/LICENSE
+ *
+ * Transactional world-patch validation and atomic application. A generated
+ * result becomes one world revision or none — never a half-installed world.
+ * Cyberart is not the host's database of record.
+ */
+
+declare const WORLD_PATCH_SCHEMA_VERSION: 1;
+declare const WORLD_PATCH_SNAPSHOT_SCHEMA_VERSION: 1;
+declare const WORLD_PATCH_OPS: readonly ["add", "replace", "revise", "remove", "tombstone", "link", "unlink"];
+type WorldPatchOp = (typeof WORLD_PATCH_OPS)[number];
+declare const WORLD_PATCH_PRECONDITION_TYPES: readonly ["base-revision", "entity-revision", "entity-hash", "identity-required", "identity-absent", "capability", "schema"];
+type WorldPatchPreconditionType = (typeof WORLD_PATCH_PRECONDITION_TYPES)[number];
+declare const WORLD_PATCH_ACCEPTED_EVENT: "world.patch.state.accepted";
+declare const WORLD_PATCH_REJECTED_EVENT: "world.patch.state.rejected";
+declare const WORLD_PATCH_SUPERSEDED_EVENT: "world.patch.state.superseded";
+declare const WORLD_PATCH_DIAGNOSTIC_EVENT: "world.patch.diagnostic.lifecycle";
+declare const WORLD_PATCH_EVENTS: readonly ["world.patch.state.accepted", "world.patch.state.rejected", "world.patch.state.superseded", "world.patch.diagnostic.lifecycle"];
+type WorldPatchEventType = (typeof WORLD_PATCH_EVENTS)[number];
+declare const WORLD_PATCH_ERROR_CODES: readonly ["invalid-schema", "unknown-field", "unknown-op", "missing-field", "missing-ref", "referential-integrity", "stale-base", "precondition-failed", "asset-unavailable", "content-unavailable", "binding-unavailable", "cycle", "over-limit", "idempotency-conflict", "superseded", "invalid-snapshot", "invalid-version", "destroyed", "domain", "capability-denied", "schema-mismatch", "identity-required", "identity-absent", "entity-revision", "entity-hash", "duplicate-id", "graph-apply-failed", "publish-failed"];
+type WorldPatchErrorCode = (typeof WORLD_PATCH_ERROR_CODES)[number];
+/** Keys replaced with REDACTED_VALUE in audit export. */
+declare const WORLD_PATCH_REDACTED_KEYS: readonly ["prompt", "credentials", "credential", "authorization", "apiKey", "secret"];
+type WorldPatchDiagnostic = {
+    code: WorldPatchErrorCode | string;
+    detail: string;
+    path?: string;
+    expectedRevision?: number;
+    actualRevision?: number;
+};
+type WorldPatchProvenance = {
+    producer: string;
+    jobId?: string;
+    contentRevisions?: string[];
+};
+type WorldPatchRefs = {
+    contentId?: string;
+    contentRevision?: string;
+    binding?: string;
+    asset?: string;
+    identity?: string;
+};
+type WorldPatchOperation = {
+    op: WorldPatchOp;
+    kind: string;
+    id: string;
+    order?: number;
+    value?: unknown;
+    from?: string;
+    to?: string;
+    refs?: WorldPatchRefs;
+};
+type WorldPatchPrecondition = {
+    type: 'base-revision';
+    revision: number;
+} | {
+    type: 'entity-revision';
+    kind: string;
+    id: string;
+    revision: number;
+} | {
+    type: 'entity-hash';
+    kind: string;
+    id: string;
+    hash: string;
+} | {
+    type: 'identity-required';
+    kind: string;
+    id: string;
+} | {
+    type: 'identity-absent';
+    kind: string;
+    id: string;
+} | {
+    type: 'capability';
+    name: string;
+} | {
+    type: 'schema';
+    schemaVersion: number;
+};
+type WorldPatch = {
+    patchId: string;
+    schemaVersion: typeof WORLD_PATCH_SCHEMA_VERSION;
+    baseRevision: number;
+    idempotencyKey: string;
+    preconditions?: WorldPatchPrecondition[];
+    operations: WorldPatchOperation[];
+    provenance: WorldPatchProvenance;
+    supersedes?: string;
+};
+type WorldEntityRecord = {
+    kind: string;
+    id: string;
+    revision: number;
+    hash: string;
+    value: unknown;
+    tombstoned: boolean;
+    refs?: WorldPatchRefs;
+};
+type WorldLinkRecord = {
+    id: string;
+    kind: string;
+    from: string;
+    to: string;
+    value?: unknown;
+};
+type WorldAcceptedPatch = {
+    patchId: string;
+    idempotencyKey: string;
+    revision: number;
+    provenance: WorldPatchProvenance;
+    supersededBy?: string;
+};
+type WorldRevisionState = {
+    revision: number;
+    entities: WorldEntityRecord[];
+    links: WorldLinkRecord[];
+    accepted: WorldAcceptedPatch[];
+};
+type WorldIdentityChange = {
+    op: WorldPatchOp;
+    kind: string;
+    id: string;
+};
+type WorldPatchAuditRecord = {
+    outcome: 'accepted' | 'rejected' | 'superseded';
+    patchId: string;
+    idempotencyKey: string;
+    at: number;
+    oldRevision: number;
+    newRevision: number;
+    reasonCodes: string[];
+    changedIdentities: WorldIdentityChange[];
+    provenance: WorldPatchProvenance | Record<string, unknown>;
+    patch: unknown;
+};
+type WorldPatchSnapshot = {
+    schemaVersion: typeof WORLD_PATCH_SNAPSHOT_SCHEMA_VERSION;
+    world: WorldRevisionState;
+    audit: WorldPatchAuditRecord[];
+    graph?: WorldGraphSnapshot;
+};
+type WorldPatchInspect = {
+    destroyed: boolean;
+    revision: number;
+    entities: WorldEntityRecord[];
+    links: WorldLinkRecord[];
+    acceptedPatchIds: string[];
+    events: WorldPatchEventType[];
+    lastRejection: WorldPatchDiagnostic[] | null;
+};
+type WorldPatchDryRunResult = {
+    ok: true;
+    previewRevision: number;
+    changedIdentities: WorldIdentityChange[];
+    diagnostics: WorldPatchDiagnostic[];
+} | {
+    ok: false;
+    errors: WorldPatchDiagnostic[];
+};
+type WorldPatchCommitResult = {
+    ok: true;
+    patchId: string;
+    oldRevision: number;
+    newRevision: number;
+    changedIdentities: WorldIdentityChange[];
+    idempotent?: boolean;
+    inspect: WorldPatchInspect;
+} | {
+    ok: false;
+    errors: WorldPatchDiagnostic[];
+    inspect: WorldPatchInspect;
+};
+type RestoreWorldPatchResult = {
+    ok: true;
+    snapshot: WorldPatchSnapshot;
+} | {
+    ok: false;
+    errors: WorldPatchDiagnostic[];
+};
+type WorldPersistenceTransaction = {
+    applyWorldRevision(next: WorldRevisionState): void;
+    commit(): void;
+    rollback(): void;
+};
+type WorldPatchAcceptedPayload = {
+    patchId: string;
+    oldRevision: number;
+    newRevision: number;
+    changedIdentities: WorldIdentityChange[];
+    producer: string;
+    jobId?: string;
+    contentRevisions?: string[];
+};
+type WorldPersistenceAdapter = {
+    begin(): WorldPersistenceTransaction;
+    current(): WorldRevisionState;
+    publish?(payload: WorldPatchAcceptedPayload): void;
+};
+type WorldPatchLimits = {
+    maxOperations?: number;
+    maxDiagnostics?: number;
+    maxEntities?: number;
+    maxBytes?: number;
+};
+type WorldPatchContentAvailability = {
+    hasRevision?(contentId: string, revision: string): boolean;
+    available?: ReadonlyArray<{
+        contentId?: string;
+        revision: string;
+    }>;
+};
+type WorldPatchBindingAvailability = {
+    listedIds?: readonly string[];
+};
+type WorldPatchAssetAvailability = {
+    availableIds?: readonly string[];
+};
+type WorldPatchGraphPolicy = {
+    allowCycles?: boolean;
+    detectCycle?(preview: WorldRevisionState): boolean;
+};
+type WorldPatchDomainValidator = (ctx: {
+    patch: WorldPatch;
+    current: WorldRevisionState;
+    preview: WorldRevisionState;
+}) => WorldPatchDiagnostic[];
+type CreateWorldPatchApplierOptions = {
+    persistence?: WorldPersistenceAdapter;
+    graph?: WorldGraph;
+    content?: WorldPatchContentAvailability;
+    bindings?: WorldPatchBindingAvailability;
+    assets?: WorldPatchAssetAvailability;
+    now?: () => number;
+    limits?: WorldPatchLimits;
+    redact?: readonly string[];
+    router?: Pick<EventRouter, 'publish'>;
+    onEvent?: (event: EventInput) => void;
+    domainValidators?: readonly WorldPatchDomainValidator[];
+    capabilities?: readonly string[];
+    graphPolicy?: WorldPatchGraphPolicy;
+    source?: string;
+};
+type WorldPatchApplier = {
+    dryRun(patch: unknown): WorldPatchDryRunResult;
+    commit(patch: unknown): WorldPatchCommitResult;
+    inspect(): WorldPatchInspect;
+    snapshot(): WorldPatchSnapshot;
+    restore(input: unknown): RestoreWorldPatchResult;
+    audit(options?: {
+        redact?: boolean;
+    }): WorldPatchAuditRecord[];
+    events(): readonly EventInput[];
+    destroy(): void;
+};
+declare function worldPatchEventContracts(): EventContract[];
+declare function isWorldPatchErrorCode(value: unknown): value is WorldPatchErrorCode;
+declare function createMemoryWorldPersistence(): WorldPersistenceAdapter;
+declare function createWorldPatchApplier(options?: CreateWorldPatchApplierOptions): WorldPatchApplier;
+
+declare const REPLAY_INSPECTOR_SCHEMA_VERSION: 1;
+declare const DEFAULT_MAX_INSPECTOR_RECORDS = 512;
+declare const REDACTED_VALUE = "[REDACTED]";
+/** Always redacted in traces (CYB-80 prompts/credentials plus user keys). */
+declare const DEFAULT_SENSITIVE_KEYS: readonly ["prompt", "credentials", "credential", "authorization", "apiKey", "secret"];
+type ReplayTraceFilter = {
+    types?: string[];
+    sources?: string[];
+    outcomes?: RouterDecisionOutcome[];
+    correlationId?: string;
+};
+type CreateReplayInspectorOptions = {
+    redactedKeys?: string[];
+    maxRecords?: number;
+    /** Optional contracts so records can include payload schema version. */
+    registry?: Pick<ContractRegistry, 'get'>;
+};
+type InspectorRecord = {
+    index: number;
+    turn: number;
+    time: number;
+    outcome: RouterDecisionOutcome;
+    reason?: RouterDecisionReason;
+    detail?: string;
+    source: string;
+    target?: string;
+    type: string;
+    kind?: EventKind;
+    envelopeId?: string;
+    priorEnvelopeId?: string;
+    correlationId?: string;
+    causationId?: string;
+    hops?: number;
+    seq?: number;
+    idempotencyKey?: string;
+    schemaVersion?: number;
+    payloadSchemaVersion?: number;
+    deliveredTo: string[];
+    payload?: unknown;
+};
+type CausationTreeNode = {
+    envelopeId?: string;
+    type: string;
+    source: string;
+    outcome: RouterDecisionOutcome;
+    reason?: RouterDecisionReason;
+    children: CausationTreeNode[];
+};
+type ReplayParticipantSummary = {
+    id: string;
+    kind?: RuntimeGroupKind;
+    emit: string[];
+    subscribe: string[];
+    authoritative: boolean;
+    seed?: string;
+    clock?: ClockSnapshot;
+    state?: unknown;
+    errorCount: number;
+    lastError?: string;
+};
+type ReplayInspectorReport = {
+    schemaVersion: typeof REPLAY_INSPECTOR_SCHEMA_VERSION;
+    participants: ReplayParticipantSummary[];
+    records: InspectorRecord[];
+    trees: CausationTreeNode[];
+    dropped: number;
+};
+type ReplayTapeAction = {
+    kind: 'publish';
+    event: EventInput;
+    extras?: PublishExtras;
+} | {
+    kind: 'dispatch';
+    participantId: string;
     event: HostEvent;
 } | {
     kind: 'step';
@@ -2093,6 +3253,183 @@ declare function replayExportedTrace(exported: ReplayInspectorExport, group: Run
     report: ReplayInspectorReport;
 }>;
 
+/**
+ * Copyright (c) 2026 Aaron Boyarsky
+ * SPDX-License-Identifier: LicenseRef-CyberArt-Engine
+ * See packages/engine/LICENSE
+ *
+ * Content-selection and presentation-decision traces. Hosts record why a
+ * binding, revision, asset, sequence, or fallback won. Reuses CYB-65
+ * redaction, bounded retention, and correlation ids. There is no Player UI.
+ */
+
+declare const SELECTION_TRACE_SCHEMA_VERSION: 1;
+declare const DEFAULT_MAX_SELECTION_RECORDS = 512;
+declare const SELECTION_REASON_CODES: readonly ["binding-conflict", "asset-failure", "revision-rollback", "sequence-interruption", "text-only-fallback"];
+type SelectionReasonCode = (typeof SELECTION_REASON_CODES)[number];
+declare const SELECTION_DECISION_KINDS: readonly ["state-projection", "binding", "content-revision", "staging", "asset", "sequence", "presentation", "snapshot"];
+type SelectionDecisionKind = (typeof SELECTION_DECISION_KINDS)[number];
+declare const SELECTION_TRACE_SENSITIVE_KEYS: readonly ["prompt", "credentials", "credential", "authorization", "apiKey", "secret", "privatePrompt", "signedUrl", "signedURL", "signed_url", "presignedUrl", "password"];
+declare function isSelectionReasonCode(value: unknown): value is SelectionReasonCode;
+declare function isSelectionDecisionKind(value: unknown): value is SelectionDecisionKind;
+type SelectionBindingEvaluation = {
+    bindingId: string;
+    priority: number;
+    predicateResult: boolean;
+    winner?: boolean;
+    rejectedReason?: string;
+};
+type SelectionContentIdentity = {
+    contentId: string;
+    revision: string;
+    manifestVersion?: number;
+    source?: string;
+    publisher?: string;
+    hashes?: Record<string, string>;
+};
+type SelectionStagingOutcome = 'validated' | 'rejected' | 'cache-hit' | 'cache-miss' | 'superseded' | 'rollback' | 'retained';
+type SelectionStagingResult = {
+    outcome: SelectionStagingOutcome;
+    cache?: 'hit' | 'miss';
+    detail?: string;
+};
+type SelectionAssetResolution = {
+    logicalRef: string;
+    resolver?: string;
+    adapter?: string;
+    mediaHash?: string;
+    ready: boolean;
+    failure?: string;
+    fallback?: string | null;
+};
+type SelectionSequenceDecision = {
+    sequenceId: string;
+    invocationId: string;
+    stepId?: string | null;
+    track?: string | null;
+    decision: 'play' | 'skip' | 'interrupt' | 'replay' | 'complete';
+    capabilityFallback?: string | null;
+};
+type SelectionPresentationDecision = {
+    layerId?: string;
+    variant?: string;
+    regionId?: string;
+    maskRevision?: string | number;
+    blend?: string;
+    hitTest?: boolean;
+    caption?: string | null;
+    audioIntent?: string | null;
+};
+type SelectionSnapshotProvenance = {
+    revision?: string | number | null;
+    schemaVersion?: number;
+    seed?: string;
+};
+type SelectionDecisionInput = {
+    kind: SelectionDecisionKind;
+    reason: SelectionReasonCode | string;
+    summary: string;
+    turn?: number;
+    time?: number;
+    correlationId?: string;
+    causationId?: string;
+    envelopeId?: string;
+    initiatingEventType?: string;
+    projectionRevision?: string | number;
+    projection?: unknown;
+    hostState?: unknown;
+    bindings?: readonly SelectionBindingEvaluation[];
+    winningBindingId?: string | null;
+    rejectedBindingIds?: readonly string[];
+    defaultFallback?: boolean;
+    requestedContent?: SelectionContentIdentity;
+    activatedContent?: SelectionContentIdentity | null;
+    staging?: SelectionStagingResult;
+    lastKnownGood?: SelectionContentIdentity | null;
+    asset?: SelectionAssetResolution;
+    sequence?: SelectionSequenceDecision;
+    presentation?: SelectionPresentationDecision;
+    snapshot?: SelectionSnapshotProvenance;
+};
+type SelectionDecisionRecord = {
+    index: number;
+    kind: SelectionDecisionKind;
+    reason: string;
+    summary: string;
+    turn?: number;
+    time?: number;
+    correlationId?: string;
+    causationId?: string;
+    envelopeId?: string;
+    initiatingEventType?: string;
+    projectionRevision?: string | number;
+    projection?: unknown;
+    bindings?: SelectionBindingEvaluation[];
+    winningBindingId?: string | null;
+    rejectedBindingIds?: string[];
+    defaultFallback?: boolean;
+    requestedContent?: SelectionContentIdentity;
+    activatedContent?: SelectionContentIdentity | null;
+    staging?: SelectionStagingResult;
+    lastKnownGood?: SelectionContentIdentity | null;
+    asset?: SelectionAssetResolution;
+    sequence?: SelectionSequenceDecision;
+    presentation?: SelectionPresentationDecision;
+    snapshot?: SelectionSnapshotProvenance;
+};
+type SelectionTraceFilter = {
+    kinds?: readonly SelectionDecisionKind[];
+    reasons?: readonly string[];
+    correlationId?: string;
+    causationId?: string;
+    envelopeId?: string;
+    contentId?: string;
+    sequenceId?: string;
+};
+type CreateSelectionTraceOptions = {
+    redactedKeys?: readonly string[];
+    maxRecords?: number;
+    sampleRate?: number;
+    /** Safe host-projection field names. All other projection/hostState keys redact. */
+    projectionWhitelist?: readonly string[];
+    inspector?: Pick<ReplayInspector, 'records'>;
+};
+type SelectionTraceExport = {
+    schemaVersion: typeof SELECTION_TRACE_SCHEMA_VERSION;
+    redactedKeys: string[];
+    projectionWhitelist: string[];
+    dropped: number;
+    sampledOut: number;
+    records: SelectionDecisionRecord[];
+    inspectorRecords: InspectorRecord[];
+    snapshotRevision?: string | number | null;
+    snapshotSchemaVersion?: number;
+    snapshotSeed?: string;
+};
+type SelectionTraceReport = {
+    schemaVersion: typeof SELECTION_TRACE_SCHEMA_VERSION;
+    records: SelectionDecisionRecord[];
+    dropped: number;
+    sampledOut: number;
+};
+type SelectionTrace = {
+    recordSelectionDecision(input: SelectionDecisionInput): SelectionDecisionRecord | null;
+    records(filter?: SelectionTraceFilter): SelectionDecisionRecord[];
+    query(filter?: SelectionTraceFilter): SelectionDecisionRecord[];
+    chain(correlationId: string): SelectionDecisionRecord[];
+    exportTrace(filter?: SelectionTraceFilter): SelectionTraceExport;
+    importTrace(exported: SelectionTraceExport | string): void;
+    report(filter?: SelectionTraceFilter): SelectionTraceReport;
+    setSnapshotProvenance(meta: SelectionSnapshotProvenance): void;
+    reset(): void;
+    destroy(): void;
+};
+declare function recordSelectionDecision(trace: SelectionTrace, input: SelectionDecisionInput): SelectionDecisionRecord | null;
+declare function attachSelectionTrace<T extends object>(bundle: T, trace: SelectionTraceExport | null): T & {
+    selectionTrace: SelectionTraceExport | null;
+};
+declare function createSelectionTrace(options?: CreateSelectionTraceOptions): SelectionTrace;
+
 declare const COMPOSITOR_BLEND_MODES: readonly ["source-over", "screen"];
 type CompositorBlendMode = (typeof COMPOSITOR_BLEND_MODES)[number];
 declare const COMPOSITOR_CLEAR_POLICIES: readonly ["transparent", "opaque"];
@@ -2311,152 +3648,882 @@ type VisualLayerSnapshotRow = {
     id: string;
     kind: VisualLayerKind;
     visible: boolean;
-    committedVersion: string | null;
-    pendingVersion: string | null;
-    activeVersion: string | null;
-    opacity: number;
-    order: number;
-    overrideVersion: string | null;
-    provenance: AssetProvenance | null;
-    fallback: VisualLayerFallbackPolicy;
-    transition: VisualLayerTransitionInspect | null;
+    committedVersion: string | null;
+    pendingVersion: string | null;
+    activeVersion: string | null;
+    opacity: number;
+    order: number;
+    overrideVersion: string | null;
+    provenance: AssetProvenance | null;
+    fallback: VisualLayerFallbackPolicy;
+    transition: VisualLayerTransitionInspect | null;
+};
+type VisualLayerControllerSnapshot = {
+    schemaVersion: typeof VISUAL_LAYER_SNAPSHOT_SCHEMA_VERSION;
+    frame: number;
+    sceneId: string | null;
+    reducedMotion: boolean;
+    layers: VisualLayerSnapshotRow[];
+    assets: Record<string, VisualLayerAssetStatus>;
+    events: VisualLayerEvent[];
+    diagnostics: VisualLayerDiagnostic[];
+};
+type PlayVisualLayerResult = PlayCueResult;
+type RestoreVisualLayerResult = {
+    ok: true;
+    snapshot: VisualLayerControllerSnapshot;
+} | {
+    ok: false;
+    errors: VisualLayerDiagnostic[];
+};
+type CreateVisualLayerControllerOptions = {
+    compositor: Compositor;
+    layers: readonly VisualLayerDeclaration[];
+    preloader?: AssetPreloader;
+    originFrame?: number;
+    reducedMotion?: boolean;
+    sceneId?: string;
+    fallback?: VisualLayerFallbackPolicy;
+    onAccepted?: readonly VisualLayerAcceptedBinding[];
+    dispatch?: (event: HostEvent) => void;
+};
+type VisualLayerController = {
+    registerSource(assetId: string, source: ImageData | HTMLCanvasElement): void;
+    handleHostEvent(event: HostEvent): void;
+    override(layerId: string, version: string | null): void;
+    play(spec: VisualLayerCueSpec): PlayVisualLayerResult;
+    step(frames?: number): VisualLayerEvent[];
+    snapshot(): VisualLayerControllerSnapshot;
+    restore(input: unknown): RestoreVisualLayerResult;
+    inspect(): VisualLayerInspect[];
+    captureComposedFrame(): ComposedFrame;
+    destroy(): void;
+    readonly frame: number;
+    readonly sceneId: string | null;
+    readonly compositor: Compositor;
+};
+type VisualLayerCapture = {
+    frame: ComposedFrame;
+    layers: VisualLayerInspect[];
+};
+declare function isVisualLayerKind(value: unknown): value is VisualLayerKind;
+declare function isVisualLayerTransitionKind(value: unknown): value is VisualLayerTransitionKind;
+declare function isVisualLayerEventType(value: unknown): value is VisualLayerEventType;
+declare function visualIncomingLayerId(layerId: string): string;
+declare function captureVisualLayers(controller: VisualLayerController): VisualLayerCapture;
+declare function createVisualLayerController(options: CreateVisualLayerControllerOptions): VisualLayerController;
+
+/**
+ * Copyright (c) 2026 Aaron Boyarsky
+ * SPDX-License-Identifier: LicenseRef-CyberArt-Engine
+ * See packages/engine/LICENSE
+ *
+ * Cart-published named semantic regions (mask / polygon / depth) in normalized
+ * space. The host drives hover/focus/selected and supplies a11y names/roles.
+ * Geometry, blend, and hit-test policy stay with the cart. Snapshot JSON is
+ * hostState-safe. Headless inspect does not require a DOM overlay.
+ */
+
+declare const SEMANTIC_LAYER_SNAPSHOT_SCHEMA_VERSION: 1;
+declare const SEMANTIC_GEOMETRY_KINDS: readonly ["mask", "polygon", "rect", "depth"];
+type SemanticGeometryKind = (typeof SEMANTIC_GEOMETRY_KINDS)[number];
+declare const SEMANTIC_HIT_TEST_POLICIES: readonly ["pass-through", "absorb", "exclusive", "depth-ordered"];
+type SemanticHitTestPolicy = (typeof SEMANTIC_HIT_TEST_POLICIES)[number];
+declare const SEMANTIC_INTERACTION_KEYS: readonly ["hover", "focus", "selected"];
+type SemanticInteractionKey = (typeof SEMANTIC_INTERACTION_KEYS)[number];
+declare const SEMANTIC_APPEARANCE_KEYS: readonly ["idle", "hover", "focus", "selected"];
+type SemanticAppearanceKey = (typeof SEMANTIC_APPEARANCE_KEYS)[number];
+type SemanticRegionState = {
+    hover: boolean;
+    focus: boolean;
+    selected: boolean;
+};
+type SemanticRegionA11y = {
+    name: string;
+    role: string;
+};
+type SemanticMaskGrid = {
+    width: number;
+    height: number;
+    /** Row-major coverage in [0, 1]. Length must be width * height. */
+    alpha: readonly number[];
+    /** Where the grid maps in normalized space. Default full content box. */
+    bounds?: NormalizedRect;
+};
+type SemanticRegionGeometry = {
+    mask?: SemanticMaskGrid;
+    polygon?: NormalizedPolygon;
+    rect?: NormalizedRect;
+    /** Higher values are closer to the viewer. Default 0. */
+    depth?: number;
+};
+type SemanticRegionVisual = {
+    opacity?: number;
+    blend?: CompositorBlendMode;
+    /** Visual-layer version applied when `visualLayerId` is set. */
+    version?: string;
+};
+type SemanticRegionVisuals = Partial<Record<SemanticAppearanceKey, SemanticRegionVisual>>;
+type SemanticRegionDeclaration = {
+    id: string;
+    geometry: SemanticRegionGeometry;
+    hitTest?: SemanticHitTestPolicy;
+    blend?: CompositorBlendMode;
+    order?: number;
+    compositorLayerId?: string;
+    visualLayerId?: string;
+    visuals?: SemanticRegionVisuals;
+    initialState?: Partial<SemanticRegionState>;
+};
+type SemanticRegionInspect = {
+    id: string;
+    geometryKinds: SemanticGeometryKind[];
+    hitTest: SemanticHitTestPolicy;
+    blend: CompositorBlendMode;
+    order: number;
+    depth: number;
+    state: SemanticRegionState;
+    appearance: SemanticAppearanceKey;
+    a11y: SemanticRegionA11y | null;
+    visual: SemanticRegionVisual;
+};
+type SemanticPublishedRegion = {
+    id: string;
+    geometryKinds: SemanticGeometryKind[];
+    a11y: SemanticRegionA11y | null;
+};
+type SemanticRegionSnapshotRow = {
+    id: string;
+    geometry: SemanticRegionGeometry;
+    hitTest: SemanticHitTestPolicy;
+    blend: CompositorBlendMode;
+    order: number;
+    compositorLayerId: string | null;
+    visualLayerId: string | null;
+    visuals: SemanticRegionVisuals;
+    state: SemanticRegionState;
+    a11y: SemanticRegionA11y | null;
+};
+type SemanticLayerControllerSnapshot = {
+    schemaVersion: typeof SEMANTIC_LAYER_SNAPSHOT_SCHEMA_VERSION;
+    frame: number;
+    regions: SemanticRegionSnapshotRow[];
+};
+type RestoreSemanticLayerResult = {
+    ok: true;
+    snapshot: SemanticLayerControllerSnapshot;
+} | {
+    ok: false;
+    errors: string[];
+};
+type CreateSemanticLayerControllerOptions = {
+    regions: readonly SemanticRegionDeclaration[];
+    compositor?: Compositor;
+    visualLayers?: VisualLayerController;
+    originFrame?: number;
+};
+type SemanticLayerController = {
+    list(): SemanticRegionInspect[];
+    inspect(): SemanticRegionInspect[];
+    inspectPublished(): SemanticPublishedRegion[];
+    get(id: string): SemanticRegionInspect | undefined;
+    geometryOf(id: string): SemanticRegionGeometry | undefined;
+    setRegionState(id: string, state: Partial<SemanticRegionState>): void;
+    setRegionA11y(id: string, a11y: SemanticRegionA11y | null): void;
+    hitTest(point: NormalizedPoint): SemanticRegionInspect | undefined;
+    hitTestAll(point: NormalizedPoint): SemanticRegionInspect[];
+    snapshot(): SemanticLayerControllerSnapshot;
+    restore(input: unknown): RestoreSemanticLayerResult;
+    destroy(): void;
+    readonly frame: number;
+};
+declare function isSemanticGeometryKind(value: unknown): value is SemanticGeometryKind;
+declare function isSemanticHitTestPolicy(value: unknown): value is SemanticHitTestPolicy;
+declare function isSemanticBlendMode(value: unknown): value is CompositorBlendMode;
+declare function geometryKindsOf(geometry: SemanticRegionGeometry): SemanticGeometryKind[];
+declare function appearanceForState(state: SemanticRegionState): SemanticAppearanceKey;
+declare function pointInSemanticGeometry(geometry: SemanticRegionGeometry, point: NormalizedPoint): boolean;
+declare function createSemanticLayerController(options: CreateSemanticLayerControllerOptions): SemanticLayerController;
+
+/**
+ * Copyright (c) 2026 Aaron Boyarsky
+ * SPDX-License-Identifier: LicenseRef-CyberArt-Engine
+ * See packages/engine/LICENSE
+ *
+ * Cross-modal presentation sequences. One frame-stepped clock coordinates
+ * audio, captions, semantic-region state, visual layers, and typed cues.
+ * Authored content is JSON-serializable: no callbacks, no ambient host access.
+ * Dialogue graphs and game rules stay with the host.
+ */
+
+declare const PRESENTATION_SEQUENCE_SNAPSHOT_SCHEMA_VERSION: 1;
+declare const PRESENTATION_SEQUENCE_REQUESTED_EVENT: "presentation.sequence.state.requested";
+declare const PRESENTATION_SEQUENCE_PRELOADING_EVENT: "presentation.sequence.state.preloading";
+declare const PRESENTATION_SEQUENCE_READY_EVENT: "presentation.sequence.state.ready";
+declare const PRESENTATION_SEQUENCE_STARTED_EVENT: "presentation.sequence.state.started";
+declare const PRESENTATION_SEQUENCE_STEP_STARTED_EVENT: "presentation.sequence.state.step-started";
+declare const PRESENTATION_SEQUENCE_STEP_COMPLETED_EVENT: "presentation.sequence.state.step-completed";
+declare const PRESENTATION_SEQUENCE_SKIPPED_EVENT: "presentation.sequence.state.skipped";
+declare const PRESENTATION_SEQUENCE_INTERRUPTED_EVENT: "presentation.sequence.state.interrupted";
+declare const PRESENTATION_SEQUENCE_FAILED_EVENT: "presentation.sequence.state.failed";
+declare const PRESENTATION_SEQUENCE_COMPLETED_EVENT: "presentation.sequence.state.completed";
+declare const PRESENTATION_SEQUENCE_DIAGNOSTIC_EVENT: "presentation.sequence.diagnostic.lifecycle";
+declare const PRESENTATION_SEQUENCE_EVENTS: readonly ["presentation.sequence.state.requested", "presentation.sequence.state.preloading", "presentation.sequence.state.ready", "presentation.sequence.state.started", "presentation.sequence.state.step-started", "presentation.sequence.state.step-completed", "presentation.sequence.state.skipped", "presentation.sequence.state.interrupted", "presentation.sequence.state.failed", "presentation.sequence.state.completed", "presentation.sequence.diagnostic.lifecycle"];
+type PresentationSequenceEventType = (typeof PRESENTATION_SEQUENCE_EVENTS)[number];
+declare const PRESENTATION_TRACK_KINDS: readonly ["audio", "caption", "semantic-region", "visual-layer", "cue"];
+type PresentationTrackKind = (typeof PRESENTATION_TRACK_KINDS)[number];
+declare const PRESENTATION_INTERRUPTION_POLICIES: readonly ["replace", "queue", "reject", "ignore"];
+type PresentationInterruptionPolicy = (typeof PRESENTATION_INTERRUPTION_POLICIES)[number];
+declare const PRESENTATION_COMPLETION_RULES: readonly ["duration", "immediate"];
+type PresentationCompletionRule = (typeof PRESENTATION_COMPLETION_RULES)[number];
+declare const PRESENTATION_AUDIO_CAPABILITY_STATUSES: readonly ["unavailable", "failed", "unauthorized", "muted"];
+type PresentationAudioCapabilityStatus = (typeof PRESENTATION_AUDIO_CAPABILITY_STATUSES)[number];
+declare const PRESENTATION_INVOCATION_PHASES: readonly ["requested", "preloading", "ready", "playing", "paused", "skipped", "interrupted", "failed", "completed"];
+type PresentationInvocationPhase = (typeof PRESENTATION_INVOCATION_PHASES)[number];
+type PresentationSequenceDiagnostic = {
+    code: string;
+    detail: string;
+    path?: string;
+};
+type PresentationStepTiming = {
+    kind: 'absolute';
+    atFrame: number;
+} | {
+    kind: 'relative';
+    afterStepId?: string;
+    delayFrames?: number;
+} | {
+    kind: 'simultaneous';
+    withStepId: string;
+    order?: number;
+    delayFrames?: number;
+};
+type PresentationStepEffect = {
+    kind: 'audio';
+    assetBinding: string;
+    channelBinding?: string;
+} | {
+    kind: 'caption';
+    textBinding: string;
+    visible: boolean;
+} | {
+    kind: 'semantic-region';
+    regionBinding: string;
+    state: Partial<Pick<SemanticRegionState, 'hover' | 'focus' | 'selected'>>;
+} | {
+    kind: 'visual-layer';
+    layerBinding: string;
+    transition: Extract<VisualLayerTransitionKind, 'show' | 'hide'>;
+    versionBinding?: string;
+} | {
+    kind: 'cue';
+    name: string;
+    easing?: CueEasing;
+};
+type PresentationStepDefinition = {
+    id: string;
+    timing: PresentationStepTiming;
+    durationFrames: number;
+    delayFrames?: number;
+    completion?: PresentationCompletionRule;
+    effect: PresentationStepEffect;
+    restoreOnComplete?: boolean;
+    reducedMotion?: CueReducedMotionPolicy;
+    reducedSensory?: 'keep' | 'skip-audio' | 'complete';
+};
+type PresentationTrackDefinition = {
+    id: string;
+    kind: PresentationTrackKind;
+    steps: readonly PresentationStepDefinition[];
+};
+type PresentationFallbackWhen = {
+    capability: 'audio';
+    status: PresentationAudioCapabilityStatus;
+};
+type PresentationFallbackDefinition = {
+    id: string;
+    when: PresentationFallbackWhen;
+    omitTrackIds?: readonly string[];
+};
+type PresentationSequenceDefinition = {
+    id: string;
+    tracks: readonly PresentationTrackDefinition[];
+    interruptionPolicy?: PresentationInterruptionPolicy;
+    fallbacks?: readonly PresentationFallbackDefinition[];
+};
+type PresentationSequenceBindings = {
+    assets?: Record<string, string>;
+    captions?: Record<string, string>;
+    regions?: Record<string, string>;
+    layers?: Record<string, string>;
+    versions?: Record<string, string>;
+    channels?: Record<string, string>;
+};
+type PlaySequenceOptions = {
+    invocationId: string;
+    idempotencyKey?: string;
+    bindings?: PresentationSequenceBindings;
+};
+type DefinePresentationSequenceResult = {
+    ok: true;
+    sequence: PresentationSequenceDefinition;
+} | {
+    ok: false;
+    errors: PresentationSequenceDiagnostic[];
+};
+type PlaySequenceResult = {
+    ok: true;
+    invocation: PresentationInvocationView;
+} | {
+    ok: false;
+    reason: 'unknown-sequence' | 'invalid' | 'busy' | 'duplicate';
+    detail: string;
+};
+type RestorePresentationSequenceResult = {
+    ok: true;
+    snapshot: PresentationSequenceSnapshot;
+} | {
+    ok: false;
+    errors: PresentationSequenceDiagnostic[];
+};
+type PresentationSequenceEvent = {
+    type: PresentationSequenceEventType;
+    atFrame: number;
+    sequenceId: string;
+    invocationId: string;
+    idempotencyKey: string;
+    stepId?: string;
+    fallbackId?: string;
+    reason?: string;
+};
+type PresentationCaptionView = {
+    id: string;
+    text: string;
+    visible: boolean;
+};
+type PresentationCueIntent = {
+    sequenceId: string;
+    stepId: string;
+    trackId: string;
+    kind: PresentationTrackKind;
+    startFrame: number;
+    durationFrames: number;
+    order: number;
+    effect: PresentationStepEffect;
+};
+type PresentationInvocationView = {
+    sequenceId: string;
+    invocationId: string;
+    idempotencyKey: string;
+    phase: PresentationInvocationPhase;
+    playhead: number;
+    startedAtFrame: number;
+    completedStepIds: string[];
+    activeStepIds: string[];
+    selectedFallbackId: string | null;
+};
+type PresentationSequenceSnapshot = {
+    schemaVersion: typeof PRESENTATION_SEQUENCE_SNAPSHOT_SCHEMA_VERSION;
+    frame: number;
+    reducedMotion: boolean;
+    reducedSensory: boolean;
+    paused: boolean;
+    active: PresentationInvocationView | null;
+    queue: PresentationSequenceSnapshotQueued[];
+    captions: PresentationCaptionView[];
+    events: PresentationSequenceEvent[];
+    bindings: PresentationSequenceBindings | null;
+};
+type PresentationSequenceSnapshotQueued = {
+    sequenceId: string;
+    invocationId: string;
+    idempotencyKey: string;
+    bindings: PresentationSequenceBindings;
+};
+type PresentationSequenceInspect = {
+    frame: number;
+    paused: boolean;
+    reducedMotion: boolean;
+    reducedSensory: boolean;
+    active: PresentationInvocationView | null;
+    queue: PresentationInvocationView[];
+    captions: PresentationCaptionView[];
+    cueIntent: PresentationCueIntent[];
+};
+type CreatePresentationSequencePlayerOptions = {
+    originFrame?: number;
+    reducedMotion?: boolean;
+    reducedSensory?: boolean;
+    audio?: AudioCueTimeline | HeadlessAudioAdapter;
+    semantic?: SemanticLayerController;
+    visual?: VisualLayerController;
+    sequences?: readonly PresentationSequenceDefinition[];
+};
+type PresentationSequencePlayer = {
+    define(input: PresentationSequenceDefinition): DefinePresentationSequenceResult;
+    playSequence(sequenceId: string, options: PlaySequenceOptions): PlaySequenceResult;
+    skip(invocationId?: string): boolean;
+    replay(invocationId?: string): PlaySequenceResult;
+    pause(): boolean;
+    resume(): boolean;
+    cancel(invocationId?: string): boolean;
+    step(frames?: number): PresentationSequenceEvent[];
+    snapshot(): PresentationSequenceSnapshot;
+    restore(input: unknown): RestorePresentationSequenceResult;
+    inspect(): PresentationSequenceInspect;
+    inspectCueIntent(sequenceId: string, options?: {
+        fallbackId?: string;
+    }): PresentationCueIntent[];
+    get(sequenceId: string): PresentationSequenceDefinition | undefined;
+    destroy(): void;
+    readonly frame: number;
+    readonly reducedMotion: boolean;
+    readonly reducedSensory: boolean;
+};
+declare function presentationSequenceEventContracts(): EventContract[];
+declare function isPresentationSequenceEventType(value: unknown): value is PresentationSequenceEventType;
+declare function definePresentationSequence(input: unknown): DefinePresentationSequenceResult;
+declare function createPresentationSequencePlayer(options?: CreatePresentationSequencePlayerOptions): PresentationSequencePlayer;
+
+/**
+ * Copyright (c) 2026 Aaron Boyarsky
+ * SPDX-License-Identifier: LicenseRef-CyberArt-Engine
+ * See packages/engine/LICENSE
+ *
+ * Declarative projection of host-authoritative state into presentation
+ * resources. The host reducer stays the owner; this module evaluates a
+ * bounded, JSON-serializable binding manifest and applies one coherent
+ * presentation revision (or the declared fail-closed defaults).
+ */
+
+declare const PRESENTATION_BINDING_SNAPSHOT_SCHEMA_VERSION: 1;
+declare const PRESENTATION_BINDING_MANIFEST_VERSION: 1;
+declare const PRESENTATION_BINDING_APPLIED_EVENT: "presentation.binding.state.applied";
+declare const PRESENTATION_BINDING_REJECTED_EVENT: "presentation.binding.state.rejected";
+declare const PRESENTATION_BINDING_DIAGNOSTIC_EVENT: "presentation.binding.diagnostic.lifecycle";
+declare const PRESENTATION_BINDING_EVENTS: readonly ["presentation.binding.state.applied", "presentation.binding.state.rejected", "presentation.binding.diagnostic.lifecycle"];
+type PresentationBindingEventType = (typeof PRESENTATION_BINDING_EVENTS)[number];
+declare const PRESENTATION_BINDING_TARGET_KINDS: readonly ["visual-layer", "presence", "prop", "semantic-region", "hotspot", "sequence", "asset"];
+type PresentationBindingTargetKind = (typeof PRESENTATION_BINDING_TARGET_KINDS)[number];
+declare const PRESENTATION_BINDING_ERROR_CODES: readonly ["invalid-manifest", "invalid-schema", "invalid-version", "invalid-id", "unknown-field", "unknown-resource", "unknown-selector", "duplicate-id", "duplicate-priority", "uncovered-default", "impossible-target", "callbacks-forbidden", "invalid-predicate", "invalid-projection", "invalid-snapshot", "destroyed"];
+type PresentationBindingErrorCode = (typeof PRESENTATION_BINDING_ERROR_CODES)[number];
+type PresentationBindingDiagnostic = {
+    code: PresentationBindingErrorCode | string;
+    detail: string;
+    path?: string;
+};
+type JsonPrimitive = string | number | boolean | null;
+type JsonObject = {
+    [key: string]: JsonValue;
+};
+type JsonValue = JsonPrimitive | JsonValue[] | JsonObject;
+type PresentationPredicate = {
+    path: string;
+    eq: JsonPrimitive;
+} | {
+    path: string;
+    neq: JsonPrimitive;
+} | {
+    path: string;
+    present: boolean;
+} | {
+    selector: string;
+} | {
+    all: PresentationPredicate[];
+} | {
+    any: PresentationPredicate[];
+} | {
+    not: PresentationPredicate;
+};
+type PresentationBindingTarget = {
+    kind: 'visual-layer';
+    layerId: string;
+    version: string;
+    transition?: Extract<VisualLayerTransitionKind, 'show' | 'hide' | 'replace'>;
+} | {
+    kind: 'presence';
+    entityId: string;
+    present: boolean;
+    regionId?: string;
+} | {
+    kind: 'prop';
+    propId: string;
+    visible: boolean;
+    layerId?: string;
+} | {
+    kind: 'semantic-region';
+    regionId: string;
+    state?: Partial<Pick<SemanticRegionState, 'hover' | 'focus' | 'selected'>>;
+    hitTestEnabled?: boolean;
+} | {
+    kind: 'hotspot';
+    hotspotId: string;
+    enabled: boolean;
+    regionId?: string;
+} | {
+    kind: 'sequence';
+    sequenceId: string;
+    play?: boolean;
+} | {
+    kind: 'asset';
+    bindingId: string;
+    assetId: string;
 };
-type VisualLayerControllerSnapshot = {
-    schemaVersion: typeof VISUAL_LAYER_SNAPSHOT_SCHEMA_VERSION;
-    frame: number;
-    sceneId: string | null;
-    reducedMotion: boolean;
-    layers: VisualLayerSnapshotRow[];
-    assets: Record<string, VisualLayerAssetStatus>;
-    events: VisualLayerEvent[];
-    diagnostics: VisualLayerDiagnostic[];
+type PresentationBinding = {
+    id: string;
+    priority: number;
+    when: PresentationPredicate;
+    targets: readonly PresentationBindingTarget[];
+};
+type PresentationBindingResources = {
+    layers?: readonly string[];
+    versions?: Readonly<Record<string, readonly string[]>>;
+    regions?: readonly string[];
+    sequences?: readonly string[];
+    hotspots?: readonly string[];
+    entities?: readonly string[];
+    props?: readonly string[];
+    assets?: readonly string[];
+};
+type PresentationBindingManifest = {
+    id: string;
+    schemaVersion: typeof PRESENTATION_BINDING_MANIFEST_VERSION;
+    bindings: readonly PresentationBinding[];
+    defaults: readonly PresentationBindingTarget[];
+    resources?: PresentationBindingResources;
 };
-type PlayVisualLayerResult = PlayCueResult;
-type RestoreVisualLayerResult = {
+type DefinePresentationBindingsResult = {
     ok: true;
-    snapshot: VisualLayerControllerSnapshot;
+    manifest: PresentationBindingManifest;
 } | {
     ok: false;
-    errors: VisualLayerDiagnostic[];
+    errors: PresentationBindingDiagnostic[];
 };
-type CreateVisualLayerControllerOptions = {
-    compositor: Compositor;
-    layers: readonly VisualLayerDeclaration[];
-    preloader?: AssetPreloader;
-    originFrame?: number;
+type PresentationBindingSelector = (projection: JsonObject) => boolean;
+type PresentationBindingConsidered = {
+    bindingId: string;
+    predicateResult: boolean;
+    detail?: string;
+};
+type PresentationBindingRejected = {
+    bindingId: string;
+    targetKey: string;
+    reason: 'lower-priority' | 'predicate-false';
+};
+type PresentationBindingFallback = {
+    targetKey: string;
+    reason: 'uncovered-default' | 'missing-state' | 'invalid-projection';
+};
+type PresentationBindingExplanation = {
+    considered: PresentationBindingConsidered[];
+    winners: Record<string, {
+        bindingId: string | null;
+        target: PresentationBindingTarget;
+    }>;
+    rejected: PresentationBindingRejected[];
+    fallbacks: PresentationBindingFallback[];
+    fallbackReason: 'missing-state' | 'invalid-projection' | null;
+};
+type PresentationBindingEvaluation = {
+    selectedBindingIds: string[];
+    targets: PresentationBindingTarget[];
+    usedFallback: boolean;
+    fallbackReason: 'missing-state' | 'invalid-projection' | null;
+    explanation: PresentationBindingExplanation;
+};
+type HostPresentationOverride = {
+    labels?: Record<string, string | Pick<SemanticRegionA11y, 'name' | 'role'>>;
+    reducedSensory?: boolean;
     reducedMotion?: boolean;
-    sceneId?: string;
-    fallback?: VisualLayerFallbackPolicy;
-    onAccepted?: readonly VisualLayerAcceptedBinding[];
-    dispatch?: (event: HostEvent) => void;
 };
-type VisualLayerController = {
-    registerSource(assetId: string, source: ImageData | HTMLCanvasElement): void;
-    handleHostEvent(event: HostEvent): void;
-    override(layerId: string, version: string | null): void;
-    play(spec: VisualLayerCueSpec): PlayVisualLayerResult;
-    step(frames?: number): VisualLayerEvent[];
-    snapshot(): VisualLayerControllerSnapshot;
-    restore(input: unknown): RestoreVisualLayerResult;
-    inspect(): VisualLayerInspect[];
-    captureComposedFrame(): ComposedFrame;
-    destroy(): void;
-    readonly frame: number;
-    readonly sceneId: string | null;
-    readonly compositor: Compositor;
+type PresentationBindingInspect = {
+    revision: string | number | null;
+    selectedBindingIds: string[];
+    layers: Record<string, string>;
+    presence: Record<string, boolean>;
+    props: Record<string, boolean>;
+    regions: Record<string, Partial<SemanticRegionState> & {
+        hitTestEnabled?: boolean;
+    }>;
+    hotspots: Record<string, boolean>;
+    sequences: Record<string, 'playing' | 'idle'>;
+    assets: Record<string, string>;
+    override: HostPresentationOverride | null;
+    usedFallback: boolean;
+    fallbackReason: 'missing-state' | 'invalid-projection' | null;
+    explanation: PresentationBindingExplanation | null;
+};
+type PresentationBindingSnapshot = {
+    schemaVersion: typeof PRESENTATION_BINDING_SNAPSHOT_SCHEMA_VERSION;
+    manifestId: string;
+    projectionRevision: string | number | null;
+    selectedBindingIds: string[];
+    targets: PresentationBindingTarget[];
+    usedFallback: boolean;
+    fallbackReason: 'missing-state' | 'invalid-projection' | null;
+    override: HostPresentationOverride | null;
+};
+type PresentationBindingEvent = {
+    type: PresentationBindingEventType;
+    atRevision: string | number | null;
+    manifestId: string;
+    selectedBindingIds: string[];
+    reason?: string;
 };
-type VisualLayerCapture = {
-    frame: ComposedFrame;
-    layers: VisualLayerInspect[];
+type ApplyPresentationBindingsResult = {
+    ok: true;
+    revision: string | number;
+    selectedBindingIds: string[];
+    usedFallback: boolean;
+    fallbackReason: 'missing-state' | 'invalid-projection' | null;
+    explanation: PresentationBindingExplanation;
+    inspect: PresentationBindingInspect;
+} | {
+    ok: false;
+    errors: PresentationBindingDiagnostic[];
+    inspect: PresentationBindingInspect;
 };
-declare function isVisualLayerKind(value: unknown): value is VisualLayerKind;
-declare function isVisualLayerTransitionKind(value: unknown): value is VisualLayerTransitionKind;
-declare function isVisualLayerEventType(value: unknown): value is VisualLayerEventType;
-declare function visualIncomingLayerId(layerId: string): string;
-declare function captureVisualLayers(controller: VisualLayerController): VisualLayerCapture;
-declare function createVisualLayerController(options: CreateVisualLayerControllerOptions): VisualLayerController;
+type RestorePresentationBindingsResult = {
+    ok: true;
+    snapshot: PresentationBindingSnapshot;
+} | {
+    ok: false;
+    errors: PresentationBindingDiagnostic[];
+};
+type CreatePresentationBindingRuntimeOptions = {
+    manifest: PresentationBindingManifest | unknown;
+    visual?: VisualLayerController;
+    semantic?: SemanticLayerController;
+    sequences?: PresentationSequencePlayer;
+    selectors?: Readonly<Record<string, PresentationBindingSelector>>;
+    router?: Pick<EventRouter, 'publish'>;
+    onEvent?: (event: EventInput) => void;
+};
+type PresentationBindingRuntime = {
+    apply(projection: unknown, options?: {
+        revision?: string | number;
+    }): ApplyPresentationBindingsResult;
+    setOverride(override: HostPresentationOverride | null): void;
+    evaluate(projection: unknown): PresentationBindingEvaluation;
+    inspect(): PresentationBindingInspect;
+    snapshot(): PresentationBindingSnapshot;
+    restore(input: unknown): RestorePresentationBindingsResult;
+    destroy(): void;
+    readonly manifest: PresentationBindingManifest;
+};
+declare function isPresentationBindingEventType(value: unknown): value is PresentationBindingEventType;
+declare function isPresentationBindingErrorCode(value: unknown): value is PresentationBindingErrorCode;
+declare function presentationBindingEventContracts(): EventContract[];
+declare function presentationBindingTargetKey(target: PresentationBindingTarget): string;
+declare function definePresentationBindings(input: unknown): DefinePresentationBindingsResult;
+declare function evaluatePresentationBindings(manifest: PresentationBindingManifest, projection: unknown, selectors?: Readonly<Record<string, PresentationBindingSelector>>): PresentationBindingEvaluation;
+declare function createPresentationBindingRuntime(options: CreatePresentationBindingRuntimeOptions): PresentationBindingRuntime;
 
 /**
  * Copyright (c) 2026 Aaron Boyarsky
  * SPDX-License-Identifier: LicenseRef-CyberArt-Engine
  * See packages/engine/LICENSE
  *
- * Trusted, versioned executable-module host. Factories are registered by
- * exact id+version; the host allowlists which refs may load. Untrusted
- * source strings are not compiled. Per-module failures do not stop siblings.
+ * Atomic external content-revision activation. Adapters discover and load
+ * revision catalogs; the activator stages every declared asset, then commits
+ * one complete bundle (or keeps the last known good). Consumers never see a
+ * mixed old/new scene.
  */
-declare const EXECUTABLE_MODULE_ERROR_CODES: readonly ["invalid-ref", "unknown-module", "version-mismatch", "not-allowlisted", "load-failed", "invoke-failed", "timeout", "rate-limited", "destroyed"];
-type ExecutableModuleErrorCode = (typeof EXECUTABLE_MODULE_ERROR_CODES)[number];
-type ExecutableModuleRef = {
-    id: string;
-    version: string;
-};
-type ExecutableModuleError = {
-    code: ExecutableModuleErrorCode;
+
+declare const CONTENT_REVISION_SNAPSHOT_SCHEMA_VERSION: 1;
+declare const CONTENT_REVISION_MANIFEST_VERSION: 1;
+declare const CONTENT_REVISION_DISCOVERED_EVENT: "content.revision.state.discovered";
+declare const CONTENT_REVISION_STAGING_EVENT: "content.revision.state.staging";
+declare const CONTENT_REVISION_VALIDATED_EVENT: "content.revision.state.validated";
+declare const CONTENT_REVISION_REJECTED_EVENT: "content.revision.state.rejected";
+declare const CONTENT_REVISION_ACTIVATED_EVENT: "content.revision.state.activated";
+declare const CONTENT_REVISION_ROLLED_BACK_EVENT: "content.revision.state.rolled-back";
+declare const CONTENT_REVISION_SUPERSEDED_EVENT: "content.revision.state.superseded";
+declare const CONTENT_REVISION_DIAGNOSTIC_EVENT: "content.revision.diagnostic.lifecycle";
+declare const CONTENT_REVISION_EVENTS: readonly ["content.revision.state.discovered", "content.revision.state.staging", "content.revision.state.validated", "content.revision.state.rejected", "content.revision.state.activated", "content.revision.state.rolled-back", "content.revision.state.superseded", "content.revision.diagnostic.lifecycle"];
+type ContentRevisionEventType = (typeof CONTENT_REVISION_EVENTS)[number];
+declare const CONTENT_REVISION_ERROR_CODES: readonly ["invalid-manifest", "invalid-schema", "invalid-version", "invalid-snapshot", "unknown-revision", "unknown-adapter", "hash-mismatch", "capability-denied", "pinned", "staging-failed", "activation-failed", "health-check-failed", "stale-health-check", "superseded", "destroyed", "adapter-missing", "asset-failed", "unsigned"];
+type ContentRevisionErrorCode = (typeof CONTENT_REVISION_ERROR_CODES)[number];
+type ContentRevisionDiagnostic = {
+    code: ContentRevisionErrorCode | string;
     detail: string;
-    ref?: ExecutableModuleRef;
-};
-type ExecutableModuleDiagnostic = ExecutableModuleError;
-type ExecutableModuleCapabilities = {
-    readonly [key: string]: unknown;
-};
-type ExecutableModuleInvokeContext = {
-    signal: AbortSignal;
-    turn: number;
-};
-type ExecutableModuleInstance = {
-    invoke(input: unknown, context: ExecutableModuleInvokeContext): unknown | Promise<unknown>;
-    destroy?: () => void;
+    path?: string;
 };
-type ExecutableModuleFactory = (capabilities: ExecutableModuleCapabilities) => ExecutableModuleInstance;
-type ExecutableModuleRegistration = {
+type ContentRevisionAssetDecl = {
     id: string;
-    version: string;
-    create: ExecutableModuleFactory;
-    capabilities?: ExecutableModuleCapabilities;
+    kind: AssetKind;
+    url: string;
+    hash: string;
+    alg: 'sha256';
+    optional?: boolean;
+    fallback?: {
+        id: string;
+        kind: AssetKind;
+        url: string;
+        hash: string;
+        alg: 'sha256';
+    };
 };
-type ExecutableModuleLimits = {
-    /** Cooperative timeout; the invoke AbortSignal aborts after this many ms. */
-    maxInvokeMs?: number;
-    maxInvokesPerTurn?: number;
+type ContentRevisionCatalog = {
+    contentId: string;
+    revision: string;
+    manifestVersion: typeof CONTENT_REVISION_MANIFEST_VERSION;
+    publisher: string;
+    source: string;
+    adapterId: string;
+    assets: ContentRevisionAssetDecl[];
+    requestedGrants?: RemoteCartGrant[];
+    capabilities?: CapabilityManifest;
+    signature?: {
+        id: string;
+        alg: string;
+    };
 };
-type CreateExecutableModuleHostOptions = {
-    allowlist: readonly ExecutableModuleRef[];
-    modules: readonly ExecutableModuleRegistration[];
-    limits?: ExecutableModuleLimits;
-    /** Default capability bag. Frozen per module; class instances stay shared handles. */
-    capabilities?: ExecutableModuleCapabilities;
+type ContentRevisionDescriptor = {
+    contentId: string;
+    revision: string;
+    adapterId: string;
+    publisher: string;
+    source: string;
 };
-type ExecutableModuleInvokeResult = {
+type ContentRevisionResource = {
+    id: string;
+    kind: AssetKind;
+    ref: string;
+    hash: string;
+    url: string;
+    optional: boolean;
+    usedFallback: boolean;
+};
+type ContentRevisionBundle = {
+    bundleId: string;
+    contentId: string;
+    revision: string;
+    manifestVersion: typeof CONTENT_REVISION_MANIFEST_VERSION;
+    publisher: string;
+    source: string;
+    adapterId: string;
+    signature?: {
+        id: string;
+        alg: string;
+    };
+    resources: Record<string, ContentRevisionResource>;
+};
+type ContentRevisionStagingView = {
+    contentId: string;
+    revision: string;
+    adapterId: string;
+    bundleId: string;
+};
+type ContentRevisionInspect = {
+    destroyed: boolean;
+    pinned: boolean;
+    active: ContentRevisionBundle | null;
+    lastKnownGood: ContentRevisionBundle | null;
+    staging: ContentRevisionStagingView | null;
+    events: ContentRevisionEventType[];
+    lastRejection: ContentRevisionDiagnostic[] | null;
+};
+type ContentRevisionSnapshot = {
+    schemaVersion: typeof CONTENT_REVISION_SNAPSHOT_SCHEMA_VERSION;
+    pinned: boolean;
+    active: ContentRevisionBundle | null;
+    lastKnownGood: ContentRevisionBundle | null;
+    previous: ContentRevisionBundle | null;
+};
+type ContentRevisionMutationResult = {
     ok: true;
-    value: unknown;
+    bundle: ContentRevisionBundle | null;
+    idempotent?: boolean;
 } | {
     ok: false;
-    error: ExecutableModuleError;
+    errors: ContentRevisionDiagnostic[];
 };
-type ExecutableModuleLoadResult = {
+type RestoreContentRevisionResult = {
     ok: true;
-    ref: ExecutableModuleRef;
+    snapshot: ContentRevisionSnapshot;
 } | {
     ok: false;
-    error: ExecutableModuleError;
+    errors: ContentRevisionDiagnostic[];
 };
-type ExecutableModuleHostInspect = {
-    allowlist: ExecutableModuleRef[];
-    registered: ExecutableModuleRef[];
-    loaded: ExecutableModuleRef[];
-    turn: number;
-    invokesThisTurn: number;
-    diagnostics: ExecutableModuleDiagnostic[];
+type ActivateContentRevisionRequest = {
+    contentId: string;
+    revision?: string;
+    adapterId?: string;
 };
-type ExecutableModuleHost = {
-    load(ref: ExecutableModuleRef): ExecutableModuleLoadResult;
-    invoke(ref: ExecutableModuleRef, input?: unknown): Promise<ExecutableModuleInvokeResult>;
-    beginTurn(): void;
-    inspect(): ExecutableModuleHostInspect;
+type ContentRevisionFetchBytes = (url: string, signal?: AbortSignal) => Promise<Uint8Array | undefined>;
+type ContentRegistryAdapter = {
+    readonly id: string;
+    hasRevision(contentId: string, revision: string): boolean;
+    discover(contentId: string): Promise<ContentRevisionDescriptor | undefined>;
+    loadRevision(contentId: string, revision: string, signal?: AbortSignal): Promise<{
+        ok: true;
+        catalog: ContentRevisionCatalog;
+    } | {
+        ok: false;
+        errors: ContentRevisionDiagnostic[];
+    }>;
+    fetchBytes: ContentRevisionFetchBytes;
+};
+type CreateStaticContentAdapterOptions = {
+    id?: string;
+    revisions: readonly ContentRevisionCatalog[];
+    bytesByUrl: Readonly<Record<string, Uint8Array>>;
+    fetchBytes?: ContentRevisionFetchBytes;
+};
+type RemoteContentEnvelope = {
+    world: string;
+    revision: string;
+    manifest: SignedRemoteCartManifest;
+};
+type CreateRemoteContentAdapterOptions = {
+    id?: string;
+    fetch: (url: string, signal?: AbortSignal) => Promise<unknown>;
+    keys: Readonly<Record<string, string>>;
+    bytesByUrl?: Readonly<Record<string, Uint8Array>>;
+    fetchBytes?: ContentRevisionFetchBytes;
+    catalogUrl?: (contentId: string, revision?: string) => string;
+    known?: ReadonlyArray<{
+        contentId: string;
+        revision: string;
+    }>;
+};
+type ContentRevisionHealthCheck = (bundle: ContentRevisionBundle) => boolean | Promise<boolean>;
+type CreateContentRevisionActivatorOptions = {
+    adapters: readonly ContentRegistryAdapter[];
+    pin?: boolean;
+    grants?: HostGrantSet;
+    hostCapabilities?: HostCapabilities;
+    healthCheck?: ContentRevisionHealthCheck;
+    router?: Pick<EventRouter, 'publish'>;
+    onEvent?: (event: EventInput) => void;
+};
+type ContentRevisionActivator = {
+    pin(frozen?: boolean): void;
+    unpin(): void;
+    isPinned(): boolean;
+    discover(contentId: string, adapterId?: string): Promise<ContentRevisionDescriptor | undefined>;
+    activate(request: ActivateContentRevisionRequest): Promise<ContentRevisionMutationResult>;
+    rollback(): ContentRevisionMutationResult;
+    inspect(): ContentRevisionInspect;
+    activeBundle(): ContentRevisionBundle | null;
+    snapshot(): ContentRevisionSnapshot;
+    restore(input: unknown): RestoreContentRevisionResult;
+    provenance(): SnapshotProvenance | undefined;
     destroy(): void;
 };
-declare function createExecutableModuleHost(options: CreateExecutableModuleHostOptions): ExecutableModuleHost;
+declare function contentRevisionEventContracts(): EventContract[];
+declare function parseContentRevisionCatalog(input: unknown): {
+    ok: true;
+    catalog: ContentRevisionCatalog;
+} | {
+    ok: false;
+    errors: ContentRevisionDiagnostic[];
+};
+declare function createStaticContentAdapter(options: CreateStaticContentAdapterOptions): ContentRegistryAdapter;
+declare function createRemoteContentAdapter(options: CreateRemoteContentAdapterOptions): ContentRegistryAdapter;
+declare function createContentRevisionActivator(options: CreateContentRevisionActivatorOptions): ContentRevisionActivator;
+declare function isContentRevisionErrorCode(value: unknown): value is ContentRevisionErrorCode;
 
 /**
  * Copyright (c) 2026 Aaron Boyarsky
@@ -2521,6 +4588,12 @@ type BrowserA11ySnapshot = {
     };
     live: string;
     html: string;
+    publishedRegions: Array<{
+        id: string;
+        geometryKinds: string[];
+        name: string | null;
+        role: string | null;
+    }>;
 };
 type BrowserReproductionMetadata = {
     seed: string;
@@ -2562,6 +4635,7 @@ type CreateBrowserHarnessOptions = {
     origin?: number;
     createId?: () => string;
     geometry?: GeometryDocument;
+    semanticLayers?: SemanticLayerController;
     contentWidth?: number;
     contentHeight?: number;
     fit?: PresentationFitMode;
@@ -2574,6 +4648,7 @@ type BrowserHarnessInspect = {
     participantEvents: Record<string, HostEvent[]>;
     state: Record<string, unknown>;
     focus: BrowserA11ySnapshot['focus'];
+    publishedRegions: BrowserA11ySnapshot['publishedRegions'];
     scrollTop: number;
     clock: {
         framesElapsed: number;
@@ -2634,6 +4709,272 @@ type PlaywrightCompatibleAdapter = {
 };
 declare function createPlaywrightCompatibleAdapter(harness: BrowserHarness): PlaywrightCompatibleAdapter;
 
+/**
+ * Copyright (c) 2026 Aaron Boyarsky
+ * SPDX-License-Identifier: LicenseRef-CyberArt-Engine
+ * See packages/engine/LICENSE
+ *
+ * End-to-end production composition scenario harness. Composes the real
+ * browser host, runtime group, compositor, visual/semantic layers, bindings,
+ * sequences, headless audio, snapshots, and replay inspector. Does not
+ * introduce a second runtime. Authored scenarios are JSON-serializable.
+ */
+
+declare const PRODUCTION_SCENARIO_SCHEMA_VERSION: 1;
+declare const PRODUCTION_SCENARIO_SNAPSHOT_SCHEMA_VERSION: 1;
+declare const PRODUCTION_SCENARIO_OBSERVED_EVENT: "production.scenario.state.observed";
+declare const PRODUCTION_SCENARIO_FAILED_EVENT: "production.scenario.state.failed";
+declare const PRODUCTION_SCENARIO_DIAGNOSTIC_EVENT: "production.scenario.diagnostic.lifecycle";
+declare const PRODUCTION_SCENARIO_EVENTS: readonly ["production.scenario.state.observed", "production.scenario.state.failed", "production.scenario.diagnostic.lifecycle"];
+type ProductionScenarioEventType = (typeof PRODUCTION_SCENARIO_EVENTS)[number];
+declare const PRODUCTION_SCENARIO_BOUNDARIES: readonly ["input", "reducer", "routing", "binding", "cue", "pixels", "caption", "audio", "save-replay"];
+type ProductionScenarioBoundary = (typeof PRODUCTION_SCENARIO_BOUNDARIES)[number];
+declare const PRODUCTION_SCENARIO_ERROR_CODES: readonly ["invalid-scenario", "invalid-schema", "unknown-field", "missing-field", "callbacks-forbidden", "missing-participant", "missing-layer", "destroyed", "assertion-failed"];
+type ProductionScenarioErrorCode = (typeof PRODUCTION_SCENARIO_ERROR_CODES)[number];
+declare const PRODUCTION_SCENARIO_VIEWPORT_PRESETS: readonly ["desktop", "mobile"];
+type ProductionScenarioViewportPreset = (typeof PRODUCTION_SCENARIO_VIEWPORT_PRESETS)[number];
+declare const DEFAULT_PRODUCTION_SCENARIO_VIEWPORTS: {
+    readonly desktop: {
+        readonly width: 64;
+        readonly height: 48;
+        readonly deviceScaleFactor: 1;
+    };
+    readonly mobile: {
+        readonly width: 48;
+        readonly height: 64;
+        readonly deviceScaleFactor: 2;
+    };
+};
+type ProductionScenarioDiagnostic = {
+    code: ProductionScenarioErrorCode | string;
+    detail: string;
+    path?: string;
+    boundary?: ProductionScenarioBoundary;
+};
+type ProductionScenarioRequired = {
+    participants: readonly string[];
+    layers: readonly string[];
+};
+type ProductionScenarioMatrix = {
+    viewport?: ProductionScenarioViewportPreset;
+    width?: number;
+    height?: number;
+    dpr?: number;
+    reducedMotion?: boolean;
+    mute?: boolean;
+    failedAssetIds?: readonly string[];
+    fallback?: boolean;
+    inputModality?: BrowserInputModality;
+};
+type ProductionScenarioStep = {
+    type: 'click';
+    selector?: string;
+    x?: number;
+    y?: number;
+} | {
+    type: 'key';
+    key: string;
+} | {
+    type: 'focus';
+    selector: string;
+} | {
+    type: 'step';
+    frames: number;
+} | {
+    type: 'viewport';
+    kind?: ProductionScenarioViewportPreset;
+    width?: number;
+    height?: number;
+    dpr?: number;
+} | {
+    type: 'reducedMotion';
+    value: boolean;
+} | {
+    type: 'mute';
+    value: boolean;
+} | {
+    type: 'failAsset';
+    assetId: string;
+} | {
+    type: 'save';
+} | {
+    type: 'reload';
+} | {
+    type: 'replay';
+};
+type ProductionScenarioDefinition = {
+    id: string;
+    schemaVersion: typeof PRODUCTION_SCENARIO_SCHEMA_VERSION;
+    seed: string;
+    required: ProductionScenarioRequired;
+    matrix?: ProductionScenarioMatrix;
+    steps?: readonly ProductionScenarioStep[];
+};
+type DefineProductionScenarioResult = {
+    ok: true;
+    scenario: ProductionScenarioDefinition;
+} | {
+    ok: false;
+    errors: ProductionScenarioDiagnostic[];
+};
+type ProductionScenarioReduceResult = {
+    accepted: boolean;
+    state: JsonObject;
+    reason?: string;
+    playSequence?: string;
+};
+type ProductionScenarioHost = {
+    initialState: JsonObject;
+    reduce(state: JsonObject, intent: EventInput): ProductionScenarioReduceResult;
+    project?(state: JsonObject): JsonObject;
+};
+type ProductionScenarioLocalization = {
+    boundary: ProductionScenarioBoundary;
+    code: ProductionScenarioErrorCode;
+    detail: string;
+};
+type ProductionScenarioObservation = {
+    inputDispatched: boolean;
+    inputTarget?: string;
+    reducerAccepted?: boolean;
+    reducerRejected?: boolean;
+    reducerReason?: string;
+    routedTypes: string[];
+    rejected: boolean;
+    selectedBindingIds: string[];
+    sequenceId?: string | null;
+    sequencePhase?: string | null;
+    captions: string[];
+    declaredOrder: string[];
+    requiredParticipantsPresent: boolean;
+    requiredLayersPresent: boolean;
+    missingParticipants: string[];
+    missingLayers: string[];
+    audioInvoked: boolean;
+    audioFailed: boolean;
+    muted: boolean;
+    replayMatch?: boolean;
+    snapshotOk?: boolean;
+};
+type ProductionScenarioExpectation = {
+    inputDispatched?: boolean;
+    reducerAccepted?: boolean;
+    reducerRejected?: boolean;
+    routedTypes?: readonly string[];
+    selectedBindingIds?: readonly string[];
+    sequenceId?: string;
+    captions?: readonly string[];
+    requiredParticipantsPresent?: boolean;
+    requiredLayersPresent?: boolean;
+    audioInvoked?: boolean;
+    audioFailed?: boolean;
+    replayMatch?: boolean;
+    snapshotOk?: boolean;
+};
+type ProductionScenarioEvidenceBundle = {
+    schemaVersion: typeof PRODUCTION_SCENARIO_SNAPSHOT_SCHEMA_VERSION;
+    scenarioId: string;
+    seed: string;
+    matrix: Required<Pick<ProductionScenarioMatrix, 'viewport' | 'width' | 'height' | 'dpr'>> & ProductionScenarioMatrix;
+    hashes: {
+        pixels: string;
+        semantic: string;
+        a11y: string;
+        trace: string;
+        snapshot: string;
+        assets: string;
+    };
+    revisions: {
+        world: string | number | null;
+        bindings: string | number | null;
+        snapshot: number;
+    };
+    traces: {
+        envelopes: EventEnvelope[];
+        inspector: InspectorRecord[];
+        audio: AudioCueEvent[];
+        actions: ProductionScenarioStep[];
+    };
+    screenshot: {
+        pngDataUrl: string | null;
+        declaredOrder: string[];
+        width: number;
+        height: number;
+    };
+    semantic: SemanticPublishedRegion[];
+    a11y: BrowserA11ySnapshot;
+    firstBrokenBoundary: ProductionScenarioBoundary | null;
+    localization: ProductionScenarioLocalization | null;
+    participants: string[];
+    layers: string[];
+    observation: ProductionScenarioObservation;
+    selectionTrace?: SelectionTraceExport | null;
+};
+type CreateProductionScenarioRunnerOptions = {
+    scenario: ProductionScenarioDefinition | unknown;
+    participants: RuntimeGroupParticipantConfig[];
+    compositorLayers: CompositorLayerConfig[];
+    visualLayers?: readonly VisualLayerDeclaration[];
+    visualSources?: Readonly<Record<string, ImageData>>;
+    semanticRegions?: readonly SemanticRegionDeclaration[];
+    sequences?: readonly PresentationSequenceDefinition[];
+    bindings?: PresentationBindingManifest | unknown;
+    geometry?: GeometryDocument;
+    host: ProductionScenarioHost;
+    sequenceBindings?: Readonly<Record<string, PresentationSequenceBindings>>;
+    contentWidth?: number;
+    contentHeight?: number;
+    origin?: number;
+    createId?: () => string;
+    mapClick?: (hotspotId: string) => EventInput;
+    mapKey?: (key: string) => EventInput | undefined;
+    router?: Pick<EventRouter, 'publish'>;
+};
+type ProductionScenarioRunner = {
+    readonly scenario: ProductionScenarioDefinition;
+    readonly harness: BrowserHarness;
+    readonly audio: HeadlessAudioAdapter;
+    readonly inspector: ReplayInspector;
+    goto(): void;
+    click(selectorOrX: string | number, y?: number): void;
+    key(key: string): void;
+    focus(selector: string): void;
+    setViewport(width: number, height: number, dpr?: number): void;
+    setReducedMotion(value: boolean): void;
+    mute(value?: boolean): void;
+    failAsset(assetId: string): void;
+    step(frames?: number): Promise<void>;
+    applyHostIntent(intent: EventInput): ProductionScenarioReduceResult;
+    playSequence(sequenceId: string, invocationId?: string): void;
+    publish(event: EventInput): EventEnvelope | undefined;
+    save(): SnapshotEnvelope;
+    reload(snapshot?: SnapshotEnvelope): void;
+    replay(): Promise<ReplayCompareResult>;
+    run(steps?: readonly ProductionScenarioStep[]): Promise<ProductionScenarioEvidenceBundle>;
+    captureEvidence(expected?: ProductionScenarioExpectation): ProductionScenarioEvidenceBundle;
+    inspect(): {
+        host: JsonObject;
+        lastDecision: ProductionScenarioReduceResult | null;
+        bindings: ReturnType<PresentationBindingRuntime['inspect']> | null;
+        sequences: ReturnType<PresentationSequencePlayer['inspect']> | null;
+        visual: ReturnType<VisualLayerController['inspect']> | null;
+        semantic: ReturnType<SemanticLayerController['inspect']> | null;
+        audio: ReturnType<HeadlessAudioAdapter['snapshot']>;
+        participants: string[];
+        layers: string[];
+        composition: ProductionScenarioLocalization | null;
+    };
+    destroy(): void;
+};
+declare function productionScenarioEventContracts(): EventContract[];
+declare function isProductionScenarioEventType(value: unknown): value is ProductionScenarioEventType;
+declare function isProductionScenarioErrorCode(value: unknown): value is ProductionScenarioErrorCode;
+declare function isProductionScenarioBoundary(value: unknown): value is ProductionScenarioBoundary;
+declare function defineProductionScenario(input: unknown): DefineProductionScenarioResult;
+declare function fnv1aHex(data: string | Uint8Array): string;
+declare function localizeProductionScenarioFailure(observed: ProductionScenarioObservation, expected?: ProductionScenarioExpectation): ProductionScenarioLocalization | null;
+declare function createProductionScenarioRunner(options: CreateProductionScenarioRunnerOptions): ProductionScenarioRunner;
+
 /**
  * Copyright (c) 2026 Aaron Boyarsky
  * SPDX-License-Identifier: LicenseRef-CyberArt-Engine
@@ -2824,4 +5165,4 @@ declare class MidiManager {
     private detachHardware;
 }
 
-export { ANCHOR_ORIGINS, ASSET_FAILED_EVENT, ASSET_FAILURE_CODES, ASSET_KINDS, ASSET_READY_EVENT, AUDIO_CUE_EVENTS, AUDIO_CUE_FAILED_EVENT, AUDIO_CUE_SCHEDULED_EVENT, AUDIO_CUE_SKIPPED_EVENT, AUDIO_CUE_STARTED_EVENT, type ActiveAudioCue, type AnchorOrigin, type AnimationCart, type AnimationTiming, type AppliedAction, type ApplySnapshotMigrationsResult, type AssetCorsMode, type AssetDeclaration, type AssetFailure, type AssetFailureCode, type AssetItemStatus, type AssetKind, type AssetPreloadSnapshot, type AssetPreloader, type AssetProvenance, type AssetResolveRequest, type AssetResolver, type AssetRuntimeOptions, type AttachOptions, type AttachPresentationAdapterOptions, type AudioAssetStatus, type AudioBroker, type AudioBrokerInspect, type AudioBrokerListener, type AudioBrokerNotice, type AudioChannelInspect, type AudioCueEvent, type AudioCueEventType, type AudioCueFailReason, type AudioCueReason, type AudioCueSkipReason, type AudioCueSpec, type AudioCueTimeline, type AudioCueTimelineSnapshot, type AudioCueView, type AudioLibraryId, type AudioLibrarySpec, type AudioUnlockState, type AudioUnlockStatus, type BoundReplaySession, type BrowserA11ySnapshot, type BrowserCompositorConfig, type BrowserHarness, type BrowserHarnessAction, type BrowserHarnessInspect, type BrowserHarnessMountContext, type BrowserHarnessRuntimeContext, type BrowserHarnessScreenshot, type BrowserHostSession, type BrowserInputModality, type BrowserReproductionMetadata, type BrowserViewport, CAPABILITY_ASSET_KINDS, CAPABILITY_BLEND_MODES, CAPABILITY_CART_KINDS, CAPABILITY_CLEAR_POLICIES, CAPABILITY_INTEGRATIONS, CAPABILITY_MANAGERS, CAPABILITY_MANIFEST_VERSION, CAPABILITY_PHASES, COMPOSITOR_BLEND_MODES, COMPOSITOR_CLEAR_POLICIES, COMPOSITOR_SOURCE_KINDS, COORDINATE_SPACES, CUE_CANCELLED_EVENT, CUE_COMPLETED_EVENT, CUE_LIFECYCLE_EVENTS, CUE_REPLACED_EVENT, CUE_STARTED_EVENT, CYBERART_CANVAS_ATTR, type CapabilityAssetDeclarationSummary, type CapabilityAssetKind, type CapabilityAssetSummary, type CapabilityBlendMode, type CapabilityCartKind, type CapabilityClearPolicy, type CapabilityDiagnostic, type CapabilityIntegration, type CapabilityLayerRequirements, type CapabilityManager, type CapabilityManifest, type CapabilityManifestInput, type CapabilityModuleRef, type CapabilityModuleRequirements, type CapabilityPermissions, type CapabilityPhase, type CapabilityRuntime, type CapabilitySurfaceRequirements, type CartHandle, type CartKind, type CartSnapshot, type CartStateBundle, type CartStateHotkeyOptions, type CartStateMessageHandler, type CartStatePersister, type CausationTreeNode, type Clock, type ClockSnapshot, type ComposedFrame, type Compositor, type CompositorBlendMode, type CompositorCanvasSource, type CompositorClearPolicy, type CompositorClip, type CompositorHostOptions, type CompositorImageSource, type CompositorInspect, type CompositorLayerConfig, type CompositorLayerInspect, type CompositorLayerSource, type CompositorParticipantSource, type CompositorPointerEvents, type CompositorSourceKind, type ContractDiagnostic, type ContractFieldType, type ContractRegistry, type CoordinateSpace, type CreateAssetPreloaderOptions, type CreateAudioBrokerOptions, type CreateAudioCueTimelineOptions, type CreateBrowserHarnessOptions, type CreateCompositorOptions, type CreateExecutableModuleHostOptions, type CreatePresentationLayoutInput, type CreatePresentationTimelineOptions, type CreateReplayInspectorOptions, type CreateRuntimeGroupOptions, type CreateRuntimeOptions, type CreateVisualLayerControllerOptions, type CueDuplicatePolicy, type CueEasing, type CueLifecycleEvent, type CueLifecycleType, type CuePhase, type CueReducedMotionPolicy, type CueRepeatPolicy, type CueSpec, type CueTimelineSnapshot, type CueView, type CyberArtRuntime, DEFAULT_BROWSER_VIEWPORT, DEFAULT_DUCK_GAIN, DEFAULT_GROUP_HEIGHT, DEFAULT_GROUP_WIDTH, DEFAULT_MAX_HOPS, DEFAULT_MAX_INSPECTOR_RECORDS, type DebugDrawCall, type DefineCapabilityManifestResult, type DefineContractResult, type DefineSnapshotResult, type DeterministicRuntimeOptions, type DimensionContext, ENGINE_SNAPSHOT_RUNTIME, EVENT_ENVELOPE_VERSION, EXECUTABLE_MODULE_ERROR_CODES, type EventContract, type EventContractManifest, type EventEnvelope, type EventInput, type EventKind, type EventRouter, type EventRouterOptions, type ExecutableModuleCapabilities, type ExecutableModuleDiagnostic, type ExecutableModuleError, type ExecutableModuleErrorCode, type ExecutableModuleFactory, type ExecutableModuleHost, type ExecutableModuleHostInspect, type ExecutableModuleInstance, type ExecutableModuleInvokeContext, type ExecutableModuleInvokeResult, type ExecutableModuleLimits, type ExecutableModuleLoadResult, type ExecutableModuleRef, type ExecutableModuleRegistration, type ExportSnapshotOptions, type FixtureAssetCatalog, type FixtureAssetRecord, type FrameErrorInfo, GEOMETRY_CONTRACT_VERSION, type GeometryAnchor, type GeometryDebugContext, type GeometryDiagnostic, type GeometryDocument, type GeometryHitbox, type GeometryPadding, type GeometrySafeArea, type GeometryValidation, HOST_STATE_ACCEPTED_EVENT, type HeadlessAudioAdapter, type HostCapabilities, HostChannel, type HostEvent, type HostEventListener, type HostedAssetResolverOptions, INVALID_PRESENTATION_MODEL_MESSAGE, type ImportCartStateExtras, IncompatibleCartStateError, type InferredPayload, type InspectorRecord, KeyboardManager, LEGACY_SNAPSHOT_SCHEMA_VERSION, type LandmarkRegisterResult, type LandmarkRegistry, type LegacySnapshot, MIDI_CHANNEL_MAX, MIDI_CHANNEL_MIN, MIDI_CONTROL_CHANGE, MIDI_DATA_MAX, MIDI_NOTE_OFF, MIDI_NOTE_ON, MIDI_PITCH_BEND, MIDI_PITCH_CENTER, MIDI_PITCH_MAX, type MidiAccessFailureReason, type MidiAccessLike, type MidiAccessResult, type MidiCcMessage, type MidiChannel, type MidiInjectInput, type MidiInputLike, MidiManager, type MidiManagerOptions, type MidiMessage, type MidiNoteMessage, type MidiOutputPort, type MidiPitchMessage, type MidiRawMessage, type MidiRequestAccess, type MidiSendFailureReason, type MidiSendResult, type MidiStatusByte, type MidiSubscribeKind, type MidiSubscribeListener, type MidiVoiceInput, type MountOptions, type MountPresentationAdapterOptions, type NormalizeContext, type NormalizeResult, type NormalizedPoint, type NormalizedPolygon, type NormalizedRect, PRESENTATION_ADAPTER_VERSION, PRESENTATION_MODEL_EVENT, PRESENTATION_PHASES, PRESENTATION_SUBSCRIBE_PATTERNS, PRESENTATION_UNSUPPORTED_EVENT, type ParseSnapshotResult, type PayloadFieldSpec, type PayloadSchema, type PayloadValidation, type PixelPoint, type PixelRect, type PlayAudioCueResult, type PlayCueResult, type PlayVisualLayerResult, type PlaywrightCompatibleAdapter, type PlaywrightCompatibleViewport, type PointerClick, PointerManager, type PointerSpace, type PresentationAdapter, type PresentationAdapterTarget, type PresentationCartState, type PresentationFitMode, type PresentationLayout, type PresentationModel, type PresentationPhase, type PresentationRegion, type PresentationTimeline, type PresentationView, type PublishExtras, REDACTED_VALUE, REJECTED_EVENT_TYPE, REPLAY_INSPECTOR_SCHEMA_VERSION, ROUND_TRIP_TOLERANCE, ROUND_TRIP_TOLERANCE_CANVAS_PX, Random, type RandomState, type RejectionPayload, type RejectionReason, type ReplayCompareResult, type ReplayInspector, type ReplayInspectorExport, type ReplayInspectorReport, type ReplayMetadata, type ReplayParticipantSummary, type ReplayTapeAction, type ReplayTraceFilter, type ResolveImportableCartStateResult, type ResolvedAsset, type RestoreVisualLayerResult, type RouterDecision, type RouterDecisionOutcome, type RouterDecisionReason, type RouterParticipantInspect, type RuntimeGroup, type RuntimeGroupCapability, type RuntimeGroupDiagnostics, type RuntimeGroupFrameError, type RuntimeGroupInspect, type RuntimeGroupKind, type RuntimeGroupParticipantConfig, type RuntimeGroupParticipantHandle, type RuntimeGroupParticipantInspect, SILENT_ASSET_FALLBACK_REF, SNAPSHOT_SCHEMA_VERSION, type SchemaCompatibility, type ScriptedAction, type SnapshotAssetRef, type SnapshotCartRef, type SnapshotClock, type SnapshotDiagnostic, type SnapshotEnvelope, type SnapshotEnvelopeInput, type SnapshotIntegrity, type SnapshotMigration, type SnapshotMigrationRegistry, type SnapshotModuleRef, type SnapshotProvenance, type TokenData, UNVERSIONED_CART_VERSION, VISUAL_LAYER_EVENTS, VISUAL_LAYER_FAILED_EVENT, VISUAL_LAYER_FAILURE_CODES, VISUAL_LAYER_HIDDEN_EVENT, VISUAL_LAYER_INCOMING_SUFFIX, VISUAL_LAYER_KINDS, VISUAL_LAYER_REVEALED_EVENT, VISUAL_LAYER_SNAPSHOT_SCHEMA_VERSION, VISUAL_LAYER_TRANSITIONS, VISUAL_LAYER_TRANSITION_COMPLETED_EVENT, VISUAL_LAYER_TRANSITION_STARTED_EVENT, type ValidateCapabilityManifestResult, type ValidateResult, type ValidateSnapshotResult, type VersionedSnapshot, type VirtualClock, type VisualLayerAcceptedBinding, type VisualLayerAssetStatus, type VisualLayerCapture, type VisualLayerController, type VisualLayerControllerSnapshot, type VisualLayerCueSpec, type VisualLayerDeclaration, type VisualLayerDiagnostic, type VisualLayerEvent, type VisualLayerEventType, type VisualLayerFailureCode, type VisualLayerFallbackPolicy, type VisualLayerInspect, type VisualLayerKind, type VisualLayerSnapshotRow, type VisualLayerTransitionInspect, type VisualLayerTransitionKind, type VisualLayerVersionDeclaration, applyCueEasing, applySnapshotMigrations, assetStatusEvent, assetToNormalized, attachCartStatePersistence, attachPresentationAdapter, canonicalizeSeed, canvasToCss, canvasToNormalized, toJSON as capabilityManifestToJSON, captureVisualLayers, cloneSnapshotJson, comparePayloadSchemas, compareReplayTraces, createAssetFailure, createAssetPreloader, createAudioBroker, createAudioCueTimeline, createBrowserHarness, createCompositor, createContractRegistry, createEngineSnapshotMigrations, createEventRouter, createExecutableModuleHost, createFixtureAssetResolver, createHeadlessAudioAdapter, createHostedAssetResolver, createLandmarkRegistry, createPlaywrightCompatibleAdapter, createPresentationLayout, createPresentationModelEvent, createPresentationTimeline, createReferencePresentationCart, createReplayInspector, createRuntime, createRuntimeGroup, createSnapshotMigrationRegistry, createVirtualClock, createVisualLayerController, createWallClock, cssToCanvas, cssToNormalized, defaultSnapshotMigrationRegistry, defineCapabilityManifest, defineDiagnostic, defineIntent, defineSnapshot, defineStateEvent, deriveAttachOptions, describeReplayMismatch, detectSnapshotSchemaVersion, drawGeometryDebug, encodeMidiMessage, engineStateFromEnvelope, familyPatternForType, inferEventKind, isAssetFailure, isAssetFailureCode, isAssetKind, isAudioCueEventType, isCueLifecycleType, isLegacyCartStateBundle, isMidiChannel, isMidiData, isPresentationModel, isPresentationPhase, isSnapshotEnvelope, isVersionedSnapshot, isVisualLayerEventType, isVisualLayerKind, isVisualLayerTransitionKind, kindSegmentInType, matchEventPattern, midiChannelFromStatus, midiStatus, mountPresentationAdapter, normalizeEvent, normalizedToAsset, normalizedToCanvas, normalizedToCss, parseCapabilityManifest, parseGeometry, parseMidiBytes, parseSnapshot, pointFromOrigin, pointerToRegion, rectToCanvas, rectToCss, regionToViewport, registerCartStateHotkeys, replayExportedTrace, resolveImportableCartState, resolveRuntimeSeed, restoreSnapshotFromUnknown, rewriteHostedAssetRef, scheduleAudioCue, serializeGeometry, snapshotErrorsToMessage, snapshotFromCartBundle, validateCapabilityManifest, validateGeometry, validateSnapshot, verifyAttachOptions, visualIncomingLayerId };
+export { ANCHOR_ORIGINS, ASSET_FAILED_EVENT, ASSET_FAILURE_CODES, ASSET_KINDS, ASSET_READY_EVENT, AUDIO_CUE_EVENTS, AUDIO_CUE_FAILED_EVENT, AUDIO_CUE_SCHEDULED_EVENT, AUDIO_CUE_SKIPPED_EVENT, AUDIO_CUE_STARTED_EVENT, type ActivateContentRevisionRequest, type ActiveAudioCue, type AnchorOrigin, type AnimationCart, type AnimationTiming, type AppliedAction, type ApplyPresentationBindingsResult, type ApplySnapshotMigrationsResult, type AssetCorsMode, type AssetDeclaration, type AssetFailure, type AssetFailureCode, type AssetItemStatus, type AssetKind, type AssetPreloadSnapshot, type AssetPreloader, type AssetProvenance, type AssetResolveRequest, type AssetResolver, type AssetRuntimeOptions, type AttachOptions, type AttachPresentationAdapterOptions, type AudioAssetStatus, type AudioBroker, type AudioBrokerInspect, type AudioBrokerListener, type AudioBrokerNotice, type AudioChannelInspect, type AudioCueEvent, type AudioCueEventType, type AudioCueFailReason, type AudioCueReason, type AudioCueSkipReason, type AudioCueSpec, type AudioCueTimeline, type AudioCueTimelineSnapshot, type AudioCueView, type AudioLibraryId, type AudioLibrarySpec, type AudioUnlockState, type AudioUnlockStatus, type BoundReplaySession, type BrowserA11ySnapshot, type BrowserCompositorConfig, type BrowserHarness, type BrowserHarnessAction, type BrowserHarnessInspect, type BrowserHarnessMountContext, type BrowserHarnessRuntimeContext, type BrowserHarnessScreenshot, type BrowserHostSession, type BrowserInputModality, type BrowserReproductionMetadata, type BrowserViewport, CAPABILITY_ASSET_KINDS, CAPABILITY_BLEND_MODES, CAPABILITY_CART_KINDS, CAPABILITY_CLEAR_POLICIES, CAPABILITY_DEVICE_GRANTS, CAPABILITY_INTEGRATIONS, CAPABILITY_MANAGERS, CAPABILITY_MANIFEST_VERSION, CAPABILITY_PHASES, COMPOSITOR_BLEND_MODES, COMPOSITOR_CLEAR_POLICIES, COMPOSITOR_SOURCE_KINDS, CONTENT_REVISION_ACTIVATED_EVENT, CONTENT_REVISION_DIAGNOSTIC_EVENT, CONTENT_REVISION_DISCOVERED_EVENT, CONTENT_REVISION_ERROR_CODES, CONTENT_REVISION_EVENTS, CONTENT_REVISION_MANIFEST_VERSION, CONTENT_REVISION_REJECTED_EVENT, CONTENT_REVISION_ROLLED_BACK_EVENT, CONTENT_REVISION_SNAPSHOT_SCHEMA_VERSION, CONTENT_REVISION_STAGING_EVENT, CONTENT_REVISION_SUPERSEDED_EVENT, CONTENT_REVISION_VALIDATED_EVENT, COORDINATE_SPACES, CUE_CANCELLED_EVENT, CUE_COMPLETED_EVENT, CUE_LIFECYCLE_EVENTS, CUE_REPLACED_EVENT, CUE_STARTED_EVENT, CYBERART_CANVAS_ATTR, type CapabilityAssetDeclarationSummary, type CapabilityAssetKind, type CapabilityAssetSummary, type CapabilityBlendMode, type CapabilityCartKind, type CapabilityClearPolicy, type CapabilityDeviceGrant, type CapabilityDiagnostic, type CapabilityIntegration, type CapabilityLayerRequirements, type CapabilityManager, type CapabilityManifest, type CapabilityManifestInput, type CapabilityModuleRef, type CapabilityModuleRequirements, type CapabilityPermissions, type CapabilityPhase, type CapabilityRuntime, type CapabilitySurfaceRequirements, type CartHandle, type CartKind, type CartSnapshot, type CartStateBundle, type CartStateHotkeyOptions, type CartStateMessageHandler, type CartStatePersister, type CausationTreeNode, type Clock, type ClockSnapshot, type ComposedFrame, type Compositor, type CompositorBlendMode, type CompositorCanvasSource, type CompositorClearPolicy, type CompositorClip, type CompositorHostOptions, type CompositorImageSource, type CompositorInspect, type CompositorLayerConfig, type CompositorLayerInspect, type CompositorLayerSource, type CompositorParticipantSource, type CompositorPointerEvents, type CompositorSourceKind, type ContentRegistryAdapter, type ContentRevisionActivator, type ContentRevisionAssetDecl, type ContentRevisionBundle, type ContentRevisionCatalog, type ContentRevisionDescriptor, type ContentRevisionDiagnostic, type ContentRevisionErrorCode, type ContentRevisionEventType, type ContentRevisionInspect, type ContentRevisionMutationResult, type ContentRevisionResource, type ContentRevisionSnapshot, type ContentRevisionStagingView, type ContractDiagnostic, type ContractFieldType, type ContractRegistry, type CoordinateSpace, type CreateAssetPreloaderOptions, type CreateAudioBrokerOptions, type CreateAudioCueTimelineOptions, type CreateBrowserHarnessOptions, type CreateCompositorOptions, type CreateContentRevisionActivatorOptions, type CreateExecutableModuleHostOptions, type CreateJobCoordinatorOptions, type CreatePortalLifecycleOptions, type CreatePresentationBindingRuntimeOptions, type CreatePresentationLayoutInput, type CreatePresentationSequencePlayerOptions, type CreatePresentationTimelineOptions, type CreateProductionScenarioRunnerOptions, type CreateRemoteCartSandboxOptions, type CreateRemoteContentAdapterOptions, type CreateReplayInspectorOptions, type CreateRuntimeGroupOptions, type CreateRuntimeOptions, type CreateSelectionTraceOptions, type CreateSemanticLayerControllerOptions, type CreateStaticContentAdapterOptions, type CreateVisualLayerControllerOptions, type CreateWorldGraphOptions, type CreateWorldPatchApplierOptions, type CueDuplicatePolicy, type CueEasing, type CueLifecycleEvent, type CueLifecycleType, type CuePhase, type CueReducedMotionPolicy, type CueRepeatPolicy, type CueSpec, type CueTimelineSnapshot, type CueView, type CyberArtRuntime, DEFAULT_BROWSER_VIEWPORT, DEFAULT_DUCK_GAIN, DEFAULT_GROUP_HEIGHT, DEFAULT_GROUP_WIDTH, DEFAULT_MAX_HOPS, DEFAULT_MAX_INSPECTOR_RECORDS, DEFAULT_MAX_SELECTION_RECORDS, DEFAULT_PORTAL_MAX_DEPTH, DEFAULT_PRODUCTION_SCENARIO_VIEWPORTS, DEFAULT_SENSITIVE_KEYS, type DebugDrawCall, type DeclaredAssetBytes, type DeclaredAssetResolverOptions, type DefineCapabilityManifestResult, type DefineContractResult, type DefinePresentationBindingsResult, type DefinePresentationSequenceResult, type DefineProductionScenarioResult, type DefineRemoteCartResult, type DefineSnapshotResult, type DeterministicRuntimeOptions, type DimensionContext, ENGINE_SNAPSHOT_RUNTIME, EVENT_ENVELOPE_VERSION, EXECUTABLE_MODULE_ERROR_CODES, type EventContract, type EventContractManifest, type EventEnvelope, type EventInput, type EventKind, type EventRouter, type EventRouterOptions, type ExecutableModuleCapabilities, type ExecutableModuleDiagnostic, type ExecutableModuleError, type ExecutableModuleErrorCode, type ExecutableModuleFactory, type ExecutableModuleHost, type ExecutableModuleHostInspect, type ExecutableModuleInstance, type ExecutableModuleInvokeContext, type ExecutableModuleInvokeResult, type ExecutableModuleLimits, type ExecutableModuleLoadResult, type ExecutableModuleRef, type ExecutableModuleRegistration, type ExportSnapshotOptions, type FixtureAssetCatalog, type FixtureAssetRecord, type FrameErrorInfo, type FrameTimingSample, GEOMETRY_CONTRACT_VERSION, type GeometryAnchor, type GeometryDebugContext, type GeometryDiagnostic, type GeometryDocument, type GeometryHitbox, type GeometryPadding, type GeometrySafeArea, type GeometryValidation, HOST_GRANT_SNAPSHOT_SCHEMA_VERSION, HOST_STATE_ACCEPTED_EVENT, type HeadlessAudioAdapter, type HeadlessJobWorker, type HostCapabilities, HostChannel, type HostEvent, type HostEventListener, type HostGrantRestoreResult, type HostGrantSet, type HostGrantSnapshot, type HostPresentationOverride, type HostedAssetResolverOptions, INVALID_PRESENTATION_MODEL_MESSAGE, type ImportCartStateExtras, IncompatibleCartStateError, type InferredPayload, type InspectorRecord, JOB_APPLIED_EVENT, JOB_AWAITING_EVALUATION_EVENT, JOB_CANCELED_EVENT, JOB_CLAIMED_EVENT, JOB_DIAGNOSTIC_EVENT, JOB_EVALUATOR_DECISIONS, JOB_FAILED_EVENT, JOB_LIFECYCLE_EVENTS, JOB_ORCHESTRATION_SNAPSHOT_SCHEMA_VERSION, JOB_PROGRESS_EVENT, JOB_QUEUED_EVENT, JOB_READY_EVENT, JOB_REDACTED_KEYS, JOB_RESULT_REF_SCHEMA_VERSION, JOB_RETRYABILITY, JOB_RETRY_SCHEDULED_EVENT, JOB_STATES, JOB_SUBMITTED_EVENT, JOB_SUPERSEDED_EVENT, type JobCoordinator, type JobCoordinatorSnapshot, type JobDefinition, type JobDiagnostic, type JobEvaluatorDecision, type JobFailureRecord, type JobInspect, type JobLifecycleEventType, type JobMutationResult, type JobPersistenceAdapter, type JobProgress, type JobRecord, type JobResultRef, type JobRetryPolicy, type JobRetryability, type JobState, type JobSubmitRequest, type JobWorkerAdapter, type JsonObject, type JsonPrimitive, type JsonValue, KeyboardManager, LEGACY_SNAPSHOT_SCHEMA_VERSION, type LandmarkRegisterResult, type LandmarkRegistry, type LegacySnapshot, type LoadRemoteCartOptions, MIDI_CHANNEL_MAX, MIDI_CHANNEL_MIN, MIDI_CONTROL_CHANGE, MIDI_DATA_MAX, MIDI_NOTE_OFF, MIDI_NOTE_ON, MIDI_PITCH_BEND, MIDI_PITCH_CENTER, MIDI_PITCH_MAX, type MidiAccessFailureReason, type MidiAccessLike, type MidiAccessResult, type MidiCcMessage, type MidiChannel, type MidiInjectInput, type MidiInputLike, MidiManager, type MidiManagerOptions, type MidiMessage, type MidiNoteMessage, type MidiOutputPort, type MidiPitchMessage, type MidiRawMessage, type MidiRequestAccess, type MidiSendFailureReason, type MidiSendResult, type MidiStatusByte, type MidiSubscribeKind, type MidiSubscribeListener, type MidiVoiceInput, type MountOptions, type MountPresentationAdapterOptions, type NormalizeContext, type NormalizeResult, type NormalizedPoint, type NormalizedPolygon, type NormalizedRect, PORTAL_ABORTED_EVENT, PORTAL_ENTERED_EVENT, PORTAL_EXCLUSIVE_GRANTS, PORTAL_EXITED_EVENT, PORTAL_LIFECYCLE_EVENTS, PORTAL_LIFECYCLE_SNAPSHOT_SCHEMA_VERSION, PORTAL_METAPHORS, PORTAL_OUTCOME_KINDS, PORTAL_OUTCOME_SCHEMA_VERSION, PRESENTATION_ADAPTER_VERSION, PRESENTATION_AUDIO_CAPABILITY_STATUSES, PRESENTATION_BINDING_APPLIED_EVENT, PRESENTATION_BINDING_DIAGNOSTIC_EVENT, PRESENTATION_BINDING_ERROR_CODES, PRESENTATION_BINDING_EVENTS, PRESENTATION_BINDING_MANIFEST_VERSION, PRESENTATION_BINDING_REJECTED_EVENT, PRESENTATION_BINDING_SNAPSHOT_SCHEMA_VERSION, PRESENTATION_BINDING_TARGET_KINDS, PRESENTATION_COMPLETION_RULES, PRESENTATION_INTERRUPTION_POLICIES, PRESENTATION_INVOCATION_PHASES, PRESENTATION_MODEL_EVENT, PRESENTATION_PHASES, PRESENTATION_SEQUENCE_COMPLETED_EVENT, PRESENTATION_SEQUENCE_DIAGNOSTIC_EVENT, PRESENTATION_SEQUENCE_EVENTS, PRESENTATION_SEQUENCE_FAILED_EVENT, PRESENTATION_SEQUENCE_INTERRUPTED_EVENT, PRESENTATION_SEQUENCE_PRELOADING_EVENT, PRESENTATION_SEQUENCE_READY_EVENT, PRESENTATION_SEQUENCE_REQUESTED_EVENT, PRESENTATION_SEQUENCE_SKIPPED_EVENT, PRESENTATION_SEQUENCE_SNAPSHOT_SCHEMA_VERSION, PRESENTATION_SEQUENCE_STARTED_EVENT, PRESENTATION_SEQUENCE_STEP_COMPLETED_EVENT, PRESENTATION_SEQUENCE_STEP_STARTED_EVENT, PRESENTATION_SUBSCRIBE_PATTERNS, PRESENTATION_TRACK_KINDS, PRESENTATION_UNSUPPORTED_EVENT, PRODUCTION_SCENARIO_BOUNDARIES, PRODUCTION_SCENARIO_DIAGNOSTIC_EVENT, PRODUCTION_SCENARIO_ERROR_CODES, PRODUCTION_SCENARIO_EVENTS, PRODUCTION_SCENARIO_FAILED_EVENT, PRODUCTION_SCENARIO_OBSERVED_EVENT, PRODUCTION_SCENARIO_SCHEMA_VERSION, PRODUCTION_SCENARIO_SNAPSHOT_SCHEMA_VERSION, PRODUCTION_SCENARIO_VIEWPORT_PRESETS, type ParseSnapshotResult, type PayloadFieldSpec, type PayloadSchema, type PayloadValidation, type PixelPoint, type PixelRect, type PlayAudioCueResult, type PlayCueResult, type PlaySequenceOptions, type PlaySequenceResult, type PlayVisualLayerResult, type PlaywrightCompatibleAdapter, type PlaywrightCompatibleViewport, type PointerClick, PointerManager, type PointerSpace, type PortalCartDeclaration, type PortalDiagnostic, type PortalEnterRequest, type PortalExclusiveGrant, type PortalFrameInspect, type PortalInspect, type PortalLifecycle, type PortalLifecycleEventType, type PortalLifecycleSnapshot, type PortalMetaphor, type PortalMutationResult, type PortalOutcome, type PortalOutcomeKind, type PresentationAdapter, type PresentationAdapterTarget, type PresentationAudioCapabilityStatus, type PresentationBinding, type PresentationBindingConsidered, type PresentationBindingDiagnostic, type PresentationBindingErrorCode, type PresentationBindingEvaluation, type PresentationBindingEvent, type PresentationBindingEventType, type PresentationBindingExplanation, type PresentationBindingFallback, type PresentationBindingInspect, type PresentationBindingManifest, type PresentationBindingRejected, type PresentationBindingResources, type PresentationBindingRuntime, type PresentationBindingSelector, type PresentationBindingSnapshot, type PresentationBindingTarget, type PresentationBindingTargetKind, type PresentationCaptionView, type PresentationCartState, type PresentationCompletionRule, type PresentationCueIntent, type PresentationFallbackDefinition, type PresentationFallbackWhen, type PresentationFitMode, type PresentationInterruptionPolicy, type PresentationInvocationPhase, type PresentationInvocationView, type PresentationLayout, type PresentationModel, type PresentationPhase, type PresentationPredicate, type PresentationRegion, type PresentationSequenceBindings, type PresentationSequenceDefinition, type PresentationSequenceDiagnostic, type PresentationSequenceEvent, type PresentationSequenceEventType, type PresentationSequenceInspect, type PresentationSequencePlayer, type PresentationSequenceSnapshot, type PresentationSequenceSnapshotQueued, type PresentationStepDefinition, type PresentationStepEffect, type PresentationStepTiming, type PresentationTimeline, type PresentationTrackDefinition, type PresentationTrackKind, type PresentationView, type ProductionScenarioBoundary, type ProductionScenarioDefinition, type ProductionScenarioDiagnostic, type ProductionScenarioErrorCode, type ProductionScenarioEventType, type ProductionScenarioEvidenceBundle, type ProductionScenarioExpectation, type ProductionScenarioHost, type ProductionScenarioLocalization, type ProductionScenarioMatrix, type ProductionScenarioObservation, type ProductionScenarioReduceResult, type ProductionScenarioRequired, type ProductionScenarioRunner, type ProductionScenarioStep, type ProductionScenarioViewportPreset, type PublishExtras, REDACTED_VALUE, REJECTED_EVENT_TYPE, REMOTE_CART_ERROR_CODES, REMOTE_CART_GRANTS, REMOTE_CART_MANIFEST_VERSION, REMOTE_CART_SIGNATURE_ALG, REPLAY_INSPECTOR_SCHEMA_VERSION, ROUND_TRIP_TOLERANCE, ROUND_TRIP_TOLERANCE_CANVAS_PX, Random, type RandomState, type RejectionPayload, type RejectionReason, type RemoteCartAsset, type RemoteCartCapabilityBag, RemoteCartCapabilityError, type RemoteCartDiagnostic, type RemoteCartErrorCode, type RemoteCartFetchAdapter, type RemoteCartGrant, type RemoteCartInspect, type RemoteCartLoadSource, type RemoteCartManifestBody, type RemoteCartNetworkApi, type RemoteCartRegistry, type RemoteCartSandbox, type RemoteCartSignature, type RemoteCartStorageApi, type RemoteContentEnvelope, type ReplayCompareResult, type ReplayInspector, type ReplayInspectorExport, type ReplayInspectorReport, type ReplayMetadata, type ReplayParticipantSummary, type ReplayTapeAction, type ReplayTraceFilter, type ResolveImportableCartStateResult, type ResolvedAsset, type RestoreContentRevisionResult, type RestoreJobResult, type RestorePortalResult, type RestorePresentationBindingsResult, type RestorePresentationSequenceResult, type RestoreSemanticLayerResult, type RestoreVisualLayerResult, type RestoreWorldGraphResult, type RestoreWorldPatchResult, type RouterDecision, type RouterDecisionOutcome, type RouterDecisionReason, type RouterParticipantInspect, type RuntimeGroup, type RuntimeGroupCapability, type RuntimeGroupDiagnostics, type RuntimeGroupFrameError, type RuntimeGroupInspect, type RuntimeGroupKind, type RuntimeGroupParticipantConfig, type RuntimeGroupParticipantHandle, type RuntimeGroupParticipantInspect, SELECTION_DECISION_KINDS, SELECTION_REASON_CODES, SELECTION_TRACE_SCHEMA_VERSION, SELECTION_TRACE_SENSITIVE_KEYS, SEMANTIC_APPEARANCE_KEYS, SEMANTIC_GEOMETRY_KINDS, SEMANTIC_HIT_TEST_POLICIES, SEMANTIC_INTERACTION_KEYS, SEMANTIC_LAYER_SNAPSHOT_SCHEMA_VERSION, SILENT_ASSET_FALLBACK_REF, SNAPSHOT_SCHEMA_VERSION, type SchemaCompatibility, type ScriptedAction, type SelectionAssetResolution, type SelectionBindingEvaluation, type SelectionContentIdentity, type SelectionDecisionInput, type SelectionDecisionKind, type SelectionDecisionRecord, type SelectionPresentationDecision, type SelectionReasonCode, type SelectionSequenceDecision, type SelectionSnapshotProvenance, type SelectionStagingOutcome, type SelectionStagingResult, type SelectionTrace, type SelectionTraceExport, type SelectionTraceFilter, type SelectionTraceReport, type SemanticAppearanceKey, type SemanticGeometryKind, type SemanticHitTestPolicy, type SemanticInteractionKey, type SemanticLayerController, type SemanticLayerControllerSnapshot, type SemanticMaskGrid, type SemanticPublishedRegion, type SemanticRegionA11y, type SemanticRegionDeclaration, type SemanticRegionGeometry, type SemanticRegionInspect, type SemanticRegionSnapshotRow, type SemanticRegionState, type SemanticRegionVisual, type SemanticRegionVisuals, type SignedRemoteCartManifest, type SnapshotAssetRef, type SnapshotCartRef, type SnapshotClock, type SnapshotDiagnostic, type SnapshotEnvelope, type SnapshotEnvelopeInput, type SnapshotIntegrity, type SnapshotMigration, type SnapshotMigrationRegistry, type SnapshotModuleRef, type SnapshotProvenance, type SnapshotSignatureRef, type TokenData, UNVERSIONED_CART_VERSION, VISUAL_LAYER_EVENTS, VISUAL_LAYER_FAILED_EVENT, VISUAL_LAYER_FAILURE_CODES, VISUAL_LAYER_HIDDEN_EVENT, VISUAL_LAYER_INCOMING_SUFFIX, VISUAL_LAYER_KINDS, VISUAL_LAYER_REVEALED_EVENT, VISUAL_LAYER_SNAPSHOT_SCHEMA_VERSION, VISUAL_LAYER_TRANSITIONS, VISUAL_LAYER_TRANSITION_COMPLETED_EVENT, VISUAL_LAYER_TRANSITION_STARTED_EVENT, type ValidateCapabilityManifestResult, type ValidateResult, type ValidateSnapshotResult, type VerifyRemoteCartResult, type VersionedSnapshot, type VirtualClock, type VisualLayerAcceptedBinding, type VisualLayerAssetStatus, type VisualLayerCapture, type VisualLayerController, type VisualLayerControllerSnapshot, type VisualLayerCueSpec, type VisualLayerDeclaration, type VisualLayerDiagnostic, type VisualLayerEvent, type VisualLayerEventType, type VisualLayerFailureCode, type VisualLayerFallbackPolicy, type VisualLayerInspect, type VisualLayerKind, type VisualLayerSnapshotRow, type VisualLayerTransitionInspect, type VisualLayerTransitionKind, type VisualLayerVersionDeclaration, WORLD_DISCOVERED_EVENT, WORLD_EDGE_ACCESS, WORLD_EDGE_ADDED_EVENT, WORLD_EDGE_VISIBILITIES, WORLD_ENTITY_KINDS, WORLD_ENTITY_STATUSES, WORLD_GRAPH_DIAGNOSTIC_EVENT, WORLD_GRAPH_EVENTS, WORLD_GRAPH_SNAPSHOT_SCHEMA_VERSION, WORLD_MAP_LAYERS, WORLD_NODE_ADDED_EVENT, WORLD_NODE_KINDS, WORLD_PATCH_ACCEPTED_EVENT, WORLD_PATCH_DIAGNOSTIC_EVENT, WORLD_PATCH_ERROR_CODES, WORLD_PATCH_EVENTS, WORLD_PATCH_OPS, WORLD_PATCH_PRECONDITION_TYPES, WORLD_PATCH_REDACTED_KEYS, WORLD_PATCH_REJECTED_EVENT, WORLD_PATCH_SCHEMA_VERSION, WORLD_PATCH_SNAPSHOT_SCHEMA_VERSION, WORLD_PATCH_SUPERSEDED_EVENT, WORLD_TRANSIT_EVENT, type WorldAcceptedPatch, type WorldEdge, type WorldEdgeAccess, type WorldEdgeVisibility, type WorldEntity, type WorldEntityKind, type WorldEntityRecord, type WorldEntityStatus, type WorldGraph, type WorldGraphDiagnostic, type WorldGraphEventType, type WorldGraphInspect, type WorldGraphPatch, type WorldGraphProjection, type WorldGraphSnapshot, type WorldIdentityChange, type WorldLinkRecord, type WorldMapLayer, type WorldMutationResult, type WorldNode, type WorldNodeKind, type WorldObserverDiscovery, type WorldPatch, type WorldPatchAcceptedPayload, type WorldPatchApplier, type WorldPatchAssetAvailability, type WorldPatchAuditRecord, type WorldPatchBindingAvailability, type WorldPatchCommitResult, type WorldPatchContentAvailability, type WorldPatchDiagnostic, type WorldPatchDomainValidator, type WorldPatchDryRunResult, type WorldPatchErrorCode, type WorldPatchEventType, type WorldPatchGraphPolicy, type WorldPatchInspect, type WorldPatchLimits, type WorldPatchOp, type WorldPatchOperation, type WorldPatchPrecondition, type WorldPatchPreconditionType, type WorldPatchProvenance, type WorldPatchRefs, type WorldPatchSnapshot, type WorldPath, type WorldPathResult, type WorldPersistenceAdapter, type WorldPersistenceTransaction, type WorldQueryBounds, type WorldReachabilityResult, type WorldRevisionState, type WorldTransit, type WorldTraversalContext, type WorldTraversalPolicy, appearanceForState, applyCueEasing, applySnapshotMigrations, assetStatusEvent, assetToNormalized, attachCartStatePersistence, attachPresentationAdapter, attachSelectionTrace, cabinetPortal, canonicalizeRemoteCartBody, canonicalizeSeed, canvasToCss, canvasToNormalized, toJSON as capabilityManifestToJSON, captureVisualLayers, cloneSnapshotJson, comparePayloadSchemas, compareReplayTraces, contentRevisionEventContracts, createAssetFailure, createAssetPreloader, createAudioBroker, createAudioCueTimeline, createBrowserHarness, createCompositor, createContentRevisionActivator, createContractRegistry, createDeclaredAssetResolver, createEngineSnapshotMigrations, createEventRouter, createExecutableModuleHost, createFixtureAssetResolver, createHeadlessAudioAdapter, createHeadlessJobWorker, createHostGrantSet, createHostedAssetResolver, createJobCoordinator, createLandmarkRegistry, createMemoryJobPersistence, createMemoryWorldPersistence, createPlaywrightCompatibleAdapter, createPortalLifecycle, createPresentationBindingRuntime, createPresentationLayout, createPresentationModelEvent, createPresentationSequencePlayer, createPresentationTimeline, createProductionScenarioRunner, createReferencePresentationCart, createRemoteCartRegistry, createRemoteCartSandbox, createRemoteContentAdapter, createReplayInspector, createRuntime, createRuntimeGroup, createSelectionTrace, createSemanticLayerController, createSnapshotMigrationRegistry, createStaticContentAdapter, createVirtualClock, createVisualLayerController, createWallClock, createWorldGraph, createWorldPatchApplier, cssToCanvas, cssToNormalized, defaultSnapshotMigrationRegistry, defineCapabilityManifest, defineDiagnostic, defineIntent, definePresentationBindings, definePresentationSequence, defineProductionScenario, defineRemoteCartManifest, defineSnapshot, defineStateEvent, deriveAttachOptions, describeReplayMismatch, detectSnapshotSchemaVersion, drawGeometryDebug, encodeMidiMessage, engineStateFromEnvelope, evaluatePresentationBindings, familyPatternForType, fnv1aHex, freezeCapabilityBag, geometryKindsOf, hmacSha256Hex, inferEventKind, isAssetFailure, isAssetFailureCode, isAssetKind, isAudioCueEventType, isContentRevisionErrorCode, isCueLifecycleType, isLegacyCartStateBundle, isMidiChannel, isMidiData, isPresentationBindingErrorCode, isPresentationBindingEventType, isPresentationModel, isPresentationPhase, isPresentationSequenceEventType, isProductionScenarioBoundary, isProductionScenarioErrorCode, isProductionScenarioEventType, isSelectionDecisionKind, isSelectionReasonCode, isSemanticBlendMode, isSemanticGeometryKind, isSemanticHitTestPolicy, isSnapshotEnvelope, isVersionedSnapshot, isVisualLayerEventType, isVisualLayerKind, isVisualLayerTransitionKind, isWorldPatchErrorCode, jobEventContracts, kindSegmentInType, listRequestedRemoteCartGrants, loadRemoteCart, localizeProductionScenarioFailure, matchEventPattern, midiChannelFromStatus, midiStatus, mountPresentationAdapter, normalizeEvent, normalizedToAsset, normalizedToCanvas, normalizedToCss, paintingPortal, parseCapabilityManifest, parseContentRevisionCatalog, parseGeometry, parseMidiBytes, parseRemoteCartManifest, parseSnapshot, pointFromOrigin, pointInHitbox, pointInSemanticGeometry, pointerToRegion, presentationBindingEventContracts, presentationBindingTargetKey, presentationSequenceEventContracts, productionScenarioEventContracts, recordSelectionDecision, rectToCanvas, rectToCss, regionToViewport, registerCartStateHotkeys, remoteCartProvenanceForSnapshot, replayExportedTrace, resolveImportableCartState, resolveRuntimeSeed, restoreSnapshotFromUnknown, rewriteHostedAssetRef, scheduleAudioCue, serializeGeometry, sha256Hex, signRemoteCartManifest, snapshotErrorsToMessage, snapshotFromCartBundle, validateCapabilityManifest, validateGeometry, validateSnapshot, verifyAttachOptions, verifyRemoteCartSignature, visualIncomingLayerId, worldGraphEventContracts, worldPatchEventContracts };