@cimplify/sdk 0.108.0 → 0.110.2

package/dist/web-Dss74a7v.d.ts

@@ -0,0 +1,883 @@
+import { a1 as ConsentKind, a2 as ReportTarget, a3 as ReportReason, a4 as MediaRef, w as ProgramInfo, a5 as ResponseEnvelope, a6 as ReplayMode, b as UiNode, x as LocaleInfo, a7 as SocialPostResult, a8 as ShareResult, M as UiEvent } from './local-VZkqsCzR.js';
+import { bf as WarmImage, be as ClipFailureCode, aK as UiCommand, ab as MessageListener, O as GuestFault, M as MilestoneName, aA as SessionCompleteMessage, J as FrameMark, a4 as LifecycleName, V as HotSwapResult } from './guest-wIdfoT05.js';
+import { D as DeviceTier, aJ as GPU_PASS_NAMES } from './backend-gUCzs5Kg.js';
+import { I as InspectorReadout } from './world-PvILHDR1.js';
+import { G as Game } from './game-fgQy2YIm.js';
+import { a as StudioMessage, b as StudioOutgoing } from './studio-CowqWqez.js';
+import { c as TreePatch } from './tree-CP_qSW4H.js';
+import { C as ChunkSource, S as SharedPartStore, n as PackageWeaveRef } from './weave-delivery-CW-Kstut.js';
+import { N as NetworkHint } from './network-ZXLD7l1b.js';
+
+interface DeviceRun {
+    readonly device: string;
+    readonly tier: DeviceTier;
+    readonly measuredFrameMs: number;
+    readonly predictedFrameMs: number;
+    readonly measuredGpuMs: number;
+    readonly predictedGpuMs: number;
+    readonly measuredMemoryBytes: number;
+    readonly predictedMemoryBytes: number;
+    readonly measuredOpenSeconds: number;
+    readonly predictedOpenSeconds: number;
+}
+interface Calibration {
+    readonly device: string;
+    readonly tier: DeviceTier;
+    readonly frameScale: number;
+    readonly gpuScale: number;
+    readonly memoryScale: number;
+    readonly openScale: number;
+    readonly runs: number;
+}
+declare const UNCALIBRATED_SCALE = 1;
+declare function fitCalibration(device: string, tier: DeviceTier, runs: readonly DeviceRun[]): Calibration;
+declare function isCalibrated(calibration: Calibration | null): calibration is Calibration;
+declare function calibrationFor(calibrations: readonly Calibration[], tier: DeviceTier): Calibration | null;
+
+type CauseAmount = "most" | "some" | "a_little";
+interface MeterCause {
+    readonly label: string;
+    readonly share: number;
+    readonly amount: CauseAmount;
+}
+interface CostEntry {
+    readonly label: string;
+    readonly cost: number;
+}
+declare const MOST_SHARE = 0.5;
+declare const SOME_SHARE = 0.2;
+declare const MAX_CAUSES = 3;
+declare const PASS_LABELS: {
+    readonly [P in (typeof GPU_PASS_NAMES)[number]]: string;
+};
+declare function amountOf(share: number): CauseAmount;
+declare function rankCauses(entries: readonly CostEntry[], limit?: number): MeterCause[];
+declare function passCauses(passNs: ArrayLike<number>, limit?: number): MeterCause[];
+
+declare const FRAME_WINDOW = 600;
+declare const MAX_MOMENTS = 64;
+type SmoothVerdict = "smooth" | "slight" | "stutters";
+type HeatVerdict = "cool" | "warm" | "hot";
+interface FrameMeter {
+    readonly tier: DeviceTier;
+    readonly frames: number;
+    readonly p50Ms: number;
+    readonly p95Ms: number;
+    readonly p99Ms: number;
+    readonly fps: number;
+    readonly targetFps: number;
+    readonly smooth: SmoothVerdict;
+    readonly worstMoment: string | null;
+    readonly causes: readonly MeterCause[];
+    readonly calibrated: boolean;
+    readonly device: string | null;
+}
+interface HeatMeter {
+    readonly busyShare: number;
+    readonly pressure: number;
+    readonly heat: HeatVerdict;
+}
+declare function smoothVerdict(fps: number, target?: number): SmoothVerdict;
+declare function heatVerdict(busyShare: number, pressure: number): HeatVerdict;
+declare class FrameRecorder {
+    private readonly frameMs;
+    private readonly moments;
+    private readonly passNs;
+    private readonly labels;
+    private head;
+    private count;
+    private moment;
+    private gpuFrames;
+    private busyNs;
+    private spanNs;
+    private pressure;
+    mark(label: string | null): void;
+    frame(seconds: number): void;
+    gpu(lastNs: number, passNs: ArrayLike<number>, pressure: number): void;
+    reset(): void;
+    get frames(): number;
+    heat(): HeatMeter;
+    meter(tier: DeviceTier, calibration?: Calibration | null, target?: number): FrameMeter;
+    private worstMoment;
+}
+
+interface MemorySample {
+    readonly scriptBytes: number;
+    readonly engineBytes: number;
+    readonly graphicsBytes: number;
+}
+type MemoryVerdict = "fits" | "tight" | "too_much";
+interface MemoryMeter {
+    readonly tier: DeviceTier;
+    readonly bytes: number;
+    readonly ceilingBytes: number;
+    readonly memory: MemoryVerdict;
+    readonly causes: readonly MeterCause[];
+    readonly calibrated: boolean;
+}
+declare class MemoryPeak {
+    private script;
+    private engine;
+    private graphics;
+    note(sample: MemorySample): void;
+    noteScript(bytes: number): void;
+    noteEngine(bytes: number): void;
+    noteGraphics(bytes: number): void;
+    reset(): void;
+    get peak(): MemorySample;
+}
+declare function memoryMeter(sample: MemorySample, tier: DeviceTier, calibration?: Calibration | null): MemoryMeter;
+
+declare const GPU_SAMPLE_FRAMES = 30;
+declare const QUALITY_FOR_TIER: {
+    readonly [T in DeviceTier]: number;
+};
+interface LiveMeters {
+    readonly tier: DeviceTier;
+    readonly asTier: boolean;
+    readonly frames: FrameMeter;
+    readonly heat: HeatMeter;
+    readonly memory: MemoryMeter;
+}
+declare class GameMeters {
+    private readonly game;
+    private readonly calibrations;
+    readonly recorder: FrameRecorder;
+    readonly memory: MemoryPeak;
+    private readonly stats;
+    private tier;
+    private forced;
+    private sinceGpu;
+    constructor(game: Game, tier: DeviceTier, calibrations?: readonly Calibration[]);
+    get playingAs(): DeviceTier;
+    get simulating(): boolean;
+    playAs(tier: DeviceTier | null): boolean;
+    measureAs(tier: DeviceTier, pin: boolean): boolean;
+    moment(label: string | null): void;
+    update(): void;
+    noteInspector(readout: InspectorReadout): void;
+    noteScriptHeap(bytes: number): void;
+    reset(): void;
+    read(): LiveMeters;
+}
+
+interface MeterRequest {
+    readonly on: boolean;
+    readonly tier: DeviceTier;
+    readonly pin: boolean;
+}
+declare const METERS_OFF: MeterRequest;
+declare const METER_REPORT_FRAMES = 30;
+declare function requestMeters(request: MeterRequest): void;
+declare function metersRequested(): MeterRequest;
+
+declare const DEFAULT_WARM_BOOT_MS = 10000;
+interface RuntimeImage {
+    readonly key: string;
+    readonly chunks: readonly string[];
+    readonly payloads: ReadonlyMap<string, string>;
+    readonly warm: WarmImage;
+}
+interface WarmGuest {
+    readonly engine: GuestEngine;
+    readonly staged: ReadonlySet<string>;
+}
+declare function runtimeImage(chunks: readonly PackageChunkRef[]): RuntimeImage;
+declare class RuntimePool {
+    private readonly factory;
+    private readonly source;
+    private readonly boot_ms;
+    private readonly slots;
+    private readonly bodies;
+    private readonly writer;
+    constructor(factory: GuestEngineFactory, source: ChunkSource, boot_ms?: number);
+    private keyOf;
+    warm(chunks: readonly PackageChunkRef[], interactive?: string): void;
+    warmed(chunks: readonly PackageChunkRef[], interactive?: string): Promise<boolean>;
+    take(chunks: readonly PackageChunkRef[], interactive?: string): Promise<WarmGuest | null>;
+    drain(): void;
+    private stage;
+    private ready;
+    private stageBody;
+    private warmedReply;
+    private fetch;
+}
+
+declare const CONSENT_KINDS: readonly ConsentKind[];
+interface KeyValueStore {
+    get(key: string): string | null;
+    set(key: string, value: string): void;
+}
+declare function memoryStore(): KeyValueStore;
+declare function browserStore(): KeyValueStore;
+type ConsentState = "granted" | "denied" | "undecided";
+declare class ConsentStore {
+    private readonly storage;
+    private readonly cache;
+    private readonly listeners;
+    private versionValue;
+    constructor(storage?: KeyValueStore);
+    readonly version: () => number;
+    readonly subscribe: (listener: (interactive_id: string) => void) => (() => void);
+    private decisions;
+    granted(interactive_id: string): readonly ConsentKind[];
+    state(interactive_id: string, kind: ConsentKind): ConsentState;
+    decide(interactive_id: string, kind: ConsentKind, granted: boolean): void;
+}
+
+interface RepairFileRef {
+    readonly first: number;
+    readonly parts: number;
+    readonly symbols: number;
+    readonly repair: number;
+    readonly digest: string;
+}
+interface RepairMember {
+    readonly digest: string;
+    readonly size: number;
+}
+type RepairOutcome = "decoded" | "insufficient" | "shape";
+interface RepairDecoder {
+    decode(block: Uint8Array, known: Uint8Array, repair: Uint8Array): RepairOutcome;
+}
+interface RepairSource {
+    fetchRepair(digest: string, symbols: number, signal?: AbortSignal): Promise<Uint8Array>;
+}
+type BlockPlan = {
+    readonly kind: "repair";
+    readonly file: RepairFileRef;
+    readonly missing: readonly number[];
+    readonly ask: number;
+} | {
+    readonly kind: "runs";
+    readonly missing: readonly number[];
+    readonly runs: number;
+};
+interface Completion {
+    readonly repaired: number;
+    readonly fetched: number;
+    readonly requests: number;
+    readonly repair_bytes: number;
+}
+declare function repairDecoder(wasm: BufferSource | WebAssembly.Module): Promise<RepairDecoder>;
+declare function cdnRepairs(base: string, fetcher?: typeof fetch): RepairSource;
+declare function planZone(members: readonly RepairMember[], held: readonly boolean[], files: readonly RepairFileRef[]): BlockPlan[];
+declare function completeZone(store: SharedPartStore, members: readonly RepairMember[], files: readonly RepairFileRef[], upstream: ChunkSource, repairs: RepairSource, decoder: RepairDecoder, signal?: AbortSignal): Promise<Completion>;
+
+interface ZoneFileRef {
+    readonly asset_group: string;
+    readonly digest: string;
+    readonly parts: number;
+    readonly bytes: number;
+    readonly repair?: readonly RepairFileRef[];
+}
+interface ZoneChunkRef {
+    readonly digest: string;
+    readonly asset_group?: string;
+    readonly size?: number;
+}
+interface ZoneSpan {
+    readonly file: string;
+    readonly offset: number;
+    readonly size: number;
+    readonly index: number;
+}
+declare class ZoneSpans {
+    private readonly spans;
+    private readonly members;
+    static of(chunks: readonly ZoneChunkRef[], files: readonly ZoneFileRef[]): ZoneSpans;
+    get size(): number;
+    locate(digest: string): ZoneSpan | undefined;
+    neighbour(digest: string, step: 1 | -1): string | null;
+    runs(digests: readonly string[]): number[][];
+}
+declare function rangedChunks(base: string, spans: ZoneSpans, fetcher?: typeof fetch): ChunkSource;
+
+type AdFormat = "rewarded" | "between_sessions" | "sponsored_item";
+type TrackingConsent = "not_asked" | "denied" | "authorized";
+type PlacementState = "decided" | "no_fill" | "capped" | "not_allowed" | "completed" | "invalid" | "rewarded";
+type PackageChannel = "live" | "test";
+interface AdCreative {
+    readonly label: string;
+    readonly sponsor_name: string;
+    readonly category: string;
+    readonly creative: string;
+    readonly destination: string;
+}
+interface ServedAd {
+    readonly placement_id: string;
+    readonly status: PlacementState;
+    readonly creative: AdCreative | null;
+}
+interface AdDecisionBody {
+    readonly request_key: string;
+    readonly format: AdFormat;
+    readonly slot: string;
+    readonly tracking: TrackingConsent;
+}
+interface PlacementCompletion {
+    readonly placement_id: string;
+    readonly status: PlacementState;
+}
+interface ReportFiling {
+    readonly target: ReportTarget;
+    readonly reason: ReportReason;
+    readonly revision_id: string | null;
+    readonly room_id: string | null;
+    readonly world_id: string | null;
+}
+interface PackageIndexRef {
+    readonly revision_id: string;
+    readonly package_digest: string;
+    readonly chunk_base_url: string;
+    readonly content_origin?: string | null;
+    readonly chunks: readonly (PackageChunkRef & {
+        readonly size: number;
+    })[];
+    readonly weave?: PackageWeaveRef;
+    readonly zone_files?: readonly ZoneFileRef[];
+}
+type PackageForm = "full" | "weave";
+interface BatchPackage {
+    readonly interactive_id: string;
+    readonly package: PackageIndexRef;
+}
+interface RegistryClient {
+    fileReport(interactive_id: string, filing: ReportFiling): Promise<void>;
+    blockHandle(handle: string): Promise<void>;
+    decideAd(interactive_id: string, body: AdDecisionBody): Promise<ServedAd>;
+    completeAd(interactive_id: string, placement_id: string, attested: boolean): Promise<PlacementCompletion>;
+    packages(ids: readonly string[], channel: PackageChannel, form?: PackageForm): Promise<readonly BatchPackage[]>;
+}
+declare class RegistryError extends Error {
+    readonly status: number;
+    readonly route: string;
+    constructor(status: number, route: string);
+}
+declare function httpRegistry(base: string, fetcher?: typeof fetch): RegistryClient;
+
+type SpendDecision = "confirmed" | "cancelled";
+type AdOutcome = "completed" | "skipped";
+type ClipChoice = "post" | "share" | "done";
+interface SpendPrompt {
+    readonly offer_id: string;
+    readonly display_name: string;
+    readonly quantity: number;
+    readonly price_cimples: number;
+}
+type ChromeSheet = {
+    readonly kind: "consent";
+    readonly consent: ConsentKind;
+} | {
+    readonly kind: "spend";
+    readonly prompt: SpendPrompt;
+} | {
+    readonly kind: "ad";
+    readonly creative: AdCreative;
+} | {
+    readonly kind: "clip";
+    readonly media: MediaRef;
+} | {
+    readonly kind: "permissions";
+} | {
+    readonly kind: "report";
+} | {
+    readonly kind: "block";
+};
+declare class HostChromeController {
+    private readonly queue;
+    private readonly listeners;
+    readonly subscribe: (listener: () => void) => (() => void);
+    readonly snapshot: () => ChromeSheet | null;
+    private ask;
+    private notify;
+    requestConsent(consent: ConsentKind): Promise<boolean>;
+    confirmSpend(prompt: SpendPrompt): Promise<SpendDecision>;
+    showAd(creative: AdCreative): Promise<AdOutcome>;
+    offerClip(media: MediaRef): Promise<ClipChoice>;
+    open(sheet: {
+        readonly kind: "permissions" | "report" | "block";
+    }): void;
+    resolve(value: unknown): void;
+    dismiss(): void;
+    dismissAll(): void;
+}
+
+interface SpendConfirmation {
+    readonly request_key: string;
+    readonly offer_id: string;
+    readonly quantity: number;
+    readonly price_cimples: number;
+    readonly decision: SpendDecision;
+}
+interface MediatorOutlet {
+    toSession(bytes: Uint8Array, length: number): void;
+}
+interface HostChromeOptions {
+    readonly interactive_id: string;
+    readonly controller: HostChromeController;
+    readonly consents: ConsentStore;
+    readonly registry: RegistryClient | null;
+}
+type HostCallOperation = "wallet.offers" | "social.post" | "share.open";
+declare class HostMediator {
+    private readonly options;
+    private readonly writer;
+    private readonly offers;
+    private readonly offerRequests;
+    private readonly hostCalls;
+    private readonly asking;
+    private outlet;
+    private program;
+    private stopConsents;
+    private nextHostCall;
+    constructor(options: HostChromeOptions);
+    start(program: ProgramInfo, outlet: MediatorOutlet): void;
+    stop(): void;
+    private send;
+    private sendConsents;
+    private relay;
+    fromGuest(bytes: Uint8Array): boolean;
+    fromSession(bytes: Uint8Array): boolean;
+    private remember;
+    private consentRequired;
+    /** Sends one ctx call on the host's own behalf, such as posting a clip the player saved from host chrome. */
+    hostCall(operation: HostCallOperation, args?: object): Promise<ResponseEnvelope>;
+    private offer;
+    private spend;
+    private placement;
+}
+
+type EngineHeapTier = "low" | "mid" | "high";
+/** Engine heap a package declares for each device tier, in bytes: the recorded boot peak plus headroom. */
+type EngineHeapDeclaration = Readonly<Partial<Record<EngineHeapTier, number>>>;
+/** The most engine heap a web host reserves on a device of each tier. */
+declare const ENGINE_HEAP_CEILING_BYTES: Readonly<Record<EngineHeapTier, number>>;
+/** Headroom added to the recorded peak when a build declares a package's engine heap. */
+declare const ENGINE_HEAP_HEADROOM = 1.25;
+type EngineHeapChoice = {
+    readonly bytes: number;
+} | {
+    readonly refused: string;
+};
+/**
+ * The engine heap a host reserves: the package's declaration for this tier, never above the tier's
+ * ceiling. A package declaring more than the device allows is refused before boot rather than
+ * failing allocation mid-game; a package declaring nothing gets the tier ceiling.
+ */
+declare function engineHeapFor(declaration: EngineHeapDeclaration | undefined, tier: EngineHeapTier): EngineHeapChoice;
+/** The declaration a build writes from the recorded peak of each tier. */
+declare function declareEngineHeap(peaks: Readonly<Partial<Record<EngineHeapTier, number>>>): EngineHeapDeclaration;
+
+declare const GPU_REQUIREMENT_NAMES: readonly ["sampled_textures_per_stage", "samplers_per_stage", "storage_buffers_per_stage", "compute_workgroup_invocations", "compute_workgroup_storage_bytes"];
+type GpuRequirementName = (typeof GPU_REQUIREMENT_NAMES)[number];
+type GpuRequirements = Partial<Readonly<Record<GpuRequirementName, number>>>;
+type GpuLimits = Readonly<Record<GpuRequirementName, number>>;
+interface GpuAdapterLike {
+    readonly limits: Readonly<Record<string, number>>;
+}
+interface GpuScope {
+    readonly navigator?: {
+        readonly gpu?: {
+            requestAdapter(): Promise<GpuAdapterLike | null>;
+        };
+    };
+    readonly document?: {
+        createElement(tag: "canvas"): {
+            getContext(kind: string): {
+                getParameter(name: number): unknown;
+            } | null;
+        };
+    };
+}
+declare function unmetGpuRequirement(requirements: GpuRequirements, limits: GpuLimits): GpuRequirementName | null;
+declare function manifestGpuRequirements(manifest: Uint8Array): GpuRequirements;
+declare function deviceGpuLimits(scope?: GpuScope): Promise<GpuLimits>;
+
+interface ClipArm {
+    readonly window_ms: number;
+    readonly fps: number;
+    readonly video_bits_per_second: number;
+    readonly audio: boolean;
+    readonly max_long_edge: number;
+}
+declare const DEFAULT_CLIP_ARM: ClipArm;
+
+interface SavedClip {
+    readonly blob: Blob;
+    readonly type: string;
+    readonly duration_ms: number;
+    readonly width: number;
+    readonly height: number;
+}
+interface GuestClips {
+    arm(config: ClipArm | null): void;
+    pause(paused: boolean): void;
+    save(keep_ms: number): Promise<SavedClip | null>;
+    readonly camera_live: boolean;
+    on_camera_live(listener: (live: boolean) => void): void;
+}
+interface Sender {
+    send(bytes: Uint8Array, length: number): void;
+}
+declare class ClipRelay implements GuestClips {
+    private readonly port;
+    private readonly writer;
+    private readonly pauseMessage;
+    private readonly saveMessage;
+    private readonly pending;
+    private nextId;
+    private live;
+    private listener;
+    private closed;
+    constructor(port: Sender);
+    get camera_live(): boolean;
+    on_camera_live(listener: (live: boolean) => void): void;
+    cameraLive(live: boolean): void;
+    arm(config: ClipArm | null): void;
+    pause(paused: boolean): void;
+    save(keep_ms: number): Promise<SavedClip | null>;
+    handle(bytes: Uint8Array): boolean;
+    shutdown(): void;
+}
+
+declare const CLIP_CAMERA = "clip_camera";
+declare const REPLAY_MEDIA_TYPE = "application/vnd.cimplify.replay";
+type ClipMediaKind = "video" | "replay";
+/** One file for the platform media upload: scope `me`, kind `video` for clips, moderated before anyone else sees it. */
+interface ClipUpload {
+    readonly kind: ClipMediaKind;
+    readonly interactive_id: string;
+    readonly blob: Blob;
+    readonly type: string;
+    readonly duration_ms: number;
+    readonly width: number;
+    readonly height: number;
+}
+interface WebHostClipOptions {
+    /** Sends the file through the platform media upload and answers its media reference. */
+    readonly upload: (clip: ClipUpload) => Promise<MediaRef>;
+    readonly window_ms?: number;
+    readonly fps?: number;
+    readonly video_bits_per_second?: number;
+    readonly audio?: boolean;
+    readonly max_long_edge?: number;
+}
+interface ClipConsent {
+    readonly consents: ConsentStore;
+    readonly controller: HostChromeController;
+}
+type ClipCommand = Extract<UiCommand, {
+    kind: "clip_start" | "clip_stop" | "clip_cancel" | "clip_keep" | "replay_save";
+}>;
+type ClipReply = {
+    readonly clip: number;
+} | {
+    readonly media_id: string;
+} | {
+    readonly error: {
+        readonly code: ClipFailureCode;
+    };
+} | null;
+type ClipOutcome = {
+    readonly media: MediaRef;
+} | {
+    readonly error: ClipFailureCode;
+};
+declare class HostClips {
+    private readonly options;
+    private readonly interactive_id;
+    private readonly consent;
+    private readonly now;
+    readonly arm: ClipArm;
+    private guest;
+    private readonly recordings;
+    private nextRecording;
+    private paused;
+    private stopConsents;
+    private asking;
+    constructor(options: WebHostClipOptions, interactive_id: string, consent: ClipConsent | null, now: () => number);
+    get available(): boolean;
+    attach(guest: GuestClips | null): void;
+    detach(): void;
+    private cameraAllowed;
+    private update;
+    /** Asks for camera in clips from host chrome; the answer lifts the pause for later saves. */
+    askCamera(): Promise<boolean>;
+    keep(keep_ms: number): Promise<ClipOutcome>;
+    saveReplay(bytes: Uint8Array): Promise<ClipOutcome>;
+    private upload;
+    command(command: ClipCommand): Promise<ClipReply>;
+}
+
+interface GuestEngine {
+    send(bytes: Uint8Array, length: number): void;
+    on_message(listener: MessageListener): void;
+    on_crash(listener: (message: string) => void): void;
+    terminate(): void;
+    readonly may_fetch_wasm?: boolean;
+    readonly fetches_wasm?: boolean;
+    /** The engine's clip capture: a rolling window of what the player sees and hears, saved on request. */
+    readonly clips?: GuestClips;
+}
+interface OpenedReplay {
+    readonly bytes: Uint8Array;
+    readonly mode: ReplayMode;
+}
+interface GuestEngineFactory {
+    spawn(interactive?: string): GuestEngine;
+    readonly isolates_interactives?: boolean;
+}
+interface CtxTransport {
+    send(bytes: Uint8Array, length: number): void;
+    on_message(listener: MessageListener): void;
+    on_close(listener: (close: SessionClose) => void): void;
+    close(): void;
+}
+interface SessionHello {
+    readonly protocol: number;
+    readonly program: ProgramInfo;
+    readonly server_time_ms: number;
+}
+interface AiLocalCapability {
+    readonly model: "apple_foundation" | "gemini_nano";
+    readonly languages: readonly string[];
+    readonly max_context_tokens: number;
+}
+interface SessionConsent {
+    readonly granted: readonly ConsentKind[];
+    readonly ai_local?: AiLocalCapability | null;
+}
+interface SessionClose {
+    readonly reason: string;
+    readonly detail: string | null;
+}
+
+interface RuntimeTag {
+    readonly name: string;
+    readonly version: string;
+}
+interface PackageChunkRef {
+    readonly digest: string;
+    readonly before_play: boolean;
+    readonly asset_group?: string;
+    readonly runtime?: RuntimeTag | null;
+    readonly payload_digest?: string | null;
+    readonly lazy?: boolean;
+    readonly size?: number;
+    /** The size of the chunk's brotli twin, when the build measured one worth fetching. */
+    readonly brotli_bytes?: number | null;
+    /** The chunk has a brotli twin (a woven package's leaf flag), whether or not its size is known. */
+    readonly twinned?: boolean;
+}
+declare const ENGINE_GROUP_PREFIX = "engine:";
+type HostDeviceTier = "low" | "mid" | "high";
+declare const ALTERNATIVE_RUNTIMES: Readonly<Record<string, string>>;
+declare function chunksForHost(chunks: readonly PackageChunkRef[], engine: string | null, isolated?: boolean, tier?: HostDeviceTier, threads?: boolean, scripts?: () => boolean, webgpu?: boolean): PackageChunkRef[];
+declare function swappable(chunk: PackageChunkRef): boolean;
+interface SwapBuild {
+    readonly ok: boolean;
+    readonly host?: boolean;
+    readonly chunks?: readonly PackageChunkRef[] | null;
+}
+declare function swapInPlace(host: Pick<WebHost, "hotSwap"> | null, build: () => Promise<SwapBuild>): Promise<HotSwapResult>;
+declare function hostThreads(): boolean;
+interface PackageRef {
+    readonly chunks: readonly PackageChunkRef[];
+    readonly keep_on_device?: boolean;
+    readonly zone_files?: readonly ZoneFileRef[];
+    readonly engine_heap?: EngineHeapDeclaration;
+}
+interface HostLimits {
+    readonly ping_ms: number;
+    readonly cpu_slice_ms: number;
+    readonly memory_bytes: number;
+    readonly boot_ms: number;
+    readonly restarts_per_window: number;
+    readonly restart_window_ms: number;
+}
+declare const DEFAULT_HOST_LIMITS: HostLimits;
+type HostFault = ({
+    readonly source: "guest";
+} & GuestFault) | {
+    readonly source: "watchdog";
+    readonly message: string;
+} | {
+    readonly source: "memory";
+    readonly message: string;
+} | {
+    readonly source: "crash";
+    readonly message: string;
+} | {
+    readonly source: "package";
+    readonly message: string;
+} | {
+    readonly source: "session";
+    readonly message: string;
+} | {
+    readonly source: "device";
+    readonly message: string;
+    readonly requirement: GpuRequirementName | string;
+};
+interface WebHostOptions {
+    readonly engines: GuestEngineFactory | GuestPool;
+    readonly runtimes?: RuntimePool;
+    readonly transport: CtxTransport;
+    readonly hello: SessionHello;
+    readonly package: PackageRef;
+    readonly chunks: ChunkSource;
+    readonly locale: LocaleInfo;
+    readonly limits?: Partial<HostLimits>;
+    readonly now?: () => number;
+    readonly on_command?: (command: UiCommand) => unknown;
+    readonly on_fault?: (fault: HostFault) => void;
+    readonly on_milestone?: (milestone: MilestoneName, at_ms: number) => void;
+    readonly on_complete?: (completion: SessionCompleteMessage, at_ms: number) => void;
+    /** A recording guest stamps each simulation frame; once every chunk the frame asked for has been delivered the host reports the frame settled and steps the guest. */
+    readonly on_frame_mark?: (mark: FrameMark) => void;
+    /** While meters are on (setMeters), the guest's game reports its frame, memory and heat meters about twice a second. */
+    readonly on_meters?: (live: LiveMeters) => void;
+    readonly on_studio?: (message: StudioMessage) => void;
+    readonly chrome?: HostChromeOptions;
+    readonly gpu?: {
+        readonly requirements: GpuRequirements;
+        readonly limits: GpuLimits;
+    };
+    readonly engine_features?: {
+        readonly required: readonly string[];
+        readonly available: readonly string[];
+    };
+    readonly device_tier?: HostDeviceTier;
+    readonly threads?: boolean;
+    readonly webgpu?: boolean;
+    readonly lazy_budget_bytes?: number;
+    readonly lazy_concurrency?: number;
+    readonly network?: NetworkHint | null;
+    readonly part_store?: SharedPartStore;
+    /** Host-owned clips: every Interactive keeps the last few seconds ready to save from chrome or from the game. */
+    readonly clips?: WebHostClipOptions;
+    /** A replay the player opened; `play` is honoured only when the replay allows playing on from it. */
+    readonly replay?: OpenedReplay | null;
+}
+type HostPhase = "idle" | "booting" | "running" | "crashed" | "disposed";
+declare class HostFaultError extends Error {
+    readonly fault: HostFault;
+    constructor(fault: HostFault);
+}
+declare function workerEngines(script: string | URL): GuestEngineFactory;
+declare class GuestPool {
+    private readonly factory;
+    private readonly size;
+    private readonly ready;
+    private readonly waiting;
+    constructor(factory: GuestEngineFactory, size: number);
+    private warm;
+    acquire(): Promise<GuestEngine>;
+    drain(): void;
+    get warmed(): number;
+}
+declare class TreeStore {
+    private readonly mirror;
+    private readonly listeners;
+    readonly subscribe: (listener: () => void) => (() => void);
+    readonly snapshot: () => UiNode | null;
+    apply(patches: readonly TreePatch[]): void;
+    reset(): void;
+}
+declare class WebHost {
+    private readonly options;
+    readonly tree: TreeStore;
+    private readonly limits;
+    private readonly writer;
+    private readonly stepMessage;
+    private supplying;
+    private readonly ping;
+    private readonly pingView;
+    private readonly lifecycleMessage;
+    private readonly now;
+    private partsSequence;
+    private engine;
+    private watchdog;
+    private pingSequence;
+    private pingSentAt;
+    private restarts;
+    private started;
+    private failed;
+    phase: HostPhase;
+    private readonly chunks;
+    private readonly parts;
+    private readonly source;
+    private readonly lazyChunks;
+    private readonly afterFirstFrame;
+    private readonly mediator;
+    private readonly outlet;
+    private readonly networkMessage;
+    private networkHint;
+    private unwatchNetwork;
+    private readonly inspectorMessage;
+    private inspectorShown;
+    private meterRequest;
+    private readonly studioIn;
+    private readonly studioOut;
+    private hotDone;
+    private readonly hosted;
+    private readonly known;
+    private readonly clips;
+    constructor(options: WebHostOptions);
+    private engineHeap;
+    private deviceRefusal;
+    start(): Promise<void>;
+    private holdsPart;
+    /**
+     * Copies the runtime wasm the guest fetched itself into the shared part store once the start-time
+     * chunks are in, so the next game on this device reads it from the store instead of the network.
+     * Skipped on a metered or data-saver link, where the copy would cost the player a second download.
+     */
+    private keepRuntimes;
+    private deliver;
+    private supply;
+    private stepWhenSettled;
+    private streamChunks;
+    private awaitReady;
+    private boot;
+    get studio(): boolean;
+    sendStudio(message: StudioOutgoing): boolean;
+    private studioReport;
+    get inspector(): boolean;
+    get meters(): MeterRequest;
+    setMeters(request: MeterRequest): void;
+    setInspector(shown: boolean): void;
+    private sendInspector;
+    get network(): NetworkHint | null;
+    setNetwork(hint: NetworkHint): void;
+    private fetchChunks;
+    private sendChunk;
+    private armWatchdog;
+    private disarmWatchdog;
+    private tick;
+    private pong;
+    private fromGuest;
+    private fromSession;
+    private openReplay;
+    get clipsEnabled(): boolean;
+    /** Saves the host's rolling window (the last 15 s by default) and uploads it, or says why it could not. */
+    saveClip(keep_ms?: number): Promise<ClipOutcome>;
+    /** Asks the player, in host chrome, whether clips may include the camera while it is on. */
+    askClipCamera(): Promise<boolean>;
+    /** Posts a saved clip as a Flick through the session, as the game's own `social.post` would. */
+    postClip(media: MediaRef, score?: number | null): Promise<SocialPostResult | null>;
+    shareClip(media: MediaRef): Promise<ShareResult | null>;
+    private command;
+    grantConsents(granted: readonly ConsentKind[]): void;
+    private evicted;
+    dispatch(event: UiEvent): void;
+    lifecycle(name: LifecycleName): void;
+    dispose(): void;
+    hotSwap(chunks: readonly PackageChunkRef[]): Promise<HotSwapResult>;
+    private finishHot;
+    restart(): Promise<void>;
+    private fail;
+    private teardown;
+}
+
+export { type AdOutcome as $, memoryMeter as A, type BatchPackage as B, type Calibration as C, type DeviceRun as D, metersRequested as E, type FrameMeter as F, GPU_SAMPLE_FRAMES as G, type HostDeviceTier as H, passCauses as I, rankCauses as J, requestMeters as K, type LiveMeters as L, type MeterCause as M, smoothVerdict as N, type GuestEngineFactory as O, type PackageForm as P, QUALITY_FOR_TIER as Q, type RegistryClient as R, SOME_SHARE as S, type CtxTransport as T, UNCALIBRATED_SCALE as U, type SessionHello as V, ALTERNATIVE_RUNTIMES as W, type AdCreative as X, type AdDecisionBody as Y, ZoneSpans as Z, type AdFormat as _, type PackageChannel as a, type SpendPrompt as a$, type BlockPlan as a0, CLIP_CAMERA as a1, CONSENT_KINDS as a2, type ChromeSheet as a3, type ClipArm as a4, type ClipChoice as a5, type ClipConsent as a6, type ClipMediaKind as a7, type ClipOutcome as a8, ClipRelay as a9, type HostLimits as aA, HostMediator as aB, type HostPhase as aC, type KeyValueStore as aD, type MediatorOutlet as aE, type OpenedReplay as aF, type PackageIndexRef as aG, type PackageRef as aH, type PlacementCompletion as aI, type PlacementState as aJ, REPLAY_MEDIA_TYPE as aK, RegistryError as aL, type RepairDecoder as aM, type RepairFileRef as aN, type RepairMember as aO, type RepairOutcome as aP, type RepairSource as aQ, type ReportFiling as aR, type RuntimeImage as aS, RuntimePool as aT, type RuntimeTag as aU, type SavedClip as aV, type ServedAd as aW, type SessionClose as aX, type SessionConsent as aY, type SpendConfirmation as aZ, type SpendDecision as a_, type ClipReply as aa, type ClipUpload as ab, type Completion as ac, type ConsentState as ad, ConsentStore as ae, DEFAULT_CLIP_ARM as af, DEFAULT_HOST_LIMITS as ag, DEFAULT_WARM_BOOT_MS as ah, ENGINE_GROUP_PREFIX as ai, ENGINE_HEAP_CEILING_BYTES as aj, ENGINE_HEAP_HEADROOM as ak, type EngineHeapDeclaration as al, type EngineHeapTier as am, GPU_REQUIREMENT_NAMES as an, type GpuLimits as ao, type GpuRequirementName as ap, type GpuRequirements as aq, type GuestClips as ar, type GuestEngine as as, GuestPool as at, type HostCallOperation as au, HostChromeController as av, type HostChromeOptions as aw, HostClips as ax, type HostFault as ay, HostFaultError as az, type PackageChunkRef as b, type SwapBuild as b0, type TrackingConsent as b1, TreeStore as b2, type WarmGuest as b3, WebHost as b4, type WebHostClipOptions as b5, type WebHostOptions as b6, type ZoneChunkRef as b7, type ZoneFileRef as b8, type ZoneSpan as b9, browserStore as ba, cdnRepairs as bb, chunksForHost as bc, completeZone as bd, declareEngineHeap as be, deviceGpuLimits as bf, engineHeapFor as bg, hostThreads as bh, httpRegistry as bi, manifestGpuRequirements as bj, memoryStore as bk, planZone as bl, rangedChunks as bm, repairDecoder as bn, runtimeImage as bo, swapInPlace as bp, swappable as bq, unmetGpuRequirement as br, workerEngines as bs, type MemoryMeter as c, type HeatMeter as d, type CauseAmount as e, type CostEntry as f, FRAME_WINDOW as g, FrameRecorder as h, GameMeters as i, type HeatVerdict as j, MAX_CAUSES as k, MAX_MOMENTS as l, METERS_OFF as m, METER_REPORT_FRAMES as n, MOST_SHARE as o, MemoryPeak as p, type MemorySample as q, type MemoryVerdict as r, type MeterRequest as s, PASS_LABELS as t, type SmoothVerdict as u, amountOf as v, calibrationFor as w, fitCalibration as x, heatVerdict as y, isCalibrated as z };