@cimplify/sdk 0.108.0 → 0.110.2

package/dist/guest-DrsA00XD.d.mts

@@ -0,0 +1,732 @@
+import { l as FramePublisher, m as FrameListener, n as ChannelMessage, o as RoomInputMessage, p as FastValueMessage, q as CounterFrame, r as PresenceTickView, s as Listener, U as Unsubscribe, t as FastReader, u as FRAME_CODES, v as UiPresentation, H as HostSheetRequest, w as ProgramInfo, x as LocaleInfo, y as CtxLifecycle, z as CtxOperationName, B as CtxRequest, D as CtxResponse, I as SubscriptionGrant, J as HostEvent, K as HostEventFamily, b as UiNode, M as UiEvent, N as ReplayListener, C as Ctx, O as GameLoop, T as TickEndpoints, Q as Family, V as LifecycleState, L as LifecycleEvent } from './local-D8_I6UeL.mjs';
+import { R as RoomDialer } from './link-BUTqGmyi.mjs';
+import { N as NetworkHint } from './network-ZXLD7l1b.mjs';
+
+declare const SESSION_PROTOCOL_VERSION = 1;
+declare const BRIDGE_PROTOCOL_VERSION = 1;
+declare const ENGINE_CORE_UNIT = "@cimplify/engine-core";
+declare const ENGINE_CORE_THREADS_UNIT = "@cimplify/engine-core-threads";
+declare const RUNTIME_WASM_SUFFIX = "/wasm";
+interface HotRequest {
+    readonly chunks: readonly string[];
+}
+interface HotSwapReport {
+    readonly replaced: readonly string[];
+    readonly added: readonly string[];
+    readonly dropped: readonly string[];
+    readonly systems: number;
+    readonly kept: boolean;
+    readonly assets: readonly string[];
+}
+type HotSwapResult = {
+    readonly swapped: true;
+    readonly report: HotSwapReport;
+} | {
+    readonly swapped: false;
+    readonly reason: string;
+};
+declare const CHUNK_TOUCH_PREFIX = "chunk:";
+declare const PIPELINE_TOUCH_PREFIX = "pipeline:";
+declare const FrameTouchKind: {
+    readonly take: 0;
+    readonly progressive: 1;
+    readonly prefetch: 2;
+    readonly pipeline: 3;
+    readonly chunk: 4;
+};
+type FrameTouchKind = (typeof FrameTouchKind)[keyof typeof FrameTouchKind];
+interface FrameTouch {
+    readonly path: string;
+    readonly kind: FrameTouchKind;
+    readonly priority: number;
+}
+interface FrameMark {
+    readonly frame: number;
+    readonly outstanding: number;
+    readonly touches: readonly FrameTouch[];
+    readonly heap?: number;
+}
+declare function encodeFrameMark(mark: FrameMark): Uint8Array;
+declare function readFrameMark(bytes: Uint8Array): FrameMark | null;
+declare const MessageTag: {
+    readonly hello: 1;
+    readonly close: 2;
+    readonly consent: 3;
+    readonly confirm: 4;
+    readonly ai_local: 5;
+    readonly ai_local_result: 6;
+    readonly request: 16;
+    readonly response: 17;
+    readonly event: 18;
+    readonly frames: 19;
+    readonly boot: 32;
+    readonly chunk: 33;
+    readonly start: 34;
+    readonly lifecycle: 35;
+    readonly ui_event: 36;
+    readonly ui_reply: 37;
+    readonly ping: 38;
+    readonly room_dialed: 39;
+    readonly room_frames: 40;
+    readonly room_closed: 41;
+    readonly stage: 42;
+    readonly warm: 43;
+    readonly chunk_ref: 44;
+    readonly stage_ref: 45;
+    readonly room_batch: 46;
+    readonly room_backpressure: 47;
+    readonly ready: 48;
+    readonly render: 49;
+    readonly ui_command: 50;
+    readonly pong: 51;
+    readonly fault: 52;
+    readonly started: 53;
+    readonly disposed: 54;
+    readonly room_dial: 55;
+    readonly room_send: 56;
+    readonly room_close: 57;
+    readonly milestone: 58;
+    readonly warmed: 59;
+    readonly chunk_request: 60;
+    readonly game_ui: 61;
+    readonly game_ui_event: 62;
+    readonly session_complete: 63;
+    readonly chunk_release: 64;
+    readonly chunk_failed: 65;
+    readonly network: 66;
+    readonly camera_open: 67;
+    readonly camera_opened: 68;
+    readonly camera_close: 69;
+    readonly camera_track: 70;
+    readonly camera_untrack: 71;
+    readonly camera_face: 72;
+    readonly camera_colours: 73;
+    readonly camera_coloured: 74;
+    readonly inspector: 75;
+    readonly frame_mark: 76;
+    readonly frame_step: 77;
+    readonly font_request: 78;
+    readonly font_reply: 79;
+    readonly hot: 80;
+    readonly hot_done: 81;
+    readonly meters: 82;
+    readonly meter_report: 83;
+    readonly studio: 84;
+    readonly studio_report: 85;
+    readonly clip_arm: 86;
+    readonly clip_pause: 87;
+    readonly clip_save: 88;
+    readonly clip_saved: 89;
+    readonly replay: 90;
+    readonly camera_place: 91;
+    readonly camera_identify: 92;
+    readonly camera_identified: 93;
+};
+type MessageTag = (typeof MessageTag)[keyof typeof MessageTag];
+declare const LifecycleCode: {
+    readonly visible: 1;
+    readonly hidden: 2;
+    readonly suspend: 3;
+    readonly resume: 4;
+    readonly revision_update: 5;
+    readonly dispose: 6;
+};
+type LifecycleName = keyof typeof LifecycleCode;
+declare const LIFECYCLE_BY_CODE: readonly (LifecycleName | null)[];
+declare const Milestone: {
+    readonly linked: 1;
+    readonly main_entered: 2;
+    readonly attach_requested: 3;
+    readonly attach_resolved: 4;
+    readonly first_frame_scheduled: 5;
+    readonly ready_for_input: 6;
+};
+type MilestoneName = keyof typeof Milestone;
+declare const MILESTONE_BY_CODE: readonly (MilestoneName | null)[];
+declare const MILESTONE_BYTES = 2;
+declare const SessionOutcomeCode: {
+    readonly won: 1;
+    readonly lost: 2;
+    readonly draw: 3;
+    readonly finished: 4;
+};
+type SessionOutcomeName = keyof typeof SessionOutcomeCode;
+declare const SESSION_OUTCOME_BY_CODE: readonly (SessionOutcomeName | null)[];
+declare const SESSION_COMPLETE_BYTES = 11;
+interface SessionCompleteMessage {
+    readonly outcome: SessionOutcomeName;
+    readonly score: number | null;
+}
+declare function writeSessionComplete(out: Uint8Array, message: SessionCompleteMessage): number;
+declare function readSessionComplete(bytes: Uint8Array): SessionCompleteMessage | null;
+declare const DIGEST_BYTES = 32;
+declare const PING_BYTES = 5;
+declare const PONG_BYTES = 13;
+declare const LIFECYCLE_BYTES = 2;
+declare const INSPECTOR_BYTES = 2;
+declare const INSPECTOR_SHOWN = 1;
+declare const INSPECTOR_HIDDEN = 0;
+declare const TAG_BYTES = 1;
+declare const BRIDGE_LIMITS: {
+    readonly max_message_bytes: number;
+    readonly max_render_bytes: number;
+    readonly max_tree_nodes: 2048;
+    readonly max_tree_depth: 64;
+    readonly frame_outbox_bytes: number;
+};
+type MessageListener = (bytes: Uint8Array) => void;
+interface HostBridge {
+    send(bytes: Uint8Array, length: number): void;
+    on_message(listener: MessageListener): void;
+}
+type FaultPhase = "boot" | "link" | "guard" | "start" | "run" | "render" | "slice";
+interface GuestFault {
+    phase: FaultPhase;
+    message: string;
+    stack: string | null;
+}
+declare class MessageWriter {
+    private buffer;
+    constructor(initialBytes?: number);
+    get bytes(): Uint8Array;
+    json(tag: MessageTag, value: unknown): number;
+    text(tag: MessageTag, text: string): number;
+    tag(tag: MessageTag): number;
+}
+declare function tagOf(bytes: Uint8Array): number;
+declare function readJson<T>(bytes: Uint8Array): T;
+declare function readText(bytes: Uint8Array, offset: number): string;
+declare function utf8(text: string): Uint8Array;
+declare function hex(bytes: Uint8Array): string;
+declare function unhexAt(text: string, out: Uint8Array, offset: number, bytes: number): boolean;
+declare function hexAt(bytes: Uint8Array, offset: number, length: number): string;
+declare const CHUNK_REQUESTS_VERSION = 1;
+declare const ChunkPriority: {
+    readonly now: 0;
+    readonly soon: 1;
+    readonly prefetch: 2;
+};
+type ChunkPriority = (typeof ChunkPriority)[keyof typeof ChunkPriority];
+declare const PREFETCH_BUDGET_SHARE = 0.75;
+declare const PREFETCH_SLOT_SHARE = 0.25;
+declare function prefetchSlots(concurrency: number): number;
+declare const ChunkFailure: {
+    readonly unknown: 0;
+    readonly budget: 1;
+    readonly network: 2;
+    readonly verify: 3;
+};
+type ChunkFailureName = keyof typeof ChunkFailure;
+declare const CHUNK_FAILURE_BY_CODE: readonly ChunkFailureName[];
+declare const CHUNK_COUNT_BYTES = 2;
+declare const CHUNK_REQUEST_ENTRY_BYTES: number;
+declare const CHUNK_RELEASE_ENTRY_BYTES = 32;
+declare const CHUNK_FAILED_BYTES: number;
+declare const MAX_CHUNK_BATCH = 256;
+declare class ChunkBatch {
+    private readonly tag;
+    private readonly entryBytes;
+    private readonly capacity;
+    readonly bytes: Uint8Array;
+    private count;
+    constructor(tag: MessageTag, entryBytes: number, capacity?: number);
+    get size(): number;
+    get full(): boolean;
+    add(digest: string, priority?: number): boolean;
+    seal(): number;
+}
+declare function chunkEntryCount(bytes: Uint8Array, entryBytes: number): number;
+declare function chunkEntryOffset(index: number, entryBytes: number): number;
+declare function forEachChunkEntry(bytes: Uint8Array, entryBytes: number, visit: (digest: string, priority: number) => void): void;
+declare function writeChunkFailed(out: Uint8Array, digest: string, reason: ChunkFailureName): number;
+declare function readChunkFailed(bytes: Uint8Array): {
+    readonly digest: string;
+    readonly reason: ChunkFailureName;
+} | null;
+declare function unhex(text: string, out: Uint8Array): boolean;
+
+type Route<M> = Map<number, FrameListener<M>[]>;
+declare class FrameLane {
+    private readonly bridge;
+    readonly out: Uint8Array;
+    readonly view: DataView;
+    private length;
+    private scheduled;
+    private readonly channel;
+    private readonly roomInput;
+    private readonly fastValue;
+    private readonly counterValue;
+    private readonly presence;
+    readonly channels: Route<ChannelMessage>;
+    readonly roomInputs: Route<RoomInputMessage>;
+    readonly fastValues: Route<FastValueMessage>;
+    readonly counterValues: Route<CounterFrame>;
+    readonly presenceTicks: Route<PresenceTickView>;
+    readonly faults: Uint32Array<ArrayBuffer>;
+    constructor(bridge: HostBridge);
+    readonly flush: () => void;
+    reserve(bytes: number): number;
+    commit(written: number): number;
+    receive(bytes: Uint8Array): void;
+}
+declare abstract class PayloadPublisher implements FramePublisher {
+    protected readonly lane: FrameLane;
+    readonly slot: number;
+    protected readonly headerBytes: number;
+    readonly max_payload_bytes: number;
+    protected readonly scratch: Uint8Array;
+    private readonly scratchView;
+    protected sequence: number;
+    constructor(lane: FrameLane, slot: number, maxPayload: number, headerBytes: number);
+    payload(): DataView;
+    send(length: number, flags?: number): number;
+    protected abstract header(offset: number, length: number, flags: number): number;
+}
+declare class ChannelPublisher extends PayloadPublisher {
+    private readonly frame;
+    constructor(lane: FrameLane, slot: number, maxPayload: number);
+    protected header(offset: number, length: number, flags: number): number;
+}
+declare class RoomInputPublisher extends PayloadPublisher {
+    private readonly frame;
+    constructor(lane: FrameLane, slot: number);
+    protected header(offset: number, length: number, flags: number): number;
+}
+declare class LaneFastReader implements FastReader {
+    private readonly lane;
+    readonly slot: number;
+    private readonly keyBytes;
+    private readonly frame;
+    constructor(lane: FrameLane, slot: number, target: keyof typeof FRAME_CODES.fast_target);
+    key(): Uint8Array;
+    read(key_length: number, correlation: number): number;
+    on_value(listener: FrameListener<FastValueMessage>): Unsubscribe;
+}
+declare class LaneCounter {
+    private readonly lane;
+    readonly slot: number;
+    private readonly frame;
+    constructor(lane: FrameLane, slot: number);
+    add(delta: number, correlation: number): number;
+    on_value(listener: Listener<CounterFrame>): Unsubscribe;
+}
+
+interface IndexedPart {
+    readonly chunk: string;
+    readonly lazy?: boolean;
+}
+
+declare const TICK_GLOBAL = "__cimplify_tick";
+declare const TICKS_PER_CHECK = 1024;
+declare const DEFAULT_SLICE_MS = 2000;
+declare class SliceExceeded extends Error {
+    constructor();
+}
+type Tick = () => void;
+interface SliceBudget {
+    begin(): void;
+    over(): boolean;
+}
+declare function clockBudget(now: () => number, slice_ms?: number): SliceBudget;
+declare class Slice {
+    private readonly budget;
+    private readonly counter;
+    private exceeded;
+    constructor(budget: SliceBudget);
+    get dead(): boolean;
+    begin(): void;
+    readonly tick: Tick;
+    private check;
+}
+
+declare const MODULE_INDEX_FORMAT = 4;
+declare const VERBOSE_MODULE_INDEX_FORMAT = 3;
+declare const MODULE_PARAMETERS: readonly ["require", "exports", "module", "__cimplify_tick"];
+declare const ChunkKind: {
+    readonly code: 0;
+    readonly texture: 1;
+    readonly mesh: 2;
+    readonly audio: 3;
+    readonly font: 4;
+    readonly data: 5;
+    readonly wasm: 6;
+    readonly index: 7;
+    readonly bytecode: 8;
+};
+interface ChunkPayload {
+    readonly kind: number;
+    readonly payload: Uint8Array;
+}
+declare class PackageError extends Error {
+    constructor(message: string);
+}
+declare function decodeChunk(bytes: Uint8Array): ChunkPayload;
+interface IndexedImport {
+    readonly at: number;
+    readonly end: number;
+    readonly module: string | null;
+    readonly library: string | null;
+    readonly export: string | null;
+    readonly specifier?: string;
+}
+type RuntimeKind = "code" | "wasm";
+interface IndexedRuntime {
+    readonly unit: string;
+    readonly kind: RuntimeKind;
+    readonly chunk: string;
+    readonly imports: readonly IndexedImport[];
+}
+interface IndexedBytecode {
+    readonly engine: string;
+    readonly bytecode: number;
+    readonly chunk: string;
+}
+interface IndexedModule {
+    readonly path: string;
+    readonly chunk: string;
+    readonly imports: readonly IndexedImport[];
+    readonly bytecode: readonly IndexedBytecode[];
+}
+interface IndexedAsset {
+    readonly path: string;
+    readonly chunk: string;
+    readonly lazy?: boolean;
+    readonly parts?: readonly IndexedPart[];
+    readonly progressive?: boolean;
+}
+interface IndexedAlternative {
+    readonly unit: string;
+    readonly chunk: string;
+    readonly replaces: string;
+}
+interface IndexedLateRuntime {
+    readonly unit: string;
+    readonly chunk: string;
+}
+interface ModuleIndex {
+    readonly format: number;
+    readonly entries: {
+        readonly client: string;
+        readonly room: string | null;
+        readonly worker: string | null;
+    };
+    readonly modules: readonly IndexedModule[];
+    readonly runtimes: readonly IndexedRuntime[];
+    readonly assets?: readonly IndexedAsset[];
+    readonly alternatives?: readonly IndexedAlternative[];
+    readonly late?: readonly IndexedLateRuntime[];
+    /** The digest of the index chunk that catalogs the assets first input does not touch; it opens the follow range. */
+    readonly more?: string;
+}
+interface ChunkChannel {
+    request(digest: string, priority: number): void;
+    release(digest: string): void;
+}
+interface AssetSink {
+    catalog(assets: readonly IndexedAsset[]): void;
+    awaitCatalog?(): void;
+    catalogued?(): void;
+    accept(digest: string, payload: Uint8Array): void;
+    connect?(channel: ChunkChannel): void;
+    fail?(digest: string, reason: ChunkFailureName): void;
+    network?(hint: NetworkHint): void;
+}
+interface ModuleImport {
+    readonly specifier: string;
+    readonly module: string | null;
+    readonly library: string | null;
+    readonly export: string | null;
+}
+type RuntimeUnitSource = {
+    readonly unit: string;
+    readonly kind: "code";
+    readonly code: string;
+    readonly imports: readonly ModuleImport[];
+} | {
+    readonly unit: string;
+    readonly kind: "wasm";
+    readonly bytes: Uint8Array;
+} | {
+    readonly unit: string;
+    readonly kind: "native";
+    readonly value: unknown;
+};
+type NativeRuntimes = (unit: string) => unknown;
+/** A runtime wasm unit the host already compiled from these exact bytes, so linking does not compile it again. */
+type CompiledRuntimes = (unit: string, bytes: Uint8Array) => Promise<WebAssembly.Module> | null;
+interface LinkableModule {
+    readonly path: string;
+    readonly code: string;
+    readonly imports: readonly ModuleImport[];
+}
+interface CommonJsModule {
+    exports: Record<string, unknown>;
+}
+type ModuleRequire = (specifier: string) => unknown;
+type ModuleFactory = (require: ModuleRequire, exports: CommonJsModule["exports"], module: CommonJsModule, tick: Tick) => void;
+interface ModuleCompiler {
+    readonly ahead: boolean;
+    compile(path: string, code: string): ModuleFactory | Promise<ModuleFactory>;
+}
+type GuestEntry = Record<string, unknown>;
+interface ModuleLinker {
+    link(modules: readonly LinkableModule[], entry: string, tick: Tick, runtimes?: readonly RuntimeUnitSource[]): Promise<GuestEntry>;
+    relink?(modules: readonly LinkableModule[], entry: string, tick: Tick): Promise<GuestEntry>;
+}
+interface AssembledPackage {
+    readonly entry: string;
+    readonly modules: LinkableModule[];
+    readonly runtimes: RuntimeUnitSource[];
+}
+declare function readIndex(chunk: ChunkPayload): ModuleIndex;
+declare class PackageAssembler {
+    private readonly onWasm;
+    private readonly native;
+    private readonly assets;
+    private index;
+    private moreCatalogued;
+    private readonly nextIndexes;
+    private readonly code;
+    private readonly wasm;
+    constructor(onWasm?: ((unit: string, bytes: Uint8Array, digest: string) => void) | null, native?: NativeRuntimes | null, assets?: AssetSink | null);
+    accept(digest: Uint8Array, bytes: Uint8Array): void;
+    swapIndex(candidates: readonly string[]): readonly string[] | null;
+    stageCode(digest: string, bytes: Uint8Array): string;
+    stage(digest: string, bytes: Uint8Array): Uint8Array;
+    lateRuntime(unit: string): string | null;
+    holdsWasm(digest: string): boolean;
+    acceptWasmPayload(digest: string, bytes: Uint8Array): void;
+    private acceptWasm;
+    private announce;
+    private standIn;
+    modules(registered?: ReadonlySet<string>): AssembledPackage;
+    private runtime;
+}
+declare function linkOrder(modules: readonly LinkableModule[], entry: string, units: ReadonlySet<string>): LinkableModule[];
+declare const RUNTIME_PATH_PREFIX = "runtime:";
+declare function commonJsLinker(compiler: ModuleCompiler, compiled?: CompiledRuntimes | null): ModuleLinker;
+declare function moduleWrapper(code: string): string;
+type ModuleImporter = (url: string) => Promise<{
+    default: ModuleFactory;
+}>;
+interface UrlFactory {
+    create(code: string): string;
+    revoke(url: string): void;
+}
+declare const BLOB_URLS: UrlFactory;
+declare function blobCompiler(urls: UrlFactory, importer: ModuleImporter): ModuleCompiler;
+
+interface EngineServices {
+    readonly linker: ModuleLinker;
+    readonly slice: Slice;
+    harden(): void;
+    now_ms(): number;
+    random_fill(out: Uint8Array): void;
+    verify_ed25519(public_key: Uint8Array, message: Uint8Array, signature: Uint8Array): Promise<boolean>;
+}
+
+declare class GuestUnavailableError extends Error {
+    readonly member: string;
+    constructor(member: string);
+}
+type UiCommand = {
+    kind: "toast";
+    text: string;
+} | {
+    kind: "haptic";
+    haptic: string;
+} | {
+    kind: "announce";
+    text: string;
+} | {
+    kind: "present";
+    mode: UiPresentation;
+} | {
+    kind: "open_sheet";
+    request: HostSheetRequest;
+} | {
+    kind: "open_handoff";
+    handoff_id: string;
+} | {
+    kind: "clip_start";
+    max_ms: number;
+} | {
+    kind: "clip_stop";
+    clip: number;
+} | {
+    kind: "clip_cancel";
+    clip: number;
+} | {
+    kind: "clip_keep";
+    ms: number;
+} | {
+    kind: "replay_save";
+    replay: string;
+};
+interface GuestCore {
+    readonly program: ProgramInfo;
+    readonly locale: LocaleInfo;
+    readonly clock_offset_ms: number;
+    readonly services: EngineServices;
+    readonly lane: FrameLane;
+    readonly lifecycle: CtxLifecycle;
+    call<O extends CtxOperationName>(operation: O, request: CtxRequest<O>): Promise<CtxResponse<O>>;
+    subscribe(grant: SubscriptionGrant, listener: Listener<HostEvent>): Unsubscribe;
+    family(family: HostEventFamily, listener: Listener<HostEvent>): Unsubscribe;
+    render(tree: UiNode): void;
+    command(command: UiCommand, awaited: boolean): Promise<unknown>;
+    on_ui(listener: Listener<UiEvent>): Unsubscribe;
+    game_ui(bytes: Uint8Array, length: number): void;
+    on_game_ui(listener: (bytes: Uint8Array) => void): Unsubscribe;
+    on_dispose(callback: () => void): void;
+    complete(message: SessionCompleteMessage): void;
+    mark(name: MilestoneName): void;
+    on_replay?(listener: ReplayListener): Unsubscribe;
+}
+type ClipFailureCode = "unavailable" | "nothing_recorded" | "unknown_clip" | "camera_consent" | "failed";
+declare class ClipError extends Error {
+    readonly code: ClipFailureCode;
+    constructor(code: ClipFailureCode);
+}
+interface RealtimeDialers {
+    readonly primary: RoomDialer | null;
+    readonly fallback: RoomDialer | null;
+}
+interface GuestProfile {
+    readonly graphics: Ctx["graphics"];
+    readonly input?: Ctx["input"];
+    readonly audio: Ctx["audio"];
+    readonly assets?: Ctx["assets"];
+    readonly camera?: Pick<Ctx["camera"], "track_face" | "view" | "capture_identity">;
+    readonly loop?: GameLoop;
+    dialers(endpoints: TickEndpoints): RealtimeDialers;
+}
+declare function createGuestCtx(core: GuestCore, profile?: GuestProfile | null): Ctx;
+
+interface WarmImage {
+    readonly files: Readonly<Record<string, readonly string[]>>;
+}
+interface GuestBoot {
+    readonly program: ProgramInfo;
+    readonly locale: LocaleInfo;
+    readonly clock_offset_ms: number;
+    readonly deadline_ms: number | null;
+    readonly chunk_requests?: number;
+    readonly network?: NetworkHint;
+    readonly engine_heap_bytes?: number;
+    /** Modules whose bytecode the host registered: they link without their source, from the index's specifiers. */
+    readonly bytecode_modules?: readonly string[];
+}
+interface GuestUiReply {
+    readonly id: number;
+    readonly value: unknown;
+}
+interface GuestOptions {
+    readonly bridge: HostBridge;
+    readonly services: EngineServices;
+    readonly heap_bytes?: () => number;
+    readonly on_runtime_wasm?: (unit: string, bytes: Uint8Array, digest: string) => void;
+    readonly fetch_wasm?: (digest: string, payload: string) => Promise<Uint8Array> | null;
+    readonly native_runtimes?: NativeRuntimes;
+    readonly assets?: AssetSink;
+    readonly on_warm?: (image: WarmImage) => Promise<unknown> | null;
+    readonly on_staged_wasm?: (digest: string, bytes: Uint8Array) => void;
+    readonly on_staged_code?: (code: string) => void;
+    readonly ctx?: (core: GuestCore) => Ctx;
+    readonly request_deadline_ms?: (family: Family) => number;
+    readonly on_boot?: (boot: GuestBoot) => void;
+}
+declare const CTX_REQUEST_DEADLINE_MS = 5000;
+declare const CTX_CONFIRMED_REQUEST_DEADLINE_MS = 300000;
+declare const CTX_LONG_REQUEST_DEADLINES_MS: Readonly<Partial<Record<Family, number>>>;
+declare function ctxFamilyOf(operation: string): Family;
+declare function ctxRequestDeadlineMs(family: Family): number;
+declare class GuestRuntime implements GuestCore {
+    private readonly options;
+    private readonly bridge;
+    private readonly writer;
+    private readonly pending;
+    private readonly subscriptions;
+    private readonly families;
+    private readonly uiListeners;
+    private readonly gameUiListeners;
+    private readonly replies;
+    private readonly lifecycleListeners;
+    private readonly disposers;
+    private readonly replayListeners;
+    private heldReplay;
+    private readonly differ;
+    private readonly assembler;
+    private readonly pong;
+    private readonly milestoneMessage;
+    private readonly completeMessage;
+    private readonly reached;
+    private readonly pongView;
+    private boot;
+    private state;
+    private nextRequest;
+    private nextCommand;
+    private sliceReported;
+    private readonly arriving;
+    private readonly wanted;
+    private readonly requested;
+    private readonly released;
+    private chunkFlushQueued;
+    private readonly studioIn;
+    private readonly studioOut;
+    private readonly flushChunks;
+    private readonly chunkChannel;
+    private starting;
+    private startTimer;
+    private stopTimer;
+    readonly services: EngineServices;
+    readonly lane: FrameLane;
+    constructor(options: GuestOptions);
+    get program(): ProgramInfo;
+    get locale(): LocaleInfo;
+    get clock_offset_ms(): number;
+    readonly lifecycle: CtxLifecycle;
+    current(): LifecycleState;
+    onLifecycle(event: LifecycleEvent, listener: () => void): Unsubscribe;
+    needRuntime(unit: string, priority?: ChunkPriority): boolean;
+    mark(name: MilestoneName): void;
+    private send;
+    private fault;
+    call<O extends CtxOperationName>(operation: O, request: CtxRequest<O>): Promise<CtxResponse<O>>;
+    private expire;
+    subscribe(grant: SubscriptionGrant, listener: Listener<HostEvent>): Unsubscribe;
+    family(family: HostEventFamily, listener: Listener<HostEvent>): Unsubscribe;
+    private listen;
+    render(tree: UiNode): void;
+    command(command: UiCommand, awaited: boolean): Promise<unknown>;
+    on_ui(listener: Listener<UiEvent>): Unsubscribe;
+    complete(message: SessionCompleteMessage): void;
+    game_ui(bytes: Uint8Array, length: number): void;
+    on_game_ui(listener: (bytes: Uint8Array) => void): Unsubscribe;
+    private dispatchGameUi;
+    on_dispose(callback: () => void): void;
+    private receive;
+    private notify;
+    private handle;
+    on_replay(listener: ReplayListener): Unsubscribe;
+    private hot;
+    private acceptChunk;
+    private arrived;
+    private acceptRef;
+    private fetchRef;
+    private want;
+    private queueChunk;
+    private chunkFailed;
+    private arrivals;
+    private warm;
+    private stageChunk;
+    private answerPing;
+    private answer;
+    private deliver;
+    private dispatchUi;
+    private reply;
+    private transition;
+    private start;
+}
+
+export { LIFECYCLE_BYTES as $, type AssetSink as A, BLOB_URLS as B, type ChunkChannel as C, DEFAULT_SLICE_MS as D, ENGINE_CORE_THREADS_UNIT as E, type FrameTouch as F, GuestRuntime as G, FrameLane as H, type IndexedAsset as I, type FrameMark as J, type GuestBoot as K, type GuestCore as L, type MilestoneName as M, type GuestEntry as N, type GuestFault as O, type GuestOptions as P, type GuestUiReply as Q, GuestUnavailableError as R, type HostBridge as S, type HotRequest as T, type HotSwapReport as U, type HotSwapResult as V, INSPECTOR_BYTES as W, INSPECTOR_HIDDEN as X, INSPECTOR_SHOWN as Y, type IndexedImport as Z, type IndexedModule as _, type ChunkFailureName as a, moduleWrapper as a$, LIFECYCLE_BY_CODE as a0, LaneCounter as a1, LaneFastReader as a2, LifecycleCode as a3, type LifecycleName as a4, type LinkableModule as a5, MAX_CHUNK_BATCH as a6, MILESTONE_BYTES as a7, MILESTONE_BY_CODE as a8, MODULE_INDEX_FORMAT as a9, type SessionCompleteMessage as aA, SessionOutcomeCode as aB, type SessionOutcomeName as aC, Slice as aD, type SliceBudget as aE, SliceExceeded as aF, TAG_BYTES as aG, TICKS_PER_CHECK as aH, TICK_GLOBAL as aI, type Tick as aJ, type UiCommand as aK, type UrlFactory as aL, VERBOSE_MODULE_INDEX_FORMAT as aM, blobCompiler as aN, chunkEntryCount as aO, chunkEntryOffset as aP, clockBudget as aQ, commonJsLinker as aR, createGuestCtx as aS, ctxFamilyOf as aT, ctxRequestDeadlineMs as aU, decodeChunk as aV, encodeFrameMark as aW, forEachChunkEntry as aX, hex as aY, hexAt as aZ, linkOrder as a_, MODULE_PARAMETERS as aa, type MessageListener as ab, MessageTag as ac, MessageWriter as ad, Milestone as ae, type ModuleCompiler as af, type ModuleFactory as ag, type ModuleImport as ah, type ModuleImporter as ai, type ModuleIndex as aj, type ModuleLinker as ak, type ModuleRequire as al, PING_BYTES as am, PIPELINE_TOUCH_PREFIX as an, PONG_BYTES as ao, PREFETCH_BUDGET_SHARE as ap, PREFETCH_SLOT_SHARE as aq, PackageAssembler as ar, PackageError as as, RUNTIME_PATH_PREFIX as at, RUNTIME_WASM_SUFFIX as au, RoomInputPublisher as av, type RuntimeUnitSource as aw, SESSION_COMPLETE_BYTES as ax, SESSION_OUTCOME_BY_CODE as ay, SESSION_PROTOCOL_VERSION as az, ChunkPriority as b, prefetchSlots as b0, readChunkFailed as b1, readFrameMark as b2, readIndex as b3, readJson as b4, readSessionComplete as b5, readText as b6, tagOf as b7, unhex as b8, unhexAt as b9, utf8 as ba, writeChunkFailed as bb, writeSessionComplete as bc, ClipError as bd, type ClipFailureCode as be, type WarmImage as bf, FrameTouchKind as c, type GuestProfile as d, type AssembledPackage as e, BRIDGE_LIMITS as f, BRIDGE_PROTOCOL_VERSION as g, CHUNK_COUNT_BYTES as h, CHUNK_FAILED_BYTES as i, CHUNK_FAILURE_BY_CODE as j, CHUNK_RELEASE_ENTRY_BYTES as k, CHUNK_REQUESTS_VERSION as l, CHUNK_REQUEST_ENTRY_BYTES as m, CHUNK_TOUCH_PREFIX as n, CTX_CONFIRMED_REQUEST_DEADLINE_MS as o, CTX_LONG_REQUEST_DEADLINES_MS as p, CTX_REQUEST_DEADLINE_MS as q, ChannelPublisher as r, ChunkBatch as s, ChunkFailure as t, ChunkKind as u, type CommonJsModule as v, DIGEST_BYTES as w, ENGINE_CORE_UNIT as x, type EngineServices as y, type FaultPhase as z };