@cimplify/sdk 0.108.0 → 0.110.2

package/dist/interactives-web.d.ts

@@ -0,0 +1,762 @@
+import { S as HostBridge, ab as MessageListener } from './guest-wIdfoT05.js';
+export { i as CHUNK_FAILED_BYTES, k as CHUNK_RELEASE_ENTRY_BYTES, l as CHUNK_REQUESTS_VERSION, m as CHUNK_REQUEST_ENTRY_BYTES, s as ChunkBatch, t as ChunkFailure, a as ChunkFailureName, b as ChunkPriority, bd as ClipError, be as ClipFailureCode, J as FrameMark, F as FrameTouch, c as FrameTouchKind, T as HotRequest, U as HotSwapReport, V as HotSwapResult, a3 as LifecycleCode, a4 as LifecycleName, ac as MessageTag, aK as UiCommand, aX as forEachChunkEntry, b1 as readChunkFailed, bb as writeChunkFailed } from './guest-wIdfoT05.js';
+export { S as STUDIO_MESSAGE_MAX_BYTES, a as StudioMessage, b as StudioOutgoing } from './studio-CowqWqez.js';
+export { C as CANNOT_REWIND, N as NOT_RECORDING, T as TIMELINE_PREFIX, a as TIMELINE_REPORT, b as TIMELINE_TOPIC, c as TimelineMoment, d as TimelineProof, e as TimelineRefused, f as TimelineState } from './timeline-protocol-hp6e8zFB.js';
+import { Z as ZoneSpans, O as GuestEngineFactory, T as CtxTransport, V as SessionHello } from './web-Dss74a7v.js';
+export { W as ALTERNATIVE_RUNTIMES, X as AdCreative, Y as AdDecisionBody, _ as AdFormat, $ as AdOutcome, B as BatchPackage, a0 as BlockPlan, a1 as CLIP_CAMERA, a2 as CONSENT_KINDS, a3 as ChromeSheet, a4 as ClipArm, a5 as ClipChoice, a6 as ClipConsent, a7 as ClipMediaKind, a8 as ClipOutcome, a9 as ClipRelay, aa as ClipReply, ab as ClipUpload, ac as Completion, ad as ConsentState, ae as ConsentStore, af as DEFAULT_CLIP_ARM, ag as DEFAULT_HOST_LIMITS, ah as DEFAULT_WARM_BOOT_MS, ai as ENGINE_GROUP_PREFIX, aj as ENGINE_HEAP_CEILING_BYTES, ak as ENGINE_HEAP_HEADROOM, al as EngineHeapDeclaration, am as EngineHeapTier, an as GPU_REQUIREMENT_NAMES, ao as GpuLimits, ap as GpuRequirementName, aq as GpuRequirements, ar as GuestClips, as as GuestEngine, at as GuestPool, au as HostCallOperation, av as HostChromeController, aw as HostChromeOptions, ax as HostClips, ay as HostFault, az as HostFaultError, aA as HostLimits, aB as HostMediator, aC as HostPhase, aD as KeyValueStore, aE as MediatorOutlet, aF as OpenedReplay, a as PackageChannel, b as PackageChunkRef, aG as PackageIndexRef, aH as PackageRef, aI as PlacementCompletion, aJ as PlacementState, aK as REPLAY_MEDIA_TYPE, R as RegistryClient, aL as RegistryError, aM as RepairDecoder, aN as RepairFileRef, aO as RepairMember, aP as RepairOutcome, aQ as RepairSource, aR as ReportFiling, aS as RuntimeImage, aT as RuntimePool, aU as RuntimeTag, aV as SavedClip, aW as ServedAd, aX as SessionClose, aY as SessionConsent, aZ as SpendConfirmation, a_ as SpendDecision, a$ as SpendPrompt, b0 as SwapBuild, b1 as TrackingConsent, b2 as TreeStore, b3 as WarmGuest, b4 as WebHost, b5 as WebHostClipOptions, b6 as WebHostOptions, b7 as ZoneChunkRef, b8 as ZoneFileRef, b9 as ZoneSpan, ba as browserStore, bb as cdnRepairs, bc as chunksForHost, bd as completeZone, be as declareEngineHeap, bf as deviceGpuLimits, bg as engineHeapFor, bh as hostThreads, bi as httpRegistry, bj as manifestGpuRequirements, bk as memoryStore, bl as planZone, bm as rangedChunks, bn as repairDecoder, bo as runtimeImage, bp as swapInPlace, bq as swappable, br as unmetGpuRequirement, bs as workerEngines } from './web-Dss74a7v.js';
+import { C as ChunkSource, P as PartStoreBackend, a as PartStoreSnapshot, b as PartStoreOptions, S as SharedPartStore, c as PartStoreDisk } from './weave-delivery-CW-Kstut.js';
+export { D as DEFAULT_DISK_RESERVE_BYTES, d as DEFAULT_KEPT_BUDGET_BYTES, e as DEFAULT_PART_STORE_BUDGET_BYTES, f as DEFAULT_PART_ZONE, E as EvictionListener, g as EvictionReason, G as GamePart, I as InstallOptions, K as KEEP_REASONS, h as KeepReason, M as MemoryPartBackend, i as PartEviction, j as PartSession, k as PartStoreStats, l as PartVerifyError, m as localFirstChunks } from './weave-delivery-CW-Kstut.js';
+import { T as TransportKind, R as RoomDialer, a as Lane } from './link-BUTqGmyi.js';
+import { b as EngineSessionGrant } from './session-grant-CJ27DwrT.js';
+export { E as EngineSessionAudience, a as EngineSessionError } from './session-grant-CJ27DwrT.js';
+import { I as IdentityBase } from './params-DxFb5G_U.js';
+import { a as IdentityFitter } from './fit-DK0oT7zO.js';
+import { X as DeclaredAgeRange, Y as HostResponse, Z as CtxError, _ as RenderingProfile, $ as Persona, a0 as RequestEnvelope, Q as Family, w as ProgramInfo } from './local-VZkqsCzR.js';
+export { C as ChunkCache, a as ChunkOrigin, F as FEED_DWELL_MS, b as FEED_SESSION_BYTES, c as FeedPrefetchOptions, d as FeedPrefetchState, e as FeedTimers, I as IDLE_SCHEDULER, M as MILESTONE_MARK_PREFIX, P as PREFETCH_BATCH, f as PackagePrefetcher, g as PrefetchScheduler, h as feedChunks, m as milestoneMarks } from './prefetch-BHnicOQj.js';
+import './network-ZXLD7l1b.js';
+import './backend-gUCzs5Kg.js';
+import './world-PvILHDR1.js';
+import './library-DXYaMFhi.js';
+import './game-fgQy2YIm.js';
+import './audio-m0w8cnxq.js';
+import './client-Dytx_ZTC.js';
+import './fluid-ARr0qUIL.js';
+import './tree-CP_qSW4H.js';
+import './schema-BrWxzKp6.js';
+import './ui-hi7S2YcH.js';
+import './vars-Dc_PrhBK.js';
+
+declare const CONTENT_BLOCKED_ERROR = "INTERACTIVES_CONTENT_BLOCKED";
+declare const CONTENT_BLOCKED_CLOSE = "content_blocked";
+declare const CONTENT_BLOCKED_STATUS = 451;
+type CreditAi = "assisted" | "generated";
+interface HostCredit {
+    readonly title: string;
+    readonly authors: readonly string[];
+    readonly licence: string;
+    readonly licenceUrl: string | null;
+    readonly sourceUrl: string | null;
+    readonly modified: boolean;
+    readonly item: string | null;
+    readonly ai: CreditAi | string | null;
+}
+declare function manifestCredits(manifest: Uint8Array): readonly HostCredit[];
+declare function blockedItems(detail: string | null): readonly string[];
+
+declare function probeHostWebGpu(): Promise<boolean>;
+declare function hostWebGpu(): boolean;
+declare function forgetHostWebGpu(): void;
+
+declare const DEFAULT_LAZY_BUDGET_BYTES: number;
+declare const DEFAULT_LAZY_CONCURRENCY = 4;
+interface LazyChunkRef {
+    readonly digest: string;
+    readonly lazy?: boolean;
+    readonly size?: number;
+}
+interface LazyChunkOptions {
+    readonly source: ChunkSource;
+    readonly budget_bytes?: number;
+    readonly concurrency?: number;
+    readonly spans?: ZoneSpans;
+    readonly run_bytes?: number;
+}
+interface LazyChunkSink {
+    deliver(digest: string, body: Uint8Array): void;
+    send(bytes: Uint8Array, length: number): void;
+}
+declare class LazyChunkServer {
+    private readonly options;
+    private sink;
+    private readonly known;
+    private readonly queues;
+    private readonly queued;
+    private readonly flying;
+    private readonly held;
+    private readonly partials;
+    private readonly failure;
+    private readonly budget;
+    private readonly concurrency;
+    private readonly prefetchSlots;
+    private heldBytes;
+    private generation;
+    private preemptions;
+    private runs;
+    constructor(refs: readonly LazyChunkRef[], options: LazyChunkOptions, sink?: LazyChunkSink | null);
+    get bytesHeld(): number;
+    get pending(): number;
+    get preempted(): number;
+    get ranged(): number;
+    priorityOf(digest: string): number | null;
+    attach(sink: LazyChunkSink | null): void;
+    request(bytes: Uint8Array): void;
+    requestOne(digest: string, priority: number): void;
+    requestMany(entries: readonly (readonly [digest: string, priority: number])[]): void;
+    private enqueue;
+    private unqueue;
+    release(bytes: Uint8Array): void;
+    private top;
+    private preempt;
+    private next;
+    private requestsFlying;
+    private prefetchFlying;
+    private pump;
+    private gather;
+    private serveRun;
+    private fits;
+    private serve;
+    private fail;
+}
+
+declare const PART_STORE_NAME = "cimplify-parts";
+declare const WEB_DISK_RESERVE_BYTES: number;
+declare class IndexedDbPartBackend implements PartStoreBackend {
+    private readonly db;
+    private constructor();
+    static open(factory: IDBFactory, name?: string): Promise<IndexedDbPartBackend>;
+    read(digest: string): Promise<Uint8Array | null>;
+    write(digest: string, bytes: Uint8Array): Promise<void>;
+    remove(digest: string): Promise<void>;
+    load(): Promise<PartStoreSnapshot | null>;
+    save(snapshot: PartStoreSnapshot): Promise<void>;
+}
+declare class CacheStoragePartBackend implements PartStoreBackend {
+    private readonly cache;
+    private constructor();
+    static open(storage: CacheStorage, name?: string): Promise<CacheStoragePartBackend>;
+    read(digest: string): Promise<Uint8Array | null>;
+    write(digest: string, bytes: Uint8Array): Promise<void>;
+    remove(digest: string): Promise<void>;
+    load(): Promise<PartStoreSnapshot | null>;
+    save(snapshot: PartStoreSnapshot): Promise<void>;
+}
+declare function webStorageDisk(storage?: StorageManager | undefined): PartStoreDisk | undefined;
+declare function openWebPartStore(options?: PartStoreOptions): Promise<SharedPartStore>;
+
+interface RelayPort {
+    readonly out: Uint8Array;
+    reserve(length: number): number;
+    commitFrame(): void;
+    commitTask(): void;
+}
+
+type FallbackFontSource = (codepoint: number) => Promise<Uint8Array | null>;
+
+interface MessagePortLike {
+    postMessage(message: ArrayBuffer, transfer: Transferable[]): void;
+    addEventListener(type: "message", listener: (event: MessageEvent<ArrayBuffer>) => void): void;
+    start?(): void;
+}
+interface FlushScheduler {
+    task(flush: () => void): void;
+    frame(flush: () => void): void;
+}
+interface FrameScope {
+    requestAnimationFrame?: (callback: (time: number) => void) => number;
+}
+declare function animationFrameScheduler(scope?: FrameScope): FlushScheduler;
+interface PortBridgeStats {
+    readonly allocated: number;
+    readonly batches: number;
+    readonly records: number;
+}
+declare class PortBridge implements HostBridge {
+    private readonly port;
+    private readonly scheduler;
+    private readonly free;
+    private readonly transfer;
+    private listener;
+    private buffer;
+    private bytes;
+    private view;
+    private used;
+    private taskPending;
+    private framePending;
+    private allocatedCount;
+    private batchCount;
+    private recordCount;
+    constructor(port: MessagePortLike, scheduler: FlushScheduler);
+    get stats(): PortBridgeStats;
+    get pooled(): number;
+    on_message(listener: MessageListener): void;
+    send(bytes: Uint8Array, length: number): void;
+    sendFrame(bytes: Uint8Array, length: number): void;
+    private write;
+    reserve(length: number): number;
+    get out(): Uint8Array;
+    commitFrame(): void;
+    commitTask(): void;
+    private dedicated;
+    private open;
+    private scheduleTask;
+    private scheduleFrame;
+    private readonly flushTask;
+    private readonly flushFrame;
+    flush(): void;
+    private post;
+    private receive;
+}
+
+type CanvasEngineChoice = "core" | "prepared";
+interface CanvasBoot {
+    readonly engine: CanvasEngineChoice;
+    readonly heartbeat?: SharedArrayBuffer | null;
+    readonly game_ui_accessibility?: boolean;
+    readonly engine_session?: EngineSessionGrant | null;
+}
+
+declare const HOST_PAGE_ISOLATION_HEADERS: Readonly<Record<string, string>>;
+interface ContentOrigin {
+    readonly scheme: "https:" | "http:";
+    readonly host: string;
+    readonly port: string;
+}
+declare function parseContentOrigin(value: string): ContentOrigin | null;
+declare function interactiveLabel(interactiveId: string): string;
+declare function guestOrigin(origin: ContentOrigin, interactiveId: string): string;
+declare function servesContent(origin: ContentOrigin, host: string): boolean;
+declare function sha256Hex(bytes: Uint8Array): string;
+
+interface FaceLandmarkerPart {
+    readonly sha256: string;
+    readonly bytes: number;
+    readonly type: string;
+    readonly upstream: string;
+}
+declare const FACE_LANDMARKER: {
+    readonly runtime: "@mediapipe/tasks-vision";
+    readonly runtime_version: "1.0.1";
+    readonly model: "face_landmarker/float16/1";
+    readonly licence: "Apache-2.0";
+    readonly points: 478;
+    readonly parts: {
+        readonly bundle: {
+            readonly sha256: "d885630c297c0b20b1fe86096cb06291c4c8080876f27852e724f24ac603713f";
+            readonly bytes: 155439;
+            readonly type: "text/javascript";
+            readonly upstream: "https://cdn.jsdelivr.net/npm/@mediapipe/tasks-vision@1.0.1/vision_bundle.mjs";
+        };
+        readonly loader: {
+            readonly sha256: "e170ee67dd4e16c1a6fcd8840a206687e5a59b22c20e4a902bc445b095454d73";
+            readonly bytes: 323377;
+            readonly type: "text/javascript";
+            readonly upstream: "https://cdn.jsdelivr.net/npm/@mediapipe/tasks-vision@1.0.1/wasm/vision_wasm_internal.js";
+        };
+        readonly wasm: {
+            readonly sha256: "8da277a733926eacd0474b8704b36742d6ec3231c57a860c5b889dff8f1df886";
+            readonly bytes: 11756954;
+            readonly type: "application/wasm";
+            readonly upstream: "https://cdn.jsdelivr.net/npm/@mediapipe/tasks-vision@1.0.1/wasm/vision_wasm_internal.wasm";
+        };
+        readonly model: {
+            readonly sha256: "64184e229b263107bc2b804c6625db1341ff2bb731874b0bcc2fe6544e0bc9ff";
+            readonly bytes: 3758596;
+            readonly type: "application/octet-stream";
+            readonly upstream: "https://storage.googleapis.com/mediapipe-models/face_landmarker/face_landmarker/float16/1/face_landmarker.task";
+        };
+    };
+};
+type FaceVideo = HTMLVideoElement;
+interface FaceLandmarkRunner {
+    detect(video: FaceVideo, timestamp_ms: number, out: Float32Array): number;
+    weigh?(out: Float32Array): boolean;
+    close(): void;
+}
+type FaceRunnerFactory = () => Promise<FaceLandmarkRunner>;
+interface FaceRunnerScope {
+    readonly URL: Pick<typeof URL, "createObjectURL" | "revokeObjectURL">;
+    readonly Blob: typeof Blob;
+    import(url: string): Promise<unknown>;
+}
+declare function mediaPipeFaceRunner(source: ChunkSource, store?: SharedPartStore | null, scope?: FaceRunnerScope): FaceRunnerFactory;
+
+declare const IdentityCopy: {
+    readonly title: "Make your character from your face";
+    readonly consent: "Use your own face only, never anyone else's. The camera picture stays on this device. The game gets only your character's shape and colours.";
+    readonly decline: "Not now";
+    readonly agree: "This is me, continue";
+    readonly capture: "Capture";
+    readonly close: "Close";
+    readonly ready: "Your character is ready";
+    readonly save: "Also save as my avatar";
+    readonly use: "Use in game";
+    readonly retake: "Try again";
+    readonly preview: "Your camera, shown only here on this device";
+};
+declare const IdentityGuidance: {
+    readonly starting: "Starting the camera";
+    readonly find_face: "Look at the camera";
+    readonly face_camera: "Face the camera straight on";
+    readonly move_closer: "Move a little closer";
+    readonly hold_still: "Hold still";
+};
+type IdentityGuidanceKey = keyof typeof IdentityGuidance;
+interface IdentitySheetEvents {
+    agree(): void;
+    decline(): void;
+    capture(): void;
+    retake(): void;
+    use(save: boolean): void;
+    close(): void;
+}
+interface IdentitySheet {
+    consent(): void;
+    framing(stream: MediaStream): void;
+    guide(guidance: IdentityGuidanceKey): void;
+    result(offerSave: boolean): void;
+    close(): void;
+}
+type IdentitySheetFactory = (events: IdentitySheetEvents) => IdentitySheet;
+interface IdentityCaptureOptions {
+    readonly base: () => Promise<IdentityBase | IdentityFitter>;
+    readonly age_range: () => DeclaredAgeRange | Promise<DeclaredAgeRange>;
+    readonly sheet?: IdentitySheetFactory;
+    readonly save_avatar?: (identity: Uint8Array) => Promise<void>;
+}
+declare function domIdentitySheet(container: HTMLElement | null): IdentitySheetFactory;
+
+declare const CAMERA_ON_COPY = "Your camera is on. It stays on this device.";
+type CameraAnswer = "age_undeclared";
+declare class CameraGrants {
+    private readonly revoked;
+    private readonly pending;
+    private readonly granted;
+    constructor(revoked?: (grant: string) => void);
+    observeRequest(bytes: Uint8Array): void;
+    observeResponse(bytes: Uint8Array): CameraAnswer | null;
+    allows(grant: string, purpose: string): boolean;
+    allowsFaceTracking(grant: string): boolean;
+    allowsPreview(grant: string): boolean;
+    revokeAll(): void;
+}
+interface CameraViewRect {
+    readonly x: number;
+    readonly y: number;
+    readonly width: number;
+    readonly height: number;
+    readonly mirror: boolean;
+    readonly over: boolean;
+}
+interface SurfaceOrigin {
+    readonly left: number;
+    readonly top: number;
+}
+declare function cameraViewStyle(rect: CameraViewRect | null, origin?: SurfaceOrigin): string;
+declare function readViewRect(bytes: Uint8Array): CameraViewRect | null;
+interface CameraMedia {
+    getUserMedia(constraints: MediaStreamConstraints): Promise<MediaStream>;
+}
+interface CameraVideo {
+    readonly video: HTMLVideoElement;
+    place(rect: CameraViewRect | null): void;
+    release(): void;
+}
+type CameraVideoFactory = (stream: MediaStream) => Promise<CameraVideo>;
+interface FaceCameraOptions {
+    readonly runner: FaceRunnerFactory;
+    readonly media?: CameraMedia;
+    readonly video?: CameraVideoFactory;
+    readonly container?: HTMLElement | null;
+    readonly surface?: () => SurfaceOrigin;
+    readonly now?: () => number;
+    readonly on_age_needed?: () => void;
+    readonly on_live?: (live: boolean) => void;
+    readonly on_under?: (under: boolean) => void;
+    readonly on_error?: (error: unknown) => void;
+    readonly identity?: IdentityCaptureOptions;
+}
+declare function insetVideo(container: HTMLElement | null, surface?: () => SurfaceOrigin): CameraVideoFactory;
+declare class FaceCameraRelay {
+    private readonly port;
+    private readonly options;
+    private readonly grants;
+    private readonly solver;
+    private readonly solved;
+    private readonly staging;
+    private readonly stagingBytes;
+    private readonly stagingWords;
+    private readonly floats;
+    private readonly expressions;
+    private readonly arkit;
+    private readonly pose;
+    private readonly points;
+    private readonly paints;
+    private session;
+    private attempt;
+    private runner;
+    private loading;
+    private visible;
+    private frameHandle;
+    private frameScheduled;
+    private nextHandle;
+    private placements;
+    private under;
+    private closed;
+    private readonly media;
+    private readonly videoFactory;
+    private readonly now;
+    private readonly step;
+    constructor(port: RelayPort, options: FaceCameraOptions | null);
+    get live(): boolean;
+    observeRequest(bytes: Uint8Array): void;
+    observeResponse(bytes: Uint8Array): void;
+    observeLifecycle(code: number): void;
+    handle(bytes: Uint8Array): boolean;
+    setVisible(visible: boolean): void;
+    shutdown(): void;
+    private releaseAll;
+    private open;
+    private acquireOrRefuse;
+    private acquire;
+    private start;
+    private stopMedia;
+    private end;
+    private consumer;
+    private close;
+    private drop;
+    private revoke;
+    private wanted;
+    private frame;
+    private identify;
+    private capture;
+    private openFor;
+    private identified;
+    private tracked;
+    private track;
+    private untrack;
+    private place;
+    private restyle;
+    private setUnder;
+    private colours;
+    private paint;
+    private answerPaints;
+    private loadRunner;
+    private schedule;
+    private cancelFrame;
+    private derive;
+    private publish;
+    private opened;
+    private coloured;
+}
+
+declare const CANVAS_SANDBOX = "allow-scripts";
+declare const CANVAS_PERMISSIONS = "cross-origin-isolated; autoplay; gamepad; fullscreen; accelerometer; gyroscope";
+type RoomDialerFactory = (transport: TransportKind, url: string) => RoomDialer | null;
+declare const NETWORK_DIALERS: RoomDialerFactory;
+interface CanvasHostOptions {
+    readonly container: HTMLElement;
+    readonly runtime: string;
+    readonly engine?: CanvasEngineChoice;
+    readonly dialers?: RoomDialerFactory;
+    readonly scheduler?: FlushScheduler;
+    readonly content?: ContentOrigin | null;
+    readonly game_ui_accessibility?: boolean;
+    readonly engine_session?: EngineSessionGrant | null;
+    readonly camera?: FaceCameraOptions | null;
+    /** Fetches fallback faces for letters no face covers; without one, `asset_cdn_base` serves the Noto set. */
+    readonly fallback_fonts?: FallbackFontSource | null;
+    /** The host's asset CDN base: the Noto fallback set is read from `notoFallbackBase(asset_cdn_base)`. */
+    readonly asset_cdn_base?: string | null;
+}
+declare function canvasPolicy(scriptHash: string): string;
+declare function canvasDocument(runtime: string): string;
+declare class RoomRelay {
+    private readonly port;
+    private readonly dialers;
+    private readonly links;
+    private readonly handlers;
+    private readonly scratch;
+    private readonly allowed;
+    private readonly pending;
+    private next;
+    constructor(port: RelayPort, dialers: RoomDialerFactory);
+    observeRequest(bytes: Uint8Array): void;
+    observeResponse(bytes: Uint8Array): void;
+    handle(bytes: Uint8Array): boolean;
+    private dial;
+    private settle;
+    private dialed;
+    private outbound;
+    inbound(id: number, lane: Lane, bytes: Uint8Array): void;
+    lost(id: number): void;
+    private close;
+    closeAll(): void;
+}
+declare function iframeEngines(options: CanvasHostOptions): GuestEngineFactory;
+
+interface ContentStore {
+    chunk(digest: string): Promise<Uint8Array | null>;
+    runtime(digest: string): Promise<Uint8Array | null>;
+    /** The brotli of a wasm chunk's payload (`{digest}.wasm.br` beside the chunk), or null when there is none. */
+    wasmTwin?(digest: string): Promise<Uint8Array | null>;
+}
+interface EdgePolicy {
+    readonly frame_ancestors: readonly string[];
+}
+declare const ISOLATION_HEADERS: Readonly<Record<string, string>>;
+declare function serveContent(request: Request, store: ContentStore, policy: EdgePolicy): Promise<Response>;
+
+interface SocketLike {
+    binaryType: string;
+    readonly readyState: number;
+    onmessage: ((event: {
+        data: unknown;
+    }) => void) | null;
+    onclose: ((event: {
+        code: number;
+        reason: string;
+    }) => void) | null;
+    onerror: ((event: unknown) => void) | null;
+    send(data: Uint8Array): void;
+    close(code?: number, reason?: string): void;
+}
+type SocketFactory = (url: string) => SocketLike;
+interface SessionTarget {
+    readonly base_url: string;
+    readonly interactive_id: string;
+    readonly revision: string;
+    readonly channel?: "live" | "test";
+}
+declare function sessionUrl(target: SessionTarget): string;
+interface OpenedSession {
+    readonly transport: CtxTransport;
+    readonly hello: SessionHello;
+}
+declare function openSession(target: SessionTarget, connect: SocketFactory): Promise<OpenedSession>;
+declare function httpChunks(base: string, fetcher?: typeof fetch): ChunkSource;
+
+/** The largest message a Shoal session sends or accepts (cimplify_delivery.h CIMPLIFY_SHOAL_MAX_MESSAGE_BYTES). */
+declare const SHOAL_MAX_MESSAGE_BYTES = 65536;
+declare const CLOSE_REASONS: readonly ["mismatch", "hostile", "peer", "finished"];
+type ShoalCloseReason = (typeof CLOSE_REASONS)[number];
+type ShoalEvent = {
+    readonly kind: "reconciled";
+    readonly zone: number;
+    readonly wanted: number;
+} | {
+    readonly kind: "unreconciled";
+    readonly zone: number;
+} | {
+    readonly kind: "admitted";
+    readonly zone: number;
+    readonly index: number;
+    readonly body: Uint8Array;
+} | {
+    readonly kind: "rejected" | "missing";
+    readonly zone: number;
+    readonly index: number;
+} | {
+    readonly kind: "closed";
+    readonly reason: ShoalCloseReason;
+};
+interface ShoalPartRef {
+    readonly digest: string;
+    readonly size: number;
+}
+interface ShoalHoldingsOptions {
+    /** The game and the signed manifest root, 32 bytes each as hex. */
+    readonly game: string;
+    readonly root: string;
+    /** The manifest's zones, each its parts in play order. */
+    readonly zones: readonly (readonly ShoalPartRef[])[];
+    readonly holds: (digest: string) => boolean;
+}
+interface ShoalExports {
+    readonly memory: WebAssembly.Memory;
+    cimplify_spindrift_alloc(bytes: number): number;
+    cimplify_spindrift_free(pointer: number, bytes: number): void;
+    cimplify_shoal_holdings_open(open: number): number;
+    cimplify_shoal_holdings_set_held(holdings: number, zone: number, index: number, held: number): number;
+    cimplify_shoal_holdings_free(holdings: number): void;
+    cimplify_shoal_open(open: number): number;
+    cimplify_shoal_receive(session: number, message: number, len: number): number;
+    cimplify_shoal_transmit(session: number, out: number, capacity: number): number;
+    cimplify_shoal_event(session: number, out: number): number;
+    cimplify_shoal_need(session: number, zone: number, index: number): number;
+    cimplify_shoal_provide(session: number, zone: number, index: number, body: number, len: number): number;
+    cimplify_shoal_admitted(session: number, out: number): number;
+    cimplify_shoal_closed(session: number): number;
+    cimplify_shoal_free(session: number): void;
+}
+/**
+ * One game's holdings in the delivery WebAssembly module: what this store holds and its Shoal sketch, kept for as
+ * long as the store keeps the game. Mark parts that arrive or leave by any route with `setHeld`; sessions borrow it.
+ */
+declare class ShoalHoldings {
+    private readonly exports;
+    private handle;
+    private sessions;
+    constructor(exports: ShoalExports, handle: number);
+    setHeld(zone: number, index: number, held: boolean): void;
+    /** A session over these holdings, asking for `order`'s zones in turn. Free it before the holdings. */
+    session(order: readonly number[]): ShoalSession;
+    /** Frees the holdings; every session over them must be freed first. */
+    free(): void;
+}
+/** One peer session in the delivery WebAssembly module, the same Rust session native hosts run. */
+declare class ShoalSession {
+    private readonly exports;
+    private readonly holdings;
+    private readonly released;
+    private session;
+    private readonly message;
+    private readonly scratch;
+    private staging;
+    private stagingBytes;
+    constructor(exports: ShoalExports, session: number, holdings: ShoalHoldings, released: () => void);
+    private get bytes();
+    private get view();
+    /** Hands the session one received message and returns the events it raised. */
+    receive(message: Uint8Array): ShoalEvent[];
+    /** The next message to send, or null when there is nothing to send now. */
+    transmit(): Uint8Array | null;
+    events(): ShoalEvent[];
+    private admitted;
+    /** The held part the peer asked for whose bytes the session is waiting on. */
+    need(): {
+        readonly zone: number;
+        readonly index: number;
+    } | null;
+    provide(zone: number, index: number, body: Uint8Array): boolean;
+    /** Marks a part held or not in the holdings this session borrows. */
+    setHeld(zone: number, index: number, held: boolean): void;
+    closed(): ShoalCloseReason | null;
+    free(): void;
+}
+interface ShoalModule {
+    /** Opens a game's holdings: build once per kept game, not per session. */
+    holdings(options: ShoalHoldingsOptions): ShoalHoldings;
+}
+/**
+ * Peer sharing ships dark: it runs only when the server lists `peer_sharing` among the session program's `features`
+ * (ProgramInfo.features, filled by the registry's session host, never by a game).
+ */
+declare const PEER_SHARING_FEATURE = "peer_sharing";
+declare function peerSharingEnabled(features: readonly string[]): boolean;
+/** The peer session module for a session whose program carries `features`, or null, without calling `load`, while off. */
+declare function openPeerSharing(features: readonly string[], load: () => Promise<BufferSource | WebAssembly.Module>): Promise<ShoalModule | null>;
+/** Loads the delivery module (the Spindrift decoder's module) for peer sessions. */
+declare function shoalModule(wasm: BufferSource | WebAssembly.Module): Promise<ShoalModule>;
+/** The part store a peer session admits into and serves from. `SharedPartStore` is one. */
+interface PeerPartStore {
+    read(digest: string): Promise<Uint8Array | null>;
+    admit(digest: string, body: Uint8Array): Promise<void>;
+}
+/** The slice of RTCDataChannel a session drives, so tests can hand it a fake. */
+interface PeerChannel {
+    binaryType: string;
+    readonly readyState: string;
+    readonly bufferedAmount: number;
+    bufferedAmountLowThreshold: number;
+    onopen: ((event: Event) => void) | null;
+    onmessage: ((event: MessageEvent) => void) | null;
+    onbufferedamountlow: ((event: Event) => void) | null;
+    onclose: ((event: Event) => void) | null;
+    send(data: Uint8Array): void;
+    close(): void;
+}
+interface PeerOutcome {
+    readonly reason: ShoalCloseReason;
+    readonly admitted: number;
+    readonly rejected: number;
+    readonly reconciled: readonly number[];
+    readonly unreconciled: readonly number[];
+}
+/**
+ * Runs `session` over a data channel until it closes: received messages go to the session, admitted bodies to
+ * `store`, the parts the peer asks for are read from `store` and staged, and sends respect the channel's buffer.
+ */
+declare function runOverChannel(session: ShoalSession, channel: PeerChannel, store: PeerPartStore, zones: readonly (readonly ShoalPartRef[])[]): Promise<PeerOutcome>;
+
+interface LocalSessionOptions {
+    readonly interactive_id: string;
+    readonly profile: RenderingProfile;
+    readonly persona: Persona;
+    readonly now?: () => number;
+    readonly answer?: (request: RequestEnvelope["call"]) => HostResponse["result"] | undefined;
+    readonly answerAsync?: (request: RequestEnvelope["call"]) => Promise<LocalAnswer> | undefined;
+}
+type LocalAnswer = {
+    readonly result: HostResponse["result"];
+} | {
+    readonly error: CtxError;
+};
+declare function familyOf(operation: string): Family | null;
+declare function localProgram(options: LocalSessionOptions): ProgramInfo;
+declare function localSession(options: LocalSessionOptions): {
+    transport: CtxTransport;
+    hello: SessionHello;
+};
+
+interface EncodedSample {
+    readonly byteLength: number;
+    copyTo(destination: Uint8Array): void;
+}
+interface EncodedRingOptions {
+    readonly capacity_bytes: number;
+    readonly max_samples: number;
+    readonly page_bytes?: number;
+}
+declare class EncodedRing {
+    readonly arena: Uint8Array;
+    readonly pageBytes: number;
+    private readonly pages;
+    private readonly starts;
+    private readonly lengths;
+    private readonly times;
+    private readonly durations;
+    private readonly keys;
+    private readonly maxSamples;
+    private head;
+    private size;
+    private writePage;
+    dropped: number;
+    constructor(options: EncodedRingOptions);
+    get count(): number;
+    get pageCount(): number;
+    private slot;
+    push(sample: EncodedSample, time_us: number, duration_us: number, key: boolean): boolean;
+    private evict;
+    retain(window_us: number): void;
+    private nextKey;
+    endUs(): number;
+    startFor(keep_us: number): number;
+    firstAtOrAfter(time_us: number): number;
+    offset(index: number): number;
+    length(index: number): number;
+    time(index: number): number;
+    duration(index: number): number;
+    key(index: number): boolean;
+    clear(): void;
+}
+
+declare const CLIP_MP4_TYPE = "video/mp4";
+interface ClipVideoTrack {
+    readonly width: number;
+    readonly height: number;
+    readonly description: Uint8Array;
+}
+interface ClipAudioTrack {
+    readonly codec: "mp4a" | "opus";
+    readonly sample_rate: number;
+    readonly channels: number;
+    readonly description: Uint8Array | null;
+}
+interface ClipRange {
+    readonly ring: EncodedRing;
+    readonly from: number;
+    readonly to: number;
+}
+interface ClipPlan {
+    readonly video: {
+        readonly track: ClipVideoTrack;
+        readonly range: ClipRange;
+    };
+    readonly audio: {
+        readonly track: ClipAudioTrack;
+        readonly range: ClipRange;
+    } | null;
+}
+declare function muxMp4(plan: ClipPlan): Uint8Array;
+
+export { CAMERA_ON_COPY, CANVAS_PERMISSIONS, CANVAS_SANDBOX, CLIP_MP4_TYPE, CONTENT_BLOCKED_CLOSE, CONTENT_BLOCKED_ERROR, CONTENT_BLOCKED_STATUS, CacheStoragePartBackend, type CameraAnswer, CameraGrants, type CameraMedia, type CameraVideo, type CameraVideoFactory, type CameraViewRect, type CanvasBoot, type CanvasEngineChoice, type CanvasHostOptions, ChunkSource, type ClipPlan, type ContentOrigin, type ContentStore, type CreditAi, CtxTransport, DEFAULT_LAZY_BUDGET_BYTES, DEFAULT_LAZY_CONCURRENCY, type EdgePolicy, EncodedRing, EngineSessionGrant, FACE_LANDMARKER, type FaceCameraOptions, FaceCameraRelay, type FaceLandmarkRunner, type FaceLandmarkerPart, type FaceRunnerFactory, type FaceRunnerScope, type FlushScheduler, GuestEngineFactory, HOST_PAGE_ISOLATION_HEADERS, type HostCredit, ISOLATION_HEADERS, type IdentityCaptureOptions, IdentityCopy, IdentityGuidance, type IdentityGuidanceKey, type IdentitySheet, type IdentitySheetEvents, type IdentitySheetFactory, IndexedDbPartBackend, type LazyChunkOptions, type LazyChunkRef, LazyChunkServer, type LazyChunkSink, type LocalAnswer, type LocalSessionOptions, NETWORK_DIALERS, type OpenedSession, PART_STORE_NAME, PEER_SHARING_FEATURE, PartStoreBackend, PartStoreDisk, PartStoreOptions, PartStoreSnapshot, type PeerChannel, type PeerOutcome, type PeerPartStore, PortBridge, type PortBridgeStats, type RoomDialerFactory, RoomRelay, SHOAL_MAX_MESSAGE_BYTES, SessionHello, type SessionTarget, SharedPartStore, type ShoalCloseReason, type ShoalEvent, ShoalHoldings, type ShoalHoldingsOptions, type ShoalModule, type ShoalPartRef, ShoalSession, type SocketFactory, type SocketLike, type SurfaceOrigin, WEB_DISK_RESERVE_BYTES, ZoneSpans, animationFrameScheduler, blockedItems, cameraViewStyle, canvasDocument, canvasPolicy, domIdentitySheet, familyOf, forgetHostWebGpu, guestOrigin, hostWebGpu, httpChunks, iframeEngines, insetVideo, interactiveLabel, localProgram, localSession, manifestCredits, mediaPipeFaceRunner, muxMp4, openPeerSharing, openSession, openWebPartStore, parseContentOrigin, peerSharingEnabled, probeHostWebGpu, readViewRect, runOverChannel, serveContent, servesContent, sessionUrl, sha256Hex, shoalModule, webStorageDisk };