@cimplify/sdk 0.108.0 → 0.110.2

package/dist/game-fgQy2YIm.d.ts

@@ -0,0 +1,1451 @@
+import { D as DespawnListener, W as World, T as Transforms, E as Entity, e as Physics, N as Nav, f as PhysicsOptions, S as SoftBodies, g as SoftBodyShape, h as SoftBodyOptions, i as SoftBody, b as TableSchema, j as EntityTableOptions, a as EntityTable } from './world-PvILHDR1.js';
+import { aw as Quat, F as FrameTime, V as Vec3, ax as AiPort, ay as AiWorldOptions, az as ArchetypeDecl, f as Vec3Like, aA as ChemistryEngine, aB as ReactivePort, ag as MediumDesc, ah as MediumVolume, aC as SmokePort, aD as StoryPort, a1 as EmitterId, aE as DestructionPort, aj as ModelInfo, aF as StructureDesc, G as GameBackend, a as FixedStepLoop, aG as LoopOptions, r as GameSurface, aH as FractureMesh, aI as FractureOptions } from './backend-gUCzs5Kg.js';
+import { A as Audio } from './audio-m0w8cnxq.js';
+import { a as RoomClientOptions, R as RoomClient } from './client-Dytx_ZTC.js';
+import { c as FluidGridDesc, d as FluidDesc, e as FluidEmitterDesc, b as Graphics, S as SceneManager, f as GamePrefetch, P as PrefetchAssets, g as Fluid, C as Cloths, h as ClothShape, i as ClothOptions, j as ClothSheet, G as GameScene, a as GameSystem, k as GameReload, R as ReloadReport } from './fluid-ARr0qUIL.js';
+
+declare const Ease: {
+    readonly Linear: 0;
+    readonly InQuad: 1;
+    readonly OutQuad: 2;
+    readonly InOutQuad: 3;
+    readonly InCubic: 4;
+    readonly OutCubic: 5;
+    readonly InOutCubic: 6;
+    readonly OutBack: 7;
+    readonly OutElastic: 8;
+    readonly OutBounce: 9;
+    readonly InSine: 10;
+    readonly OutSine: 11;
+    readonly InOutSine: 12;
+    readonly OutExpo: 13;
+};
+type EaseId = (typeof Ease)[keyof typeof Ease];
+declare function ease(id: number, t: number): number;
+declare function easeInPlace(id: number, registers: Float64Array, slot: number): void;
+
+declare const tweenBrand: unique symbol;
+declare const valueBrand: unique symbol;
+declare const clipPlayerBrand: unique symbol;
+type TweenId = number & {
+    readonly [tweenBrand]: true;
+};
+type ValueSlot = number & {
+    readonly [valueBrand]: true;
+};
+type ClipPlayerId = number & {
+    readonly [clipPlayerBrand]: true;
+};
+declare const TweenTarget: {
+    readonly PositionX: 0;
+    readonly PositionY: 1;
+    readonly PositionZ: 2;
+    readonly ScaleX: 3;
+    readonly ScaleY: 4;
+    readonly ScaleZ: 5;
+    readonly ScaleUniform: 6;
+    readonly Rotation: 7;
+    readonly Value: 8;
+};
+type TweenTargetId = (typeof TweenTarget)[keyof typeof TweenTarget];
+declare const Repeat: {
+    readonly Once: 0;
+    readonly Loop: 1;
+    readonly PingPong: 2;
+};
+type RepeatMode = (typeof Repeat)[keyof typeof Repeat];
+interface ClipTrack {
+    readonly target: TweenTargetId;
+    readonly times: Float32Array;
+    readonly values: Float32Array;
+}
+interface ClipDesc {
+    readonly duration: number;
+    readonly tracks: readonly ClipTrack[];
+}
+interface AnimationOptions {
+    readonly maxTweens?: number;
+    readonly maxClipPlayers?: number;
+    readonly maxValueSlots?: number;
+}
+declare class Clip {
+    readonly duration: number;
+    readonly tracks: readonly ClipTrack[];
+    constructor(desc: ClipDesc);
+}
+declare class Animation implements DespawnListener {
+    private readonly transforms;
+    private readonly tweenCapacity;
+    private readonly tweenActive;
+    private readonly tweenGeneration;
+    private readonly tweenTarget;
+    private readonly tweenEase;
+    private readonly tweenRepeat;
+    private readonly tweenEntity;
+    private readonly tweenSlot;
+    private readonly tweenFrom;
+    private readonly tweenTo;
+    private readonly tweenDuration;
+    private readonly tweenElapsed;
+    private readonly tweenDelay;
+    private readonly tweenFree;
+    private tweenFreeCount;
+    private tweenHigh;
+    private readonly values;
+    private valueCount;
+    private readonly clips;
+    private readonly clipEntity;
+    private readonly clipTime;
+    private readonly clipSpeed;
+    private readonly clipRepeat;
+    private readonly registers;
+    constructor(world: World, transforms: Transforms, options?: AnimationOptions);
+    createValue(initial?: number): ValueSlot;
+    value(slot: ValueSlot): number;
+    setValue(slot: ValueSlot, value: number): void;
+    tween(entity: Entity, target: TweenTargetId, to: number, durationSeconds: number, easing: EaseId, delaySeconds?: number, repeat?: RepeatMode): TweenId;
+    tweenValue(slot: ValueSlot, to: number, durationSeconds: number, easing: EaseId, delaySeconds?: number, repeat?: RepeatMode): TweenId;
+    tweenRotation(entity: Entity, to: Quat, durationSeconds: number, easing: EaseId, delaySeconds?: number, repeat?: RepeatMode): TweenId;
+    isActive(id: TweenId): boolean;
+    cancel(id: TweenId): void;
+    playClip(entity: Entity, clip: Clip, repeat?: RepeatMode, speed?: number): ClipPlayerId;
+    stopClip(player: ClipPlayerId): void;
+    isClipPlaying(player: ClipPlayerId): boolean;
+    onDespawn(entity: Entity): void;
+    update(time: FrameTime): void;
+    private handle;
+    private allocTween;
+    private releaseTween;
+    private advanceTween;
+    private applyTween;
+    private advanceClip;
+    private sampleTrack;
+    private loadScalar;
+    private writeScalar;
+}
+
+declare const actionBrand: unique symbol;
+type ActionId = number & {
+    readonly [actionBrand]: true;
+};
+type ButtonBinding = {
+    readonly device: "key";
+    readonly code: string;
+} | {
+    readonly device: "pointer";
+} | {
+    readonly device: "gamepad";
+    readonly button: number;
+    readonly threshold?: number;
+} | {
+    readonly device: "virtual";
+    readonly control: string;
+};
+type AxisBinding = {
+    readonly device: "keys";
+    readonly negative: string;
+    readonly positive: string;
+} | {
+    readonly device: "gamepad";
+    readonly axis: number;
+    readonly deadzone?: number;
+    readonly invert?: boolean;
+} | {
+    readonly device: "virtual";
+    readonly control: string;
+    readonly invert?: boolean;
+};
+type PointerPhase = "down" | "move" | "up";
+interface PointerFilter {
+    filterPointer(phase: PointerPhase, id: number, stage: Float64Array): boolean;
+}
+interface GestureOptions {
+    swipeMinDistance?: number;
+    swipeMaxDurationMs?: number;
+    longPressMs?: number;
+}
+declare const RECORDED_EVENT_BYTES = 32;
+type DrainSource = "touch" | "key" | "tilt";
+/** What kind of input a recorded drain carries, by its first event. */
+declare function drainSource(events: Uint8Array, count: number): DrainSource;
+/** Hears every drain of the input queue: the frame's time and the events it applied, packed 32 bytes each. */
+interface InputTap {
+    drained(nowMs: number, events: Uint8Array, count: number): void;
+}
+declare const InputDevice: {
+    readonly none: 0;
+    readonly keyboard: 1;
+    readonly pointer: 2;
+    readonly gamepad: 3;
+};
+type InputDeviceId = (typeof InputDevice)[keyof typeof InputDevice];
+declare const STAGE_X = 0;
+declare const STAGE_Y = 1;
+declare const STAGE_Z = 2;
+declare const STAGE_TIME = 3;
+declare class SwipeGesture {
+    ready: boolean;
+    startX: number;
+    startY: number;
+    endX: number;
+    endY: number;
+    deltaX: number;
+    deltaY: number;
+    distance: number;
+    durationMs: number;
+    velocityX: number;
+    velocityY: number;
+    curl: number;
+}
+declare class TapGesture {
+    ready: boolean;
+    x: number;
+    y: number;
+}
+declare class PointerState {
+    active: boolean;
+    down: boolean;
+    x: number;
+    y: number;
+    buttons: number;
+    count: number;
+}
+declare class PinchGesture {
+    active: boolean;
+    scale: number;
+    totalScale: number;
+    centerX: number;
+    centerY: number;
+    panX: number;
+    panY: number;
+    rotation: number;
+    distance: number;
+}
+declare class WheelState {
+    deltaX: number;
+    deltaY: number;
+    deltaZ: number;
+    x: number;
+    y: number;
+}
+declare class PointerDelta {
+    x: number;
+    y: number;
+}
+declare class FrameInput {
+    readonly drag: PointerDelta;
+    readonly motion: PointerDelta;
+    readonly wheel: WheelState;
+    readonly pinch: PinchGesture;
+    pressed: boolean;
+    released: boolean;
+    releasedButtons: number;
+    pressX: number;
+    pressY: number;
+    dragging(pointer: PointerState): boolean;
+    dragButtons(pointer: PointerState): number;
+    begin(): void;
+}
+declare class LongPressGesture {
+    ready: boolean;
+    x: number;
+    y: number;
+    durationMs: number;
+}
+declare class OrientationState {
+    available: boolean;
+    alpha: number;
+    beta: number;
+    gamma: number;
+}
+declare class InputActions {
+    readonly swipe: SwipeGesture;
+    readonly tap: TapGesture;
+    readonly pointer: PointerState;
+    readonly pinch: PinchGesture;
+    readonly wheel: WheelState;
+    readonly drag: PointerDelta;
+    readonly motion: PointerDelta;
+    readonly look: PointerDelta;
+    readonly frame: FrameInput;
+    readonly longPress: LongPressGesture;
+    readonly orientation: OrientationState;
+    private readonly pendingSwipe;
+    private readonly pendingTap;
+    private readonly pendingPinch;
+    private readonly pendingWheel;
+    private readonly pendingDrag;
+    private readonly pendingMotion;
+    private readonly pendingLongPress;
+    private readonly swipeMinDistance;
+    private readonly swipeMaxDurationMs;
+    private readonly longPressMs;
+    private readonly pointerX;
+    private readonly pointerY;
+    private readonly pointerButtons;
+    private readonly pointerOrder;
+    private pointerSerial;
+    private pinchA;
+    private pinchB;
+    private pinchDistance;
+    private pinchAngle;
+    private pinchCenterX;
+    private pinchCenterY;
+    private multiTouch;
+    private longPressFired;
+    private longPressMoved;
+    private lastEventTime;
+    private lastDevice;
+    private lastDeviceTime;
+    private frameNow;
+    private pointerFilter;
+    readonly stage: Float64Array<ArrayBuffer>;
+    private readonly pointerStage;
+    private readonly actionNames;
+    private actionCount;
+    private readonly actionKind;
+    private readonly actionValue;
+    private readonly bindingOut;
+    private readonly actionDown;
+    private readonly pressedLatch;
+    private readonly releasedLatch;
+    private readonly justPressedStep;
+    private readonly justReleasedStep;
+    private bindingCount;
+    private readonly bindAction;
+    private readonly bindKind;
+    private readonly bindA;
+    private readonly bindB;
+    private readonly bindParam;
+    private readonly bindInvert;
+    private readonly keySlots;
+    private readonly keyDown;
+    private readonly virtualSlots;
+    private readonly virtualValue;
+    private readonly virtualButtons;
+    private readonly gamepadButtons;
+    private readonly gamepadAxes;
+    private readonly pointerIds;
+    private primaryPointer;
+    private pointerDownCount;
+    private gestureStartX;
+    private gestureStartY;
+    private gestureStartTime;
+    private readonly sampleX;
+    private readonly sampleY;
+    private sampleCount;
+    private readonly eventType;
+    private readonly eventA;
+    private readonly eventX;
+    private readonly eventY;
+    private readonly eventZ;
+    private readonly eventTime;
+    private eventHead;
+    private eventCount;
+    private droppedEvents;
+    private unlockListener;
+    private inputTap;
+    private tapBytes;
+    private tapView;
+    private replayView;
+    constructor(options?: GestureOptions);
+    pointerCount(): number;
+    pointerAt(index: number, out: Float32Array | Float64Array, offset?: number): boolean;
+    get dropped(): number;
+    onFirstGesture(listener: () => void): void;
+    defineButton(name: string, bindings: readonly ButtonBinding[]): ActionId;
+    defineAxis(name: string, bindings: readonly AxisBinding[]): ActionId;
+    hasAction(name: string): boolean;
+    axisAction(name: string, negative: readonly string[], positive: readonly string[]): ActionId;
+    action(name: string): ActionId;
+    pressed(action: ActionId): boolean;
+    justPressed(action: ActionId): boolean;
+    justReleased(action: ActionId): boolean;
+    value(action: ActionId): number;
+    valueInto(action: ActionId, out: Float32Array | Float64Array, index: number): void;
+    keyEvent(code: string, down: boolean, timeMs: number): void;
+    pointerStaged(phase: PointerPhase, id: number, buttons?: number): void;
+    setPointerFilter(filter: PointerFilter | null): void;
+    pointerEvent(phase: PointerPhase, id: number, x: number, y: number, timeMs: number, buttons?: number): void;
+    wheelEvent(deltaX: number, deltaY: number, deltaZ: number, x: number, y: number, timeMs: number): void;
+    motionEvent(movementX: number, movementY: number, timeMs: number): void;
+    orientationEvent(alpha: number, beta: number, gamma: number, timeMs: number): void;
+    gamepadButtonEvent(button: number, value: number, timeMs: number): void;
+    gamepadAxisEvent(axis: number, value: number, timeMs: number): void;
+    virtualEvent(control: string, value: number, timeMs: number): void;
+    virtualControl(control: string): number;
+    virtualSlotEvent(slot: number, value: number, timeMs: number): void;
+    virtualStaged(slot: number): void;
+    lookEvent(dx: number, dy: number, timeMs: number): void;
+    lookStaged(): void;
+    deviceStaged(device: InputDeviceId): void;
+    deviceEvent(device: InputDeviceId, timeMs: number): void;
+    get device(): InputDeviceId;
+    get deviceTimeMs(): number;
+    processEvents(nowMs?: number): void;
+    processEventsFrom(clock: Float64Array, slot: number): void;
+    /** Starts or stops hearing every drain, for recording a play; preallocates the packing buffer once. */
+    setTap(tap: InputTap | null): void;
+    /** Applies a recorded drain exactly as it first happened: its events in order, then the drain at its frame time. */
+    replay(nowMs: number, events: Uint8Array | null, count: number): void;
+    private record;
+    private drain;
+    beginStep(): void;
+    private trackPinch;
+    private detectLongPress;
+    private defineAction;
+    private bind;
+    private keySlot;
+    private virtualSlot;
+    private checkIndex;
+    private pushStaged;
+    private push;
+    private apply;
+    private latchVirtual;
+    private firstGesture;
+    private latchSlot;
+    private pointerDown;
+    private pointerMove;
+    private pointerUp;
+    private addDrag;
+    private pointerSlot;
+    private recordSample;
+    private recognize;
+    private curlInto;
+    private evaluate;
+    private bindingValue;
+}
+
+interface ScratchCapacity {
+    vec3?: number;
+    quat?: number;
+    mat4?: number;
+}
+declare class ScratchArena {
+    private readonly vec3s;
+    private readonly quats;
+    private readonly mat4s;
+    private readonly mat4Capacity;
+    private vec3Used;
+    private quatUsed;
+    private mat4Used;
+    constructor(capacity?: ScratchCapacity);
+    vec3(x?: number, y?: number, z?: number): Vec3;
+    quat(): Quat;
+    mat4(): number;
+    get matrices(): Float32Array;
+    reset(): void;
+}
+
+interface AgentSpawn {
+    readonly entity: number;
+    readonly team?: number;
+    readonly position?: readonly [number, number, number];
+    readonly forward?: readonly [number, number];
+    readonly skill?: number;
+    readonly threat?: number;
+}
+interface TargetSpawn {
+    readonly entity: number;
+    readonly team: number;
+    readonly position: readonly [number, number, number];
+    readonly threat?: number;
+}
+interface SmartObjectSpawn {
+    readonly kind: number;
+    readonly position: readonly [number, number, number];
+    readonly advertisements: readonly (readonly [need: number, amount: number])[];
+    readonly capacity: number;
+    readonly useMinutes: number;
+    readonly interactRadius: number;
+}
+interface ArchetypeHandle {
+    readonly id: number;
+    readonly decl: ArchetypeDecl;
+}
+declare class GameAi {
+    private readonly port;
+    private readonly exports;
+    private handle;
+    private capacity;
+    private buffer;
+    private registerWords;
+    private registerFloats;
+    private viewWords;
+    private viewFloats;
+    private slotFloats;
+    private eventBuffer;
+    private eventWords;
+    private eventCapacity;
+    private scratch;
+    private scratchBytes;
+    private scratchWords;
+    constructor(port: AiPort);
+    get backend(): string;
+    get ready(): boolean;
+    private check;
+    private require;
+    private refresh;
+    private scratchFor;
+    init(options: AiWorldOptions): void;
+    dispose(): void;
+    archetype(decl: ArchetypeDecl): ArchetypeHandle;
+    action(archetype: ArchetypeHandle, name: string): number;
+    private registers;
+    private writePosition;
+    spawn(archetype: ArchetypeHandle, init: AgentSpawn): number;
+    despawn(agent: number): void;
+    addTarget(init: TargetSpawn): number;
+    removeTarget(target: number): void;
+    moveTarget(target: number, x: number, y: number, z: number, vx: number, vz: number): void;
+    setThreat(target: number, threat: number): void;
+    targetOf(agent: number): number;
+    noise(x: number, y: number, z: number, radius: number, kind: number, source?: number): void;
+    setGoal(agent: number, x: number, y: number, z: number): void;
+    clearGoal(agent: number): void;
+    setFocus(agent: number, target?: number, omniscient?: boolean): void;
+    setSkill(agent: number, skill: number): void;
+    setNeed(agent: number, need: number, level: number): void;
+    setSpeedScale(agent: number, scale: number): void;
+    place(agent: number, x: number, y: number, z: number, vx: number, vz: number): void;
+    slot(slot: number): Float32Array;
+    setInput(agent: number, slot: number, value: number): void;
+    step(): void;
+    private viewAt;
+    x(agent: number): number;
+    y(agent: number): number;
+    z(agent: number): number;
+    vx(agent: number): number;
+    vz(agent: number): number;
+    forwardX(agent: number): number;
+    forwardZ(agent: number): number;
+    actionOf(agent: number): number;
+    phaseOf(agent: number): number;
+    focusOf(agent: number): number;
+    drainEvents(out: Uint32Array): number;
+    doing(archetype: ArchetypeHandle, action: number, out: Uint32Array): number;
+    aimNoise(agent: number, salt: number): number;
+    digest(out: Uint32Array): void;
+    squad(slots: readonly (readonly [right: number, forward: number])[]): number;
+    join(agent: number, squad: number): void;
+    leave(agent: number): void;
+    addObject(object: SmartObjectSpawn): number;
+    removeObject(object: number): void;
+    addCover(x: number, y: number, z: number): number;
+    removeCover(cover: number): void;
+}
+
+type WireScalar = "bool" | "u8" | "u16" | "u32" | "i8" | "i16" | "i32" | "f32" | "f64";
+interface QuantizedField {
+    readonly kind: "quantized";
+    readonly min: number;
+    readonly max: number;
+    readonly bits: number;
+}
+type WireField = WireScalar | QuantizedField;
+type MessageSchema = Readonly<Record<string, WireField>>;
+declare class MessageType {
+    readonly id: number;
+    readonly name: string;
+    readonly bytes: number;
+    private readonly names;
+    readonly fieldKind: Uint8Array;
+    readonly fieldBits: Uint8Array;
+    readonly fieldOffset: Uint32Array;
+    readonly fieldMin: Float64Array;
+    readonly fieldScale: Float64Array;
+    readonly fieldMax: Float64Array;
+    constructor(id: number, name: string, schema: MessageSchema);
+    field(name: string): number;
+}
+declare class MessageWriter {
+    readonly buffer: Uint8Array;
+    private type;
+    constructor(capacity?: number);
+    get length(): number;
+    get messageType(): MessageType | null;
+    begin(type: MessageType): this;
+    set(field: number, value: number): this;
+    setFrom(field: number, source: Float32Array | Float64Array, index: number): this;
+    setBool(field: number, value: boolean): this;
+    setVec3(fieldX: number, fieldY: number, fieldZ: number, value: Vec3Like): this;
+    private encode;
+}
+declare class MessageReader {
+    private bytes;
+    private base;
+    private size;
+    private type;
+    private readonly types;
+    constructor(types: (MessageType | null)[]);
+    get messageType(): MessageType | null;
+    get length(): number;
+    bind(bytes: Uint8Array, base: number, length: number): boolean;
+    is(type: MessageType): boolean;
+    get(field: number): number;
+    getInto(field: number, out: Float32Array | Float64Array, index: number): void;
+    getBool(field: number): boolean;
+    getVec3(fieldX: number, fieldY: number, fieldZ: number, out: Vec3Like): Vec3Like;
+    private decode;
+}
+declare function quantized(min: number, max: number, bits: number): QuantizedField;
+
+type Delivery = "reliable" | "latest";
+interface RoomTransport {
+    readonly participant: number;
+    open(channel: string, delivery: Delivery): number;
+    send(channel: number, bytes: Uint8Array, length: number): void;
+    receive(channel: number, reader: MessageReader): boolean;
+    close(): void;
+}
+declare class Channel {
+    readonly name: string;
+    readonly delivery: Delivery;
+    private readonly transport;
+    private readonly id;
+    constructor(transport: RoomTransport, name: string, delivery: Delivery);
+    send(writer: MessageWriter): void;
+    receive(reader: MessageReader): boolean;
+}
+declare class GameNet {
+    private readonly types;
+    private typeCount;
+    private transport;
+    private joinedRoom;
+    joinRoom(options: RoomClientOptions, nowMs: number): RoomClient;
+    get room(): RoomClient | null;
+    defineMessage(name: string, schema: MessageSchema): MessageType;
+    reader(): MessageReader;
+    connect(transport: RoomTransport): void;
+    get connected(): boolean;
+    get participant(): number;
+    channel(name: string, delivery: Delivery): Channel;
+    disconnect(): void;
+    private requireTransport;
+}
+interface LoopbackOptions {
+    readonly slots?: number;
+    readonly slotBytes?: number;
+}
+declare class LoopbackTransport implements RoomTransport {
+    readonly participant: number;
+    private peer;
+    private readonly names;
+    private readonly queues;
+    private readonly slots;
+    private readonly slotBytes;
+    private constructor();
+    static pair(options?: LoopbackOptions): readonly [LoopbackTransport, LoopbackTransport];
+    open(channel: string, delivery: Delivery): number;
+    send(channel: number, bytes: Uint8Array, length: number): void;
+    receive(channel: number, reader: MessageReader): boolean;
+    dropped(channel: number): number;
+    close(): void;
+}
+declare class SnapshotBuffer {
+    readonly entities: number;
+    readonly history: number;
+    private readonly ticks;
+    private readonly positions;
+    private readonly rotations;
+    private readonly heads;
+    private readonly counts;
+    private readonly weight;
+    constructor(entities: number, history?: number);
+    push(slot: number, tick: number, positions: Float32Array, po: number, rotations: Float32Array, ro: number): void;
+    sample(slot: number, tick: number, outPosition: Float32Array, positionOffset: number, outRotation: Float32Array, rotationOffset: number): boolean;
+}
+
+declare class SeededRandom {
+    private readonly state;
+    private readonly output;
+    private readonly words;
+    private readonly drawn;
+    private readonly limbs;
+    private readonly cell;
+    private readonly halves;
+    private readonly views;
+    constructor(seed: number);
+    rollbackViews(): readonly ArrayBufferView[];
+    get seed(): number;
+    reseed(seed: number): void;
+    nextUint32(): number;
+    float(): number;
+    range(min: number, max: number): number;
+    rangeInto(out: Float64Array, slot: number, min: number, max: number): void;
+    int(min: number, maxInclusive: number): number;
+    chance(probability: number): boolean;
+    centeredInto(out: Float64Array, slot: number, halfExtent: number, fixed: Int32Array, fixedAt: number): void;
+    private advance;
+    saveState(out: Uint32Array): void;
+    restoreState(source: Uint32Array): void;
+}
+
+declare const CHEMISTRY_REFUSALS: readonly ["unknown_species", "bad_formula", "duplicate_name", "bad_name", "too_many_terms", "bad_count", "element_imbalance", "energy_mismatch", "bad_rate", "bad_window", "property_out_of_range", "book_full", "policy_disabled", "too_energetic", "duplicate_term", "bad_debris", "bad_aqueous", "catalyst_consumed", "no_products", "unreachable", "bad_placement", "bad_batch", "unknown_element", "no_reactants", "overflow", "malformed"];
+type ChemistryRefusal = (typeof CHEMISTRY_REFUSALS)[number];
+declare const CHEMISTRY_REFUSAL_TEXT: Readonly<Record<ChemistryRefusal, string>>;
+declare const CHEMISTRY_GROUPS: readonly ["fuel", "oxidiser", "acid", "base", "metal", "salt", "ore", "oxide", "organic", "aqueous", "powder", "catalyst", "explosive", "inert", "solvent", "carbonate", "polymer", "sugar", "living", "reducer", "toxic", "mineral", "atmosphere", "custom"];
+type ChemistryGroup = (typeof CHEMISTRY_GROUPS)[number];
+declare const CELL_CLASSES: readonly ["empty", "gas", "liquid", "powder", "solid"];
+type CellClass = (typeof CELL_CLASSES)[number];
+declare const CHEMISTRY_EVENT_KINDS: readonly ["none", "reaction", "explosion", "threshold", "phase", "fracture"];
+type ChemistryEventKind = (typeof CHEMISTRY_EVENT_KINDS)[number];
+interface NatureOptions {
+    readonly tickHz?: number;
+    readonly ambientK?: number;
+    readonly pressureAtm?: number;
+    readonly gravity?: number;
+    readonly conduction?: number;
+    readonly rateShift?: number;
+    readonly radiation?: number;
+    readonly atmosphere?: "earth" | "mars";
+}
+type DefineResult = {
+    readonly ok: true;
+    readonly added: number;
+} | {
+    readonly ok: false;
+    readonly line: number;
+    readonly refusal: ChemistryRefusal;
+    readonly reason: string;
+};
+interface MaterialInfo {
+    readonly id: number;
+    readonly name: string;
+    readonly molarMassGrams: number;
+    readonly meltK: number | null;
+    readonly boilK: number | null;
+    readonly ignitionK: number | null;
+    readonly groups: readonly ChemistryGroup[];
+    readonly colours: readonly [number, number, number];
+    readonly density: readonly [number, number];
+    readonly heatCapacity: readonly [number, number, number];
+    readonly volume: number;
+    readonly hardness: number;
+    readonly electrical: number;
+    readonly strengthKpa: number;
+}
+interface ReactionTerm {
+    readonly material: number;
+    readonly count: number;
+}
+interface ReactionInfo {
+    readonly id: number;
+    readonly name: string;
+    readonly reactants: readonly ReactionTerm[];
+    readonly products: readonly ReactionTerm[];
+    readonly catalyst: number | null;
+    readonly minK: number;
+    readonly maxK: number | null;
+    readonly enthalpyJ: number;
+    readonly electricJ: number;
+    readonly generatesJ: number;
+}
+interface CellBox {
+    readonly x0: number;
+    readonly y0: number;
+    readonly z0?: number;
+    readonly x1: number;
+    readonly y1: number;
+    readonly z1?: number;
+}
+interface CellProbe {
+    cls: CellClass;
+    kelvin: number;
+    pressureAtm: number;
+    readonly materials: number[];
+    readonly amounts: number[];
+    heat: number;
+    power: number;
+}
+interface ChemistryEvent {
+    kind: ChemistryEventKind;
+    code: number;
+    cell: number;
+    x: number;
+    y: number;
+    z: number;
+    value: number;
+    extra: number;
+}
+interface RegionStats {
+    tick: number;
+    activeTiles: number;
+    blocks: number;
+    fired: number;
+    moves: number;
+    massMilligrams: number;
+    energyJ: number;
+    events: number;
+    dropped: number;
+    digest: string;
+}
+interface RegionOptions {
+    readonly width: number;
+    readonly height: number;
+    readonly depth?: number;
+    readonly seed?: number;
+    readonly open?: boolean;
+}
+declare class ChemistryMemory {
+    private readonly engine;
+    private buffer;
+    words: Uint32Array<ArrayBufferLike>;
+    ints: Int32Array<ArrayBufferLike>;
+    halves: Uint16Array<ArrayBufferLike>;
+    bytes: Uint8Array<ArrayBufferLike>;
+    constructor(engine: ChemistryEngine);
+    views(): this;
+}
+declare class Chemistry {
+    private readonly engine;
+    private readonly nature;
+    private handle;
+    private scratch;
+    private opened;
+    private memory;
+    private readonly names;
+    private readonly encoder;
+    private readonly decoder;
+    constructor(engine: ChemistryEngine | null, nature?: NatureOptions);
+    get available(): boolean;
+    private ensure;
+    get handleValue(): number;
+    withText<T>(text: string, run: (pointer: number, length: number) => T): T;
+    define(text: string, options?: {
+        readonly proposal?: boolean;
+    }): DefineResult;
+    private find;
+    material(name: string): number;
+    hasMaterial(name: string): boolean;
+    reaction(name: string): number;
+    get counts(): {
+        readonly materials: number;
+        readonly reactions: number;
+    };
+    private text;
+    catalog(): string;
+    materialName(id: number): string;
+    reactionName(id: number): string;
+    materialInfo(id: number): MaterialInfo;
+    reactionInfo(id: number): ReactionInfo;
+    region(options: RegionOptions): ChemistryRegion;
+    loadRegion(bytes: Uint8Array, options?: {
+        readonly seed?: number;
+        readonly open?: boolean;
+    }): ChemistryRegion;
+    vessel(volumeCells?: number, seed?: number): ChemistryVessel;
+    particles(capacity: number, seed?: number): ChemistryParticles;
+    scratchWords(): {
+        readonly words: Uint32Array<ArrayBufferLike>;
+        readonly ints: Int32Array<ArrayBufferLike>;
+        readonly at: number;
+        readonly pointer: number;
+    };
+    views(): ChemistryMemory;
+    dispose(): void;
+}
+declare class ChemistryRegion {
+    private readonly chemistry;
+    private readonly engine;
+    private readonly handle;
+    readonly width: number;
+    readonly height: number;
+    readonly depth: number;
+    readonly cells: number;
+    private readonly columns;
+    private buffer;
+    private speciesViews;
+    private amountViews;
+    private heatView;
+    private tempView;
+    private infoView;
+    private powerView;
+    private colourView;
+    private disposed;
+    private readonly event;
+    private readonly probeOut;
+    constructor(chemistry: Chemistry, engine: ChemistryEngine, handle: number);
+    private live;
+    private refresh;
+    index(x: number, y: number, z?: number): number;
+    species(slot?: number): Uint16Array<ArrayBufferLike>;
+    amounts(slot?: number): Uint16Array<ArrayBufferLike>;
+    get heat(): Int32Array<ArrayBufferLike>;
+    get temperatureQ4(): Int32Array<ArrayBufferLike>;
+    get info(): Uint32Array<ArrayBufferLike>;
+    get power(): Uint32Array<ArrayBufferLike>;
+    kelvinAt(x: number, y: number, z?: number): number;
+    classAt(x: number, y: number, z?: number): CellClass;
+    fill(material: number | "air" | "vacuum", box: CellBox, kelvin?: number): number;
+    paint(material: number | "air" | "vacuum", x: number, y: number, z?: number, kelvin?: number): number;
+    set(x: number, y: number, z: number, contents: readonly (readonly [number, number])[], kelvin: number): void;
+    heatBox(box: CellBox, joules: number): number;
+    powerBox(box: CellBox, joules: number): number;
+    step(ticks?: number): number;
+    colours(): Uint32Array<ArrayBufferLike>;
+    probe(x: number, y: number, z?: number): CellProbe;
+    watchReaction(id: number, on?: boolean): void;
+    watchMaterial(id: number, on?: boolean): void;
+    threshold(box: CellBox, kelvin: number): number;
+    clearThreshold(id: number): void;
+    events(handler: (event: Readonly<ChemistryEvent>) => void): number;
+    fired(reaction: number): number;
+    stats(out?: RegionStats): RegionStats;
+    save(): Uint8Array;
+    dispose(): void;
+}
+interface VesselState {
+    kelvin: number;
+    pressureAtm: number;
+    power: number;
+    generated: number;
+    readonly materials: number[];
+    readonly amounts: number[];
+}
+declare class ChemistryVessel {
+    private readonly chemistry;
+    private readonly engine;
+    private readonly handle;
+    private disposed;
+    private readonly out;
+    constructor(chemistry: Chemistry, engine: ChemistryEngine, handle: number);
+    private live;
+    add(material: number, parcels: number, kelvin?: number): void;
+    take(material: number, parcels: number): number;
+    heat(joules: number): void;
+    power(joules: number): number;
+    step(ticks?: number): number;
+    vent(maxAtm: number): number;
+    state(): VesselState;
+    dispose(): void;
+}
+declare class ChemistryParticles {
+    private readonly chemistry;
+    private readonly engine;
+    private readonly handle;
+    readonly capacity: number;
+    private disposed;
+    private pairs;
+    private pairCapacity;
+    private readonly event;
+    constructor(chemistry: Chemistry, engine: ChemistryEngine, handle: number, capacity: number);
+    private live;
+    spawn(index: number, material: number, kelvin?: number): void;
+    despawn(index: number): void;
+    step(count: number, pairs: Uint32Array, pairCount: number): number;
+    columns(): Uint32Array<ArrayBufferLike>;
+    events(handler: (event: Readonly<ChemistryEvent>) => void): number;
+    dispose(): void;
+}
+declare function groupNames(mask: number): ChemistryGroup[];
+
+declare const hudSlotBrand: unique symbol;
+declare const uiActionBrand: unique symbol;
+type HudSlot = number & {
+    readonly [hudSlotBrand]: true;
+};
+type UiActionId = number & {
+    readonly [uiActionBrand]: true;
+};
+type UiValue = string | number | boolean | null;
+type HapticPattern = "light" | "medium" | "heavy" | "success" | "warning" | "error" | "selection";
+type HudSlotKind = "number" | "text";
+interface HudSlotLayout {
+    readonly name: string;
+    readonly kind: HudSlotKind;
+}
+interface GameUiHost {
+    declareHud(layout: readonly HudSlotLayout[]): void;
+    publishHud(numbers: Float64Array, texts: readonly string[], dirty: Uint16Array, dirtyCount: number): void;
+    showPanel(panel: string, props: Readonly<Record<string, UiValue>>): void;
+    hidePanel(panel: string): void;
+    haptic(pattern: HapticPattern): void;
+}
+declare const NO_UI_ACTION = -1;
+declare class GameUi {
+    private readonly host;
+    private readonly layout;
+    private readonly numbers;
+    private readonly texts;
+    private readonly dirtyFlags;
+    private readonly dirty;
+    private dirtyCount;
+    private declaredSize;
+    private readonly actions;
+    private readonly queue;
+    private queueHead;
+    private queueCount;
+    constructor(host: GameUiHost | null, maxSlots?: number);
+    hudNumber(name: string, initial?: number): HudSlot;
+    hudText(name: string, initial?: string): HudSlot;
+    setNumber(slot: HudSlot, value: number): void;
+    setText(slot: HudSlot, value: string): void;
+    number(slot: HudSlot): number;
+    text(slot: HudSlot): string;
+    show(panel: string, props?: Readonly<Record<string, UiValue>>): void;
+    hide(panel: string): void;
+    haptic(pattern: HapticPattern): void;
+    defineAction(name: string): UiActionId;
+    dispatch(name: string): boolean;
+    pollAction(): UiActionId | typeof NO_UI_ACTION;
+    flush(): void;
+    private declare;
+    private markDirty;
+    private clearDirty;
+}
+
+type ReactiveSpecies = string | number;
+interface ReactiveGrid {
+    readonly origin: Vec3Like;
+    readonly cell: number;
+    readonly cells: readonly [number, number, number];
+}
+interface ReactiveFluidDesc {
+    readonly chemistry?: Chemistry;
+    readonly liquid: ReactiveSpecies;
+    readonly liquidKelvin?: number;
+    readonly parcels?: number;
+    readonly fluid: FluidGridDesc & Partial<Omit<FluidDesc, "bounds" | "capacity" | "cell" | "material" | "look" | "emitters">>;
+    readonly volume: ReactiveGrid;
+    readonly contact?: number;
+    readonly coupling?: number;
+    readonly maxPairs?: number;
+    readonly seed?: number;
+    readonly framesPerTick?: number;
+    readonly smoke?: readonly ReactiveSpecies[];
+    readonly glowFromK?: number;
+    readonly glowFullK?: number;
+    readonly plumeFromK?: number;
+    readonly smokeFullParcels?: number;
+    readonly flameExtinction?: number;
+}
+interface ReactiveHobDesc {
+    readonly first: readonly [number, number];
+    readonly last: readonly [number, number];
+    readonly layers?: number;
+    readonly metal?: ReactiveSpecies;
+    readonly startK?: number;
+    readonly panK: number;
+    readonly panJoules: number;
+    readonly flameK?: number;
+    readonly flameJoules?: number;
+    readonly flameLayers?: number;
+}
+interface ReactivePlume {
+    readonly cell: [number, number, number];
+    kelvin: number;
+    smoke: number;
+    readonly position: {
+        x: number;
+        y: number;
+        z: number;
+    };
+}
+interface ReactiveStats {
+    tick: number;
+    particles: number;
+    pairs: number;
+    droppedPairs: number;
+    fired: number;
+    vented: number;
+    retired: number;
+    panK: number;
+    burning: number;
+    smoky: number;
+    hottestK: number;
+    plumes: number;
+    lit: boolean;
+}
+interface ReactiveMediumLook {
+    readonly emission?: number;
+    readonly extinction?: number;
+    readonly albedo?: readonly [number, number, number];
+}
+declare const REACTIVE_DEFAULTS: {
+    readonly liquidKelvin: 293;
+    readonly parcels: 1;
+    readonly contact: 1;
+    readonly coupling: 4;
+    readonly maxPairs: 65536;
+    readonly seed: 0;
+    readonly framesPerTick: 2;
+    readonly smoke: readonly ["CO2", "H2O"];
+    readonly metal: "Fe";
+    readonly layers: 2;
+    readonly startK: 293;
+    readonly flameK: 1300;
+    readonly flameJoules: 6000;
+    readonly flameLayers: 2;
+    readonly preheatTicks: 1200;
+    readonly emission: 24;
+    readonly extinction: 18;
+    readonly albedo: readonly [0.35, 0.33, 0.31];
+};
+declare function createReactiveStats(): ReactiveStats;
+declare function createReactivePlume(): ReactivePlume;
+declare class ReactiveFluid {
+    private readonly port;
+    private readonly chemistry;
+    private readonly ownsChemistry;
+    readonly framesPerTick: number;
+    readonly cells: readonly [number, number, number];
+    readonly capacity: number;
+    private readonly handle;
+    private readonly volume;
+    private readonly emitterWords;
+    private medium;
+    private frame;
+    private disposed;
+    constructor(port: ReactivePort, chemistry: Chemistry, desc: ReactiveFluidDesc, ownsChemistry?: boolean);
+    private species;
+    private live;
+    hob(desc: ReactiveHobDesc): void;
+    setLit(on: boolean): void;
+    pour(stream: FluidEmitterDesc | null, slot?: number): void;
+    preheat(targetK: number, maxTicks?: number): number;
+    step(seconds: number): boolean;
+    mediumDesc(look?: ReactiveMediumLook): MediumDesc;
+    attach(medium: MediumVolume | null): void;
+    writeMedia(): number;
+    get texels(): Uint32Array;
+    get particles(): number;
+    positions(): Float32Array;
+    get plumeCount(): number;
+    plume(index: number, out: ReactivePlume): boolean;
+    stats(out?: ReactiveStats): ReactiveStats;
+    digest(): bigint;
+    dispose(): void;
+}
+
+interface SmokeVolumeDesc {
+    readonly origin: Vec3Like;
+    readonly cell: number;
+    readonly cells: readonly [number, number, number];
+    readonly medium: MediumVolume;
+    readonly step?: number;
+    readonly ambientKelvin?: number;
+    readonly smokeWeight?: number;
+    readonly lift?: number;
+    readonly vorticity?: number;
+    readonly smokeHalfLife?: number;
+    readonly coolingHalfLife?: number;
+    readonly ignitionKelvin?: number;
+    readonly burnRate?: number;
+    readonly heatRelease?: number;
+    readonly soot?: number;
+    readonly expansion?: number;
+    readonly pressureCycles?: number;
+    readonly smokeFull?: number;
+    readonly glowFromKelvin?: number;
+    readonly glowFullKelvin?: number;
+    readonly flameExtinction?: number;
+}
+interface SmokeEmitter {
+    readonly position: Vec3Like;
+    readonly radius: number;
+    readonly density?: number;
+    readonly heat?: number;
+    readonly fuel?: number;
+    readonly velocity?: Vec3Like;
+    readonly strength?: number;
+    readonly tint?: SmokeTint;
+}
+interface SmokeTint {
+    readonly r: number;
+    readonly g: number;
+    readonly b: number;
+}
+declare class SmokeVolume {
+    private readonly port;
+    private readonly emitterFloats;
+    private readonly handle;
+    private disposed;
+    constructor(port: SmokePort, desc: SmokeVolumeDesc);
+    setEmitters(emitters: readonly SmokeEmitter[]): void;
+    follow(centre: Vec3Like): void;
+    step(seconds: number): number;
+    dispose(): void;
+}
+
+declare const STORY_VARIABLE_TYPES: readonly ["bool", "int", "number", "text"];
+declare const STORY_PERSISTS: readonly ["play", "player", "shared"];
+declare const STORY_INTERACTIONS: readonly ["tap", "hold", "swipe", "gift", "vote"];
+type StoryVariableType = (typeof STORY_VARIABLE_TYPES)[number];
+type StoryPersist = (typeof STORY_PERSISTS)[number];
+type StoryInteraction = (typeof STORY_INTERACTIONS)[number];
+type StoryValue = boolean | number | string;
+declare const STORY_RULE_ACTIONS: readonly ["set", "add", "go", "say", "show", "hide", "emit"];
+type StoryRuleAction = (typeof STORY_RULE_ACTIONS)[number];
+type StoryNodeKind = "variable" | "choice" | "beat" | "scene" | "track" | "actor" | "rule" | "action";
+interface StoryVariable {
+    readonly index: number;
+    readonly name: string;
+    readonly type: StoryVariableType;
+    readonly persist: StoryPersist;
+}
+interface StoryHandlers {
+    entered?(beat: number, scene: number): void;
+    offered?(choice: number): void;
+    taken?(choice: number): void;
+    refused?(choice: number): void;
+    logic?(logic: number, interaction: number): void;
+    key?(track: number, key: number): void;
+    finished?(beat: number): void;
+    rule?(action: number, actor: number, kind: StoryRuleAction): void;
+    persist?(variable: StoryVariable, value: StoryValue): void;
+}
+interface StorySample {
+    track: number;
+    target: number;
+    channel: number;
+    key: number;
+    x: number;
+    y: number;
+    z: number;
+    w: number;
+}
+declare class StoryPlayer {
+    private readonly port;
+    private readonly handlers;
+    readonly variables: readonly StoryVariable[];
+    private readonly byName;
+    private readonly inputs;
+    private pending;
+    private views;
+    private buffer;
+    private readonly handle;
+    private disposed;
+    constructor(port: StoryPort, program: Uint8Array, handlers?: StoryHandlers);
+    private live;
+    private text;
+    private dispatch;
+    private queue;
+    start(): void;
+    step(): void;
+    choose(choice: number): void;
+    interact(kind: StoryInteraction, target?: number): void;
+    gift(name: string): void;
+    seek(tick: number): void;
+    available(choice: number): boolean;
+    label(choice: number): string;
+    beatName(beat: number): string;
+    sceneName(scene: number): string;
+    actorName(actor: number): string;
+    keyText(track: number, key: number): string;
+    ruleName(rule: number): string;
+    actionText(action: number): string;
+    nodeId(kind: StoryNodeKind, index: number): string | null;
+    private variable;
+    get(name: string | number): StoryValue;
+    set(name: string | number, value: StoryValue): void;
+    sample(index: number, out: StorySample): StorySample;
+    get sampleCount(): number;
+    get beat(): number;
+    get scene(): number;
+    get beatTick(): number;
+    get sceneTick(): number;
+    get sceneLength(): number;
+    get tickRate(): number;
+    get started(): boolean;
+    get finished(): boolean;
+    digest(): string;
+    dispose(): void;
+}
+
+declare const FramePhase: {
+    readonly kernels: 0;
+    readonly input: 1;
+    readonly steps: 2;
+    readonly update: 3;
+    readonly transforms: 4;
+    readonly sync: 5;
+    readonly fluids: 6;
+    readonly audio: 7;
+    readonly ui: 8;
+    readonly render: 9;
+};
+type FramePhase = (typeof FramePhase)[keyof typeof FramePhase];
+declare const FRAME_PHASE_NAMES: readonly string[];
+declare class FramePhases {
+    readonly current: Float64Array<ArrayBuffer>;
+    readonly slowest: Float64Array<ArrayBuffer>;
+    private readonly now;
+    private mark;
+    private started;
+    slowestMs: number;
+    slowestSteps: number;
+    steps: number;
+    constructor(now: () => number);
+    begin(): void;
+    lap(phase: FramePhase): void;
+    end(): void;
+    reset(): void;
+    describe(digits?: number): string;
+}
+
+type BreakCause = "damage" | "impact" | "support" | "overflow" | "lifetime" | "stress" | "joint";
+interface BreakEvent {
+    readonly kind: "break" | "retire" | "remove" | "intact_lost" | "bond";
+    readonly fragment: number;
+    readonly cause: BreakCause;
+    readonly x: number;
+    readonly y: number;
+    readonly z: number;
+    readonly speed: number;
+}
+interface DestructibleDesc {
+    readonly fracture: Uint8Array;
+    readonly position?: Vec3Like;
+    readonly rotation?: readonly [number, number, number, number];
+    readonly scale?: number;
+    readonly health?: number;
+    readonly impactThreshold?: number;
+    readonly impactScale?: number;
+    readonly spread?: number;
+    readonly density?: number;
+    readonly friction?: number;
+    readonly restitution?: number;
+    readonly breakSpeed?: number;
+    readonly maxDebris?: number;
+    readonly lifetime?: number;
+    readonly removeRetired?: boolean;
+    readonly support?: boolean;
+    readonly maxBreaksPerStep?: number;
+    /** Broken pieces collide with each other and pile up. Off by default: debris still lands on the world and on intact pieces, and the physics cost of a 500-piece collapse is about a quarter. */
+    readonly debrisCollide?: boolean;
+    readonly collisionGroups?: {
+        readonly membership: number;
+        readonly filter: number;
+    };
+    readonly chips?: {
+        readonly emitter: EmitterId;
+        readonly entity: Entity;
+        readonly perBreak?: number;
+    };
+    readonly onBreak?: (event: BreakEvent) => void;
+}
+declare class Destructible {
+    private readonly port;
+    private readonly world;
+    private readonly transforms;
+    private readonly graphics;
+    private readonly desc;
+    readonly root: Entity;
+    readonly intact: Entity;
+    readonly fragments: readonly Entity[];
+    private readonly event;
+    private chipX;
+    private chipY;
+    private chipZ;
+    private chipCount;
+    private disposed;
+    readonly id: number;
+    constructor(port: DestructionPort, world: World, transforms: Transforms, graphics: Graphics, model: ModelInfo, desc: DestructibleDesc);
+    get attached(): number;
+    damage(point: Vec3Like, radius: number, amount: number): number;
+    configure(structure: StructureDesc): void;
+    handle(words: Uint32Array, floats: Float32Array, at: number): void;
+    flushChips(): void;
+    dispose(): void;
+}
+
+interface GameOptions extends LoopOptions {
+    readonly backend: GameBackend;
+    readonly seed?: number;
+    readonly capacity?: number;
+    readonly surface?: GameSurface | null;
+    readonly ui?: GameUiHost | null;
+    readonly physics?: PhysicsOptions;
+    readonly animation?: AnimationOptions;
+    readonly gestures?: GestureOptions;
+    readonly scratch?: ScratchCapacity;
+    readonly maxVoices?: number;
+    readonly maxHudSlots?: number;
+    readonly nature?: NatureOptions;
+    readonly assets?: PrefetchAssets | null;
+}
+declare class Game {
+    phases: FramePhases | null;
+    readonly backend: GameBackend;
+    readonly world: World;
+    readonly transforms: Transforms;
+    readonly loop: FixedStepLoop;
+    readonly random: SeededRandom;
+    readonly input: InputActions;
+    readonly physics: Physics;
+    readonly nav: Nav;
+    readonly ai: GameAi | null;
+    readonly graphics: Graphics;
+    readonly animation: Animation;
+    readonly audio: Audio;
+    readonly ui: GameUi;
+    readonly net: GameNet;
+    readonly scratch: ScratchArena;
+    readonly scenes: SceneManager<Game>;
+    readonly prefetch: GamePrefetch;
+    readonly clock: Float64Array;
+    private readonly tables;
+    private chemistryApi;
+    private readonly fluids;
+    private destruction;
+    private softBodySystem;
+    private readonly reactives;
+    private readonly smokes;
+    private readonly stories;
+    private clothSystem;
+    private readonly nature;
+    private readonly kernelRunner;
+    private meters;
+    private meterFrames;
+    private stopMeters;
+    private timeline;
+    private stopTimeline;
+    private disposed;
+    constructor(options: GameOptions);
+    private applyMeters;
+    private meter;
+    get chemistry(): Chemistry;
+    get tick(): number;
+    get alpha(): number;
+    get stepSeconds(): number;
+    get frameSeconds(): number;
+    get time(): FrameTime;
+    fluid(desc: FluidDesc): Fluid;
+    get softBodies(): SoftBodies;
+    softBody(shape: SoftBodyShape, options?: SoftBodyOptions): SoftBody;
+    get cloths(): Cloths;
+    cloth(shape: ClothShape, options?: ClothOptions): ClothSheet;
+    reactiveFluid(desc: ReactiveFluidDesc): ReactiveFluid;
+    smokeVolume(desc: SmokeVolumeDesc): SmokeVolume;
+    story(program: Uint8Array, handlers?: StoryHandlers): StoryPlayer;
+    removeStory(story: StoryPlayer): void;
+    removeSmokeVolume(smoke: SmokeVolume): void;
+    removeReactiveFluid(reactive: ReactiveFluid): void;
+    removeFluid(fluid: Fluid): void;
+    destructible(model: ModelInfo, desc: DestructibleDesc): Destructible;
+    breakable(mesh: FractureMesh, options: FractureOptions, desc?: Omit<DestructibleDesc, "fracture">): Promise<Destructible>;
+    removeDestructible(item: Destructible): void;
+    table<const S extends TableSchema>(schema: S, options: EntityTableOptions): EntityTable<S>;
+    addScene(scene: GameScene<Game>): void;
+    addSystem(system: GameSystem<Game>): void;
+    reload(next: GameReload<Game>): ReloadReport;
+    start(scene: string): void;
+    private studio;
+    private timelineGame;
+    private storyValues;
+    private steps;
+    frame(nowMs: number): void;
+    private governorFrames;
+    private sampleGovernor;
+    runFrame(): void;
+    private profiledFrame;
+    advance(steps: number): void;
+    dispose(): void;
+    private fixedStep;
+    private present;
+    private stream;
+}
+declare function createGame(options: GameOptions): Promise<Game>;
+
+export { Clip as $, type ActionId as A, type RegionStats as B, Chemistry as C, type Delivery as D, groupNames as E, type AgentSpawn as F, Game as G, type ArchetypeHandle as H, InputActions as I, GameAi as J, type SmartObjectSpawn as K, type EaseId as L, MessageReader as M, type NatureOptions as N, type InputTap as O, type PointerFilter as P, Animation as Q, type RoomTransport as R, SeededRandom as S, type TargetSpawn as T, type AnimationOptions as U, type VesselState as V, type AxisBinding as W, type BreakCause as X, type BreakEvent as Y, type ButtonBinding as Z, Channel as _, type GameUiHost as a, drainSource as a$, type ClipDesc as a0, type ClipPlayerId as a1, type ClipTrack as a2, Destructible as a3, type DestructibleDesc as a4, type DrainSource as a5, Ease as a6, FRAME_PHASE_NAMES as a7, FrameInput as a8, FramePhase as a9, type ReactiveMediumLook as aA, type ReactivePlume as aB, type ReactiveSpecies as aC, type ReactiveStats as aD, Repeat as aE, type RepeatMode as aF, STAGE_TIME as aG, STAGE_X as aH, STAGE_Y as aI, STAGE_Z as aJ, ScratchArena as aK, type ScratchCapacity as aL, SnapshotBuffer as aM, SwipeGesture as aN, TapGesture as aO, type TweenId as aP, TweenTarget as aQ, type TweenTargetId as aR, type UiActionId as aS, type UiValue as aT, type ValueSlot as aU, WheelState as aV, type WireField as aW, type WireScalar as aX, createGame as aY, createReactivePlume as aZ, createReactiveStats as a_, FramePhases as aa, type GameOptions as ab, type GestureOptions as ac, type HapticPattern as ad, type HudSlot as ae, type HudSlotKind as af, type HudSlotLayout as ag, InputDevice as ah, type InputDeviceId as ai, LongPressGesture as aj, type LoopbackOptions as ak, LoopbackTransport as al, type MessageSchema as am, MessageWriter as an, NO_UI_ACTION as ao, OrientationState as ap, PinchGesture as aq, PointerDelta as ar, PointerState as as, type QuantizedField as at, REACTIVE_DEFAULTS as au, RECORDED_EVENT_BYTES as av, ReactiveFluid as aw, type ReactiveFluidDesc as ax, type ReactiveGrid as ay, type ReactiveHobDesc as az, type DefineResult as b, ease as b0, easeInPlace as b1, quantized as b2, type PointerPhase as c, MessageType as d, GameNet as e, GameUi as f, ChemistryRegion as g, type ChemistryEvent as h, CELL_CLASSES as i, CHEMISTRY_EVENT_KINDS as j, CHEMISTRY_GROUPS as k, CHEMISTRY_REFUSALS as l, CHEMISTRY_REFUSAL_TEXT as m, type CellBox as n, type CellClass as o, type CellProbe as p, type ChemistryEventKind as q, type ChemistryGroup as r, ChemistryMemory as s, ChemistryParticles as t, type ChemistryRefusal as u, ChemistryVessel as v, type MaterialInfo as w, type ReactionInfo as x, type ReactionTerm as y, type RegionOptions as z };