@cimplify/sdk 0.108.0 → 0.110.2

package/dist/backend-gUCzs5Kg.d.mts

@@ -0,0 +1,3866 @@
+interface AudioCapabilities {
+    readonly spatial: boolean;
+    readonly filters: boolean;
+    readonly meters: boolean;
+    readonly analyser: boolean;
+    readonly reverb: boolean;
+    readonly sends: boolean;
+    readonly loopPoints: boolean;
+    readonly streaming: boolean;
+    readonly detune: boolean;
+    readonly procedural: boolean;
+    readonly emitters?: boolean;
+    readonly lockstep?: boolean;
+    readonly voiceLimits?: boolean;
+    readonly voiceFilters?: boolean;
+    readonly limiter?: boolean;
+    readonly scheduling?: boolean;
+    readonly music?: boolean;
+    readonly binaural?: boolean;
+    readonly occlusion?: boolean;
+}
+interface OcclusionDesc {
+    readonly radius?: number;
+    readonly occludedGain?: number;
+    readonly occludedCutoff?: number;
+    readonly smoothingSeconds?: number;
+}
+type MusicQuantize = "now" | "beat" | "bar" | {
+    readonly bars: number;
+};
+interface LimiterDesc {
+    readonly ceilingDb?: number;
+    readonly releaseSeconds?: number;
+}
+declare const STEAL_POLICIES: readonly ["oldest", "quietest", "refuse"];
+type StealPolicy = (typeof STEAL_POLICIES)[number];
+interface SoundLimitDesc {
+    readonly voices: number;
+    readonly steal?: StealPolicy;
+}
+/**
+ * A sound's boot preview: mono, 22.05 kHz AAC-LC at about 24 kbps, catalogued beside the sound at its path plus this
+ * suffix. The publish step makes it for large sounds in a before-play group and moves the full file after start; hosts
+ * play the preview until the full file arrives.
+ */
+declare const AUDIO_PREVIEW_SUFFIX = ".preview.m4a";
+declare const FILTER_KINDS: readonly ["lowpass", "highpass", "bandpass", "notch", "allpass", "peaking", "lowshelf", "highshelf"];
+type FilterKind = (typeof FILTER_KINDS)[number];
+interface FilterDesc {
+    readonly kind: FilterKind;
+    readonly frequency: number;
+    readonly q?: number;
+    readonly gain?: number;
+}
+declare const DISTANCE_MODELS: readonly ["linear", "inverse", "exponential"];
+type DistanceModel = (typeof DISTANCE_MODELS)[number];
+interface PannerDesc {
+    readonly distanceModel?: DistanceModel;
+    readonly refDistance?: number;
+    readonly maxDistance?: number;
+    readonly rolloff?: number;
+    readonly coneInnerAngle?: number;
+    readonly coneOuterAngle?: number;
+    readonly coneOuterGain?: number;
+    readonly doppler?: number;
+}
+declare const DEFAULT_PANNER: {
+    readonly distanceModel: "inverse";
+    readonly refDistance: 1;
+    readonly maxDistance: 10000;
+    readonly rolloff: 1;
+    readonly coneInnerAngle: 360;
+    readonly coneOuterAngle: 360;
+    readonly coneOuterGain: 0;
+    readonly doppler: 0;
+};
+interface AnalyserDesc {
+    readonly fftSize?: number;
+    readonly smoothing?: number;
+    readonly minDecibels?: number;
+    readonly maxDecibels?: number;
+}
+declare function detuneRate(rate: number, cents: number): number;
+
+interface AnalyserSettings {
+    readonly fftSize: number;
+    readonly smoothing: number;
+    readonly minDecibels: number;
+    readonly maxDecibels: number;
+}
+declare function analyserSettings(desc?: AnalyserDesc): AnalyserSettings;
+declare class FftAnalyser {
+    readonly fftSize: number;
+    readonly binCount: number;
+    smoothing: number;
+    minDecibels: number;
+    maxDecibels: number;
+    private readonly ring;
+    private head;
+    private readonly real;
+    private readonly imag;
+    private readonly window;
+    private readonly smoothed;
+    private readonly bitReverse;
+    private readonly cos;
+    private readonly sin;
+    constructor(settings: AnalyserSettings);
+    push(samples: ArrayLike<number>, start: number, count: number): void;
+    reset(): void;
+    timeDomain(out: Float32Array | Uint8Array): void;
+    frequency(out: Float32Array | Uint8Array): void;
+    private transform;
+}
+
+type Scalar = "f32" | "f64" | "i8" | "i16" | "i32" | "u8" | "u16" | "u32";
+type TypedArray = Float32Array | Float64Array | Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array;
+type ArrayFor<S extends Scalar> = S extends "f32" ? Float32Array : S extends "f64" ? Float64Array : S extends "i8" ? Int8Array : S extends "i16" ? Int16Array : S extends "i32" ? Int32Array : S extends "u8" ? Uint8Array : S extends "u16" ? Uint16Array : Uint32Array;
+interface ComponentMemory {
+    allocate<S extends Scalar>(scalar: S, length: number): ArrayFor<S>;
+}
+
+/** Priority for `WorldPackReader.take`: `now` holds first input, `soon` follows it. */
+declare const AssetPriority: {
+    readonly now: 0;
+    readonly soon: 1;
+};
+type DeviceTier = "low" | "mid" | "high";
+interface WorldStreamingPort {
+    lazyPacks?(): boolean;
+    open(world: Uint8Array, materials: readonly number[], tier: number): number;
+    provide(stream: number, pack: Uint8Array): number;
+    update(stream: number, eye: Float32Array): void;
+    registers(stream: number): Uint32Array;
+    openLogic(stream: number, stepSeconds: number, budget: number, actors: number): number;
+    stepLogic(stream: number, actors: Float32Array, count: number, ops: Uint32Array): number;
+    collider(stream: number, index: number, out: Float32Array): void;
+    close(stream: number): void;
+}
+
+declare const TERRAIN_REGISTER: {
+    readonly requested: 0;
+    readonly installed: 1;
+    readonly inflight: 2;
+    readonly resident: 3;
+    readonly nodes: 4;
+    readonly touched: 5;
+    readonly deferred: 6;
+    readonly totalInstalls: 7;
+};
+declare const BRUSH: {
+    readonly raise: 0;
+    readonly lower: 1;
+    readonly smooth: 2;
+    readonly flatten: 3;
+    readonly paint: 4;
+    readonly hole: 5;
+    readonly fill: 6;
+};
+type BrushOp = keyof typeof BRUSH;
+declare const NOISE: {
+    readonly perlin: 0;
+    readonly simplex2: 1;
+    readonly simplex3: 2;
+    readonly worley: 3;
+};
+type NoiseKind = keyof typeof NOISE;
+interface TerrainPort {
+    open(desc: Float32Array, source: number, recipe: Float32Array, pack: Uint8Array | null): number;
+    close(terrain: number): void;
+    update(terrain: number, eye: Float32Array): number;
+    registers(terrain: number): Uint32Array;
+    height(x: number, z: number): number;
+    normal(x: number, z: number, out: Float32Array): boolean;
+    sculpt(terrain: number, brush: Float32Array): number;
+    colliders(terrain: number, x: number, y: number, z: number): number;
+    gravity(x: number, y: number, z: number, surface: number, radius: number): number;
+    grass(params: Float32Array): number;
+    wind(x: number, z: number, strength: number, gust: number): void;
+    interactors(data: Float32Array, count: number): void;
+    look(layers: Float32Array, count: number): void;
+    scatter(rules: Float32Array, out: Float32Array, capacity: number): number;
+    noise(kind: number, x: number, y: number, z: number, seed: number): number;
+    fbm(x: number, z: number, octaves: number, frequency: number, seed: number): number;
+}
+
+declare const SCENERY_REQUEST_SLOTS = 8;
+declare const SCENERY_REGISTER_WORDS = 20;
+declare const SCENERY_REGISTER: {
+    readonly chunks: 0;
+    readonly resident: 1;
+    readonly requested: 2;
+    readonly installed: 3;
+    readonly evicted: 4;
+    readonly deferred: 5;
+    readonly failed: 6;
+    readonly installedKib: 7;
+    readonly residentSplats: 8;
+    readonly drawnSplats: 9;
+    readonly listedPages: 10;
+    readonly poolCapacity: 11;
+    readonly poolFreePages: 12;
+    readonly tier: 13;
+    readonly updates: 14;
+    readonly heroSplats: 15;
+    readonly heroShed: 16;
+    readonly standIn: 17;
+    readonly deformedSplats: 18;
+};
+interface SceneryBodyPort {
+    edit(scene: number, region: number, values: Float32Array): void;
+    bind(scene: number, root: number): void;
+    heroBudget(scene: number, caps: Uint32Array | null): void;
+    drape(scene: number, cloths: number, cloth: number, region: number, rest: Float32Array | null): void;
+    motionRows(scene: number): number;
+    motion(scene: number, table: number, columns: Uint32Array | null, reachMillimetres: number, mask: number): void;
+}
+interface SceneryPort {
+    readonly bodies?: SceneryBodyPort | null;
+    open(manifest: Uint8Array): number;
+    provide(scene: number, index: number, chunk: Uint8Array): number;
+    fail(scene: number, index: number): number;
+    update(scene: number, eye: Float32Array, requests: Uint32Array): number;
+    setTransform(scene: number, transform: Float32Array): void;
+    registers(scene: number): Uint32Array;
+    close(scene: number): void;
+}
+
+declare const SOA_EXPORT_NAMES: readonly ["engine_soa_create", "engine_soa_destroy", "engine_soa_generations", "engine_soa_header", "engine_soa_turn", "engine_soa_remove", "engine_soa_map", "engine_soa_vec", "engine_soa_select", "engine_soa_reduce", "engine_soa_sort", "engine_soa_grid", "engine_soa_near", "engine_soa_nearest"];
+type SoaExportName = (typeof SOA_EXPORT_NAMES)[number];
+type SoaExports = Readonly<Record<SoaExportName | "engine_alloc" | "engine_free", (...args: number[]) => number>>;
+declare const SOA_BULK_EXPORT_NAMES: readonly ["engine_soa_inventory", "engine_soa_effect", "engine_soa_raycast", "engine_soa_paths", "engine_soa_pick", "engine_soa_flow", "engine_flow_create", "engine_flow_destroy", "engine_flow_registers", "engine_flow_costs", "engine_flow_rasterize", "engine_flow_build"];
+type SoaBulkName = (typeof SOA_BULK_EXPORT_NAMES)[number];
+type SoaBulkExports = Partial<Readonly<Record<SoaBulkName, (...args: number[]) => number>>>;
+interface SoaEngine {
+    readonly exports: SoaExports;
+    readonly memory: {
+        readonly buffer: ArrayBufferLike;
+    };
+    readonly bulk?: SoaBulkExports;
+}
+declare function bindSoaEngine(symbols: Readonly<Record<string, unknown>>, memory: {
+    readonly buffer: ArrayBufferLike;
+}): SoaEngine | null;
+
+interface Vec3Like {
+    x: number;
+    y: number;
+    z: number;
+}
+declare class Vec2 {
+    x: number;
+    y: number;
+    constructor(x?: number, y?: number);
+    set(x: number, y: number): this;
+    copy(v: Vec2): this;
+    length(): number;
+    add(v: Vec2): this;
+    sub(v: Vec2): this;
+    scale(s: number): this;
+    dot(v: Vec2): number;
+    cross(v: Vec2): number;
+    normalize(): this;
+    distanceTo(v: Vec2): number;
+    lerp(a: Vec2, b: Vec2, t: number): this;
+    angle(): number;
+    rotateAround(center: Vec2, radians: number): this;
+}
+declare class Vec4 {
+    x: number;
+    y: number;
+    z: number;
+    w: number;
+    constructor(x?: number, y?: number, z?: number, w?: number);
+    set(x: number, y: number, z: number, w: number): this;
+    copy(v: Vec4): this;
+    dot(v: Vec4): number;
+    length(): number;
+    scale(s: number): this;
+    lerp(a: Vec4, b: Vec4, t: number): this;
+    applyMat4(m: ArrayLike<number>, o: number): this;
+    readFrom(array: ArrayLike<number>, offset: number): this;
+    writeTo(array: Float32Array | Float64Array, offset: number): void;
+}
+declare class Vec3 implements Vec3Like {
+    x: number;
+    y: number;
+    z: number;
+    constructor(x?: number, y?: number, z?: number);
+    set(x: number, y: number, z: number): this;
+    copy(v: Vec3Like): this;
+    add(v: Vec3Like): this;
+    sub(v: Vec3Like): this;
+    scale(s: number): this;
+    addScaled(v: Vec3Like, s: number): this;
+    dot(v: Vec3Like): number;
+    cross(a: Vec3Like, b: Vec3Like): this;
+    lengthSq(): number;
+    length(): number;
+    normalize(): this;
+    lerp(a: Vec3Like, b: Vec3Like, t: number): this;
+    distanceTo(v: Vec3Like): number;
+    distanceToSquared(v: Vec3Like): number;
+    negate(): this;
+    min(v: Vec3Like): this;
+    max(v: Vec3Like): this;
+    clamp(lo: Vec3Like, hi: Vec3Like): this;
+    clampLength(min: number, max: number): this;
+    subVectors(a: Vec3Like, b: Vec3Like): this;
+    addVectors(a: Vec3Like, b: Vec3Like): this;
+    applyQuat(q: Quat): this;
+    applyMat4(m: ArrayLike<number>, o: number): this;
+    transformDirection(m: ArrayLike<number>, o: number): this;
+    projectOnVector(v: Vec3Like): this;
+    projectOnPlane(normal: Vec3Like): this;
+    reflect(normal: Vec3Like): this;
+    angleTo(v: Vec3Like): number;
+    setFromSpherical(radius: number, polar: number, azimuth: number): this;
+    setFromMatrixColumn(m: ArrayLike<number>, o: number, column: number): this;
+    equals(v: Vec3Like, tolerance?: number): boolean;
+    readFrom(array: ArrayLike<number>, offset: number): this;
+    writeTo(array: Float32Array | Float64Array, offset: number): void;
+}
+declare class Quat {
+    x: number;
+    y: number;
+    z: number;
+    w: number;
+    constructor(x?: number, y?: number, z?: number, w?: number);
+    set(x: number, y: number, z: number, w: number): this;
+    identity(): this;
+    copy(q: Quat): this;
+    setAxisAngle(axis: Vec3Like, radians: number): this;
+    setEuler(x: number, y: number, z: number): this;
+    multiply(a: Quat, b: Quat): this;
+    normalize(): this;
+    rotate(v: Vec3): Vec3;
+    dot(q: Quat): number;
+    conjugate(): this;
+    invert(): this;
+    premultiply(q: Quat): this;
+    slerp(a: Quat, b: Quat, t: number): this;
+    rotateTowards(target: Quat, maxRadians: number): this;
+    angleTo(q: Quat): number;
+    setFromUnitVectors(from: Vec3Like, to: Vec3Like): this;
+    setFromRotationMatrix(m: ArrayLike<number>, o: number): this;
+    lookRotation(forwardX: number, forwardY: number, forwardZ: number, upX?: number, upY?: number, upZ?: number): this;
+    toEuler(out: Vec3): Vec3;
+    readFrom(array: ArrayLike<number>, offset: number): this;
+    writeTo(array: Float32Array | Float64Array, offset: number): void;
+}
+
+declare const FRAME_STEP_SECONDS_SLOT = 0;
+declare const FRAME_SECONDS_SLOT = 1;
+declare const FRAME_ALPHA_SLOT = 2;
+declare const TIME_SCALE_SLOT = 6;
+declare const FRAME_TICK_SLOT = 7;
+declare const FRAME_NOW_MS_SLOT = 8;
+declare class FrameTime {
+    readonly values: Float64Array<ArrayBuffer>;
+    get stepSeconds(): number;
+    get frameSeconds(): number;
+    get alpha(): number;
+    get tick(): number;
+}
+interface LoopOptions {
+    fixedHz?: number;
+    maxSubsteps?: number;
+    maxFrameDeltaMs?: number;
+}
+declare class FixedStepLoop {
+    readonly time: FrameTime;
+    private readonly views;
+    rollbackViews(): readonly ArrayBufferView[];
+    readonly stepMs: number;
+    readonly maxSubsteps: number;
+    readonly maxFrameDeltaMs: number;
+    constructor(options?: LoopOptions);
+    get stepSeconds(): number;
+    get alpha(): number;
+    get tick(): number;
+    get frameDeltaSeconds(): number;
+    get droppedTimeMs(): number;
+    get timeScale(): number;
+    set timeScale(scale: number);
+    begin(nowMs: number): number;
+    beginAtClock(): number;
+    /** Keeps the clock at this frame without stepping, so a held game resumes without catching up the time it was held. */
+    hold(): void;
+    completeStep(): void;
+    settle(steps: number): void;
+    reset(): void;
+}
+
+declare const AGENT_X = 0;
+declare const AGENT_STRIDE = 8;
+declare const AGENT_IDLE = 0;
+declare const AGENT_REQUESTING = 1;
+declare const AGENT_MOVING = 2;
+declare const AGENT_ARRIVED = 3;
+declare const AGENT_LOST = 4;
+declare const AGENT_ON_LINK = 5;
+declare const NO_LINK = -1;
+declare const POSE_X = 0;
+declare const POSE_Z = 2;
+declare const POSE_DIR_X = 3;
+declare const POSE_DIR_Z = 4;
+declare const POSE_SPEED = 5;
+declare const POSE_LANE = 6;
+declare const POSE_STRIDE$1 = 8;
+declare const SIGNAL_GREEN = 0;
+declare const SIGNAL_AMBER = 1;
+declare const SIGNAL_RED = 2;
+interface NavDesc {
+    readonly tileWorld: number;
+    readonly origin?: readonly [number, number];
+    readonly maxTiles?: number;
+    readonly queryNodes?: number;
+    readonly maxAgents?: number;
+    readonly neighbourDistance?: number;
+    readonly timeHorizon?: number;
+    readonly pathBudget?: number;
+    readonly maxPathPolys?: number;
+    readonly extents?: readonly [number, number, number];
+}
+interface AgentDesc {
+    readonly radius?: number;
+    readonly maxSpeed?: number;
+    readonly maxAcceleration?: number;
+}
+interface OffMeshLinkDesc {
+    readonly start: readonly [number, number, number];
+    readonly end: readonly [number, number, number];
+    readonly radius?: number;
+    readonly bidirectional?: boolean;
+    readonly area?: number;
+    readonly user?: number;
+}
+interface DriverDesc {
+    readonly length?: number;
+    readonly desire?: number;
+    readonly headway?: number;
+    readonly jam?: number;
+    readonly accel?: number;
+    readonly decel?: number;
+}
+interface LaneSpec {
+    readonly points: readonly (readonly [number, number, number])[];
+    readonly speedLimit: number;
+    readonly next?: readonly number[];
+    readonly signal?: number;
+    readonly group?: number;
+    readonly giveWay?: boolean;
+    readonly conflicts?: readonly number[];
+}
+interface SignalSpec {
+    readonly phases: readonly {
+        readonly groups: readonly number[];
+        readonly seconds: number;
+    }[];
+    readonly amber: number;
+    readonly offset?: number;
+}
+interface RoadGraphDesc {
+    readonly lanes: readonly LaneSpec[];
+    readonly signals?: readonly SignalSpec[];
+    readonly maxVehicles: number;
+    readonly seed?: number;
+}
+interface NavPort {
+    readonly name: string;
+    init(desc: NavDesc): void;
+    addTile(bytes: Uint8Array): number;
+    removeTile(x: number, z: number): void;
+    addLink(start: readonly [number, number, number], end: readonly [number, number, number], radius: number, bidirectional: boolean, area: number, user: number): number;
+    removeLink(link: number): void;
+    setAreaCost(area: number, cost: number): void;
+    setIncludeMask(low: number, high: number): void;
+    nearest(x: number, y: number, z: number, out: Float32Array): boolean;
+    findPath(sx: number, sy: number, sz: number, ex: number, ey: number, ez: number, out: Float32Array): number;
+    readonly pathComplete: boolean;
+    batchHandle?(): number;
+    addAgent(x: number, y: number, z: number, radius: number, speed: number, accel: number): number;
+    removeAgent(agent: number): void;
+    setAgentTarget(agent: number, x: number, y: number, z: number): void;
+    stopAgent(agent: number): void;
+    agents(): Float32Array;
+    loadRoads(words: Uint32Array): void;
+    addVehicle(lane: number, position: number, speed: number, driver: Float32Array): number;
+    removeVehicle(vehicle: number): void;
+    setExternalVehicle(vehicle: number, lane: number, position: number, speed: number): void;
+    vehicles(): Float32Array;
+    signal(lane: number): number;
+    step(dt: number): void;
+    dispose(): void;
+}
+
+interface RollbackState {
+    rollbackViews(): readonly ArrayBufferView[];
+}
+
+type SnapshotPolicy = "scan" | "marked";
+interface WorldRollbackDesc {
+    readonly regionBytes?: number;
+    readonly trackedBytes?: number;
+    readonly journalBytes?: number;
+    readonly frames?: number;
+}
+interface WorldSnapshotStats {
+    readonly depth: number;
+    readonly newest: number | null;
+    readonly oldest: number | null;
+    readonly dirtyPages: number;
+    readonly scannedPages: number;
+    readonly restoredPages: number;
+    readonly saveMs: number;
+    readonly restoreMs: number;
+    readonly evicted: number;
+    readonly heapBytes: number;
+    readonly trackedPages: number;
+    readonly spilled: boolean;
+    readonly breaks: number;
+    readonly residents: number;
+    readonly quietPages: number;
+    readonly missedPages: number;
+}
+interface KeyframeDesc {
+    readonly every?: number;
+    readonly slots?: number;
+    readonly leaves?: number;
+}
+interface KeyframeStats {
+    readonly frames: number;
+    readonly oldest: number | null;
+    readonly newest: number | null;
+    readonly leavesUsed: number;
+    readonly leavesShared: number;
+    readonly captures: number;
+    readonly evicted: number;
+    readonly installs: number;
+}
+declare class WorldSnapshots {
+    private readonly exports;
+    private readonly memory;
+    readonly world: number;
+    private readonly beforeRestore;
+    private view;
+    private digestAt;
+    private readonly ring;
+    private keyRing;
+    private keyframes;
+    private every;
+    private readonly states;
+    private constructor();
+    static bind(symbols: Readonly<Record<string, unknown>>, memory: {
+        readonly buffer: ArrayBufferLike;
+    }, world: number, beforeRestore?: () => void, frames?: number): WorldSnapshots | null;
+    attach(state: RollbackState): void;
+    enableKeyframes(desc: KeyframeDesc): boolean;
+    get keyframeEvery(): number;
+    keyframe(tick: number): boolean;
+    nearestKeyframe(at: number): number | null;
+    seekKeyframe(tick: number): boolean;
+    truncateKeyframes(after: number): void;
+    clearKeyframes(): void;
+    keyframeStats(): KeyframeStats | null;
+    get stateBreaks(): number;
+    save(tick: number): number;
+    restore(tick: number): boolean;
+    clear(): void;
+    private adopt;
+    track(view: ArrayBufferView, policy?: SnapshotPolicy): void;
+    trackTable(table: number, policy?: SnapshotPolicy): void;
+    untrack(view: ArrayBufferView): void;
+    mark(view: ArrayBufferView & {
+        readonly BYTES_PER_ELEMENT: number;
+    }, from?: number, to?: number): boolean;
+    digest(): bigint;
+    stats(): WorldSnapshotStats;
+    private registers;
+    private owned;
+    private check;
+}
+
+type BodyKind = "dynamic" | "kinematic" | "fixed";
+interface BodyDesc {
+    readonly kind: BodyKind;
+    readonly linearDamping?: number;
+    readonly angularDamping?: number;
+    readonly gravityScale?: number;
+    readonly ccd?: boolean;
+    readonly canSleep?: boolean;
+    readonly lockRotations?: boolean;
+    readonly lockTranslations?: boolean;
+    readonly enabledTranslations?: readonly [boolean, boolean, boolean];
+    readonly enabledRotations?: readonly [boolean, boolean, boolean];
+    readonly planar?: boolean;
+    readonly dominance?: number;
+}
+type PrimitiveShapeDesc = {
+    readonly kind: "ball";
+    readonly radius: number;
+} | {
+    readonly kind: "cuboid";
+    readonly halfExtents: readonly [number, number, number];
+} | {
+    readonly kind: "capsule";
+    readonly halfHeight: number;
+    readonly radius: number;
+} | {
+    readonly kind: "cylinder";
+    readonly halfHeight: number;
+    readonly radius: number;
+} | {
+    readonly kind: "cone";
+    readonly halfHeight: number;
+    readonly radius: number;
+} | {
+    readonly kind: "round_cuboid";
+    readonly halfExtents: readonly [number, number, number];
+    readonly border: number;
+} | {
+    readonly kind: "round_cylinder";
+    readonly halfHeight: number;
+    readonly radius: number;
+    readonly border: number;
+} | {
+    readonly kind: "round_cone";
+    readonly halfHeight: number;
+    readonly radius: number;
+    readonly border: number;
+};
+interface CompoundPartDesc {
+    readonly shape: PrimitiveShapeDesc;
+    readonly offset?: readonly [number, number, number];
+    readonly rotation?: readonly [number, number, number, number];
+}
+type ShapeDesc = PrimitiveShapeDesc | {
+    readonly kind: "round_convex_hull";
+    readonly points: Float32Array;
+    readonly border: number;
+} | {
+    readonly kind: "compound";
+    readonly parts: readonly CompoundPartDesc[];
+} | {
+    readonly kind: "trimesh";
+    readonly vertices: Float32Array;
+    readonly indices: Uint32Array;
+} | {
+    readonly kind: "convex_hull";
+    readonly points: Float32Array;
+} | {
+    readonly kind: "heightfield";
+    readonly rows: number;
+    readonly columns: number;
+    readonly heights: Float32Array;
+    readonly scale: readonly [number, number, number];
+};
+interface ColliderDesc {
+    readonly shape: ShapeDesc;
+    readonly offset?: readonly [number, number, number];
+    readonly rotation?: readonly [number, number, number, number];
+    readonly density?: number;
+    readonly mass?: number;
+    readonly friction?: number;
+    readonly restitution?: number;
+    readonly sensor?: boolean;
+    readonly events?: boolean;
+    readonly membership?: number;
+    readonly filter?: number;
+}
+type JointDesc = {
+    readonly kind: "fixed";
+    readonly anchorA: readonly [number, number, number];
+    readonly anchorB: readonly [number, number, number];
+} | {
+    readonly kind: "spherical";
+    readonly anchorA: readonly [number, number, number];
+    readonly anchorB: readonly [number, number, number];
+} | {
+    readonly kind: "revolute";
+    readonly anchorA: readonly [number, number, number];
+    readonly anchorB: readonly [number, number, number];
+    readonly axis: readonly [number, number, number];
+    readonly limits?: readonly [number, number];
+} | {
+    readonly kind: "prismatic";
+    readonly anchorA: readonly [number, number, number];
+    readonly anchorB: readonly [number, number, number];
+    readonly axis: readonly [number, number, number];
+    readonly limits?: readonly [number, number];
+} | {
+    readonly kind: "rope";
+    readonly anchorA: readonly [number, number, number];
+    readonly anchorB: readonly [number, number, number];
+    readonly length: number;
+} | {
+    readonly kind: "spring";
+    readonly anchorA: readonly [number, number, number];
+    readonly anchorB: readonly [number, number, number];
+    readonly restLength: number;
+    readonly stiffness: number;
+    readonly damping: number;
+} | {
+    readonly kind: "cone";
+    readonly anchorA: readonly [number, number, number];
+    readonly anchorB: readonly [number, number, number];
+    readonly axis: readonly [number, number, number];
+    readonly swing: number;
+    readonly twist: readonly [number, number];
+} | {
+    readonly kind: "six_dof";
+    readonly anchorA: readonly [number, number, number];
+    readonly anchorB: readonly [number, number, number];
+    readonly frameA?: readonly [number, number, number, number];
+    readonly frameB?: readonly [number, number, number, number];
+    readonly linear?: readonly [AxisMotion, AxisMotion, AxisMotion];
+    readonly angular?: readonly [AxisMotion, AxisMotion, AxisMotion];
+    readonly swingCone?: number;
+};
+type AxisMotion = "locked" | "free" | readonly [number, number];
+interface CharacterControllerDesc {
+    readonly offset?: number;
+    readonly maxSlopeClimbDegrees?: number;
+    readonly minSlopeSlideDegrees?: number;
+    readonly autostepMaxHeight?: number;
+    readonly autostepMinWidth?: number;
+    readonly snapToGround?: number;
+    readonly slide?: boolean;
+    readonly up?: readonly [number, number, number];
+}
+declare const MAX_SOLVER_ITERATIONS = 64;
+declare const MAX_PGS_ITERATIONS = 16;
+declare const MAX_CCD_SUBSTEPS = 16;
+interface SolverSettings {
+    readonly iterations?: number;
+    readonly pgsIterations?: number;
+    readonly ccdSubsteps?: number;
+}
+interface SleepThresholds {
+    readonly linear?: number;
+    readonly angular?: number;
+    readonly seconds?: number;
+}
+interface PhysicsWorldDesc {
+    readonly gravity?: readonly [number, number, number];
+    readonly stepSeconds: number;
+    readonly maxBodies?: number;
+    readonly maxColliders?: number;
+    readonly maxJoints?: number;
+    readonly maxContactEvents?: number;
+    readonly maxCharacterControllers?: number;
+    readonly rollback?: WorldRollbackDesc;
+}
+declare class RayQuery {
+    readonly origin: Vec3;
+    readonly direction: Vec3;
+    maxDistance: number;
+    solid: boolean;
+    includeSensors: boolean;
+    excludeCollider: number;
+    set(ox: number, oy: number, oz: number, dx: number, dy: number, dz: number, maxDistance: number): this;
+}
+declare class RayHit {
+    hit: boolean;
+    collider: number;
+    distance: number;
+    pointX: number;
+    pointY: number;
+    pointZ: number;
+    normalX: number;
+    normalY: number;
+    normalZ: number;
+}
+declare class CharacterMove {
+    grounded: boolean;
+    x: number;
+    y: number;
+    z: number;
+}
+
+type Base = Omit<StandardMaterialDesc, "kind" | "metalness" | "metalnessMap">;
+interface SkinMaterialDesc extends Base {
+    readonly kind: "skin";
+    readonly scatter?: readonly [number, number, number];
+    readonly thickness?: number;
+    readonly sheen?: number;
+    readonly sheenRoughness?: number;
+    readonly warmth?: number;
+    readonly rim?: number;
+}
+interface EyeMaterialDesc extends Base {
+    readonly kind: "eye";
+    readonly irisMap?: TextureId;
+    readonly irisRadius?: number;
+    readonly irisDepth?: number;
+    readonly limbus?: number;
+    readonly pupil?: number;
+}
+interface HairMaterialDesc extends Base {
+    readonly kind: "hair";
+    readonly melanin?: number;
+    readonly redness?: number;
+    readonly azimuthalRoughness?: number;
+    readonly density?: number;
+}
+
+declare const geometryBrand: unique symbol;
+declare const materialBrand: unique symbol;
+declare const textureBrand: unique symbol;
+declare const nodeBrand: unique symbol;
+declare const renderTargetBrand: unique symbol;
+declare const postChainBrand: unique symbol;
+declare const renderPassBrand: unique symbol;
+declare const modelBrand: unique symbol;
+declare const clipActionBrand: unique symbol;
+declare const emitterBrand: unique symbol;
+declare const fontBrand: unique symbol;
+type GeometryId = number & {
+    readonly [geometryBrand]: true;
+};
+type MaterialId = number & {
+    readonly [materialBrand]: true;
+};
+type TextureId = number & {
+    readonly [textureBrand]: true;
+};
+type NodeId = number & {
+    readonly [nodeBrand]: true;
+};
+type RenderTargetId = number & {
+    readonly [renderTargetBrand]: true;
+};
+type PostChainId = number & {
+    readonly [postChainBrand]: true;
+};
+type RenderPassId = number & {
+    readonly [renderPassBrand]: true;
+};
+type ModelId = number & {
+    readonly [modelBrand]: true;
+};
+type ClipActionId = number & {
+    readonly [clipActionBrand]: true;
+};
+type EmitterId = number & {
+    readonly [emitterBrand]: true;
+};
+type FontId = number & {
+    readonly [fontBrand]: true;
+};
+type TextAlign = "start" | "end" | "left" | "center" | "right";
+type TextDirection = "auto" | "ltr" | "rtl";
+interface FontSource {
+    readonly atlas: AssetSource;
+    readonly table: AssetSource;
+    /** The font file the atlas was baked from: game UI text shapes the letters the atlas lacks through it (complex scripts, marks). */
+    readonly face?: AssetSource;
+}
+interface TextStyleDesc {
+    readonly size?: number;
+    readonly color?: number;
+    readonly opacity?: number;
+    readonly maxWidth?: number;
+    readonly lineHeight?: number;
+    readonly letterSpacing?: number;
+    readonly align?: TextAlign;
+    readonly direction?: TextDirection;
+    readonly anchor?: readonly [number, number];
+    readonly outlineWidth?: number;
+    readonly outlineColor?: number;
+    readonly capacity?: number;
+}
+interface PickHit {
+    node: NodeId;
+    instance: number;
+    triangle: number;
+    distance: number;
+    readonly point: Float32Array;
+    readonly barycentric: Float32Array;
+    readonly uv: Float32Array;
+}
+declare function createPickHit(): PickHit;
+type VertexData = Float32Array | Uint32Array | Uint16Array | Uint8Array | Int16Array | Int8Array;
+interface VertexAttributeDesc {
+    readonly data: VertexData;
+    readonly itemSize: 1 | 2 | 3 | 4;
+    readonly normalized?: boolean;
+    readonly dynamic?: boolean;
+    readonly customSlot?: number;
+}
+interface GeometryGroup {
+    readonly start: number;
+    readonly count: number;
+    readonly materialIndex: number;
+}
+interface MorphTargetDesc {
+    readonly name: string;
+    readonly position: Float32Array;
+    readonly normal?: Float32Array;
+}
+interface GeometryDesc {
+    readonly attributes: Readonly<Record<string, VertexAttributeDesc>>;
+    readonly index?: Uint16Array | Uint32Array;
+    readonly groups?: readonly GeometryGroup[];
+    readonly morphTargets?: readonly MorphTargetDesc[];
+    readonly morphRelative?: boolean;
+}
+type ColorSpace = "srgb" | "linear";
+type TextureWrap = "repeat" | "clamp" | "mirror";
+type TextureFilter = "linear" | "nearest";
+type TexelData = Uint8Array | Uint16Array | Uint32Array | Int32Array | Float32Array;
+type TextureKind = "2d" | "cube" | "equirect" | "2d-array" | "3d";
+type TexelFormat = "rgba8" | "rgba16f" | "rgba32f" | "r8" | "rg8" | "r16f" | "rg16f" | "r32f" | "rg32f" | "r8ui" | "r16ui" | "r32ui" | "rg32ui" | "rgba8ui" | "rgba16ui" | "rgba32ui" | "r32i" | "rgba32i";
+interface TextureRegion {
+    readonly x: number;
+    readonly y: number;
+    readonly z?: number;
+    readonly width: number;
+    readonly height: number;
+    readonly depth?: number;
+}
+type TextureSource = {
+    readonly kind: "pixels";
+    readonly width: number;
+    readonly height: number;
+    readonly depth?: number;
+    readonly data: TexelData;
+    readonly format?: TexelFormat;
+} | {
+    readonly kind: "image";
+    readonly image: TexImageSource;
+} | {
+    readonly kind: "video";
+    readonly width: number;
+    readonly height: number;
+};
+type VideoFrameSource = TexImageSource;
+interface TextureDesc {
+    readonly source: TextureSource;
+    readonly kind?: TextureKind;
+    readonly colorSpace?: ColorSpace;
+    readonly wrap?: TextureWrap;
+    readonly filter?: TextureFilter;
+    readonly mipmaps?: boolean;
+    readonly flipY?: boolean;
+    readonly encode?: TextureEncode;
+}
+type TextureEncode = "none" | "blocks" | "astc" | "bc7";
+type Side = "front" | "back" | "double";
+type Blending = "normal" | "additive" | "multiply" | "none" | "custom";
+type CompareFunction = "never" | "less" | "equal" | "lessEqual" | "greater" | "notEqual" | "greaterEqual" | "always";
+type BlendEquation = "add" | "subtract" | "reverseSubtract" | "min" | "max";
+type BlendFactor = "zero" | "one" | "srcColor" | "oneMinusSrcColor" | "srcAlpha" | "oneMinusSrcAlpha" | "dstColor" | "oneMinusDstColor" | "dstAlpha" | "oneMinusDstAlpha" | "srcAlphaSaturate";
+type StencilOperation = "keep" | "zero" | "replace" | "increment" | "decrement" | "invert" | "incrementWrap" | "decrementWrap";
+type Transparency = "sorted" | "oit";
+interface BlendDesc {
+    readonly equation?: BlendEquation;
+    readonly alphaEquation?: BlendEquation;
+    readonly src?: BlendFactor;
+    readonly dst?: BlendFactor;
+    readonly srcAlpha?: BlendFactor;
+    readonly dstAlpha?: BlendFactor;
+}
+interface StencilDesc {
+    readonly func?: CompareFunction;
+    readonly ref?: number;
+    readonly readMask?: number;
+    readonly writeMask?: number;
+    readonly fail?: StencilOperation;
+    readonly depthFail?: StencilOperation;
+    readonly pass?: StencilOperation;
+}
+interface PolygonOffsetDesc {
+    readonly factor: number;
+    readonly units: number;
+}
+type Plane = readonly [number, number, number, number];
+interface TextureTransform {
+    readonly offset?: readonly [number, number];
+    readonly repeat?: readonly [number, number];
+    readonly rotation?: number;
+    readonly center?: readonly [number, number];
+    readonly channel?: number;
+}
+interface MaterialStateDesc {
+    readonly blend?: BlendDesc;
+    readonly stencil?: StencilDesc;
+    readonly depthFunc?: CompareFunction;
+    readonly polygonOffset?: PolygonOffsetDesc;
+    readonly clippingPlanes?: readonly Plane[];
+    readonly alphaToCoverage?: boolean;
+    readonly transparency?: Transparency;
+    readonly envMapIntensity?: number;
+}
+interface MaterialCommon extends MaterialStateDesc {
+    readonly transparent?: boolean;
+    readonly opacity?: number;
+    readonly side?: Side;
+    readonly depthTest?: boolean;
+    readonly depthWrite?: boolean;
+    readonly blending?: Blending;
+    readonly vertexColors?: boolean;
+    readonly wireframe?: boolean;
+    readonly alphaTest?: number;
+    readonly textureTransforms?: Readonly<Partial<Record<MaterialTextureSlot, TextureTransform>>>;
+}
+interface StandardMaterialDesc extends MaterialCommon {
+    readonly kind: "standard";
+    readonly color?: number;
+    readonly metalness?: number;
+    readonly roughness?: number;
+    readonly emissive?: number;
+    readonly emissiveIntensity?: number;
+    readonly map?: TextureId;
+    readonly normalMap?: TextureId;
+    readonly roughnessMap?: TextureId;
+    readonly metalnessMap?: TextureId;
+    readonly emissiveMap?: TextureId;
+    readonly aoMap?: TextureId;
+    readonly flatShading?: boolean;
+    readonly tintable?: boolean;
+    readonly tintMask?: TextureId;
+}
+interface KitTint {
+    readonly primary?: number;
+    readonly secondary?: number;
+    readonly tertiary?: number;
+}
+interface MaterialTint {
+    readonly tintable: boolean;
+    readonly mask: TextureId | undefined;
+}
+declare function materialTint(desc: MaterialDesc): MaterialTint;
+interface PhysicalMaterialDesc extends Omit<StandardMaterialDesc, "kind"> {
+    readonly kind: "physical";
+    readonly clearcoat?: number;
+    readonly clearcoatRoughness?: number;
+    readonly clearcoatMap?: TextureId;
+    readonly clearcoatRoughnessMap?: TextureId;
+    readonly clearcoatNormalMap?: TextureId;
+    readonly clearcoatNormalScale?: number;
+    readonly transmission?: number;
+    readonly transmissionMap?: TextureId;
+    readonly ior?: number;
+    readonly thickness?: number;
+    readonly sheen?: number;
+    readonly sheenColor?: number;
+    readonly sheenRoughness?: number;
+    readonly sheenColorMap?: TextureId;
+    readonly sheenRoughnessMap?: TextureId;
+    readonly specularColor?: number;
+    readonly specularIntensity?: number;
+    readonly specularIntensityMap?: TextureId;
+    readonly specularColorMap?: TextureId;
+    readonly iridescence?: number;
+    readonly iridescenceIOR?: number;
+    readonly iridescenceThicknessRange?: readonly [number, number];
+    readonly iridescenceMap?: TextureId;
+    readonly iridescenceThicknessMap?: TextureId;
+    readonly anisotropy?: number;
+    readonly anisotropyRotation?: number;
+    readonly anisotropyMap?: TextureId;
+    readonly attenuationColor?: number;
+    readonly attenuationDistance?: number;
+    readonly dispersion?: number;
+}
+interface ToonMaterialDesc extends MaterialCommon {
+    readonly kind: "toon";
+    readonly color?: number;
+    readonly map?: TextureId;
+    readonly gradientMap?: TextureId;
+    readonly normalMap?: TextureId;
+    readonly emissive?: number;
+    readonly emissiveIntensity?: number;
+    readonly emissiveMap?: TextureId;
+    readonly aoMap?: TextureId;
+}
+interface MatcapMaterialDesc extends MaterialCommon {
+    readonly kind: "matcap";
+    readonly color?: number;
+    readonly map?: TextureId;
+    readonly matcap?: TextureId;
+    readonly normalMap?: TextureId;
+    readonly flatShading?: boolean;
+}
+interface UnlitMaterialDesc extends MaterialCommon {
+    readonly kind: "unlit";
+    readonly color?: number;
+    readonly map?: TextureId;
+}
+interface SpriteMaterialDesc extends MaterialCommon {
+    readonly kind: "sprite";
+    readonly color?: number;
+    readonly map?: TextureId;
+    readonly sizeAttenuation?: boolean;
+    readonly rotation?: number;
+}
+interface PointsMaterialDesc extends MaterialCommon {
+    readonly kind: "points";
+    readonly color?: number;
+    readonly size?: number;
+    readonly map?: TextureId;
+    readonly sizeAttenuation?: boolean;
+}
+interface LinesMaterialDesc extends MaterialCommon {
+    readonly kind: "lines";
+    readonly color?: number;
+    readonly width?: number;
+    readonly worldUnits?: boolean;
+    readonly dashSize?: number;
+    readonly gapSize?: number;
+    readonly dashScale?: number;
+}
+interface WgslSource {
+    readonly vertex?: string;
+    readonly fragment: string;
+}
+interface GlslSource {
+    readonly vertex: string;
+    readonly fragment: string;
+}
+interface ShaderSource {
+    readonly wgsl: WgslSource;
+    readonly glsl?: GlslSource;
+}
+type UniformType = "f32" | "i32" | "vec2" | "vec3" | "vec4" | "mat4" | "texture";
+interface UniformDesc {
+    readonly type: UniformType;
+    readonly value?: number | Float32Array | TextureId;
+}
+interface ShaderMaterialDesc extends MaterialCommon {
+    readonly kind: "shader";
+    readonly shader: ShaderSource;
+    readonly uniforms?: Readonly<Record<string, UniformDesc>>;
+    readonly lights?: boolean;
+}
+type MaterialDesc = StandardMaterialDesc | PhysicalMaterialDesc | ToonMaterialDesc | MatcapMaterialDesc | UnlitMaterialDesc | SpriteMaterialDesc | PointsMaterialDesc | LinesMaterialDesc | ShaderMaterialDesc | SkinMaterialDesc | EyeMaterialDesc | HairMaterialDesc;
+type MaterialTextureSlot = "map" | "normalMap" | "roughnessMap" | "metalnessMap" | "emissiveMap" | "aoMap" | "clearcoatMap" | "clearcoatRoughnessMap" | "clearcoatNormalMap" | "sheenColorMap" | "sheenRoughnessMap" | "specularIntensityMap" | "specularColorMap" | "transmissionMap" | "gradientMap" | "matcap";
+interface SkeletonDesc {
+    readonly parents: Int16Array;
+    readonly bindPose: Float32Array;
+    readonly inverseBindMatrices?: Float32Array;
+}
+interface ShadowDesc {
+    readonly castShadow?: boolean;
+    readonly receiveShadow?: boolean;
+    readonly giExclude?: boolean;
+}
+type GlobalIlluminationMode = "off" | "field" | "full";
+interface GlobalIlluminationDesc {
+    readonly mode?: GlobalIlluminationMode;
+    readonly intensity?: number;
+    readonly spacing?: number;
+    readonly sunAngle?: number;
+}
+interface ShadowParamsDesc {
+    readonly cascades?: 1 | 2 | 3;
+    readonly split?: number;
+    readonly maxFar?: number;
+    readonly fade?: number;
+    readonly bias?: number;
+    readonly normalBias?: number;
+    readonly radius?: number;
+    readonly blurSamples?: number;
+    readonly type?: ShadowType;
+}
+type ShadowType = "pcf" | "pcss";
+interface LodRange {
+    readonly near?: number;
+    readonly far?: number;
+    readonly hysteresis?: number;
+}
+interface NodeCommon {
+    readonly renderOrder?: number;
+    readonly lod?: LodRange;
+}
+type LightKind = "directional" | "point" | "spot" | "ambient" | "hemisphere" | "rectArea" | "probe" | "reflectionProbe";
+type Vec3Tuple = readonly [number, number, number];
+declare const SH_COEFFICIENT_FLOATS = 27;
+type Interpolation = "linear" | "step" | "cubic";
+type EmitterShape = {
+    readonly kind: "point";
+} | {
+    readonly kind: "sphere";
+    readonly radius: number;
+} | {
+    readonly kind: "cone";
+    readonly angle: number;
+    readonly radius?: number;
+} | {
+    readonly kind: "box";
+    readonly size: readonly [number, number, number];
+} | {
+    readonly kind: "disc";
+    readonly radius: number;
+};
+type EmitterCollision = {
+    readonly kind: "none";
+} | {
+    readonly kind: "plane";
+    readonly plane: Plane;
+    readonly bounce?: number;
+} | {
+    readonly kind: "depth";
+    readonly bounce?: number;
+};
+interface CurvePoint {
+    readonly t: number;
+    readonly value: number | readonly [number, number, number, number];
+}
+interface EmitterDesc {
+    readonly capacity: number;
+    readonly rate?: number;
+    readonly burst?: number;
+    readonly lifetime?: readonly [number, number];
+    readonly speed?: readonly [number, number];
+    readonly size?: readonly [number, number];
+    readonly color?: readonly [number, number];
+    readonly alpha?: readonly [number, number];
+    readonly gravity?: readonly [number, number, number];
+    readonly drag?: number;
+    readonly noise?: {
+        readonly strength: number;
+        readonly scale: number;
+    };
+    readonly shape?: EmitterShape;
+    readonly collision?: EmitterCollision;
+    readonly material?: MaterialId;
+    readonly spread?: number;
+    readonly spin?: number;
+    readonly seed?: number;
+    readonly soft?: boolean;
+    readonly sorted?: boolean;
+    readonly localSpace?: boolean;
+    readonly deterministic?: boolean;
+    readonly additive?: boolean;
+    readonly stretch?: boolean;
+    readonly oit?: boolean;
+    readonly velocityAligned?: boolean;
+    readonly sizeCurve?: readonly CurvePoint[];
+    readonly colorCurve?: readonly CurvePoint[];
+}
+type NodeDesc = NodeCommon & NodeKindDesc;
+type NodeKindDesc = ({
+    readonly kind: "mesh";
+    readonly geometry: GeometryId;
+    readonly material: MaterialId | readonly MaterialId[];
+} & ShadowDesc) | ({
+    readonly kind: "instanced";
+    readonly geometry: GeometryId;
+    readonly material: MaterialId;
+    readonly capacity: number;
+    readonly colors?: boolean;
+    readonly batchSlots?: number;
+} & ShadowDesc) | ({
+    readonly kind: "skinned";
+    readonly geometry: GeometryId;
+    readonly material: MaterialId;
+    readonly skeleton: SkeletonDesc;
+} & ShadowDesc) | {
+    readonly kind: "points";
+    readonly geometry: GeometryId;
+    readonly material: MaterialId;
+} | {
+    readonly kind: "lines";
+    readonly geometry: GeometryId;
+    readonly material: MaterialId;
+    readonly segments?: boolean;
+} | {
+    readonly kind: "sprite";
+    readonly material: MaterialId;
+    readonly center?: readonly [number, number];
+} | {
+    readonly kind: "camera";
+    readonly projection: "perspective";
+    readonly fov?: number;
+    readonly near?: number;
+    readonly far?: number;
+} | {
+    readonly kind: "camera";
+    readonly projection: "orthographic";
+    readonly height: number;
+    readonly near?: number;
+    readonly far?: number;
+} | {
+    readonly kind: "camera";
+    readonly projection: "custom";
+    readonly matrix: Float32Array;
+    readonly near: number;
+    readonly far: number;
+} | {
+    readonly kind: "decal";
+    readonly material: MaterialId;
+    readonly angleFade?: number;
+    readonly fade?: number;
+} | {
+    readonly kind: "light";
+    readonly light: LightKind;
+    readonly color?: number;
+    readonly intensity?: number;
+    readonly distance?: number;
+    readonly decay?: number;
+    readonly angle?: number;
+    readonly penumbra?: number;
+    readonly groundColor?: number;
+    readonly castShadow?: boolean;
+    readonly shadowMapSize?: number;
+    readonly shadow?: ShadowParamsDesc;
+    readonly width?: number;
+    readonly height?: number;
+    readonly sh?: Float32Array;
+    readonly fromEnvironment?: boolean;
+    readonly texture?: TextureId;
+    readonly boxMin?: Vec3Tuple;
+    readonly boxMax?: Vec3Tuple;
+} | {
+    readonly kind: "particles";
+    readonly emitter: EmitterId;
+} | {
+    readonly kind: "group";
+} | {
+    readonly kind: "shape2d";
+    readonly shape: "rect" | "circle";
+    readonly width?: number;
+    readonly height?: number;
+    readonly radius?: number;
+    readonly color?: number;
+    readonly alpha?: number;
+} | ({
+    readonly kind: "text2d";
+    readonly text: string;
+    readonly font?: FontId;
+    readonly fontFamily?: string;
+} & TextStyleDesc) | ({
+    readonly kind: "text3d";
+    readonly font: FontId;
+    readonly text?: string;
+    readonly billboard?: boolean;
+} & TextStyleDesc);
+type RenderTargetFormat = "rgba8" | "rgba16f" | "rgba32f";
+interface RenderTargetDesc {
+    readonly width: number;
+    readonly height: number;
+    readonly format?: RenderTargetFormat;
+    readonly depth?: boolean;
+    readonly samples?: number;
+    readonly kind?: "2d" | "cube" | "2d-array";
+    readonly layers?: number;
+    readonly sampleDepth?: boolean;
+    readonly colors?: number;
+}
+type PostEffectDesc = {
+    readonly kind: "bloom";
+    readonly strength?: number;
+    readonly radius?: number;
+    readonly threshold?: number;
+    readonly physical?: boolean;
+} | {
+    readonly kind: "fxaa";
+} | {
+    readonly kind: "ao";
+    readonly radius?: number;
+    readonly intensity?: number;
+    readonly thickness?: number;
+    readonly quality?: number;
+} | {
+    readonly kind: "smaa";
+    readonly threshold?: number;
+    readonly temporal?: boolean;
+} | {
+    readonly kind: "taa";
+    readonly feedback?: number;
+    readonly sharpness?: number;
+} | {
+    readonly kind: "outline";
+    readonly thickness?: number;
+    readonly depthThreshold?: number;
+    readonly normalThreshold?: number;
+    readonly color?: number;
+} | {
+    readonly kind: "ssr";
+    readonly intensity?: number;
+    readonly maxDistance?: number;
+    readonly thickness?: number;
+    readonly fade?: number;
+} | {
+    readonly kind: "dof";
+    readonly focus?: number;
+    readonly aperture?: number;
+    readonly maxBlur?: number;
+} | {
+    readonly kind: "motion_blur";
+    readonly intensity?: number;
+    readonly samples?: number;
+} | {
+    readonly kind: "lut";
+    readonly texture: TextureId;
+    readonly intensity?: number;
+    readonly size?: number;
+} | {
+    readonly kind: "grain";
+    readonly intensity?: number;
+} | {
+    readonly kind: "god_rays";
+    readonly intensity?: number;
+    readonly decay?: number;
+    readonly density?: number;
+    readonly weight?: number;
+} | {
+    readonly kind: "lens_dirt";
+    readonly texture: TextureId;
+    readonly intensity?: number;
+} | {
+    readonly kind: "sharpen";
+    readonly sharpness?: number;
+} | {
+    readonly kind: "chromatic";
+    readonly amount?: number;
+} | {
+    readonly kind: "mask";
+    readonly texture: TextureId;
+    readonly outline?: boolean;
+    readonly bloom?: boolean;
+    readonly hidden?: number;
+} | {
+    readonly kind: "weather";
+    readonly rain?: number;
+    readonly snow?: number;
+    readonly wetness?: number;
+    readonly night?: number;
+} | {
+    readonly kind: "vignette";
+    readonly offset?: number;
+    readonly darkness?: number;
+} | {
+    readonly kind: "color_grade";
+    readonly exposure?: number;
+    readonly contrast?: number;
+    readonly saturation?: number;
+} | {
+    readonly kind: "shader";
+    readonly shader: ShaderSource;
+    readonly uniforms?: Readonly<Record<string, UniformDesc>>;
+    readonly textures?: readonly TextureId[];
+} | {
+    readonly kind: "lens_flare";
+    readonly intensity?: number;
+    readonly ghosts?: number;
+    readonly halo?: number;
+    readonly dispersal?: number;
+};
+interface PostChainDesc {
+    readonly effects: readonly PostEffectDesc[];
+}
+interface RenderPassDesc {
+    readonly camera: NodeId;
+    readonly target: RenderTargetId | null;
+    readonly layers?: number;
+    readonly clearColor?: number;
+    readonly clearAlpha?: number;
+    readonly order?: number;
+    readonly viewport?: readonly [number, number, number, number];
+    readonly slice?: number;
+    readonly cubeFace?: boolean;
+    readonly reflect?: readonly [number, number, number, number];
+    readonly once?: boolean;
+}
+type ToneMapping = "none" | "linear" | "reinhard" | "aces" | "agx" | "neutral" | "cineon" | "custom";
+type FogDesc = {
+    readonly mode?: "linear";
+    readonly color: number;
+    readonly near: number;
+    readonly far: number;
+} | {
+    readonly mode: "exp2";
+    readonly color: number;
+    readonly density: number;
+} | {
+    readonly mode: "height";
+    readonly color: number;
+    readonly density: number;
+    readonly height: number;
+    readonly falloff: number;
+};
+interface WeatherState {
+    readonly cloudCover?: number;
+    readonly haze?: number;
+    readonly precipitation?: number;
+    readonly snow?: boolean;
+    readonly wetness?: number;
+    readonly wind?: readonly [number, number];
+}
+interface VolumetricFogDesc {
+    readonly density?: number;
+    readonly height?: number;
+    readonly falloff?: number;
+    readonly anisotropy?: number;
+    readonly albedo?: number;
+    readonly noise?: number;
+    readonly range?: number;
+    readonly ambient?: number;
+}
+interface VolumetricCloudsDesc {
+    readonly coverage?: number;
+    readonly density?: number;
+    readonly altitude?: number;
+    readonly thickness?: number;
+    readonly type?: number;
+    readonly shadow?: number;
+    readonly detail?: number;
+}
+interface AtmosphereDesc {
+    readonly rayleigh?: number;
+    readonly mie?: number;
+    readonly mieAnisotropy?: number;
+    readonly ozone?: number;
+    readonly groundAlbedo?: number;
+    readonly sunDiscDegrees?: number;
+}
+interface VolumetricsDesc {
+    readonly enabled?: boolean;
+    readonly fog?: VolumetricFogDesc;
+    readonly clouds?: VolumetricCloudsDesc;
+    readonly atmosphere?: AtmosphereDesc;
+}
+interface CloudDesc {
+    readonly coverage?: number;
+    readonly density?: number;
+    readonly scale?: number;
+    readonly speed?: number;
+    readonly elevation?: number;
+}
+interface SkyDesc {
+    readonly turbidity?: number;
+    readonly rayleigh?: number;
+    readonly mie?: number;
+    readonly mieDirectionalG?: number;
+    readonly clouds?: CloudDesc | false;
+}
+interface EnvironmentDesc {
+    readonly sky?: SkyDesc | false;
+    readonly background?: {
+        readonly color: number;
+    } | {
+        readonly texture: TextureId;
+    } | {
+        readonly environment: true;
+    } | {
+        readonly sky: true;
+    };
+    readonly backgroundBlurriness?: number;
+    readonly backgroundIntensity?: number;
+    readonly environment?: TextureId;
+    readonly environmentIntensity?: number;
+    readonly environmentRotation?: number;
+    readonly fog?: FogDesc;
+    readonly toneMapping?: ToneMapping;
+    readonly toneCurve?: TextureId;
+    readonly exposure?: number;
+    readonly shadows?: boolean;
+    readonly volumetrics?: VolumetricsDesc;
+    readonly gi?: GlobalIlluminationDesc;
+}
+type AssetSource = {
+    readonly url: string;
+} | {
+    readonly bytes: ArrayBuffer;
+} | {
+    readonly text: string;
+};
+interface ModelInfo {
+    readonly id: ModelId;
+    readonly nodeNames: readonly string[];
+    readonly clipNames: readonly string[];
+    readonly materialNames: readonly string[];
+    readonly materials: readonly MaterialId[];
+}
+interface TextureUpgrade {
+    readonly texture: TextureId;
+    readonly inPlace: boolean;
+}
+interface ModelUpgrade {
+    readonly model: ModelInfo;
+    readonly inPlace: boolean;
+}
+interface GraphicsCapabilities {
+    readonly backend: string;
+    readonly dimensions: "2d" | "3d";
+    readonly rendering: boolean;
+    readonly webgpu: boolean;
+    readonly compute: boolean;
+    readonly shaderLanguages: readonly ("wgsl" | "glsl")[];
+    readonly instancing: boolean;
+    readonly skinning: boolean;
+    readonly morphTargets: boolean;
+    readonly renderTargets: boolean;
+    readonly postProcessing: boolean;
+    readonly models: boolean;
+    readonly particles?: boolean;
+    readonly orderIndependentTransparency?: boolean;
+    readonly imageBasedLighting?: boolean;
+    readonly cascadedShadows?: boolean;
+    readonly renderState?: boolean;
+    readonly rawRender?: boolean;
+    readonly decals?: boolean;
+    readonly lod?: boolean;
+    readonly fatLines?: boolean;
+    readonly text?: boolean;
+    readonly picking?: boolean;
+    readonly pointShadows?: boolean;
+    readonly sky?: boolean;
+    readonly customProjection?: boolean;
+    readonly gpuTiming?: boolean;
+    readonly globalIllumination?: boolean;
+    readonly rayTracing?: boolean;
+    readonly vectorSurfaces?: number;
+}
+interface GpuStats {
+    gpuLastNs: number;
+    gpuP50Ns: number;
+    gpuP95Ns: number;
+    gpuBytes: number;
+    thermalTier: number;
+    particlesAlive: number;
+    rawDispatches: number;
+    rawGpuNs: number;
+    rawDisabled: number;
+    transparentSorted: number;
+    textGlyphs: number;
+    drawCalls: number;
+    triangles: number;
+    readonly passNs: Float64Array;
+}
+declare const GPU_PASS_NAMES: readonly ["cull", "particles", "shadow", "main", "overlay", "post", "targets", "gi", "rt", "volumetrics"];
+declare function createGpuStats(): GpuStats;
+interface BatchBuffers {
+    readonly slots: Uint32Array;
+    readonly ranges: Uint32Array;
+}
+interface ViewOffset {
+    readonly fullWidth: number;
+    readonly fullHeight: number;
+    readonly x: number;
+    readonly y: number;
+    readonly width: number;
+    readonly height: number;
+}
+interface GraphicsStats {
+    nodes: number;
+    geometries: number;
+    materials: number;
+    textures: number;
+    renderTargets: number;
+    postChains: number;
+    renderPasses: number;
+    frames: number;
+}
+interface GameSurface {
+    readonly canvas: HTMLCanvasElement | OffscreenCanvas;
+    readonly width: number;
+    readonly height: number;
+    readonly pixelRatio: number;
+}
+
+declare const KERNEL_ISA_VERSION = 4;
+declare const KERNEL_ISA_BASE = 1;
+declare const KERNEL_ISA_CALLS = 2;
+declare const KERNEL_ISA_WRITES = 3;
+declare const KERNEL_FEATURE = "kernel_isa_1";
+declare const KERNEL_CALLS_FEATURE = "kernel_isa_2";
+declare const KERNEL_WRITES_FEATURE = "kernel_isa_3";
+declare const KERNEL_ISA_EXTENDED = 4;
+declare const KERNEL_EXTENDED_FEATURE = "kernel_isa_4";
+declare const PROGRAM_MAGIC = 827345731;
+declare const LIBRARY_MAGIC = 827083587;
+declare const PROGRAM_HEADER_WORDS = 16;
+declare const LIBRARY_HEADER_WORDS = 4;
+declare const INSTRUCTION_WORDS = 4;
+declare const GROUP_WORDS = 4;
+declare const NONE = 4294967295;
+declare const UNIFORM = 2147483648;
+declare const DST_BITS = 8;
+declare const MAX_REGISTERS: number;
+declare const MAX_SLOTS = 256;
+declare const MAX_UNIFORMS: number;
+declare const MAX_GROUPS = 256;
+declare const MAX_TRIPS: number;
+declare const KERNEL_LIBRARY_PATH = "kernels.ckl";
+declare const H_MAGIC = 0;
+declare const H_VERSION = 1;
+declare const H_FLAGS = 2;
+declare const H_REGISTERS = 3;
+declare const H_SLOTS = 4;
+declare const H_ARGS = 5;
+declare const H_CONSTANTS = 6;
+declare const H_LOOPS = 7;
+declare const H_INSTRUCTIONS = 8;
+declare const H_GROUPS = 9;
+declare const H_STATE = 10;
+declare const H_POSITION_X = 11;
+declare const H_POSITION_Y = 12;
+declare const H_POSITION_Z = 13;
+declare const H_EVENTS = 14;
+declare const CHANNEL_WORDS = 4;
+declare const MAX_CHANNELS = 64;
+declare const MAX_EVENT_WORDS = 8;
+declare const EVENT_HEADER_WORDS = 2;
+declare const EVENT_STRIDE: number;
+declare const FLAG_NEIGHBOURS = 1;
+declare const FLAG_GROUPS = 2;
+declare const KIND_F32 = 0;
+declare const KIND_I32 = 1;
+declare const KIND_U32 = 2;
+declare const KIND_BOOL = 3;
+declare const ACCESS_READ: number;
+declare const ACCESS_WRITE: number;
+declare const ACCESS_NEIGHBOUR: number;
+declare const ACCESS_SCRATCH: number;
+declare const ACCESS_HIGH: number;
+declare const ACCESS_SPAWN: number;
+declare const SERVICE_RAYCAST = 1;
+declare const SERVICE_LINE_OF_SIGHT = 2;
+declare const SERVICE_GROUND_HEIGHT = 3;
+declare const SERVICE_PATH = 4;
+declare const SERVICE_FLOW = 5;
+declare const SERVICE_FORCE = 6;
+declare const SERVICE_IMPULSE = 7;
+declare const SERVICE_VELOCITY = 8;
+declare const SERVICE_OVERLAP = 9;
+declare const SERVICE_SWEEP = 10;
+declare const SERVICE_CLIP_WEIGHT = 11;
+declare const SERVICE_PLAY_CLIP = 12;
+declare const SERVICE_IK_TARGET = 13;
+declare const SERVICE_INSTANCE = 14;
+declare const SERVICE_INSTANCE_COLOUR = 15;
+declare const SERVICE_ANCHOR = 16;
+declare const SERVICE_SOUND = 17;
+declare const SERVICE_PICK = 18;
+declare const SERVICE_VOXEL_GET = 19;
+declare const SERVICE_VOXEL_SET = 20;
+declare const SERVICE_CHEMISTRY = 21;
+declare const SERVICE_SPAWN = 22;
+declare const SERVICE_KILL = 23;
+declare const SERVICE_BITS = 8;
+declare const SERVICE_MASK: number;
+declare const MAX_SPAWN_FIELDS = 64;
+declare function serviceOf(dst: number): number;
+declare function operandCount(dst: number): number;
+declare function serviceVersion(service: number): number;
+declare function deferredService(service: number): boolean;
+interface ServiceSignature {
+    readonly args: readonly number[];
+    readonly results: readonly number[];
+}
+declare const SERVICE_SIGNATURES: Readonly<Record<number, ServiceSignature>>;
+declare const ATTACH_UI = 4;
+declare const ATTACH_AUDIO = 5;
+declare const ATTACH_VOXELS = 6;
+declare const ATTACH_CHEMISTRY_GRID = 7;
+declare const ATTACH_SPAWN_TABLE = 9;
+declare const SPAWN_STATS_WORDS = 3;
+declare const GROUP_DEFAULT = 1;
+declare const LOOP_COUNT_F32 = 1;
+declare const Op: {
+    readonly NOP: 0;
+    readonly MOV: 1;
+    readonly LOAD: 2;
+    readonly STORE: 3;
+    readonly ROW: 4;
+    readonly SEL: 5;
+    readonly JNONE: 6;
+    readonly LOOP_INIT: 8;
+    readonly LOOP_NEXT: 9;
+    readonly NEIGHBOURS: 11;
+    readonly NLOAD: 12;
+    readonly OUTER: 13;
+    readonly NROW: 14;
+    readonly ACC_FADD: 15;
+    readonly ACC_FMIN: 16;
+    readonly ACC_FMAX: 17;
+    readonly ACC_IADD: 18;
+    readonly EXT: 19;
+    readonly FADD: 20;
+    readonly FSUB: 21;
+    readonly FMUL: 22;
+    readonly FDIV: 23;
+    readonly FMIN: 24;
+    readonly FMAX: 25;
+    readonly FMOD: 26;
+    readonly FPOW: 27;
+    readonly FATAN2: 28;
+    readonly FMULADD: 29;
+    readonly FMULSUB: 30;
+    readonly FSUBMUL: 31;
+    readonly FADDMUL: 32;
+    readonly FCLAMP: 33;
+    readonly FLERP: 34;
+    readonly FLOG2: 39;
+    readonly FNEG: 40;
+    readonly FABS: 41;
+    readonly FSQRT: 42;
+    readonly FFLOOR: 43;
+    readonly FCEIL: 44;
+    readonly FROUND: 45;
+    readonly FTRUNC: 46;
+    readonly FSIGN: 47;
+    readonly FSIN: 48;
+    readonly FCOS: 49;
+    readonly FTAN: 50;
+    readonly FASIN: 51;
+    readonly FACOS: 52;
+    readonly FATAN: 53;
+    readonly FEXP: 54;
+    readonly FLOG: 55;
+    readonly FLEN2: 56;
+    readonly FLEN3: 57;
+    readonly FDOT2: 58;
+    readonly FDOT3: 59;
+    readonly FLT: 60;
+    readonly FLE: 61;
+    readonly FEQ: 62;
+    readonly FNE: 63;
+    readonly IADD: 70;
+    readonly ISUB: 71;
+    readonly IMUL: 72;
+    readonly IREM: 73;
+    readonly UREM: 74;
+    readonly IAND: 75;
+    readonly IOR: 76;
+    readonly IXOR: 77;
+    readonly ISHL: 78;
+    readonly ISHR: 79;
+    readonly IUSHR: 80;
+    readonly IMIN: 81;
+    readonly IMAX: 82;
+    readonly UMIN: 83;
+    readonly UMAX: 84;
+    readonly INEG: 85;
+    readonly IABS: 86;
+    readonly INOT: 87;
+    readonly ILT: 90;
+    readonly ILE: 91;
+    readonly IEQ: 92;
+    readonly INE: 93;
+    readonly ULT: 94;
+    readonly ULE: 95;
+    readonly ITOF: 100;
+    readonly UTOF: 101;
+    readonly FTOI: 102;
+    readonly BTOF: 103;
+    readonly BTOI: 104;
+    readonly FTOB: 105;
+    readonly ITOB: 106;
+    readonly MAND: 110;
+    readonly MOR: 111;
+    readonly MANDN: 112;
+    readonly MNOT: 113;
+    readonly NOISE2: 120;
+    readonly NOISE3: 121;
+    readonly HASH: 122;
+    readonly RAND: 123;
+    readonly EMIT: 124;
+    readonly CALL: 125;
+    readonly UADDC: 126;
+    readonly USUBB: 127;
+    readonly UMULHI: 128;
+};
+type OpCode = (typeof Op)[keyof typeof Op];
+declare const STATUS_FAILURE = 0;
+declare const STATUS_SUCCESS = 1;
+declare const STATUS_RUNNING = 2;
+declare const KERNEL_EXPORT_NAMES: readonly ["engine_kernel_isa", "engine_kernel_load", "engine_kernel_unload", "engine_kernel_bind", "engine_kernel_unbind", "engine_kernel_run", "engine_kernel_events", "engine_kernel_clear_events"];
+declare const KERNEL_CALL_EXPORT_NAMES: readonly ["engine_kernel_attach"];
+declare const KERNEL_WRITE_EXPORT_NAMES: readonly ["engine_kernel_attach_handle", "engine_kernel_spawns"];
+declare const KERNEL_STAGE_EXPORT_NAMES: readonly ["engine_kernel_stage_begin", "engine_kernel_stage_uniforms", "engine_kernel_stage_column", "engine_kernel_stage_storage", "engine_kernel_stage_records", "engine_kernel_stage_call", "engine_kernel_stage_finish", "engine_kernel_stage_end"];
+declare const KERNEL_DATA_EXPORT_NAMES: readonly ["engine_kernel_bind_table", "engine_kernel_bind_pool", "engine_kernel_data"];
+declare const DATA_REPORT_HEADER = 70;
+declare const RING_HEADER_WORDS = 2;
+declare const RING_COUNT = 0;
+declare const RING_DROPPED = 1;
+declare const DEFAULT_EVENT_CAPACITY = 4096;
+declare const CROSS_OP: {
+    readonly REDUCE: 160;
+    readonly ARG: 161;
+    readonly HIST: 162;
+    readonly SCATTER: 163;
+    readonly SCAN: 164;
+    readonly COMPACT: 165;
+};
+declare const ACCESS_ARRAY: number;
+declare const CROSS_BLOCK = 256;
+declare const REDUCE_FSUM = 0;
+declare const REDUCE_ISUM = 1;
+declare const REDUCE_FMIN = 2;
+declare const REDUCE_FMAX = 3;
+declare const REDUCE_IMIN = 4;
+declare const REDUCE_IMAX = 5;
+declare const REDUCE_UMIN = 6;
+declare const REDUCE_UMAX = 7;
+declare const ARG_FMIN = 0;
+declare const ARG_FMAX = 1;
+declare const ARG_IMIN = 2;
+declare const ARG_IMAX = 3;
+declare const ARG_UMIN = 4;
+declare const ARG_UMAX = 5;
+declare const SCATTER_FADD = 0;
+declare const SCATTER_IADD = 1;
+declare const SCAN_F_INCLUSIVE = 0;
+declare const SCAN_F_EXCLUSIVE = 1;
+declare const SCAN_I_INCLUSIVE = 2;
+declare const SCAN_I_EXCLUSIVE = 3;
+declare function crossRow(op: number): boolean;
+declare const LOOKUP_OP: {
+    readonly CURVE: 176;
+    readonly LUT1: 177;
+    readonly LUT2: 178;
+    readonly SAMPLE: 179;
+    readonly CELL: 180;
+};
+declare const ACCESS_INDEXED: number;
+declare const CURVE_STEP = 0;
+declare const CURVE_LINEAR = 1;
+declare const CURVE_HERMITE = 2;
+declare const CURVE_BEZIER = 3;
+declare const CURVE_HEADER = 4;
+declare const CURVE_MAX_KEYS = 256;
+declare const CURVE_MAX_CHANNELS = 4;
+declare const LUT1_HEADER = 4;
+declare const LUT1_MAX: number;
+declare const LUT2_HEADER = 8;
+declare const LUT2_MAX: number;
+declare const LUT_LINEAR = 1;
+declare const LUT_WRAP = 2;
+declare const SAMPLER_WORDS = 8;
+declare const SAMPLE_NEAREST = 0;
+declare const SAMPLE_BILINEAR = 1;
+declare const SAMPLE_NORMAL_X = 2;
+declare const SAMPLE_NORMAL_Y = 3;
+declare const SAMPLE_NORMAL_Z = 4;
+declare const CELL_WRAP: number;
+declare function lookupOp(op: number): boolean;
+declare const XOP_QUERY = 4096;
+declare const XOP_QSHAPE = 4097;
+declare const XOP_QFILTER = 4098;
+declare const XOP_QSTOP = 4099;
+declare const XOP_QRANK = 4100;
+declare const KERNEL_QUERY_RANK_FEATURE = "kernel_query_rank_1";
+declare const QUERY_SPHERE = 0;
+declare const QUERY_CONE = 1;
+declare const QUERY_BOX = 2;
+declare const QUERY_SEGMENT = 3;
+declare const QUERY_SHAPE = 3;
+declare const QUERY_FILTERED = 4;
+declare const QFILTER_EQUAL = 1;
+declare const QFILTER_ANY = 2;
+declare const QFILTER_NONE = 3;
+declare function curveWords(kind: number, keys: number, channels: number): number;
+declare const XOP = 175;
+declare const XOP_MAX = 65535;
+declare const XOP_RANGE_SHIFT = 12;
+declare const XOP_RANGE: {
+    readonly CROSS: 0;
+    readonly SAMPLING: 1;
+    readonly NARROW: 2;
+    readonly DATA: 3;
+    readonly STDLIB: 4;
+    readonly SYSTEMS: 5;
+    readonly NEURAL: 6;
+    readonly SIMD: 7;
+};
+declare const XOP_MLP_IN = 24576;
+declare const XOP_MLP_RUN = 24577;
+declare const XOP_MLP_OUT = 24578;
+declare const XOP_MLP_MOE = 24579;
+declare const KERNEL_MOE_FEATURE = "kernel_moe_1";
+declare const MLP_MAX_WIDTH = 128;
+declare const MLP_MAX_OUTPUTS = 32;
+declare const SIMD_MAP = 28672;
+declare const SIMD_MAP_OPS = 256;
+declare const SIMD_SHUFFLE = 28928;
+declare const SIMD_EXTRACT = 28929;
+declare const SIMD_REPLACE = 28930;
+declare const SIMD_PACK = 28931;
+declare const SIMD_DOT = 28944;
+declare const SIMD_REDUCE = 28945;
+declare const SIMD_LENGTH = 28946;
+declare const SIMD_NORMALIZE = 28947;
+declare const SIMD_CROSS = 28948;
+declare const SIMD_MIN_WIDTH = 2;
+declare const SIMD_MAX_WIDTH = 4;
+declare const SIMD_WIDTH_MASK = 7;
+declare const SIMD_SCALAR_A: number;
+declare const SIMD_SCALAR_B: number;
+declare const SIMD_SCALAR_C: number;
+declare const SIMD_LANE_BITS = 3;
+declare const SIMD_LANE_MASK: number;
+declare const SIMD_DOT_F32 = 0;
+declare const SIMD_DOT_I32 = 1;
+declare const SIMD_CROSS_WIDTH = 3;
+declare const KERNEL_SIMD_FEATURE = "kernel_simd_1";
+declare function xopRange(sub: number): number;
+declare const ACCESS_TABLE_SHIFT = 19;
+declare const ACCESS_TABLE_MASK = 15;
+declare const ACCESS_TABLE: number;
+declare const ACCESS_POOL: number;
+declare const DATA_TABLES = 16;
+declare const DATA_KEYOF = 12288;
+declare const DATA_ROWOF = 12289;
+declare const DATA_FLOAD = 12290;
+declare const DATA_ROWS = 12291;
+declare const DATA_LIST = 12304;
+declare const DATA_PGET = 12305;
+declare const DATA_PSET = 12306;
+declare const DATA_TALLY = 12307;
+declare const DATA_SEND = 12320;
+declare const DATA_PICK = 12336;
+declare const DATA_LIST_MAX = 4096;
+declare const DATA_TALLIES = 64;
+declare const SEND: {
+    readonly SET: 0;
+    readonly FADD: 1;
+    readonly FMUL: 2;
+    readonly FMIN: 3;
+    readonly FMAX: 4;
+    readonly IADD: 5;
+    readonly IMIN: 6;
+    readonly IMAX: 7;
+    readonly UMIN: 8;
+    readonly UMAX: 9;
+    readonly OR: 10;
+    readonly AND: 11;
+    readonly PUSH: 12;
+};
+declare const PICK_U32 = 0;
+declare const PICK_F32 = 1;
+declare const XOP_SORT = 1;
+declare const XOP_TOPK = 2;
+declare const XOP_GROUP = 3;
+declare const XOP_DEDUP = 4;
+declare const XOP_GATHER = 16;
+declare const XOP_FIELD = 17;
+declare const FIELD_MAX = 64;
+declare const KERNEL_GATHER_FEATURE = "kernel_gather_1";
+declare const XOP_RECUR = 32;
+declare const XOP_RECUR_IN = 33;
+declare const KERNEL_SCAN_FEATURE = "kernel_scan_1";
+declare const KERNEL_MLP_FEATURE = "kernel_mlp_1";
+declare const RECUR: {
+    readonly LINEAR_F32: 0;
+    readonly LINEAR_U32: 1;
+    readonly FEEDBACK_F32: 2;
+    readonly PHASE_F64: 3;
+    readonly ADD_F32: 4;
+    readonly MUL_F32: 5;
+    readonly MIN_F32: 6;
+    readonly MAX_F32: 7;
+    readonly ADD_INT: 8;
+    readonly MUL_INT: 9;
+    readonly MIN_I32: 10;
+    readonly MAX_I32: 11;
+    readonly MIN_U32: 12;
+    readonly MAX_U32: 13;
+    readonly AND: 14;
+    readonly OR: 15;
+    readonly XOR: 16;
+};
+declare const RECUR_KINDS = 17;
+declare const RECUR_KIND_MASK = 31;
+declare const RECUR_EXCLUSIVE = 32;
+declare const RECUR_WIDE = 64;
+declare function recurSub(sub: number): boolean;
+declare function recurStateWords(kind: number): number;
+declare function recurCoefficient(kind: number): boolean;
+declare function recurFloatOutput(kind: number): boolean;
+declare const XOP_COMPONENTS_GRID = 20480;
+declare const XOP_REACH_GRID = 20481;
+declare const XOP_PROPAGATE_GRID = 20482;
+declare const XOP_COMPONENTS_EDGES = 20483;
+declare const GRAPH_EMPTY = 4294967295;
+declare const SORT_KEY_U32 = 0;
+declare const SORT_KEY_I32 = 1;
+declare const SORT_KEY_F32 = 2;
+declare const SORT_KEY_MASK = 3;
+declare const SORT_DESCENDING = 4;
+declare const SORT_RADIX_BITS = 8;
+declare function sortKey(kind: number, raw: number): number;
+declare function stageEnds(sub: number): boolean;
+declare function stageEndingOp(op: number, sub: number): boolean;
+
+declare const isa_ACCESS_ARRAY: typeof ACCESS_ARRAY;
+declare const isa_ACCESS_HIGH: typeof ACCESS_HIGH;
+declare const isa_ACCESS_INDEXED: typeof ACCESS_INDEXED;
+declare const isa_ACCESS_NEIGHBOUR: typeof ACCESS_NEIGHBOUR;
+declare const isa_ACCESS_POOL: typeof ACCESS_POOL;
+declare const isa_ACCESS_READ: typeof ACCESS_READ;
+declare const isa_ACCESS_SCRATCH: typeof ACCESS_SCRATCH;
+declare const isa_ACCESS_SPAWN: typeof ACCESS_SPAWN;
+declare const isa_ACCESS_TABLE: typeof ACCESS_TABLE;
+declare const isa_ACCESS_TABLE_MASK: typeof ACCESS_TABLE_MASK;
+declare const isa_ACCESS_TABLE_SHIFT: typeof ACCESS_TABLE_SHIFT;
+declare const isa_ACCESS_WRITE: typeof ACCESS_WRITE;
+declare const isa_ARG_FMAX: typeof ARG_FMAX;
+declare const isa_ARG_FMIN: typeof ARG_FMIN;
+declare const isa_ARG_IMAX: typeof ARG_IMAX;
+declare const isa_ARG_IMIN: typeof ARG_IMIN;
+declare const isa_ARG_UMAX: typeof ARG_UMAX;
+declare const isa_ARG_UMIN: typeof ARG_UMIN;
+declare const isa_ATTACH_AUDIO: typeof ATTACH_AUDIO;
+declare const isa_ATTACH_CHEMISTRY_GRID: typeof ATTACH_CHEMISTRY_GRID;
+declare const isa_ATTACH_SPAWN_TABLE: typeof ATTACH_SPAWN_TABLE;
+declare const isa_ATTACH_UI: typeof ATTACH_UI;
+declare const isa_ATTACH_VOXELS: typeof ATTACH_VOXELS;
+declare const isa_CELL_WRAP: typeof CELL_WRAP;
+declare const isa_CHANNEL_WORDS: typeof CHANNEL_WORDS;
+declare const isa_CROSS_BLOCK: typeof CROSS_BLOCK;
+declare const isa_CROSS_OP: typeof CROSS_OP;
+declare const isa_CURVE_BEZIER: typeof CURVE_BEZIER;
+declare const isa_CURVE_HEADER: typeof CURVE_HEADER;
+declare const isa_CURVE_HERMITE: typeof CURVE_HERMITE;
+declare const isa_CURVE_LINEAR: typeof CURVE_LINEAR;
+declare const isa_CURVE_MAX_CHANNELS: typeof CURVE_MAX_CHANNELS;
+declare const isa_CURVE_MAX_KEYS: typeof CURVE_MAX_KEYS;
+declare const isa_CURVE_STEP: typeof CURVE_STEP;
+declare const isa_DATA_FLOAD: typeof DATA_FLOAD;
+declare const isa_DATA_KEYOF: typeof DATA_KEYOF;
+declare const isa_DATA_LIST: typeof DATA_LIST;
+declare const isa_DATA_LIST_MAX: typeof DATA_LIST_MAX;
+declare const isa_DATA_PGET: typeof DATA_PGET;
+declare const isa_DATA_PICK: typeof DATA_PICK;
+declare const isa_DATA_PSET: typeof DATA_PSET;
+declare const isa_DATA_REPORT_HEADER: typeof DATA_REPORT_HEADER;
+declare const isa_DATA_ROWOF: typeof DATA_ROWOF;
+declare const isa_DATA_ROWS: typeof DATA_ROWS;
+declare const isa_DATA_SEND: typeof DATA_SEND;
+declare const isa_DATA_TABLES: typeof DATA_TABLES;
+declare const isa_DATA_TALLIES: typeof DATA_TALLIES;
+declare const isa_DATA_TALLY: typeof DATA_TALLY;
+declare const isa_DEFAULT_EVENT_CAPACITY: typeof DEFAULT_EVENT_CAPACITY;
+declare const isa_DST_BITS: typeof DST_BITS;
+declare const isa_EVENT_HEADER_WORDS: typeof EVENT_HEADER_WORDS;
+declare const isa_EVENT_STRIDE: typeof EVENT_STRIDE;
+declare const isa_FIELD_MAX: typeof FIELD_MAX;
+declare const isa_FLAG_GROUPS: typeof FLAG_GROUPS;
+declare const isa_FLAG_NEIGHBOURS: typeof FLAG_NEIGHBOURS;
+declare const isa_GRAPH_EMPTY: typeof GRAPH_EMPTY;
+declare const isa_GROUP_DEFAULT: typeof GROUP_DEFAULT;
+declare const isa_GROUP_WORDS: typeof GROUP_WORDS;
+declare const isa_H_ARGS: typeof H_ARGS;
+declare const isa_H_CONSTANTS: typeof H_CONSTANTS;
+declare const isa_H_EVENTS: typeof H_EVENTS;
+declare const isa_H_FLAGS: typeof H_FLAGS;
+declare const isa_H_GROUPS: typeof H_GROUPS;
+declare const isa_H_INSTRUCTIONS: typeof H_INSTRUCTIONS;
+declare const isa_H_LOOPS: typeof H_LOOPS;
+declare const isa_H_MAGIC: typeof H_MAGIC;
+declare const isa_H_POSITION_X: typeof H_POSITION_X;
+declare const isa_H_POSITION_Y: typeof H_POSITION_Y;
+declare const isa_H_POSITION_Z: typeof H_POSITION_Z;
+declare const isa_H_REGISTERS: typeof H_REGISTERS;
+declare const isa_H_SLOTS: typeof H_SLOTS;
+declare const isa_H_STATE: typeof H_STATE;
+declare const isa_H_VERSION: typeof H_VERSION;
+declare const isa_INSTRUCTION_WORDS: typeof INSTRUCTION_WORDS;
+declare const isa_KERNEL_CALLS_FEATURE: typeof KERNEL_CALLS_FEATURE;
+declare const isa_KERNEL_CALL_EXPORT_NAMES: typeof KERNEL_CALL_EXPORT_NAMES;
+declare const isa_KERNEL_DATA_EXPORT_NAMES: typeof KERNEL_DATA_EXPORT_NAMES;
+declare const isa_KERNEL_EXPORT_NAMES: typeof KERNEL_EXPORT_NAMES;
+declare const isa_KERNEL_EXTENDED_FEATURE: typeof KERNEL_EXTENDED_FEATURE;
+declare const isa_KERNEL_FEATURE: typeof KERNEL_FEATURE;
+declare const isa_KERNEL_GATHER_FEATURE: typeof KERNEL_GATHER_FEATURE;
+declare const isa_KERNEL_ISA_BASE: typeof KERNEL_ISA_BASE;
+declare const isa_KERNEL_ISA_CALLS: typeof KERNEL_ISA_CALLS;
+declare const isa_KERNEL_ISA_EXTENDED: typeof KERNEL_ISA_EXTENDED;
+declare const isa_KERNEL_ISA_VERSION: typeof KERNEL_ISA_VERSION;
+declare const isa_KERNEL_ISA_WRITES: typeof KERNEL_ISA_WRITES;
+declare const isa_KERNEL_LIBRARY_PATH: typeof KERNEL_LIBRARY_PATH;
+declare const isa_KERNEL_MLP_FEATURE: typeof KERNEL_MLP_FEATURE;
+declare const isa_KERNEL_MOE_FEATURE: typeof KERNEL_MOE_FEATURE;
+declare const isa_KERNEL_QUERY_RANK_FEATURE: typeof KERNEL_QUERY_RANK_FEATURE;
+declare const isa_KERNEL_SCAN_FEATURE: typeof KERNEL_SCAN_FEATURE;
+declare const isa_KERNEL_SIMD_FEATURE: typeof KERNEL_SIMD_FEATURE;
+declare const isa_KERNEL_STAGE_EXPORT_NAMES: typeof KERNEL_STAGE_EXPORT_NAMES;
+declare const isa_KERNEL_WRITES_FEATURE: typeof KERNEL_WRITES_FEATURE;
+declare const isa_KERNEL_WRITE_EXPORT_NAMES: typeof KERNEL_WRITE_EXPORT_NAMES;
+declare const isa_KIND_BOOL: typeof KIND_BOOL;
+declare const isa_KIND_F32: typeof KIND_F32;
+declare const isa_KIND_I32: typeof KIND_I32;
+declare const isa_KIND_U32: typeof KIND_U32;
+declare const isa_LIBRARY_HEADER_WORDS: typeof LIBRARY_HEADER_WORDS;
+declare const isa_LIBRARY_MAGIC: typeof LIBRARY_MAGIC;
+declare const isa_LOOKUP_OP: typeof LOOKUP_OP;
+declare const isa_LOOP_COUNT_F32: typeof LOOP_COUNT_F32;
+declare const isa_LUT1_HEADER: typeof LUT1_HEADER;
+declare const isa_LUT1_MAX: typeof LUT1_MAX;
+declare const isa_LUT2_HEADER: typeof LUT2_HEADER;
+declare const isa_LUT2_MAX: typeof LUT2_MAX;
+declare const isa_LUT_LINEAR: typeof LUT_LINEAR;
+declare const isa_LUT_WRAP: typeof LUT_WRAP;
+declare const isa_MAX_CHANNELS: typeof MAX_CHANNELS;
+declare const isa_MAX_EVENT_WORDS: typeof MAX_EVENT_WORDS;
+declare const isa_MAX_GROUPS: typeof MAX_GROUPS;
+declare const isa_MAX_REGISTERS: typeof MAX_REGISTERS;
+declare const isa_MAX_SLOTS: typeof MAX_SLOTS;
+declare const isa_MAX_SPAWN_FIELDS: typeof MAX_SPAWN_FIELDS;
+declare const isa_MAX_TRIPS: typeof MAX_TRIPS;
+declare const isa_MAX_UNIFORMS: typeof MAX_UNIFORMS;
+declare const isa_MLP_MAX_OUTPUTS: typeof MLP_MAX_OUTPUTS;
+declare const isa_MLP_MAX_WIDTH: typeof MLP_MAX_WIDTH;
+declare const isa_NONE: typeof NONE;
+declare const isa_Op: typeof Op;
+type isa_OpCode = OpCode;
+declare const isa_PICK_F32: typeof PICK_F32;
+declare const isa_PICK_U32: typeof PICK_U32;
+declare const isa_PROGRAM_HEADER_WORDS: typeof PROGRAM_HEADER_WORDS;
+declare const isa_PROGRAM_MAGIC: typeof PROGRAM_MAGIC;
+declare const isa_QFILTER_ANY: typeof QFILTER_ANY;
+declare const isa_QFILTER_EQUAL: typeof QFILTER_EQUAL;
+declare const isa_QFILTER_NONE: typeof QFILTER_NONE;
+declare const isa_QUERY_BOX: typeof QUERY_BOX;
+declare const isa_QUERY_CONE: typeof QUERY_CONE;
+declare const isa_QUERY_FILTERED: typeof QUERY_FILTERED;
+declare const isa_QUERY_SEGMENT: typeof QUERY_SEGMENT;
+declare const isa_QUERY_SHAPE: typeof QUERY_SHAPE;
+declare const isa_QUERY_SPHERE: typeof QUERY_SPHERE;
+declare const isa_RECUR: typeof RECUR;
+declare const isa_RECUR_EXCLUSIVE: typeof RECUR_EXCLUSIVE;
+declare const isa_RECUR_KINDS: typeof RECUR_KINDS;
+declare const isa_RECUR_KIND_MASK: typeof RECUR_KIND_MASK;
+declare const isa_RECUR_WIDE: typeof RECUR_WIDE;
+declare const isa_REDUCE_FMAX: typeof REDUCE_FMAX;
+declare const isa_REDUCE_FMIN: typeof REDUCE_FMIN;
+declare const isa_REDUCE_FSUM: typeof REDUCE_FSUM;
+declare const isa_REDUCE_IMAX: typeof REDUCE_IMAX;
+declare const isa_REDUCE_IMIN: typeof REDUCE_IMIN;
+declare const isa_REDUCE_ISUM: typeof REDUCE_ISUM;
+declare const isa_REDUCE_UMAX: typeof REDUCE_UMAX;
+declare const isa_REDUCE_UMIN: typeof REDUCE_UMIN;
+declare const isa_RING_COUNT: typeof RING_COUNT;
+declare const isa_RING_DROPPED: typeof RING_DROPPED;
+declare const isa_RING_HEADER_WORDS: typeof RING_HEADER_WORDS;
+declare const isa_SAMPLER_WORDS: typeof SAMPLER_WORDS;
+declare const isa_SAMPLE_BILINEAR: typeof SAMPLE_BILINEAR;
+declare const isa_SAMPLE_NEAREST: typeof SAMPLE_NEAREST;
+declare const isa_SAMPLE_NORMAL_X: typeof SAMPLE_NORMAL_X;
+declare const isa_SAMPLE_NORMAL_Y: typeof SAMPLE_NORMAL_Y;
+declare const isa_SAMPLE_NORMAL_Z: typeof SAMPLE_NORMAL_Z;
+declare const isa_SCAN_F_EXCLUSIVE: typeof SCAN_F_EXCLUSIVE;
+declare const isa_SCAN_F_INCLUSIVE: typeof SCAN_F_INCLUSIVE;
+declare const isa_SCAN_I_EXCLUSIVE: typeof SCAN_I_EXCLUSIVE;
+declare const isa_SCAN_I_INCLUSIVE: typeof SCAN_I_INCLUSIVE;
+declare const isa_SCATTER_FADD: typeof SCATTER_FADD;
+declare const isa_SCATTER_IADD: typeof SCATTER_IADD;
+declare const isa_SEND: typeof SEND;
+declare const isa_SERVICE_ANCHOR: typeof SERVICE_ANCHOR;
+declare const isa_SERVICE_BITS: typeof SERVICE_BITS;
+declare const isa_SERVICE_CHEMISTRY: typeof SERVICE_CHEMISTRY;
+declare const isa_SERVICE_CLIP_WEIGHT: typeof SERVICE_CLIP_WEIGHT;
+declare const isa_SERVICE_FLOW: typeof SERVICE_FLOW;
+declare const isa_SERVICE_FORCE: typeof SERVICE_FORCE;
+declare const isa_SERVICE_GROUND_HEIGHT: typeof SERVICE_GROUND_HEIGHT;
+declare const isa_SERVICE_IK_TARGET: typeof SERVICE_IK_TARGET;
+declare const isa_SERVICE_IMPULSE: typeof SERVICE_IMPULSE;
+declare const isa_SERVICE_INSTANCE: typeof SERVICE_INSTANCE;
+declare const isa_SERVICE_INSTANCE_COLOUR: typeof SERVICE_INSTANCE_COLOUR;
+declare const isa_SERVICE_KILL: typeof SERVICE_KILL;
+declare const isa_SERVICE_LINE_OF_SIGHT: typeof SERVICE_LINE_OF_SIGHT;
+declare const isa_SERVICE_MASK: typeof SERVICE_MASK;
+declare const isa_SERVICE_OVERLAP: typeof SERVICE_OVERLAP;
+declare const isa_SERVICE_PATH: typeof SERVICE_PATH;
+declare const isa_SERVICE_PICK: typeof SERVICE_PICK;
+declare const isa_SERVICE_PLAY_CLIP: typeof SERVICE_PLAY_CLIP;
+declare const isa_SERVICE_RAYCAST: typeof SERVICE_RAYCAST;
+declare const isa_SERVICE_SIGNATURES: typeof SERVICE_SIGNATURES;
+declare const isa_SERVICE_SOUND: typeof SERVICE_SOUND;
+declare const isa_SERVICE_SPAWN: typeof SERVICE_SPAWN;
+declare const isa_SERVICE_SWEEP: typeof SERVICE_SWEEP;
+declare const isa_SERVICE_VELOCITY: typeof SERVICE_VELOCITY;
+declare const isa_SERVICE_VOXEL_GET: typeof SERVICE_VOXEL_GET;
+declare const isa_SERVICE_VOXEL_SET: typeof SERVICE_VOXEL_SET;
+declare const isa_SIMD_CROSS: typeof SIMD_CROSS;
+declare const isa_SIMD_CROSS_WIDTH: typeof SIMD_CROSS_WIDTH;
+declare const isa_SIMD_DOT: typeof SIMD_DOT;
+declare const isa_SIMD_DOT_F32: typeof SIMD_DOT_F32;
+declare const isa_SIMD_DOT_I32: typeof SIMD_DOT_I32;
+declare const isa_SIMD_EXTRACT: typeof SIMD_EXTRACT;
+declare const isa_SIMD_LANE_BITS: typeof SIMD_LANE_BITS;
+declare const isa_SIMD_LANE_MASK: typeof SIMD_LANE_MASK;
+declare const isa_SIMD_LENGTH: typeof SIMD_LENGTH;
+declare const isa_SIMD_MAP: typeof SIMD_MAP;
+declare const isa_SIMD_MAP_OPS: typeof SIMD_MAP_OPS;
+declare const isa_SIMD_MAX_WIDTH: typeof SIMD_MAX_WIDTH;
+declare const isa_SIMD_MIN_WIDTH: typeof SIMD_MIN_WIDTH;
+declare const isa_SIMD_NORMALIZE: typeof SIMD_NORMALIZE;
+declare const isa_SIMD_PACK: typeof SIMD_PACK;
+declare const isa_SIMD_REDUCE: typeof SIMD_REDUCE;
+declare const isa_SIMD_REPLACE: typeof SIMD_REPLACE;
+declare const isa_SIMD_SCALAR_A: typeof SIMD_SCALAR_A;
+declare const isa_SIMD_SCALAR_B: typeof SIMD_SCALAR_B;
+declare const isa_SIMD_SCALAR_C: typeof SIMD_SCALAR_C;
+declare const isa_SIMD_SHUFFLE: typeof SIMD_SHUFFLE;
+declare const isa_SIMD_WIDTH_MASK: typeof SIMD_WIDTH_MASK;
+declare const isa_SORT_DESCENDING: typeof SORT_DESCENDING;
+declare const isa_SORT_KEY_F32: typeof SORT_KEY_F32;
+declare const isa_SORT_KEY_I32: typeof SORT_KEY_I32;
+declare const isa_SORT_KEY_MASK: typeof SORT_KEY_MASK;
+declare const isa_SORT_KEY_U32: typeof SORT_KEY_U32;
+declare const isa_SORT_RADIX_BITS: typeof SORT_RADIX_BITS;
+declare const isa_SPAWN_STATS_WORDS: typeof SPAWN_STATS_WORDS;
+declare const isa_STATUS_FAILURE: typeof STATUS_FAILURE;
+declare const isa_STATUS_RUNNING: typeof STATUS_RUNNING;
+declare const isa_STATUS_SUCCESS: typeof STATUS_SUCCESS;
+type isa_ServiceSignature = ServiceSignature;
+declare const isa_UNIFORM: typeof UNIFORM;
+declare const isa_XOP: typeof XOP;
+declare const isa_XOP_COMPONENTS_EDGES: typeof XOP_COMPONENTS_EDGES;
+declare const isa_XOP_COMPONENTS_GRID: typeof XOP_COMPONENTS_GRID;
+declare const isa_XOP_DEDUP: typeof XOP_DEDUP;
+declare const isa_XOP_FIELD: typeof XOP_FIELD;
+declare const isa_XOP_GATHER: typeof XOP_GATHER;
+declare const isa_XOP_GROUP: typeof XOP_GROUP;
+declare const isa_XOP_MAX: typeof XOP_MAX;
+declare const isa_XOP_MLP_IN: typeof XOP_MLP_IN;
+declare const isa_XOP_MLP_MOE: typeof XOP_MLP_MOE;
+declare const isa_XOP_MLP_OUT: typeof XOP_MLP_OUT;
+declare const isa_XOP_MLP_RUN: typeof XOP_MLP_RUN;
+declare const isa_XOP_PROPAGATE_GRID: typeof XOP_PROPAGATE_GRID;
+declare const isa_XOP_QFILTER: typeof XOP_QFILTER;
+declare const isa_XOP_QRANK: typeof XOP_QRANK;
+declare const isa_XOP_QSHAPE: typeof XOP_QSHAPE;
+declare const isa_XOP_QSTOP: typeof XOP_QSTOP;
+declare const isa_XOP_QUERY: typeof XOP_QUERY;
+declare const isa_XOP_RANGE: typeof XOP_RANGE;
+declare const isa_XOP_RANGE_SHIFT: typeof XOP_RANGE_SHIFT;
+declare const isa_XOP_REACH_GRID: typeof XOP_REACH_GRID;
+declare const isa_XOP_RECUR: typeof XOP_RECUR;
+declare const isa_XOP_RECUR_IN: typeof XOP_RECUR_IN;
+declare const isa_XOP_SORT: typeof XOP_SORT;
+declare const isa_XOP_TOPK: typeof XOP_TOPK;
+declare const isa_crossRow: typeof crossRow;
+declare const isa_curveWords: typeof curveWords;
+declare const isa_deferredService: typeof deferredService;
+declare const isa_lookupOp: typeof lookupOp;
+declare const isa_operandCount: typeof operandCount;
+declare const isa_recurCoefficient: typeof recurCoefficient;
+declare const isa_recurFloatOutput: typeof recurFloatOutput;
+declare const isa_recurStateWords: typeof recurStateWords;
+declare const isa_recurSub: typeof recurSub;
+declare const isa_serviceOf: typeof serviceOf;
+declare const isa_serviceVersion: typeof serviceVersion;
+declare const isa_sortKey: typeof sortKey;
+declare const isa_stageEndingOp: typeof stageEndingOp;
+declare const isa_stageEnds: typeof stageEnds;
+declare const isa_xopRange: typeof xopRange;
+declare namespace isa {
+  export { isa_ACCESS_ARRAY as ACCESS_ARRAY, isa_ACCESS_HIGH as ACCESS_HIGH, isa_ACCESS_INDEXED as ACCESS_INDEXED, isa_ACCESS_NEIGHBOUR as ACCESS_NEIGHBOUR, isa_ACCESS_POOL as ACCESS_POOL, isa_ACCESS_READ as ACCESS_READ, isa_ACCESS_SCRATCH as ACCESS_SCRATCH, isa_ACCESS_SPAWN as ACCESS_SPAWN, isa_ACCESS_TABLE as ACCESS_TABLE, isa_ACCESS_TABLE_MASK as ACCESS_TABLE_MASK, isa_ACCESS_TABLE_SHIFT as ACCESS_TABLE_SHIFT, isa_ACCESS_WRITE as ACCESS_WRITE, isa_ARG_FMAX as ARG_FMAX, isa_ARG_FMIN as ARG_FMIN, isa_ARG_IMAX as ARG_IMAX, isa_ARG_IMIN as ARG_IMIN, isa_ARG_UMAX as ARG_UMAX, isa_ARG_UMIN as ARG_UMIN, isa_ATTACH_AUDIO as ATTACH_AUDIO, isa_ATTACH_CHEMISTRY_GRID as ATTACH_CHEMISTRY_GRID, isa_ATTACH_SPAWN_TABLE as ATTACH_SPAWN_TABLE, isa_ATTACH_UI as ATTACH_UI, isa_ATTACH_VOXELS as ATTACH_VOXELS, isa_CELL_WRAP as CELL_WRAP, isa_CHANNEL_WORDS as CHANNEL_WORDS, isa_CROSS_BLOCK as CROSS_BLOCK, isa_CROSS_OP as CROSS_OP, isa_CURVE_BEZIER as CURVE_BEZIER, isa_CURVE_HEADER as CURVE_HEADER, isa_CURVE_HERMITE as CURVE_HERMITE, isa_CURVE_LINEAR as CURVE_LINEAR, isa_CURVE_MAX_CHANNELS as CURVE_MAX_CHANNELS, isa_CURVE_MAX_KEYS as CURVE_MAX_KEYS, isa_CURVE_STEP as CURVE_STEP, isa_DATA_FLOAD as DATA_FLOAD, isa_DATA_KEYOF as DATA_KEYOF, isa_DATA_LIST as DATA_LIST, isa_DATA_LIST_MAX as DATA_LIST_MAX, isa_DATA_PGET as DATA_PGET, isa_DATA_PICK as DATA_PICK, isa_DATA_PSET as DATA_PSET, isa_DATA_REPORT_HEADER as DATA_REPORT_HEADER, isa_DATA_ROWOF as DATA_ROWOF, isa_DATA_ROWS as DATA_ROWS, isa_DATA_SEND as DATA_SEND, isa_DATA_TABLES as DATA_TABLES, isa_DATA_TALLIES as DATA_TALLIES, isa_DATA_TALLY as DATA_TALLY, isa_DEFAULT_EVENT_CAPACITY as DEFAULT_EVENT_CAPACITY, isa_DST_BITS as DST_BITS, isa_EVENT_HEADER_WORDS as EVENT_HEADER_WORDS, isa_EVENT_STRIDE as EVENT_STRIDE, isa_FIELD_MAX as FIELD_MAX, isa_FLAG_GROUPS as FLAG_GROUPS, isa_FLAG_NEIGHBOURS as FLAG_NEIGHBOURS, isa_GRAPH_EMPTY as GRAPH_EMPTY, isa_GROUP_DEFAULT as GROUP_DEFAULT, isa_GROUP_WORDS as GROUP_WORDS, isa_H_ARGS as H_ARGS, isa_H_CONSTANTS as H_CONSTANTS, isa_H_EVENTS as H_EVENTS, isa_H_FLAGS as H_FLAGS, isa_H_GROUPS as H_GROUPS, isa_H_INSTRUCTIONS as H_INSTRUCTIONS, isa_H_LOOPS as H_LOOPS, isa_H_MAGIC as H_MAGIC, isa_H_POSITION_X as H_POSITION_X, isa_H_POSITION_Y as H_POSITION_Y, isa_H_POSITION_Z as H_POSITION_Z, isa_H_REGISTERS as H_REGISTERS, isa_H_SLOTS as H_SLOTS, isa_H_STATE as H_STATE, isa_H_VERSION as H_VERSION, isa_INSTRUCTION_WORDS as INSTRUCTION_WORDS, isa_KERNEL_CALLS_FEATURE as KERNEL_CALLS_FEATURE, isa_KERNEL_CALL_EXPORT_NAMES as KERNEL_CALL_EXPORT_NAMES, isa_KERNEL_DATA_EXPORT_NAMES as KERNEL_DATA_EXPORT_NAMES, isa_KERNEL_EXPORT_NAMES as KERNEL_EXPORT_NAMES, isa_KERNEL_EXTENDED_FEATURE as KERNEL_EXTENDED_FEATURE, isa_KERNEL_FEATURE as KERNEL_FEATURE, isa_KERNEL_GATHER_FEATURE as KERNEL_GATHER_FEATURE, isa_KERNEL_ISA_BASE as KERNEL_ISA_BASE, isa_KERNEL_ISA_CALLS as KERNEL_ISA_CALLS, isa_KERNEL_ISA_EXTENDED as KERNEL_ISA_EXTENDED, isa_KERNEL_ISA_VERSION as KERNEL_ISA_VERSION, isa_KERNEL_ISA_WRITES as KERNEL_ISA_WRITES, isa_KERNEL_LIBRARY_PATH as KERNEL_LIBRARY_PATH, isa_KERNEL_MLP_FEATURE as KERNEL_MLP_FEATURE, isa_KERNEL_MOE_FEATURE as KERNEL_MOE_FEATURE, isa_KERNEL_QUERY_RANK_FEATURE as KERNEL_QUERY_RANK_FEATURE, isa_KERNEL_SCAN_FEATURE as KERNEL_SCAN_FEATURE, isa_KERNEL_SIMD_FEATURE as KERNEL_SIMD_FEATURE, isa_KERNEL_STAGE_EXPORT_NAMES as KERNEL_STAGE_EXPORT_NAMES, isa_KERNEL_WRITES_FEATURE as KERNEL_WRITES_FEATURE, isa_KERNEL_WRITE_EXPORT_NAMES as KERNEL_WRITE_EXPORT_NAMES, isa_KIND_BOOL as KIND_BOOL, isa_KIND_F32 as KIND_F32, isa_KIND_I32 as KIND_I32, isa_KIND_U32 as KIND_U32, isa_LIBRARY_HEADER_WORDS as LIBRARY_HEADER_WORDS, isa_LIBRARY_MAGIC as LIBRARY_MAGIC, isa_LOOKUP_OP as LOOKUP_OP, isa_LOOP_COUNT_F32 as LOOP_COUNT_F32, isa_LUT1_HEADER as LUT1_HEADER, isa_LUT1_MAX as LUT1_MAX, isa_LUT2_HEADER as LUT2_HEADER, isa_LUT2_MAX as LUT2_MAX, isa_LUT_LINEAR as LUT_LINEAR, isa_LUT_WRAP as LUT_WRAP, isa_MAX_CHANNELS as MAX_CHANNELS, isa_MAX_EVENT_WORDS as MAX_EVENT_WORDS, isa_MAX_GROUPS as MAX_GROUPS, isa_MAX_REGISTERS as MAX_REGISTERS, isa_MAX_SLOTS as MAX_SLOTS, isa_MAX_SPAWN_FIELDS as MAX_SPAWN_FIELDS, isa_MAX_TRIPS as MAX_TRIPS, isa_MAX_UNIFORMS as MAX_UNIFORMS, isa_MLP_MAX_OUTPUTS as MLP_MAX_OUTPUTS, isa_MLP_MAX_WIDTH as MLP_MAX_WIDTH, isa_NONE as NONE, isa_Op as Op, type isa_OpCode as OpCode, isa_PICK_F32 as PICK_F32, isa_PICK_U32 as PICK_U32, isa_PROGRAM_HEADER_WORDS as PROGRAM_HEADER_WORDS, isa_PROGRAM_MAGIC as PROGRAM_MAGIC, isa_QFILTER_ANY as QFILTER_ANY, isa_QFILTER_EQUAL as QFILTER_EQUAL, isa_QFILTER_NONE as QFILTER_NONE, isa_QUERY_BOX as QUERY_BOX, isa_QUERY_CONE as QUERY_CONE, isa_QUERY_FILTERED as QUERY_FILTERED, isa_QUERY_SEGMENT as QUERY_SEGMENT, isa_QUERY_SHAPE as QUERY_SHAPE, isa_QUERY_SPHERE as QUERY_SPHERE, isa_RECUR as RECUR, isa_RECUR_EXCLUSIVE as RECUR_EXCLUSIVE, isa_RECUR_KINDS as RECUR_KINDS, isa_RECUR_KIND_MASK as RECUR_KIND_MASK, isa_RECUR_WIDE as RECUR_WIDE, isa_REDUCE_FMAX as REDUCE_FMAX, isa_REDUCE_FMIN as REDUCE_FMIN, isa_REDUCE_FSUM as REDUCE_FSUM, isa_REDUCE_IMAX as REDUCE_IMAX, isa_REDUCE_IMIN as REDUCE_IMIN, isa_REDUCE_ISUM as REDUCE_ISUM, isa_REDUCE_UMAX as REDUCE_UMAX, isa_REDUCE_UMIN as REDUCE_UMIN, isa_RING_COUNT as RING_COUNT, isa_RING_DROPPED as RING_DROPPED, isa_RING_HEADER_WORDS as RING_HEADER_WORDS, isa_SAMPLER_WORDS as SAMPLER_WORDS, isa_SAMPLE_BILINEAR as SAMPLE_BILINEAR, isa_SAMPLE_NEAREST as SAMPLE_NEAREST, isa_SAMPLE_NORMAL_X as SAMPLE_NORMAL_X, isa_SAMPLE_NORMAL_Y as SAMPLE_NORMAL_Y, isa_SAMPLE_NORMAL_Z as SAMPLE_NORMAL_Z, isa_SCAN_F_EXCLUSIVE as SCAN_F_EXCLUSIVE, isa_SCAN_F_INCLUSIVE as SCAN_F_INCLUSIVE, isa_SCAN_I_EXCLUSIVE as SCAN_I_EXCLUSIVE, isa_SCAN_I_INCLUSIVE as SCAN_I_INCLUSIVE, isa_SCATTER_FADD as SCATTER_FADD, isa_SCATTER_IADD as SCATTER_IADD, isa_SEND as SEND, isa_SERVICE_ANCHOR as SERVICE_ANCHOR, isa_SERVICE_BITS as SERVICE_BITS, isa_SERVICE_CHEMISTRY as SERVICE_CHEMISTRY, isa_SERVICE_CLIP_WEIGHT as SERVICE_CLIP_WEIGHT, isa_SERVICE_FLOW as SERVICE_FLOW, isa_SERVICE_FORCE as SERVICE_FORCE, isa_SERVICE_GROUND_HEIGHT as SERVICE_GROUND_HEIGHT, isa_SERVICE_IK_TARGET as SERVICE_IK_TARGET, isa_SERVICE_IMPULSE as SERVICE_IMPULSE, isa_SERVICE_INSTANCE as SERVICE_INSTANCE, isa_SERVICE_INSTANCE_COLOUR as SERVICE_INSTANCE_COLOUR, isa_SERVICE_KILL as SERVICE_KILL, isa_SERVICE_LINE_OF_SIGHT as SERVICE_LINE_OF_SIGHT, isa_SERVICE_MASK as SERVICE_MASK, isa_SERVICE_OVERLAP as SERVICE_OVERLAP, isa_SERVICE_PATH as SERVICE_PATH, isa_SERVICE_PICK as SERVICE_PICK, isa_SERVICE_PLAY_CLIP as SERVICE_PLAY_CLIP, isa_SERVICE_RAYCAST as SERVICE_RAYCAST, isa_SERVICE_SIGNATURES as SERVICE_SIGNATURES, isa_SERVICE_SOUND as SERVICE_SOUND, isa_SERVICE_SPAWN as SERVICE_SPAWN, isa_SERVICE_SWEEP as SERVICE_SWEEP, isa_SERVICE_VELOCITY as SERVICE_VELOCITY, isa_SERVICE_VOXEL_GET as SERVICE_VOXEL_GET, isa_SERVICE_VOXEL_SET as SERVICE_VOXEL_SET, isa_SIMD_CROSS as SIMD_CROSS, isa_SIMD_CROSS_WIDTH as SIMD_CROSS_WIDTH, isa_SIMD_DOT as SIMD_DOT, isa_SIMD_DOT_F32 as SIMD_DOT_F32, isa_SIMD_DOT_I32 as SIMD_DOT_I32, isa_SIMD_EXTRACT as SIMD_EXTRACT, isa_SIMD_LANE_BITS as SIMD_LANE_BITS, isa_SIMD_LANE_MASK as SIMD_LANE_MASK, isa_SIMD_LENGTH as SIMD_LENGTH, isa_SIMD_MAP as SIMD_MAP, isa_SIMD_MAP_OPS as SIMD_MAP_OPS, isa_SIMD_MAX_WIDTH as SIMD_MAX_WIDTH, isa_SIMD_MIN_WIDTH as SIMD_MIN_WIDTH, isa_SIMD_NORMALIZE as SIMD_NORMALIZE, isa_SIMD_PACK as SIMD_PACK, isa_SIMD_REDUCE as SIMD_REDUCE, isa_SIMD_REPLACE as SIMD_REPLACE, isa_SIMD_SCALAR_A as SIMD_SCALAR_A, isa_SIMD_SCALAR_B as SIMD_SCALAR_B, isa_SIMD_SCALAR_C as SIMD_SCALAR_C, isa_SIMD_SHUFFLE as SIMD_SHUFFLE, isa_SIMD_WIDTH_MASK as SIMD_WIDTH_MASK, isa_SORT_DESCENDING as SORT_DESCENDING, isa_SORT_KEY_F32 as SORT_KEY_F32, isa_SORT_KEY_I32 as SORT_KEY_I32, isa_SORT_KEY_MASK as SORT_KEY_MASK, isa_SORT_KEY_U32 as SORT_KEY_U32, isa_SORT_RADIX_BITS as SORT_RADIX_BITS, isa_SPAWN_STATS_WORDS as SPAWN_STATS_WORDS, isa_STATUS_FAILURE as STATUS_FAILURE, isa_STATUS_RUNNING as STATUS_RUNNING, isa_STATUS_SUCCESS as STATUS_SUCCESS, type isa_ServiceSignature as ServiceSignature, isa_UNIFORM as UNIFORM, isa_XOP as XOP, isa_XOP_COMPONENTS_EDGES as XOP_COMPONENTS_EDGES, isa_XOP_COMPONENTS_GRID as XOP_COMPONENTS_GRID, isa_XOP_DEDUP as XOP_DEDUP, isa_XOP_FIELD as XOP_FIELD, isa_XOP_GATHER as XOP_GATHER, isa_XOP_GROUP as XOP_GROUP, isa_XOP_MAX as XOP_MAX, isa_XOP_MLP_IN as XOP_MLP_IN, isa_XOP_MLP_MOE as XOP_MLP_MOE, isa_XOP_MLP_OUT as XOP_MLP_OUT, isa_XOP_MLP_RUN as XOP_MLP_RUN, isa_XOP_PROPAGATE_GRID as XOP_PROPAGATE_GRID, isa_XOP_QFILTER as XOP_QFILTER, isa_XOP_QRANK as XOP_QRANK, isa_XOP_QSHAPE as XOP_QSHAPE, isa_XOP_QSTOP as XOP_QSTOP, isa_XOP_QUERY as XOP_QUERY, isa_XOP_RANGE as XOP_RANGE, isa_XOP_RANGE_SHIFT as XOP_RANGE_SHIFT, isa_XOP_REACH_GRID as XOP_REACH_GRID, isa_XOP_RECUR as XOP_RECUR, isa_XOP_RECUR_IN as XOP_RECUR_IN, isa_XOP_SORT as XOP_SORT, isa_XOP_TOPK as XOP_TOPK, isa_crossRow as crossRow, isa_curveWords as curveWords, isa_deferredService as deferredService, isa_lookupOp as lookupOp, isa_operandCount as operandCount, isa_recurCoefficient as recurCoefficient, isa_recurFloatOutput as recurFloatOutput, isa_recurStateWords as recurStateWords, isa_recurSub as recurSub, isa_serviceOf as serviceOf, isa_serviceVersion as serviceVersion, isa_sortKey as sortKey, isa_stageEndingOp as stageEndingOp, isa_stageEnds as stageEnds, isa_xopRange as xopRange };
+}
+
+type CastShapeKind = "ball" | "cuboid" | "capsule" | "cylinder";
+declare class ShapeCastQuery {
+    kind: CastShapeKind;
+    readonly params: Vec3;
+    readonly origin: Vec3;
+    readonly rotation: Float32Array<ArrayBuffer>;
+    readonly direction: Vec3;
+    maxDistance: number;
+    includeSensors: boolean;
+    excludeBody: number;
+    ball(radius: number): this;
+    cuboid(hx: number, hy: number, hz: number): this;
+    capsule(halfHeight: number, radius: number): this;
+    cylinder(halfHeight: number, radius: number): this;
+}
+interface SphereOverlap {
+    count: number;
+    collider: number;
+}
+
+type KernelExportName = (typeof KERNEL_EXPORT_NAMES)[number];
+type KernelExports = Readonly<Record<KernelExportName | "engine_alloc" | "engine_free", (...args: number[]) => number>>;
+type KernelAttach = (binding: number, physics: number, nav: number, flow: number, render: number) => number;
+type KernelAttachHandle = (binding: number, which: number, handle: number) => number;
+type KernelSpawns = (binding: number) => number;
+interface KernelEngine {
+    readonly exports: KernelExports;
+    readonly memory: {
+        readonly buffer: ArrayBufferLike;
+    };
+    readonly isa?: number;
+    readonly attach?: KernelAttach | null;
+    readonly attachHandle?: KernelAttachHandle | null;
+    readonly spawns?: KernelSpawns | null;
+    readonly data?: KernelDataExports | null;
+    readonly runRegion?: KernelRunRegion | null;
+}
+type KernelRunRegion = (program: number, columns: number, rows: number, count: number, args: number, argWords: number) => number;
+interface KernelDataExports {
+    readonly bindTable: (binding: number, which: number, table: number) => number;
+    readonly bindPool: (binding: number, slot: number, pool: number, words: number) => number;
+    readonly report: (binding: number) => number;
+}
+declare function bindKernelEngine(symbols: Readonly<Record<string, unknown>>, memory: {
+    readonly buffer: ArrayBufferLike;
+}): KernelEngine | null;
+
+declare const CHEMISTRY_EXPORT_NAMES: readonly ["engine_chemistry_open", "engine_chemistry_close", "engine_chemistry_define", "engine_chemistry_find", "engine_chemistry_catalog", "engine_chemistry_text", "engine_chemistry_counts", "engine_chemistry_species_info", "engine_chemistry_reaction_info", "engine_chemistry_grid_open", "engine_chemistry_grid_close", "engine_chemistry_grid_step", "engine_chemistry_grid_paint", "engine_chemistry_grid_set", "engine_chemistry_grid_heat", "engine_chemistry_grid_power", "engine_chemistry_grid_columns", "engine_chemistry_grid_colours", "engine_chemistry_grid_events", "engine_chemistry_grid_clear_events", "engine_chemistry_grid_watch", "engine_chemistry_grid_threshold", "engine_chemistry_grid_unthreshold", "engine_chemistry_grid_fired", "engine_chemistry_grid_stats", "engine_chemistry_grid_probe", "engine_chemistry_grid_save", "engine_chemistry_grid_saved", "engine_chemistry_grid_load", "engine_chemistry_vessel_open", "engine_chemistry_vessel_close", "engine_chemistry_vessel_add", "engine_chemistry_vessel_take", "engine_chemistry_vessel_heat", "engine_chemistry_vessel_power", "engine_chemistry_vessel_step", "engine_chemistry_vessel_vent", "engine_chemistry_vessel_state", "engine_chemistry_particles_open", "engine_chemistry_particles_close", "engine_chemistry_particles_spawn", "engine_chemistry_particles_step", "engine_chemistry_particles_columns", "engine_chemistry_particles_events"];
+type ChemistryExportName = (typeof CHEMISTRY_EXPORT_NAMES)[number];
+type ChemistryExports = Readonly<Record<ChemistryExportName | "engine_alloc" | "engine_free", (...args: number[]) => number>>;
+interface ChemistryEngine {
+    readonly exports: ChemistryExports;
+    readonly memory: {
+        readonly buffer: ArrayBufferLike;
+    };
+}
+declare const CHEMISTRY_NATURE_WORDS = 8;
+declare const CHEMISTRY_BOX_WORDS = 6;
+declare const CHEMISTRY_SPECIES_WORDS = 16;
+declare const CHEMISTRY_REACTION_WORDS = 24;
+declare const CHEMISTRY_COLUMNS = 16;
+declare const CHEMISTRY_STATS_WORDS = 16;
+declare const CHEMISTRY_PROBE_WORDS = 16;
+declare const CHEMISTRY_EVENT_HEADER = 2;
+declare const CHEMISTRY_EVENT_WORDS = 4;
+declare const CHEMISTRY_VESSEL_SLOTS = 16;
+declare const CHEMISTRY_VESSEL_WORDS: number;
+declare const CHEMISTRY_ATMOSPHERE = 0;
+declare const CHEMISTRY_VACUUM = 4294967295;
+declare const CHEMISTRY_REFUSED = 65536;
+declare const CHEMISTRY_SLOTS = 4;
+declare const CHEMISTRY_TQ = 16;
+declare const CHEMISTRY_UNSET = 4294967295;
+declare function bindChemistryEngine(symbols: Readonly<Record<string, unknown>>, memory: {
+    readonly buffer: ArrayBufferLike;
+}): ChemistryEngine | null;
+
+declare const clipMaskBrand: unique symbol;
+declare const blendSpaceBrand: unique symbol;
+declare const ikChainBrand: unique symbol;
+declare const rootMotionBrand: unique symbol;
+type ClipMaskId = number & {
+    readonly [clipMaskBrand]: true;
+};
+type BlendSpaceId = number & {
+    readonly [blendSpaceBrand]: true;
+};
+type IkChainId = number & {
+    readonly [ikChainBrand]: true;
+};
+type RootMotionId = number & {
+    readonly [rootMotionBrand]: true;
+};
+declare const boneSetBrand: unique symbol;
+type BoneSetId = number & {
+    readonly [boneSetBrand]: true;
+};
+type ClipLoop = "once" | "repeat" | "pingpong";
+type BlendSpaceKind = "1d" | "cartesian" | "directional";
+type IkSolver = "twoBone" | "lookAt" | "fabrik" | "ccd";
+type ClipEventKind = "event" | "loop" | "finished";
+type ClipSyncMode = "phase" | "markers";
+declare const HUMAN_BONES: readonly ["hips", "spine", "chest", "upperChest", "neck", "head", "leftEye", "rightEye", "jaw", "leftUpperLeg", "leftLowerLeg", "leftFoot", "leftToes", "rightUpperLeg", "rightLowerLeg", "rightFoot", "rightToes", "leftShoulder", "leftUpperArm", "leftLowerArm", "leftHand", "rightShoulder", "rightUpperArm", "rightLowerArm", "rightHand", "leftThumbMetacarpal", "leftThumbProximal", "leftThumbDistal", "leftIndexProximal", "leftIndexIntermediate", "leftIndexDistal", "leftMiddleProximal", "leftMiddleIntermediate", "leftMiddleDistal", "leftRingProximal", "leftRingIntermediate", "leftRingDistal", "leftLittleProximal", "leftLittleIntermediate", "leftLittleDistal", "rightThumbMetacarpal", "rightThumbProximal", "rightThumbDistal", "rightIndexProximal", "rightIndexIntermediate", "rightIndexDistal", "rightMiddleProximal", "rightMiddleIntermediate", "rightMiddleDistal", "rightRingProximal", "rightRingIntermediate", "rightRingDistal", "rightLittleProximal", "rightLittleIntermediate", "rightLittleDistal"];
+type HumanBone = (typeof HUMAN_BONES)[number];
+type HumanoidMap = Partial<Record<HumanBone, string>>;
+interface ClipInfo {
+    readonly duration: number;
+    readonly tracks: number;
+    readonly morphWeights: number;
+    readonly events: number;
+}
+interface ClipEventDesc {
+    readonly time: number;
+    readonly id: number;
+}
+interface ClipEvent {
+    action: ClipActionId;
+    kind: ClipEventKind;
+    id: number;
+    time: number;
+}
+interface ClipActionState {
+    time: number;
+    weight: number;
+    speed: number;
+    running: boolean;
+    paused: boolean;
+    finished: boolean;
+}
+interface BlendSpaceMember {
+    readonly action: ClipActionId;
+    readonly x: number;
+    readonly y?: number;
+}
+interface BlendSpaceDesc {
+    readonly kind: BlendSpaceKind;
+    readonly members: readonly BlendSpaceMember[];
+}
+interface IkDesc {
+    readonly solver: IkSolver;
+    readonly bones: readonly string[];
+    readonly iterations?: number;
+    readonly tolerance?: number;
+    readonly maxAngle?: number;
+    readonly forward?: readonly [number, number, number];
+}
+interface RootMotionDesc {
+    readonly bone: string;
+    readonly horizontal?: boolean;
+    readonly vertical?: boolean;
+    readonly yaw?: boolean;
+    readonly apply?: boolean;
+}
+declare const propertyClipBrand: unique symbol;
+type PropertyClipId = number & {
+    readonly [propertyClipBrand]: true;
+};
+type TrackInterpolation = "linear" | "step" | "cubic";
+type PropertyTarget = {
+    readonly kind: "uniform";
+    readonly material: MaterialId;
+    readonly name: string;
+} | {
+    readonly kind: "light";
+    readonly node: NodeId;
+    readonly color: number;
+} | {
+    readonly kind: "post";
+    readonly chain: PostChainId;
+    readonly effect: number;
+    readonly name: string;
+} | {
+    readonly kind: "emitterRate";
+    readonly emitter: EmitterId;
+};
+interface PropertyTrackDesc {
+    readonly target: PropertyTarget;
+    readonly size?: number;
+    readonly interpolation?: TrackInterpolation;
+    readonly times: ArrayLike<number>;
+    readonly values: ArrayLike<number>;
+    readonly rest: ArrayLike<number>;
+}
+interface PropertyClipDesc {
+    readonly duration: number;
+    readonly tracks: readonly PropertyTrackDesc[];
+}
+interface HumanoidMaps {
+    readonly source: HumanoidMap;
+    readonly target: HumanoidMap;
+}
+interface BakeRetargetOptions {
+    readonly rate?: number;
+    readonly maps?: HumanoidMaps;
+}
+interface ClipAnimationPort {
+    createPropertyClip(desc: PropertyClipDesc): PropertyClipId;
+    playPropertyClip(clip: PropertyClipId, loop: boolean, fadeSeconds: number, speed: number): ClipActionId;
+    setPropertyClipEvents(clip: PropertyClipId, events: readonly ClipEventDesc[]): void;
+    destroyPropertyClip(clip: PropertyClipId): void;
+    setClipTime(action: ClipActionId, seconds: number): void;
+    setClipSpeed(action: ClipActionId, speed: number): void;
+    setClipLoop(action: ClipActionId, loop: ClipLoop, repetitions: number, clampWhenFinished: boolean): void;
+    setClipPaused(action: ClipActionId, paused: boolean): void;
+    setClipRange(action: ClipActionId, start: number, end: number): void;
+    setClipSync(action: ClipActionId, group: number | null): void;
+    setClipSyncMode(action: ClipActionId, mode: ClipSyncMode): void;
+    setClipSyncMarkers(root: NodeId, clip: string, markers: readonly ClipEventDesc[]): void;
+    inertialize(from: ClipActionId, to: ClipActionId, seconds: number): void;
+    bakeRetarget(target: NodeId, source: NodeId, clip: string, options?: BakeRetargetOptions): string;
+    setClipEventsEnabled(action: ClipActionId, enabled: boolean): void;
+    setClipAdditive(action: ClipActionId, referenceTime: number | null): void;
+    crossFade(from: ClipActionId, to: ClipActionId, seconds: number, warp: boolean): void;
+    fadeClip(action: ClipActionId, weight: number, seconds: number): void;
+    fadeClipFrom(action: ClipActionId, values: Float32Array | Float64Array, offset: number): void;
+    createClipMask(root: NodeId, weights: Readonly<Record<string, number>>): ClipMaskId;
+    setClipMask(action: ClipActionId, mask: ClipMaskId | null): void;
+    destroyClipMask(root: NodeId, mask: ClipMaskId): void;
+    setClipEvents(root: NodeId, clip: string, events: readonly ClipEventDesc[]): void;
+    clipInfo(root: NodeId, clip: string): ClipInfo;
+    createBlendSpace(root: NodeId, desc: BlendSpaceDesc): BlendSpaceId;
+    setBlendParameter(space: BlendSpaceId, x: number, y: number, weight: number): void;
+    setBlendParameterFrom(space: BlendSpaceId, values: Float32Array | Float64Array, offset: number): void;
+    destroyBlendSpace(root: NodeId, space: BlendSpaceId): void;
+    createIk(root: NodeId, desc: IkDesc): IkChainId;
+    setIkTarget(chain: IkChainId, x: number, y: number, z: number, weight: number): void;
+    setIkTargetFrom(chain: IkChainId, values: Float32Array | Float64Array, offset: number): void;
+    setIkPole(chain: IkChainId, x: number, y: number, z: number): void;
+    destroyIk(root: NodeId, chain: IkChainId): void;
+    humanoid(root: NodeId): HumanoidMap;
+    retarget(target: NodeId, source: NodeId, maps?: {
+        readonly source: HumanoidMap;
+        readonly target: HumanoidMap;
+    }): void;
+    stopRetarget(target: NodeId): void;
+    setAnimationLod(root: NodeId, interval: number): void;
+    createBoneSet(root: NodeId, bones: readonly string[]): BoneSetId;
+    readBonePoses(set: BoneSetId, out: Float32Array | Float64Array, offset: number): void;
+    destroyBoneSet(set: BoneSetId): void;
+    enableRootMotion(root: NodeId, desc: RootMotionDesc): RootMotionId;
+    disableRootMotion(root: NodeId): void;
+    readRootMotion(motion: RootMotionId, out: Float32Array, offset: number): void;
+    readClipState(action: ClipActionId, out: ClipActionState): void;
+    readClipEvents(out: ClipEvent[]): number;
+}
+
+declare const vectorAssetBrand: unique symbol;
+declare const vectorSurfaceBrand: unique symbol;
+type VectorAssetId = number & {
+    readonly [vectorAssetBrand]: true;
+};
+type VectorSurfaceId = number & {
+    readonly [vectorSurfaceBrand]: true;
+};
+type VectorSurfacePhase = "down" | "move" | "up" | "cancel";
+type VectorSurfacePlay = "machine" | "animation" | "stop";
+type VectorSurfaceSeek = Exclude<VectorSurfacePlay, "stop">;
+type VectorSurfaceTier = "low" | "mid" | "high";
+declare const VECTOR_SURFACE_TIERS: Readonly<Record<VectorSurfaceTier, number>>;
+declare const VECTOR_SURFACE_CAPS: Readonly<Record<VectorSurfaceTier, number>>;
+declare const VECTOR_SURFACE_EDGES: Readonly<Record<VectorSurfaceTier, number>>;
+interface VectorSurfaceDesc {
+    readonly asset: VectorAssetId;
+    readonly artboard?: number;
+    readonly target: RenderTargetId;
+    readonly node?: NodeId | null;
+}
+interface VectorSurfaceEvent {
+    surface: VectorSurfaceId;
+    event: number;
+}
+interface VectorSurfaceStats {
+    cap: number;
+    live: number;
+    encoded: number;
+    unchanged: number;
+    offscreen: number;
+    occluded: number;
+    overCap: number;
+    droppedEvents: number;
+}
+declare function createVectorSurfaceStats(): VectorSurfaceStats;
+interface VectorSurfacePort {
+    readonly cap: number;
+    load(bytes: Uint8Array): VectorAssetId;
+    unload(asset: VectorAssetId): void;
+    create(desc: VectorSurfaceDesc): VectorSurfaceId;
+    destroy(surface: VectorSurfaceId): void;
+    setNode(surface: VectorSurfaceId, node: NodeId | null): void;
+    play(surface: VectorSurfaceId, kind: VectorSurfacePlay, index: number): void;
+    seek?(surface: VectorSurfaceId, kind: VectorSurfaceSeek, index: number, seconds: number): void;
+    inputIndex(surface: VectorSurfaceId, name: string): number;
+    setInput(surface: VectorSurfaceId, input: number, value: number): void;
+    dataIndex(surface: VectorSurfaceId, path: string): number;
+    setData(surface: VectorSurfaceId, handle: number, kind: "number" | "bool" | "color" | "id" | "fire", value: number): void;
+    pointer(surface: VectorSurfaceId, phase: VectorSurfacePhase, u: number, v: number): boolean;
+    pick(origin: ArrayLike<number>, direction: ArrayLike<number>, far: number, phase: VectorSurfacePhase): VectorSurfaceId | null;
+    events(out: VectorSurfaceEvent[]): number;
+    stats(out: VectorSurfaceStats): void;
+    setTier(tier: VectorSurfaceTier): void;
+}
+
+declare const gpuBufferBrand: unique symbol;
+declare const gpuShaderBrand: unique symbol;
+declare const gpuPipelineBrand: unique symbol;
+declare const gpuBindGroupBrand: unique symbol;
+type GpuBufferId = number & {
+    readonly [gpuBufferBrand]: true;
+};
+type GpuShaderId = number & {
+    readonly [gpuShaderBrand]: true;
+};
+type GpuPipelineId = number & {
+    readonly [gpuPipelineBrand]: true;
+};
+type GpuBindGroupId = number & {
+    readonly [gpuBindGroupBrand]: true;
+};
+declare const gpuTextureBrand: unique symbol;
+declare const gpuSamplerBrand: unique symbol;
+type GpuTextureId = number & {
+    readonly [gpuTextureBrand]: true;
+};
+type GpuSamplerId = number & {
+    readonly [gpuSamplerBrand]: true;
+};
+type GpuTextureFormat = "rgba8" | "rgba16f" | "rgba32f";
+type GpuTextureUsage = "sampled" | "storage" | "target";
+type GpuSceneTexture = "depth" | "motion" | "color";
+type GpuTopology = "triangle-list" | "triangle-strip" | "line-list" | "point-list";
+type GpuBlendFactor = "zero" | "one" | "src" | "one-minus-src" | "src-alpha" | "one-minus-src-alpha" | "dst" | "one-minus-dst" | "dst-alpha" | "one-minus-dst-alpha" | "src-alpha-saturated";
+interface GpuTextureDesc {
+    readonly width: number;
+    readonly height: number;
+    readonly format: GpuTextureFormat;
+    readonly usage: readonly GpuTextureUsage[];
+    readonly mipLevels?: number;
+    readonly label?: string;
+}
+interface GpuSamplerDesc {
+    readonly filter?: "linear" | "nearest";
+    readonly wrap?: "repeat" | "clamp" | "mirror";
+}
+interface GpuBlendComponent {
+    readonly src: GpuBlendFactor;
+    readonly dst: GpuBlendFactor;
+}
+interface GpuBlend {
+    readonly color: GpuBlendComponent;
+    readonly alpha: GpuBlendComponent;
+}
+interface GpuRenderPipelineDesc {
+    readonly shader: GpuShaderId;
+    readonly vertexEntry: string;
+    readonly fragmentEntry: string;
+    readonly targets: readonly GpuTextureFormat[];
+    readonly blend?: GpuBlend;
+    readonly topology?: GpuTopology;
+    readonly label?: string;
+}
+interface GpuRect {
+    readonly x: number;
+    readonly y: number;
+    readonly width: number;
+    readonly height: number;
+}
+interface GpuDrawOptions {
+    readonly hook?: GpuHook;
+    readonly target?: GpuTextureId | "color";
+    readonly instances?: number;
+}
+interface GpuTextureCopy {
+    readonly from?: readonly [number, number];
+    readonly to?: readonly [number, number];
+    readonly size?: readonly [number, number];
+    readonly hook?: GpuHook;
+}
+type GpuBufferUsage = "storage" | "uniform" | "vertex" | "index" | "indirect" | "copy_src" | "copy_dst" | "map_read";
+type GpuHook = "beforeScene" | "afterOpaque" | "afterTransparent" | "post" | "afterPost";
+type GpuSceneResource = "depth" | "motion" | "color" | "instances" | "particles";
+interface GpuDispatchOptions {
+    readonly hook?: GpuHook;
+    readonly indirect?: GpuBufferId;
+}
+interface GpuBufferDesc {
+    readonly size: number;
+    readonly usage: readonly GpuBufferUsage[];
+    readonly label?: string;
+}
+interface GpuComputePipelineDesc {
+    readonly shader: GpuShaderId;
+    readonly entryPoint: string;
+    readonly workgroupSize?: readonly [number, number, number];
+    readonly label?: string;
+}
+type GpuBindingDesc = {
+    readonly binding: number;
+    readonly buffer: GpuBufferId | GpuSceneResource;
+    readonly offset?: number;
+    readonly size?: number;
+} | {
+    readonly binding: number;
+    readonly texture: GpuTextureId | GpuSceneTexture;
+} | {
+    readonly binding: number;
+    readonly sampler: GpuSamplerId;
+};
+interface RawGpu {
+    readonly api: "wgsl" | "webgpu";
+    createBuffer(desc: GpuBufferDesc): GpuBufferId;
+    writeBuffer(buffer: GpuBufferId, offset: number, data: ArrayBufferView): void;
+    createShader(wgsl: string, label?: string): GpuShaderId;
+    createComputePipeline(desc: GpuComputePipelineDesc): GpuPipelineId;
+    createBindGroup(pipeline: GpuPipelineId, group: number, bindings: readonly GpuBindingDesc[]): GpuBindGroupId;
+    dispatch(pipeline: GpuPipelineId, bindGroup: GpuBindGroupId, x: number, y?: number, z?: number, options?: GpuDispatchOptions): void;
+    copyBuffer(source: GpuBufferId, sourceOffset: number, target: GpuBufferId, targetOffset: number, size: number): void;
+    submit(): void;
+    readBuffer(buffer: GpuBufferId, offset: number, out: Uint8Array): Promise<void>;
+    destroyBuffer(buffer: GpuBufferId): void;
+    createTexture(desc: GpuTextureDesc): GpuTextureId;
+    writeTexture(texture: GpuTextureId, data: ArrayBufferView): void;
+    readTexture(texture: GpuTextureId, rect: GpuRect, out: Uint8Array): Promise<void>;
+    copyTexture(source: GpuTextureId, target: GpuTextureId, copy?: GpuTextureCopy): void;
+    destroyTexture(texture: GpuTextureId): void;
+    createSampler(desc?: GpuSamplerDesc): GpuSamplerId;
+    createRenderPipeline(desc: GpuRenderPipelineDesc): GpuPipelineId;
+    draw(pipeline: GpuPipelineId, bindGroup: GpuBindGroupId, vertexCount: number, options?: GpuDrawOptions): void;
+    dispose(): void;
+}
+
+interface CurveTable {
+    readonly x: readonly number[];
+    readonly y: readonly number[];
+}
+declare function sampleCurve(curve: CurveTable, x: number): number;
+declare function peakCurve(peakSlip: number, peakValue: number, slideSlip: number, slideValue: number): CurveTable;
+
+declare const GEAR_AUTO = 100;
+declare const GEAR_REVERSE = -1;
+declare const GEAR_NEUTRAL = 0;
+declare const WHEEL_CENTER = 0;
+declare const WHEEL_SPIN = 3;
+declare const WHEEL_STEER = 4;
+declare const WHEEL_LENGTH = 5;
+declare const WHEEL_GROUND = 6;
+declare const WHEEL_POINT = 7;
+declare const WHEEL_SLIP = 10;
+declare const WHEEL_SLIP_ANGLE = 11;
+declare const WHEEL_LOAD = 12;
+declare const WHEEL_OMEGA = 13;
+declare const WHEEL_FORCE_LONG = 14;
+declare const WHEEL_FORCE_LAT = 15;
+interface WheelDesc {
+    readonly position: readonly [number, number, number];
+    readonly radius: number;
+    readonly inertia?: number;
+    readonly restLength?: number;
+    readonly travel?: number;
+    readonly stiffness?: number;
+    readonly compressionDamping?: number;
+    readonly relaxationDamping?: number;
+    readonly maxSuspensionForce?: number;
+    readonly steer?: number;
+    readonly drive?: number;
+    readonly brakeTorque?: number;
+    readonly handbrakeTorque?: number;
+    readonly longitudinal?: CurveTable;
+    readonly lateral?: CurveTable;
+    readonly grip?: number;
+    readonly axle?: number;
+    readonly side?: number;
+    readonly width?: number;
+}
+interface EngineCurveDesc {
+    readonly torque: CurveTable;
+    readonly idleRpm: number;
+    readonly maxRpm: number;
+    readonly engineBraking?: number;
+    readonly inertia?: number;
+}
+interface GearboxDesc {
+    readonly ratios: readonly number[];
+    readonly reverse: number;
+    readonly finalDrive: number;
+    readonly efficiency?: number;
+    readonly shiftUpRpm: number;
+    readonly shiftDownRpm: number;
+    readonly shiftSeconds?: number;
+}
+interface LeanDesc {
+    readonly maxAngle: number;
+    readonly stiffness: number;
+    readonly damping: number;
+    readonly fullSpeed?: number;
+}
+interface VehicleDesc {
+    readonly wheels: readonly WheelDesc[];
+    readonly engine: EngineCurveDesc;
+    readonly gearbox: GearboxDesc;
+    readonly maxSteerRadians: number;
+    readonly steerRate?: number;
+    readonly antiRoll?: number;
+    readonly downforce?: number;
+    readonly drag?: number;
+    readonly rollingResistance?: number;
+    readonly handbrakeGrip?: number;
+    readonly differentialLock?: number;
+    readonly centerLock?: number;
+    readonly skidTorque?: number;
+    readonly forceHeight?: number;
+    readonly ackermann?: number;
+    readonly lean?: LeanDesc;
+}
+declare function encodeVehicleDesc(desc: VehicleDesc, out?: Float32Array): Float32Array;
+interface VehiclePort {
+    createVehicle(body: number, desc: Float32Array): number;
+    destroyVehicle(vehicle: number): void;
+    vehicleInputs(): Float32Array;
+    vehicleStates(): Float32Array;
+}
+declare class Vehicle {
+    readonly id: number;
+    readonly entity: number;
+    readonly wheelCount: number;
+    private readonly port;
+    private inputs;
+    private states;
+    private readonly input;
+    private readonly state;
+    constructor(port: VehiclePort, id: number, entity: number, wheelCount: number);
+    refresh(): void;
+    drive(throttle: number, brake: number, steer: number, handbrake?: number, gear?: number): void;
+    driveFrom(source: Float64Array | Float32Array, at: number): void;
+    get speed(): number;
+    get rpm(): number;
+    get gear(): number;
+    get steer(): number;
+    get groundedWheels(): number;
+    get shifting(): boolean;
+    wheel(index: number, field: number): number;
+    get stateView(): Float32Array;
+    get stateOffset(): number;
+}
+
+declare const MAX_COLLIDER_CLASSES = 16;
+declare const DEFAULT_COLLIDER_CLASS = 0;
+interface ContactRuleDesc {
+    readonly ignore?: boolean;
+    readonly friction?: number;
+    readonly restitution?: number;
+    readonly oneWay?: readonly [number, number, number];
+}
+declare const NO_CONTACT_RULE: ContactRuleDesc;
+declare class ContactRuleTable {
+    readonly flags: Uint8Array<ArrayBuffer>;
+    readonly friction: Float32Array<ArrayBuffer>;
+    readonly restitution: Float32Array<ArrayBuffer>;
+    readonly normal: Float32Array<ArrayBuffer>;
+    private active;
+    get count(): number;
+    set(platform: number, other: number, rule: ContactRuleDesc): void;
+    index(a: number, b: number): number;
+    private write;
+}
+
+type SeaState = "mirror" | "lake" | "calm" | "moderate" | "rough" | "storm";
+declare const SEA_STATES: readonly SeaState[];
+interface WaveDesc {
+    readonly direction: readonly [number, number];
+    readonly wavelength: number;
+    readonly amplitude: number;
+    readonly steepness: number;
+    readonly phase: number;
+}
+interface WaterDesc {
+    readonly level?: number;
+    readonly depth?: number;
+    readonly gravity?: number;
+    readonly density?: number;
+    readonly current?: readonly [number, number];
+    readonly wind?: readonly [number, number];
+    readonly gust?: number;
+    readonly gustPeriod?: number;
+    readonly iterations?: number;
+    readonly waves?: readonly WaveDesc[];
+}
+declare class WaterSample {
+    height: number;
+    normalX: number;
+    normalY: number;
+    normalZ: number;
+    velocityX: number;
+    velocityY: number;
+    velocityZ: number;
+}
+declare function seaDesc(state: SeaState, windRadians: number, seed: number): WaterDesc;
+declare class Water {
+    private readonly kx;
+    private readonly kz;
+    private readonly phase;
+    private readonly amplitude;
+    private readonly qax;
+    private readonly qaz;
+    private readonly kax;
+    private readonly kaz;
+    private readonly kqa;
+    private readonly wqax;
+    private readonly wqaz;
+    private readonly wa;
+    private readonly omega;
+    private readonly sc;
+    private readonly seconds;
+    private count;
+    private iterations;
+    private currentX;
+    private currentZ;
+    private windX;
+    private windZ;
+    private gust;
+    private gustOmega;
+    private gustPhase;
+    private time;
+    level: number;
+    density: number;
+    gravity: number;
+    constructor(desc?: WaterDesc);
+    configure(desc: WaterDesc): void;
+    setWind(x: number, z: number, gust?: number, gustPeriod?: number): void;
+    setCurrent(x: number, z: number): void;
+    crest(): number;
+    get elapsed(): number;
+    advance(dt: number): void;
+    advanceFrom(values: Float64Array, at: number): void;
+    windInto(out: Float64Array, at?: number): Float64Array;
+    height(x: number, z: number): number;
+    sample(x: number, z: number, out: WaterSample): WaterSample;
+    sampleBatch(points: Float32Array, count: number, out: Float32Array): void;
+    private readonly batchSample;
+    private px;
+    private pz;
+    private theta;
+    private undisplace;
+}
+
+interface WaterFlow {
+    readonly level: number;
+    readonly current: readonly [number, number];
+    readonly wind: readonly [number, number];
+    readonly gust: number;
+    readonly gustPeriod: number;
+}
+interface OceanDesc {
+    readonly size?: number;
+    readonly patch?: number;
+    readonly wind?: readonly [number, number];
+    readonly amplitude?: number;
+    readonly choppiness?: number;
+    readonly smallWave?: number;
+    readonly seed?: number;
+    readonly updateEvery?: number;
+}
+/** Ripples and wakes over the water: a window of `size` cells (a power of two, 16 to 256) of
+ * `cell` metres that follows the camera or a boat, whose waves run at `speed` m/s. */
+interface RippleOptions {
+    readonly size?: number;
+    readonly cell?: number;
+    readonly speed?: number;
+}
+/** The FFT ocean, drawn and floated on as one: a JONSWAP spectrum over up to four cascades
+ * of `size` texels, the coarsest `patches[0]` metres across. */
+interface OceanCascades {
+    readonly size?: number;
+    readonly count?: number;
+    readonly patches?: readonly [number, number, number, number];
+    readonly windSpeed?: number;
+    readonly windDirection?: number;
+    readonly fetch?: number;
+    readonly peakEnhancement?: number;
+    readonly swell?: number;
+    readonly depth?: number;
+    readonly shortWaves?: number;
+    readonly scale?: number;
+    readonly choppiness?: number;
+    readonly foam?: {
+        readonly threshold?: number;
+        readonly gain?: number;
+        readonly decaySeconds?: number;
+    };
+    readonly gravity?: number;
+    readonly seed?: number;
+    /** The CPU instance hulls float on: the same waves at this size, 64 by default. */
+    readonly physicsSize?: number;
+}
+/** Puddles and streams: `width` by `height` cells of `cell` metres from world `origin`
+ * (x, z), deep enough for `maxDepth` metres. */
+interface PuddleOptions {
+    readonly origin: readonly [number, number];
+    readonly cell: number;
+    readonly width: number;
+    readonly height: number;
+    readonly maxDepth?: number;
+}
+interface CraftPort {
+    setOcean(desc: OceanDesc | null): void;
+    setCascades?(desc: OceanCascades | null): void;
+    setPuddles?(desc: PuddleOptions | null): void;
+    setPuddleBed?(heights: Float32Array): void;
+    pourPuddles?(x: number, z: number, volume: number): void;
+    puddleWeather?(rain: number, evaporation: number): void;
+    setRipples?(desc: RippleOptions | null): void;
+    followRipples?(x: number, z: number): void;
+    pushRipples?(x: number, z: number, amount: number): void;
+    bindRender?(source: () => number): void;
+    readonly name: string;
+    readonly capacity: number;
+    configureWater(desc: WaterDesc): void;
+    sea(state: SeaState, windRadians: number, seed: number): void;
+    setFlow(flow: WaterFlow): void;
+    createCraft(entity: number, body: number, collider: number, words: Float32Array, running: boolean): number;
+    removeCraft(craft: number): void;
+    controls(): Float32Array;
+    telemetry(): Float32Array;
+    step(): void;
+    sampleWater(points: Float32Array, count: number, out: Float32Array): void;
+    crumple?(craft: number, vertices: Float32Array, desc: Float32Array | null): void;
+    impact?(craft: number, point: readonly [number, number, number], severity: readonly [number, number, number]): boolean;
+    damage?(craft: number): number;
+    presentCrumple?(craft: number, geometry: number): number;
+    dispose(): void;
+}
+
+declare const JOINT_AXES: {
+    readonly linX: 0;
+    readonly linY: 1;
+    readonly linZ: 2;
+    readonly angX: 3;
+    readonly angY: 4;
+    readonly angZ: 5;
+};
+type JointAxisName = keyof typeof JOINT_AXES;
+declare const POSE_STRIDE = 10;
+interface JointDrive {
+    readonly targetPosition?: number;
+    readonly targetVelocity?: number;
+    readonly stiffness: number;
+    readonly damping: number;
+    readonly maxForce?: number;
+}
+interface JointLoad {
+    force: number;
+    torque: number;
+}
+interface RagdollBoneDesc {
+    readonly joint: number;
+    readonly axis?: readonly [number, number, number];
+    readonly length: number;
+    readonly radius: number;
+    readonly density?: number;
+    readonly swing?: number;
+    readonly twist?: readonly [number, number];
+    readonly entity?: number;
+}
+interface RagdollRoot {
+    readonly position?: readonly [number, number, number];
+    readonly rotation?: readonly [number, number, number, number];
+    readonly scale?: readonly [number, number, number];
+}
+interface RagdollDesc {
+    readonly parents: readonly number[];
+    readonly pose: Float32Array;
+    readonly bones: readonly RagdollBoneDesc[];
+    readonly root?: RagdollRoot;
+    readonly linearDamping?: number;
+    readonly angularDamping?: number;
+    readonly friction?: number;
+}
+interface RagdollDrive {
+    readonly stiffness: number;
+    readonly damping: number;
+    readonly maxTorque: number;
+}
+interface Ragdoll {
+    readonly id: number;
+    readonly pose: Float32Array;
+    readonly bodies: Uint32Array;
+    drive(drive: RagdollDrive): void;
+    place(): void;
+    read(): Float32Array;
+    setRoot(root: RagdollRoot): void;
+    destroy(): void;
+}
+interface JointPort {
+    setDrive(joint: number, axis: JointAxisName, drive: JointDrive): void;
+    clearDrive(joint: number, axis: JointAxisName): void;
+    setTarget(joint: number, rotation: readonly [number, number, number, number], drive: RagdollDrive): void;
+    setBreakable(joint: number, force: number, torque: number): void;
+    setEnabled(joint: number, enabled: boolean): void;
+    setContacts(joint: number, enabled: boolean): void;
+    broken(joint: number): boolean;
+    load(joint: number, out: JointLoad): void;
+    breaks(): Uint32Array;
+    createRagdoll(desc: RagdollDesc): Ragdoll;
+}
+
+declare const AI_EVENT_WORDS = 5;
+declare const AI_NONE = 4294967295;
+declare const AI_MAX_GAME_SLOTS = 16;
+declare const BUILTIN_INPUTS: readonly ["focus_distance", "focus_visible", "focus_since_seen", "focus_confidence", "focus_threat", "hostiles_known", "allies_near", "attack_token_free", "action_seconds", "goal_distance", "lateness", "best_object"];
+type BuiltinInput = (typeof BUILTIN_INPUTS)[number];
+declare const PHASE_IDLE = 0;
+declare const PHASE_WINDUP = 1;
+declare const PHASE_STRIKE = 2;
+declare const PHASE_RECOVER = 3;
+declare const AiEventKind: {
+    readonly actionChanged: 1;
+    readonly focusAcquired: 2;
+    readonly focusLost: 3;
+    readonly heard: 4;
+    readonly arrived: 5;
+    readonly attackWindup: 6;
+    readonly attackStrike: 7;
+    readonly attackDone: 8;
+    readonly bark: 9;
+    readonly objectUsed: 10;
+    readonly coverTaken: 11;
+};
+type AiEventKindCode = (typeof AiEventKind)[keyof typeof AiEventKind];
+type CurveDecl = {
+    readonly kind: "linear";
+    readonly slope: number;
+    readonly offset: number;
+} | {
+    readonly kind: "polynomial";
+    readonly exponent: number;
+    readonly slope: number;
+    readonly offset: number;
+} | {
+    readonly kind: "logistic";
+    readonly steepness: number;
+    readonly midpoint: number;
+} | {
+    readonly kind: "step";
+    readonly threshold: number;
+    readonly below: number;
+    readonly above: number;
+} | {
+    readonly kind: "points";
+    readonly x: readonly number[];
+    readonly y: readonly number[];
+};
+type InputSourceDecl = {
+    readonly kind: "builtin";
+    readonly input: BuiltinInput;
+} | {
+    readonly kind: "game";
+    readonly slot: number;
+} | {
+    readonly kind: "need";
+    readonly need: number;
+};
+interface InputDecl {
+    readonly source: InputSourceDecl;
+    readonly min: number;
+    readonly max: number;
+}
+interface ConsiderationDecl {
+    readonly input: string;
+    readonly curve: CurveDecl;
+}
+type BehaviourDecl = {
+    readonly kind: "idle";
+} | {
+    readonly kind: "move_to_focus";
+    readonly arriveRadius: number;
+} | {
+    readonly kind: "pursue";
+    readonly leadSeconds: number;
+    readonly arriveRadius: number;
+} | {
+    readonly kind: "flee";
+    readonly safeDistance: number;
+} | {
+    readonly kind: "keep_distance";
+    readonly min: number;
+    readonly max: number;
+} | {
+    readonly kind: "search";
+    readonly arriveRadius: number;
+} | {
+    readonly kind: "wander";
+} | {
+    readonly kind: "move_to_goal";
+    readonly arriveRadius: number;
+} | {
+    readonly kind: "attack";
+    readonly range: number;
+    readonly windupTicks: number;
+    readonly strikeTicks: number;
+    readonly recoverTicks: number;
+} | {
+    readonly kind: "take_cover";
+    readonly maxDistance: number;
+} | {
+    readonly kind: "hold_formation";
+    readonly arriveRadius: number;
+} | {
+    readonly kind: "use_object";
+    readonly kinds: readonly number[];
+    readonly maxDistance: number;
+} | {
+    readonly kind: "follow_schedule";
+    readonly arriveRadius: number;
+} | {
+    readonly kind: "bark";
+    readonly lineSet: number;
+} | {
+    readonly kind: "game";
+    readonly code: number;
+};
+interface ActionDecl {
+    readonly name: string;
+    readonly base: number;
+    readonly momentum: number;
+    readonly cooldownTicks: number;
+    readonly speed: number;
+    readonly considerations: readonly ConsiderationDecl[];
+    readonly behaviour: BehaviourDecl;
+}
+interface SightDecl {
+    readonly range: number;
+    readonly fovCos: number;
+    readonly peripheralRange: number;
+    readonly peripheralCos: number;
+    readonly eyeHeight: number;
+    readonly lineOfSight: boolean;
+}
+interface SteeringDecl {
+    readonly maxSpeed: number;
+    readonly maxAcceleration: number;
+    readonly radius: number;
+    readonly separationWeight: number;
+    readonly separationRadius: number;
+    readonly motion: "kinematic" | "external" | "crowd";
+}
+type SkillPair = readonly [atSkill0: number, atSkill1: number];
+interface SkillDecl {
+    readonly reactionSeconds: SkillPair;
+    readonly aimSigma: SkillPair;
+    readonly perceptionScale: SkillPair;
+    readonly tolerance: SkillPair;
+    readonly mistakeChance: SkillPair;
+}
+interface NeedDecl {
+    readonly name: string;
+    readonly decayPerMinute: number;
+    readonly initial: number;
+    readonly urgency: CurveDecl;
+}
+interface ScheduleBlockDecl {
+    readonly startMinute: number;
+    readonly endMinute: number;
+    readonly activity: number;
+    readonly place: readonly [number, number, number];
+    readonly radius: number;
+}
+interface ArchetypeDecl {
+    readonly name: string;
+    readonly thinkEveryTicks: number;
+    readonly senseEveryTicks: number;
+    readonly inputs: Readonly<Record<string, InputDecl>>;
+    readonly actions: readonly ActionDecl[];
+    readonly sight: SightDecl | null;
+    readonly hearing: {
+        readonly sensitivity: number;
+    } | null;
+    readonly memorySeconds: number;
+    readonly awarenessRadius: number;
+    readonly steering: SteeringDecl;
+    readonly skill: SkillDecl;
+    readonly needs: readonly NeedDecl[];
+    readonly schedule: readonly ScheduleBlockDecl[];
+    readonly scheduleJitterMinutes: number;
+}
+interface AiWorldOptions {
+    readonly maxAgents: number;
+    readonly maxTargets?: number;
+    readonly maxSquads?: number;
+    readonly maxObjects?: number;
+    readonly maxCover?: number;
+    readonly memorySlots?: number;
+    readonly sightRaysPerTick?: number;
+    readonly eventCapacity?: number;
+    readonly tickHz?: number;
+    readonly seed?: number;
+    readonly attackTokens?: number;
+    readonly gridCell?: number;
+    readonly minutesPerTick?: number;
+    readonly startMinute?: number;
+}
+declare const ENGINE_AI_EXPORT_NAMES: readonly ["engine_ai_create", "engine_ai_destroy", "engine_ai_registers", "engine_ai_view", "engine_ai_slots", "engine_ai_archetype", "engine_ai_spawn", "engine_ai_despawn", "engine_ai_target_add", "engine_ai_target_remove", "engine_ai_target_move", "engine_ai_target_threat", "engine_ai_agent_target", "engine_ai_noise", "engine_ai_goal", "engine_ai_focus", "engine_ai_skill", "engine_ai_need", "engine_ai_speed", "engine_ai_place", "engine_ai_step", "engine_ai_events", "engine_ai_doing", "engine_ai_aim", "engine_ai_digest", "engine_ai_squad", "engine_ai_join", "engine_ai_leave", "engine_ai_object_add", "engine_ai_object_remove", "engine_ai_cover_add", "engine_ai_cover_remove"];
+type AiExportName = (typeof ENGINE_AI_EXPORT_NAMES)[number];
+type AiExports = Readonly<Record<AiExportName, (...args: number[]) => number>>;
+interface AiPort {
+    readonly name: string;
+    readonly exports: AiExports;
+    step(ai: number): number;
+    buffer(): ArrayBufferLike;
+    alloc(bytes: number, align: number): number;
+    free(pointer: number, bytes: number, align: number): void;
+}
+
+declare const FLUID_CAP_SIMULATION = 1;
+declare const FLUID_CAP_SURFACE = 2;
+/** A signed distance volume a fluid holds, baked from a mesh; kind 3 colliders name it. */
+interface FluidVolume {
+    readonly index: number;
+    /** Where the volume's centre sits in the mesh's own frame. */
+    readonly centre: readonly [number, number, number];
+    readonly half: readonly [number, number, number];
+}
+interface FluidPort {
+    readonly caps: number;
+    create(desc: Float32Array, surface: Float32Array): number;
+    destroy(fluid: number): void;
+    parameters(fluid: number, desc: Float32Array): void;
+    surface(fluid: number, surface: Float32Array): void;
+    emitter(fluid: number, index: number, emitter: Float32Array): void;
+    colliders(fluid: number, colliders: Float32Array, count: number): void;
+    step(fluid: number, seconds: number): void;
+    pause(fluid: number, paused: boolean): void;
+    clear(fluid: number): void;
+    count(fluid: number): number;
+    forces(fluid: number, out: Float32Array): void;
+    volume(fluid: number, positions: Float32Array, indices: Uint32Array, resolution: number, padding: number): FluidVolume;
+    clearVolumes(fluid: number): void;
+}
+
+interface FractureMesh {
+    readonly positions: Float32Array;
+    readonly normals?: Float32Array;
+    readonly uvs?: Float32Array;
+    readonly indices: Uint32Array;
+}
+interface FractureOptions {
+    readonly pieces: number;
+    readonly seed?: number;
+    readonly impact?: readonly [number, number, number];
+    readonly focus?: number;
+    readonly interiorUvScale?: number;
+    readonly anchorHeight?: number;
+}
+interface FracturePiece {
+    readonly centroid: readonly [number, number, number];
+    readonly positions: Float32Array;
+    readonly normals: Float32Array;
+    readonly uvs: Float32Array;
+    readonly indices: Uint32Array;
+    readonly interiorStart: number;
+}
+interface FractureResult {
+    readonly asset: Uint8Array;
+    readonly model: Uint8Array;
+    readonly pieces: readonly FracturePiece[];
+}
+
+interface DestructionEvents {
+    readonly words: Uint32Array;
+    readonly floats: Float32Array;
+    readonly offset: number;
+    readonly count: number;
+}
+interface StructureDesc {
+    readonly bondStrength: number;
+    readonly propagation?: number;
+    readonly stress?: boolean;
+    readonly clusters?: boolean;
+    readonly levels?: number;
+    readonly levelStrength?: number;
+}
+interface DestructionPort {
+    create(asset: Uint8Array, entities: Uint32Array, intact: number, desc: Float32Array): number;
+    destroy(destructible: number): void;
+    damage(destructible: number, x: number, y: number, z: number, radius: number, amount: number): number;
+    configure?(destructible: number, structure: StructureDesc): void;
+    attached(destructible: number): number;
+    update(seconds: number): DestructionEvents;
+    fracture?(mesh: FractureMesh, options: FractureOptions): FractureResult;
+    dispose(): void;
+}
+
+declare const SOFT_BODY_FEATURE = "soft_body_1";
+interface SoftBodyInfo {
+    readonly id: number;
+    readonly particles: number;
+    readonly skinned: number;
+    readonly tets: number;
+    readonly colours: number;
+}
+interface SoftLattice {
+    readonly cells: readonly [number, number, number];
+    readonly size: readonly [number, number, number];
+    readonly origin: readonly [number, number, number];
+    readonly density: number;
+}
+interface SoftBodyPort {
+    readonly registers: Uint32Array;
+    readonly floats: Float32Array;
+    prepare(): Float32Array;
+    lattice(lattice: SoftLattice, vertices: Float32Array | null): SoftBodyInfo;
+    rope(points: Float32Array, mass: number, pinFirst: boolean): SoftBodyInfo;
+    asset(bytes: Uint8Array): SoftBodyInfo;
+    remove(id: number): void;
+    params(id: number): void;
+    colliders(words: Float32Array, count: number): void;
+    anchors(id: number, anchors: Float32Array): void;
+    activate(id: number, activation: number): void;
+    move(id: number, offset: readonly [number, number, number], velocity: readonly [number, number, number]): void;
+    step(seconds: number): void;
+    positions(id: number, count: number): Float32Array;
+    digest(): bigint;
+    present(id: number, geometry: number): number;
+    couple?(collider: number): number;
+    uncouple?(slot: number): void;
+    dispose(): void;
+}
+
+declare const mediumBrand: unique symbol;
+type MediumId = number & {
+    readonly [mediumBrand]: true;
+};
+interface MediumDesc {
+    readonly origin: Vec3Like;
+    readonly extent: Vec3Like;
+    readonly size: readonly [number, number, number];
+    readonly emission?: number;
+    readonly extinction?: number;
+    readonly albedo?: readonly [number, number, number];
+}
+interface MediumPort {
+    createMedium?(desc: MediumDesc): MediumId;
+    setMedium?(medium: MediumId, desc: MediumDesc): void;
+    mediumTexels?(medium: MediumId): Uint32Array;
+    markMedium?(medium: MediumId): void;
+    destroyMedium?(medium: MediumId): void;
+}
+declare const MEDIUM_DEFAULTS: {
+    readonly emission: 1;
+    readonly extinction: 1;
+    readonly albedo: readonly [0.5, 0.5, 0.5];
+};
+declare const MEDIUM_MAX = 16;
+declare const MEDIUM_MAX_EDGE = 64;
+declare function mediumTexel(r: number, g: number, b: number, a: number): number;
+declare function mediumTexelCount(size: readonly [number, number, number]): number;
+declare function mediumIndex(size: readonly [number, number, number], x: number, y: number, z: number): number;
+declare class MediumVolume {
+    private readonly port;
+    readonly id: MediumId;
+    private desc;
+    private disposed;
+    constructor(port: Required<MediumPort>, id: MediumId, desc: MediumDesc);
+    get size(): readonly [number, number, number];
+    get texels(): Uint32Array;
+    index(x: number, y: number, z: number): number;
+    set(desc: MediumDesc): void;
+    mark(): void;
+    dispose(): void;
+}
+
+declare const REACTIVE_FEATURE = "reactive_fluid_1";
+interface ReactivePort {
+    open(chemistry: number, fluid: Float32Array, desc: Uint32Array): number;
+    registers(reactive: number): Uint32Array;
+    hob(reactive: number, desc: Uint32Array): void;
+    lit(reactive: number, on: boolean): void;
+    emitter(reactive: number, index: number, emitter: Float32Array): void;
+    preheat(reactive: number, targetK: number, maxTicks: number): number;
+    step(reactive: number, seconds: number, tick: boolean): void;
+    media(reactive: number, medium: number): number;
+    texels(reactive: number, count: number): Uint32Array;
+    positions(reactive: number, count: number): Float32Array;
+    digest(reactive: number): bigint;
+    close(reactive: number): void;
+}
+
+declare const CLOTH_FEATURE = "cloth_1";
+interface ClothInfo {
+    readonly id: number;
+    readonly particles: number;
+    readonly triangles: number;
+    readonly pins: number;
+    readonly colours: number;
+}
+interface ClothPort {
+    readonly engineHost?: number;
+    readonly registers: Uint32Array;
+    readonly floats: Float32Array;
+    prepare(): Float32Array;
+    grid(pins: Uint32Array | null): ClothInfo;
+    mesh(positions: Float32Array, triangles: Uint32Array, pins: Uint32Array | null): ClothInfo;
+    remove(id: number): void;
+    params(id: number): void;
+    colliders(words: Float32Array, count: number): void;
+    anchors(id: number, anchors: Float32Array): void;
+    step(seconds: number): void;
+    positions(id: number, count: number): Float32Array;
+    digest(): bigint;
+    present(id: number, geometry: number): number;
+    couple?(collider: number): number;
+    uncouple?(slot: number): void;
+    dispose(): void;
+}
+
+interface SmokePort {
+    create(desc: Float32Array, medium: number): number;
+    emitters(smoke: number, floats: Float32Array, count: number): void;
+    follow?(smoke: number, x: number, y: number, z: number): void;
+    step(smoke: number, seconds: number): number;
+    destroy(smoke: number): void;
+}
+
+interface StoryPort {
+    create(program: Uint8Array): number;
+    destroy(story: number): void;
+    start(story: number): void;
+    step(story: number, inputs: Uint32Array, count: number): void;
+    seek(story: number, tick: number): void;
+    available(story: number, choice: number): boolean;
+    variable(story: number, variable: number): number;
+    get(story: number, variable: number): number;
+    set(story: number, variable: number, value: number): void;
+    setText(story: number, variable: number, text: string): void;
+    variableText(story: number, variable: number): string;
+    programText(story: number, index: number): string;
+    textIndex(story: number, text: string): number;
+    textOf(story: number, what: number, index: number, key: number): number;
+    idOf(story: number, what: number, index: number): string | null;
+    buffer(): ArrayBufferLike;
+    views(story: number): StoryViews;
+}
+interface StoryViews {
+    readonly registers: Uint32Array;
+    readonly events: Uint32Array;
+    readonly samples: Float64Array;
+}
+
+interface GraphicsPort extends MediumPort {
+    readonly capabilities: GraphicsCapabilities;
+    readonly gpu: RawGpu | null;
+    attach(surface: GameSurface | null): Promise<void>;
+    resize(width: number, height: number, pixelRatio: number): void;
+    createGeometry(desc: GeometryDesc): GeometryId;
+    geometryAttribute(geometry: GeometryId, name: string): VertexData;
+    markGeometryDirty(geometry: GeometryId, name: string, start: number, count: number): void;
+    setDrawRange(geometry: GeometryId, start: number, count: number): void;
+    destroyGeometry(geometry: GeometryId): void;
+    createTexture(desc: TextureDesc): TextureId;
+    loadTexture(source: AssetSource): Promise<TextureId>;
+    upgradeTexture?(texture: TextureId, source: AssetSource): Promise<TextureUpgrade>;
+    markTextureDirty(texture: TextureId, region?: TextureRegion): void;
+    pushVideoFrame?(texture: TextureId, frame: VideoFrameSource, width: number, height: number): boolean;
+    readRenderTarget?(target: RenderTargetId, rect: readonly [number, number, number, number], slice?: number): Promise<Uint8Array>;
+    destroyTexture(texture: TextureId): void;
+    createMaterial(desc: MaterialDesc): MaterialId;
+    setMaterialColor(material: MaterialId, r: number, g: number, b: number): void;
+    setMaterialOpacity(material: MaterialId, opacity: number): void;
+    setMaterialTexture(material: MaterialId, slot: MaterialTextureSlot, texture: TextureId | null): void;
+    setMaterialScalar(material: MaterialId, uniform: string, value: number): void;
+    setMaterialVector(material: MaterialId, uniform: string, value: Float32Array): void;
+    setMaterialUniformTexture(material: MaterialId, uniform: string, texture: TextureId): void;
+    setMaterialState(material: MaterialId, state: MaterialStateDesc): void;
+    destroyMaterial(material: MaterialId): void;
+    createEmitter(desc: EmitterDesc): EmitterId;
+    emit(emitter: EmitterId, count: number): void;
+    setEmitterRate(emitter: EmitterId, rate: number): void;
+    clearEmitter(emitter: EmitterId): void;
+    destroyEmitter(emitter: EmitterId): void;
+    setRenderOrder(node: NodeId, order: number): void;
+    setShadow(light: NodeId, shadow: ShadowParamsDesc): void;
+    setLod(node: NodeId, near: number, far: number, hysteresis: number): void;
+    setSprite(node: NodeId, rotation: number, centerX: number, centerY: number): void;
+    setProbeCoefficients(light: NodeId, sh: Float32Array): void;
+    setProjectionMatrix(camera: NodeId, matrix: Float32Array | null, near: number, far: number): void;
+    setViewOffset(camera: NodeId, offset: ViewOffset | null): void;
+    gpuStats(out: GpuStats): boolean;
+    batchBuffers(node: NodeId): BatchBuffers | null;
+    markBatch(node: NodeId): void;
+    createNode(desc: NodeDesc): NodeId;
+    destroyNode(node: NodeId): void;
+    setNodeVisible(node: NodeId, visible: boolean): void;
+    setNodeLayers(node: NodeId, mask: number): void;
+    setNodeMaterial(node: NodeId, material: MaterialId): void;
+    setNodeText(node: NodeId, text: string): void;
+    loadFont(source: FontSource, family?: string): Promise<FontId>;
+    setTextStyle(node: NodeId, style: TextStyleDesc): void;
+    textBounds(node: NodeId, out: Float32Array): void;
+    raycast(origin: ArrayLike<number>, direction: ArrayLike<number>, far: number, layers: number, out: PickHit): boolean;
+    batchHandle?(): number;
+    governorPressure?(): number;
+    forceQualityTier?(tier: number | null): boolean;
+    qualityTier?(): number;
+    writeNodeMatrices(nodes: Uint32Array, matrices: Float32Array, rows: Int32Array, count: number): void;
+    readNodeMatrix(node: NodeId, out: Float32Array, offset: number): void;
+    instanceMatrices(node: NodeId): Float32Array;
+    instanceColors(node: NodeId): Float32Array | null;
+    setInstanceCount(node: NodeId, count: number): void;
+    markInstancesDirty(node: NodeId): void;
+    setInstanceFeed?(node: NodeId, table: number, columns: readonly number[], hostReads: boolean, pose?: readonly number[]): boolean;
+    setInstancePalette?(node: NodeId, model: ModelId, skin: number, firstClip: number, clips: number, frames: number): boolean;
+    clearInstanceFeed?(node: NodeId): void;
+    morphWeights(node: NodeId): Float32Array;
+    markMorphWeightsDirty(node: NodeId): void;
+    skeletonPose(node: NodeId): Float32Array;
+    markSkeletonDirty(node: NodeId): void;
+    setCameraPerspective(node: NodeId, fovDegrees: number, near: number, far: number): void;
+    setCameraPerspectiveFrom(node: NodeId, values: Float32Array | Float64Array, offset: number): void;
+    setCameraOrthographic(node: NodeId, height: number, near: number, far: number): void;
+    setActiveCamera(node: NodeId): void;
+    setLight(node: NodeId, color: number, intensity: number): void;
+    setEnvironment(desc: EnvironmentDesc): void;
+    createRenderTarget(desc: RenderTargetDesc): RenderTargetId;
+    renderTargetTexture(target: RenderTargetId): TextureId;
+    renderTargetDepthTexture?(target: RenderTargetId): TextureId;
+    renderTargetAttachment?(target: RenderTargetId, attachment: number): TextureId;
+    resizeRenderTarget(target: RenderTargetId, width: number, height: number): void;
+    destroyRenderTarget(target: RenderTargetId): void;
+    createPostChain(desc: PostChainDesc): PostChainId;
+    setPostScalar(chain: PostChainId, effect: number, uniform: string, value: number): void;
+    setPostChain(chain: PostChainId | null): void;
+    setWeather(state: WeatherState): void;
+    setTimeOfDay(hours: number, latitude?: number, dayOfYear?: number): void;
+    destroyPostChain(chain: PostChainId): void;
+    createRenderPass(desc: RenderPassDesc): RenderPassId;
+    setRenderPassEnabled(pass: RenderPassId, enabled: boolean): void;
+    destroyRenderPass(pass: RenderPassId): void;
+    loadModel(source: AssetSource): Promise<ModelInfo>;
+    upgradeModel?(model: ModelId, source: AssetSource): Promise<ModelUpgrade>;
+    loadClips?(root: NodeId, source: AssetSource, options?: {
+        readonly rate?: number;
+    }): Promise<readonly string[]>;
+    setTint?(node: NodeId, tint: KitTint | null): void;
+    instantiateModel(model: ModelId): NodeId;
+    findNode(root: NodeId, name: string): NodeId | null;
+    playClip(root: NodeId, clip: string, loop: boolean, fadeSeconds: number, speed: number): ClipActionId;
+    playClipIndex?(root: NodeId, clip: number, loop: boolean, fadeSeconds: number, speed: number): ClipActionId;
+    clipIndex?(root: NodeId, clip: string): number;
+    setClipWeight(action: ClipActionId, weight: number): void;
+    stopClip(action: ClipActionId, fadeSeconds: number): void;
+    readonly clips?: ClipAnimationPort;
+    readonly vectorSurfaces?: VectorSurfacePort | null;
+    advanceAnimations(time: FrameTime): void;
+    render(time: FrameTime): void;
+    stats(out: GraphicsStats): void;
+    dispose(): void;
+}
+interface TransformColumns {
+    readonly capacity: number;
+    readonly position: Float32Array;
+    readonly rotation: Float32Array;
+    readonly scale: Float32Array;
+    readonly previousPosition: Float32Array;
+    readonly previousRotation: Float32Array;
+    readonly previousScale: Float32Array;
+    readonly parent: Uint32Array;
+    readonly render: Float32Array;
+    readonly entities: Uint32Array;
+    readonly sparse: Int32Array;
+}
+interface TransformPort {
+    bind(columns: TransformColumns): void;
+    snapshot(count: number): void;
+    computeRender(count: number, time: FrameTime, version: number): void;
+}
+interface PhysicsPort {
+    readonly name: string;
+    readonly rollback?: WorldSnapshots | null;
+    bindTransforms(columns: TransformColumns): void;
+    init(desc: PhysicsWorldDesc): Promise<void>;
+    setGravity(gravity: Vec3Like): void;
+    createBody(entity: number, desc: BodyDesc): number;
+    destroyBody(body: number): void;
+    createCollider(body: number, desc: ColliderDesc): number;
+    destroyCollider(collider: number): void;
+    setColliderEnabled(collider: number, enabled: boolean): void;
+    createJoint(bodyA: number, bodyB: number, desc: JointDesc): number;
+    setJointMotor(joint: number, targetVelocity: number, maxForce: number): void;
+    destroyJoint(joint: number): void;
+    step(): void;
+    setBodyPose(body: number, positions: Float32Array, positionOffset: number, rotations: Float32Array, rotationOffset: number): void;
+    linearVelocity(body: number, out: Vec3Like): void;
+    angularVelocity(body: number, out: Vec3Like): void;
+    setLinearVelocity(body: number, velocity: Vec3Like): void;
+    setAngularVelocity(body: number, velocity: Vec3Like): void;
+    applyImpulse(body: number, impulse: Vec3Like): void;
+    applyTorqueImpulse(body: number, impulse: Vec3Like): void;
+    addForce(body: number, force: Vec3Like): void;
+    resetForces(body: number): void;
+    isSleeping(body: number): boolean;
+    wake(body: number): void;
+    raycast(ray: RayQuery, out: RayHit): boolean;
+    batchHandle?(): number;
+    contactCount(): number;
+    contactColliderA(index: number): number;
+    contactColliderB(index: number): number;
+    contactStarted(index: number): boolean;
+    createCharacterController(desc: CharacterControllerDesc): number;
+    moveCharacter(controller: number, collider: number, desired: Vec3Like, out: CharacterMove): void;
+    destroyCharacterController(controller: number): void;
+    applyImpulseAtPoint(body: number, impulse: Vec3Like, point: Vec3Like): void;
+    addForceAtPoint(body: number, force: Vec3Like, point: Vec3Like): void;
+    addTorque(body: number, torque: Vec3Like): void;
+    velocityAtPoint(body: number, point: Vec3Like, out: Vec3Like): void;
+    setJointMotorPosition(joint: number, target: number, stiffness: number, damping: number): void;
+    castShape(query: ShapeCastQuery, out: RayHit): boolean;
+    overlapSphere?(x: number, y: number, z: number, radius: number, includeSensors: boolean, out: SphereOverlap): void;
+    setColliderClass(collider: number, colliderClass: number): void;
+    setContactRule(platform: number, other: number, rule: ContactRuleDesc): void;
+    setCollisionGroups(collider: number, membership: number, filter: number): void;
+    setSolver?(iterations: number, pgsIterations: number, ccdSubsteps: number): void;
+    setSoftCcd?(body: number, distance: number): void;
+    setSleepThresholds?(body: number, linear: number, angular: number, seconds: number): void;
+    readonly vehicles?: VehiclePort | null;
+    readonly craft?: CraftPort | null;
+    readonly jointPort?: JointPort | null;
+    dispose(): void;
+}
+interface AudioPort {
+    readonly name: string;
+    readonly unlocked: boolean;
+    unlock(): void;
+    decode(source: AssetSource): Promise<number>;
+    createBus(name: string, parent: number): number;
+    setBusGain(bus: number, gain: number, rampSeconds: number): void;
+    play(sound: number, bus: number, gain: number, rate: number, loop: boolean, spatial: boolean, priority?: number): number;
+    setSoundLimit?(sound: number, voices: number, steal: number): void;
+    setVoiceBudget?(voices: number): void;
+    setVoiceFilter?(voice: number, kind: number, frequency: number, q: number, gainDb: number): void;
+    setLimiter?(enabled: boolean, ceilingDb: number, releaseSeconds: number): void;
+    nowFrame?(): number;
+    playOn?(sound: number, bus: number, gain: number, rate: number, loop: boolean, spatial: boolean, priority: number, frame: number): number;
+    stopOn?(voice: number, frame: number, fadeSeconds: number): void;
+    setVoiceBinaural?(voice: number, binaural: boolean): void;
+    setVoiceOcclusion?(voice: number, params: Float32Array | null): void;
+    musicTempo?(bpm: number, beatsPerBar: number, quantize: number): number;
+    musicPlay?(sounds: Int32Array, gains: Float32Array, bars: number, bus: number, quantize: number, fadeSeconds: number): number;
+    musicLayer?(layer: number, gain: number, rampSeconds: number): void;
+    musicStinger?(sound: number, bus: number, gain: number, quantize: number): number;
+    musicStop?(quantize: number, fadeSeconds: number): number;
+    musicPosition?(out: Float64Array): boolean;
+    stop(voice: number, fadeSeconds: number): void;
+    isPlaying(voice: number): boolean;
+    setVoicePosition(voice: number, matrix: Float32Array, offset: number): void;
+    setListener(matrix: Float32Array, offset: number): void;
+    commit?(frame: Float64Array, at: number): void;
+    suspend(): void;
+    resume(): void;
+    dispose(): void;
+    readonly capabilities: AudioCapabilities;
+    readonly sampleRate: number;
+    createSound(samples: Float32Array, channels: number, sampleRate: number): number;
+    setVoiceGain(voice: number, gain: number, rampSeconds: number): void;
+    setVoiceRate(voice: number, rate: number, detuneCents: number): void;
+    setVoiceSpatial(voice: number, params: Float32Array): void;
+    setVoiceLoop(voice: number, loop: boolean, startSeconds: number, endSeconds: number): void;
+    setBusFilter(bus: number, kind: number, frequency: number, q: number, gainDb: number): void;
+    meter(bus: number, out: Float32Array): void;
+    createAnalyser(bus: number, settings: AnalyserSettings): number;
+    readAnalyser(analyser: number, mode: number, out: Float32Array | Uint8Array): void;
+    createReverb(parent: number, impulse: number): number;
+    setBusSend(bus: number, target: number, gain: number): void;
+    openStream(source: AssetSource, bus: number): Promise<number>;
+    playStream(stream: number, gain: number, loop: boolean): void;
+    pauseStream(stream: number): void;
+    seekStream(stream: number, seconds: number): void;
+    streamTime(stream: number): number;
+    streamDuration(stream: number): number;
+    closeStream(stream: number): void;
+    lockstep?(step: number, stepsPerSecond: number): void;
+    flush?(): void;
+    createEmitters?(sound: number, bus: number, capacity: number, params: Float32Array | null): number;
+    feedEmitters?(bank: number, table: number, columns: Uint32Array): number;
+    releaseEmitters?(bank: number): void;
+}
+interface GameBackend {
+    readonly name: string;
+    readonly version: string;
+    readonly memory: ComponentMemory;
+    readonly transforms: TransformPort;
+    readonly graphics: GraphicsPort;
+    readonly physics: PhysicsPort;
+    readonly audio: AudioPort;
+    readonly nav?: NavPort | null;
+    readonly ai?: AiPort | null;
+    readonly streaming?: WorldStreamingPort | null;
+    readonly terrain?: TerrainPort | null;
+    readonly scenery?: SceneryPort | null;
+    readonly soa?: SoaEngine | null;
+    readonly kernels?: KernelEngine | null;
+    readonly chemistry?: ChemistryEngine | null;
+    readonly fluids?: FluidPort | null;
+    readonly destruction?: DestructionPort | null;
+    readonly softBodies?: SoftBodyPort | null;
+    readonly reactive?: ReactivePort | null;
+    readonly cloths?: ClothPort | null;
+    readonly smoke?: SmokePort | null;
+    readonly story?: StoryPort | null;
+}
+
+export { type MaterialTextureSlot as $, type AudioPort as A, type BrushOp as B, type CompoundPartDesc as C, type DeviceTier as D, type EmitterDesc as E, FrameTime as F, type GameBackend as G, type VideoFrameSource as H, type RenderTargetId as I, type VectorAssetId as J, type VectorSurfaceDesc as K, type LimiterDesc as L, type MusicQuantize as M, type NodeId as N, type OcclusionDesc as O, type PannerDesc as P, type VectorSurfaceId as Q, type RawGpu as R, type SoundLimitDesc as S, type TerrainPort as T, type VectorSurfacePlay as U, Vec3 as V, type VectorSurfaceSeek as W, type VectorSurfacePhase as X, type VectorSurfaceEvent as Y, type VectorSurfaceStats as Z, type VectorSurfaceTier as _, FixedStepLoop as a, type TransformPort as a$, type MaterialStateDesc as a0, type EmitterId as a1, type ShadowParamsDesc as a2, type ViewOffset as a3, type GpuStats as a4, type NodeDesc as a5, type FontSource as a6, type FontId as a7, type TextStyleDesc as a8, type PickHit as a9, type ChemistryEngine as aA, type ReactivePort as aB, type SmokePort as aC, type StoryPort as aD, type DestructionPort as aE, type StructureDesc as aF, type LoopOptions as aG, type FractureMesh as aH, type FractureOptions as aI, GPU_PASS_NAMES as aJ, createPickHit as aK, type NavPort as aL, type NavDesc as aM, type OffMeshLinkDesc as aN, type AgentDesc as aO, type RoadGraphDesc as aP, type DriverDesc as aQ, RayQuery as aR, RayHit as aS, type SoaEngine as aT, type SoaBulkExports as aU, ShapeCastQuery as aV, type RollbackState as aW, type Scalar as aX, type ArrayFor as aY, type ComponentMemory as aZ, type TransformColumns as a_, type EnvironmentDesc as aa, type RenderTargetDesc as ab, type RenderPassId as ac, type PostChainDesc as ad, type PostChainId as ae, type WeatherState as af, type MediumDesc as ag, MediumVolume as ah, type RenderPassDesc as ai, type ModelInfo as aj, type KitTint as ak, type ClipActionId as al, type ClipAnimationPort as am, type GraphicsStats as an, type FluidPort as ao, type IkChainId as ap, type ClipEvent as aq, type BlendSpaceId as ar, type BoneSetId as as, type RootMotionId as at, type VehicleDesc as au, Vehicle as av, Quat as aw, type AiPort as ax, type AiWorldOptions as ay, type ArchetypeDecl as az, type AssetSource as b, type ScheduleBlockDecl as b$, type CurveTable as b0, type SoftBodyPort as b1, type SoftBodyInfo as b2, type CraftPort as b3, type WaterDesc as b4, type SeaState as b5, type OceanDesc as b6, type OceanCascades as b7, type PuddleOptions as b8, type RippleOptions as b9, CHEMISTRY_REFUSED as bA, CHEMISTRY_SLOTS as bB, CHEMISTRY_SPECIES_WORDS as bC, CHEMISTRY_STATS_WORDS as bD, CHEMISTRY_TQ as bE, CHEMISTRY_UNSET as bF, CHEMISTRY_VACUUM as bG, CHEMISTRY_VESSEL_SLOTS as bH, CHEMISTRY_VESSEL_WORDS as bI, type ChemistryExportName as bJ, type ChemistryExports as bK, bindChemistryEngine as bL, type ClipLoop as bM, type LightKind as bN, type TypedArray as bO, type PhysicsWorldDesc as bP, Vec2 as bQ, type ShapeDesc as bR, type VehiclePort as bS, type BehaviourDecl as bT, type ConsiderationDecl as bU, type InputDecl as bV, type ActionDecl as bW, type SightDecl as bX, type SteeringDecl as bY, type SkillDecl as bZ, type NeedDecl as b_, WaterSample as ba, type ColliderDesc as bb, type PhysicsPort as bc, type WorldRollbackDesc as bd, type SolverSettings as be, type SleepThresholds as bf, WorldSnapshots as bg, type BodyDesc as bh, type JointPort as bi, type RagdollDesc as bj, type Ragdoll as bk, type JointDesc as bl, type ContactRuleDesc as bm, type CharacterControllerDesc as bn, CharacterMove as bo, type WorldStreamingPort as bp, type KernelEngine as bq, CHEMISTRY_ATMOSPHERE as br, CHEMISTRY_BOX_WORDS as bs, CHEMISTRY_COLUMNS as bt, CHEMISTRY_EVENT_HEADER as bu, CHEMISTRY_EVENT_WORDS as bv, CHEMISTRY_EXPORT_NAMES as bw, CHEMISTRY_NATURE_WORDS as bx, CHEMISTRY_PROBE_WORDS as by, CHEMISTRY_REACTION_WORDS as bz, type AudioCapabilities as c, GEAR_AUTO as c$, type CurveDecl as c0, type BuiltinInput as c1, AI_EVENT_WORDS as c2, AI_MAX_GAME_SLOTS as c3, AI_NONE as c4, AiEventKind as c5, type AiEventKindCode as c6, BUILTIN_INPUTS as c7, PHASE_IDLE as c8, PHASE_RECOVER as c9, CLOTH_FEATURE as cA, type CastShapeKind as cB, type CloudDesc as cC, type ColorSpace as cD, type CompareFunction as cE, ContactRuleTable as cF, type CurvePoint as cG, DEFAULT_COLLIDER_CLASS as cH, DEFAULT_PANNER as cI, DISTANCE_MODELS as cJ, type DistanceModel as cK, type EmitterCollision as cL, type EmitterShape as cM, type EngineCurveDesc as cN, FILTER_KINDS as cO, FLUID_CAP_SIMULATION as cP, FLUID_CAP_SURFACE as cQ, FRAME_ALPHA_SLOT as cR, FRAME_NOW_MS_SLOT as cS, FRAME_SECONDS_SLOT as cT, FRAME_STEP_SECONDS_SLOT as cU, FRAME_TICK_SLOT as cV, FftAnalyser as cW, type FilterKind as cX, type FogDesc as cY, type FracturePiece as cZ, type FractureResult as c_, PHASE_STRIKE as ca, PHASE_WINDUP as cb, type ToneMapping as cc, type PostEffectDesc as cd, type SceneryBodyPort as ce, type KeyframeDesc as cf, type KeyframeStats as cg, AGENT_ARRIVED as ch, AGENT_IDLE as ci, AGENT_LOST as cj, AGENT_MOVING as ck, AGENT_ON_LINK as cl, AGENT_REQUESTING as cm, AGENT_STRIDE as cn, AGENT_X as co, AUDIO_PREVIEW_SUFFIX as cp, AssetPriority as cq, type AtmosphereDesc as cr, type AxisMotion as cs, BRUSH as ct, type BatchBuffers as cu, type BlendDesc as cv, type BlendEquation as cw, type BlendFactor as cx, type Blending as cy, type BodyKind as cz, type FilterDesc as d, POSE_LANE as d$, GEAR_NEUTRAL as d0, GEAR_REVERSE as d1, type GearboxDesc as d2, type GeometryGroup as d3, type GlobalIlluminationDesc as d4, type GlobalIlluminationMode as d5, type GlslSource as d6, type GpuBindGroupId as d7, type GpuBindingDesc as d8, type GpuBlend as d9, type JointAxisName as dA, type JointDrive as dB, type JointLoad as dC, type LaneSpec as dD, type LeanDesc as dE, type LinesMaterialDesc as dF, type LodRange as dG, MAX_CCD_SUBSTEPS as dH, MAX_COLLIDER_CLASSES as dI, MAX_PGS_ITERATIONS as dJ, MAX_SOLVER_ITERATIONS as dK, MEDIUM_DEFAULTS as dL, MEDIUM_MAX as dM, MEDIUM_MAX_EDGE as dN, type MatcapMaterialDesc as dO, type MaterialCommon as dP, type MaterialTint as dQ, type MediumId as dR, type MediumPort as dS, type MorphTargetDesc as dT, NOISE as dU, NO_CONTACT_RULE as dV, NO_LINK as dW, type NodeCommon as dX, type NodeKindDesc as dY, POSE_DIR_X as dZ, POSE_DIR_Z as d_, type GpuBlendComponent as da, type GpuBlendFactor as db, type GpuBufferDesc as dc, type GpuBufferId as dd, type GpuBufferUsage as de, type GpuComputePipelineDesc as df, type GpuDispatchOptions as dg, type GpuDrawOptions as dh, type GpuHook as di, type GpuPipelineId as dj, type GpuRect as dk, type GpuRenderPipelineDesc as dl, type GpuSamplerDesc as dm, type GpuSamplerId as dn, type GpuSceneResource as dp, type GpuSceneTexture as dq, type GpuShaderId as dr, type GpuTextureCopy as ds, type GpuTextureDesc as dt, type GpuTextureFormat as du, type GpuTextureId as dv, type GpuTextureUsage as dw, type GpuTopology as dx, type Interpolation as dy, JOINT_AXES as dz, type AnalyserDesc as e, type VolumetricFogDesc as e$, POSE_SPEED as e0, POSE_STRIDE$1 as e1, POSE_X as e2, POSE_Z as e3, type PhysicalMaterialDesc as e4, type PointsMaterialDesc as e5, type PolygonOffsetDesc as e6, type PrimitiveShapeDesc as e7, POSE_STRIDE as e8, REACTIVE_FEATURE as e9, type StencilDesc as eA, type StencilOperation as eB, TERRAIN_REGISTER as eC, TIME_SCALE_SLOT as eD, type TexelData as eE, type TexelFormat as eF, type TextAlign as eG, type TextDirection as eH, type TextureEncode as eI, type TextureFilter as eJ, type TextureKind as eK, type TextureSource as eL, type TextureTransform as eM, type TextureWrap as eN, type ToonMaterialDesc as eO, type Transparency as eP, type UniformDesc as eQ, type UniformType as eR, type UnlitMaterialDesc as eS, VECTOR_SURFACE_CAPS as eT, VECTOR_SURFACE_EDGES as eU, VECTOR_SURFACE_TIERS as eV, type Vec3Tuple as eW, Vec4 as eX, type VectorSurfacePort as eY, type VertexAttributeDesc as eZ, type VolumetricCloudsDesc as e_, type RagdollBoneDesc as ea, type RagdollDrive as eb, type RagdollRoot as ec, type RenderTargetFormat as ed, SCENERY_REGISTER as ee, SCENERY_REGISTER_WORDS as ef, SCENERY_REQUEST_SLOTS as eg, SEA_STATES as eh, SH_COEFFICIENT_FLOATS as ei, SIGNAL_AMBER as ej, SIGNAL_GREEN as ek, SIGNAL_RED as el, SOA_EXPORT_NAMES as em, SOFT_BODY_FEATURE as en, type ShaderMaterialDesc as eo, type ShaderSource as ep, type ShadowDesc as eq, type ShadowType as er, type Side as es, type SignalSpec as et, type SkeletonDesc as eu, type SkyDesc as ev, type SoaExports as ew, type SphereOverlap as ex, type SpriteMaterialDesc as ey, type StandardMaterialDesc as ez, type Vec3Like as f, type VolumetricsDesc as f0, WHEEL_CENTER as f1, WHEEL_FORCE_LAT as f2, WHEEL_FORCE_LONG as f3, WHEEL_GROUND as f4, WHEEL_LENGTH as f5, WHEEL_LOAD as f6, WHEEL_OMEGA as f7, WHEEL_POINT as f8, WHEEL_SLIP as f9, WHEEL_SLIP_ANGLE as fa, WHEEL_SPIN as fb, WHEEL_STEER as fc, Water as fd, type WaterFlow as fe, type WaveDesc as ff, type WgslSource as fg, type WheelDesc as fh, analyserSettings as fi, bindKernelEngine as fj, bindSoaEngine as fk, createGpuStats as fl, createVectorSurfaceStats as fm, detuneRate as fn, encodeVehicleDesc as fo, isa as fp, materialTint as fq, mediumIndex as fr, mediumTexel as fs, mediumTexelCount as ft, peakCurve as fu, sampleCurve as fv, seaDesc as fw, type NoiseKind as g, type Plane as h, type GeometryId as i, type MaterialId as j, type MaterialDesc as k, type AnalyserSettings as l, type ClothPort as m, type ClothInfo as n, type SceneryPort as o, type GraphicsPort as p, type GraphicsCapabilities as q, type GameSurface as r, type GeometryDesc as s, type VertexData as t, type TextureDesc as u, type TextureId as v, type TextureUpgrade as w, type ModelId as x, type ModelUpgrade as y, type TextureRegion as z };