@cimplify/sdk 0.108.0 → 0.110.2

package/dist/fluid-DLlEj2cs.d.mts

@@ -0,0 +1,939 @@
+import { P as PrefetchLayer, c as PrefetchLayerDesc, b as TableSchema, a as EntityTable, d as PrefetchItemDesc, D as DespawnListener, W as World, T as Transforms, E as Entity, C as ComponentType, e as Physics } from './world-qekkXjJv.mjs';
+import { m as ClothPort, n as ClothInfo, i as GeometryId, f as Vec3Like, o as SceneryPort, p as GraphicsPort, q as GraphicsCapabilities, R as RawGpu, r as GameSurface, s as GeometryDesc, t as VertexData, u as TextureDesc, v as TextureId, b as AssetSource, w as TextureUpgrade, x as ModelId, y as ModelUpgrade, z as TextureRegion, H as VideoFrameSource, I as RenderTargetId, J as VectorAssetId, K as VectorSurfaceDesc, Q as VectorSurfaceId, N as NodeId, U as VectorSurfacePlay, W as VectorSurfaceSeek, X as VectorSurfacePhase, Y as VectorSurfaceEvent, Z as VectorSurfaceStats, _ as VectorSurfaceTier, k as MaterialDesc, j as MaterialId, $ as MaterialTextureSlot, a0 as MaterialStateDesc, E as EmitterDesc, a1 as EmitterId, a2 as ShadowParamsDesc, a3 as ViewOffset, a4 as GpuStats, a5 as NodeDesc, a6 as FontSource, a7 as FontId, a8 as TextStyleDesc, a9 as PickHit, aa as EnvironmentDesc, ab as RenderTargetDesc, ac as RenderPassId, ad as PostChainDesc, ae as PostChainId, af as WeatherState, ag as MediumDesc, ah as MediumVolume, ai as RenderPassDesc, aj as ModelInfo, ak as KitTint, al as ClipActionId, am as ClipAnimationPort, an as GraphicsStats, F as FrameTime, ao as FluidPort } from './backend-gUCzs5Kg.mjs';
+import { N as NetworkHint, P as PrefetchDepth } from './network-ZXLD7l1b.mjs';
+
+interface ClothOptions {
+    readonly mass?: number;
+    readonly stretch?: number;
+    readonly bend?: number;
+    readonly tetherSlack?: number;
+    readonly damping?: number;
+    readonly gravity?: Vec3Like;
+    readonly substeps?: number;
+    readonly thickness?: number;
+    readonly friction?: number;
+    readonly geometry?: GeometryId;
+}
+type ClothPinning = "none" | "top" | "corners";
+type ClothShape = {
+    readonly grid: {
+        readonly columns: number;
+        readonly rows: number;
+        readonly spacing: number;
+        readonly origin: Vec3Like;
+        readonly across?: Vec3Like;
+        readonly down?: Vec3Like;
+        readonly pin?: ClothPinning;
+        readonly pins?: readonly number[];
+    };
+} | {
+    readonly mesh: {
+        readonly positions: Float32Array;
+        readonly triangles: Uint32Array;
+        readonly pins?: Uint32Array;
+    };
+};
+type ClothCollider = {
+    readonly sphere: {
+        readonly center: Vec3Like;
+        readonly radius: number;
+    };
+} | {
+    readonly capsule: {
+        readonly a: Vec3Like;
+        readonly b: Vec3Like;
+        readonly radius: number;
+    };
+};
+declare const CLOTH_DEFAULTS: {
+    readonly mass: 0.01;
+    readonly stretch: 1e-7;
+    readonly bend: 0.0001;
+    readonly tetherSlack: 0.05;
+    readonly damping: 0.5;
+    readonly gravity: {
+        readonly x: 0;
+        readonly y: -9.81;
+        readonly z: 0;
+    };
+    readonly substeps: 8;
+    readonly thickness: 0.005;
+    readonly friction: 0.2;
+};
+declare class ClothSheet {
+    private readonly port;
+    private readonly info;
+    readonly particles: number;
+    readonly triangles: number;
+    readonly pins: number;
+    private geometry;
+    private disposed;
+    constructor(port: ClothPort, info: ClothInfo, geometry: GeometryId | null);
+    get id(): number;
+    get engineHost(): number | null;
+    positions(): Float32Array;
+    attach(geometry: GeometryId | null): void;
+    setOptions(options: ClothOptions): void;
+    setAnchors(anchors: Float32Array): void;
+    present(): number;
+    dispose(): void;
+}
+declare class Cloths {
+    readonly port: ClothPort;
+    private readonly sheets;
+    private readonly block;
+    constructor(port: ClothPort);
+    create(shape: ClothShape, options?: ClothOptions): ClothSheet;
+    remove(sheet: ClothSheet): void;
+    setColliders(colliders: readonly ClothCollider[]): void;
+    couple(collider: number): number;
+    uncouple(slot: number): void;
+    get count(): number;
+    step(seconds: number): void;
+    present(): void;
+    digest(): bigint;
+    dispose(): void;
+}
+
+interface ReachGrid {
+    readonly cellSize: number;
+    readonly origin: readonly [number, number];
+    readonly cols: number;
+    readonly rows: number;
+}
+interface ReachNav {
+    nearest(point: Vec3Like, out: Vec3Like): boolean;
+}
+declare class PrefetchReach {
+    readonly cellSize: number;
+    readonly originX: number;
+    readonly originZ: number;
+    readonly cols: number;
+    readonly rows: number;
+    readonly mask: Uint8Array;
+    readonly distance: Float64Array;
+    private readonly heap;
+    private readonly heapKey;
+    private readonly slot;
+    private readonly args;
+    private source;
+    private range;
+    constructor(grid: ReachGrid, mask?: Uint8Array);
+    static fromNav(nav: ReachNav, grid: ReachGrid, options?: {
+        readonly y?: number;
+        readonly from?: Vec3Like;
+    }): PrefetchReach;
+    cellAt(x: number, z: number): number;
+    walkable(x: number, z: number): boolean;
+    keepConnected(x: number, z: number): void;
+    pathDistance(x: number, z: number): number;
+    update(x: number, z: number, range: number): void;
+    stopTime(x: number, z: number, vx: number, vz: number, horizon: number): number;
+    updateFrom(args: Float64Array): void;
+    stopTimeInto(args: Float64Array): void;
+    private flood;
+    private push;
+    private pop;
+}
+
+interface PrefetchAssets {
+    prefetch?(path: string, priority?: number): boolean;
+    cancelPrefetch?(path: string): boolean;
+    resident?(path: string): boolean;
+    pending?(path: string): boolean;
+    networkHint?(): NetworkHint | null;
+}
+interface PredictorOptions {
+    readonly horizons?: readonly number[];
+    readonly maxSpeed?: number;
+    readonly spread?: number;
+    readonly minSpread?: number;
+    readonly turnPenalty?: number;
+    readonly interval?: number;
+    readonly budgetBytes?: number;
+    readonly maxPending?: number;
+    readonly maxSpeculative?: number;
+    readonly releaseSeconds?: number;
+    readonly capacity?: number;
+    readonly teleport?: number;
+    readonly smoothing?: number;
+    readonly saturationSeconds?: number;
+    readonly reach?: PrefetchReach | null;
+}
+declare const DEFAULT_HORIZONS: readonly number[];
+declare const DEFAULT_PREFETCH_BUDGET: number;
+declare const EntryState: {
+    readonly idle: 0;
+    readonly pending: 1;
+    readonly resident: 2;
+    readonly consumed: 3;
+};
+interface PredictorStats {
+    plans: number;
+    requested: number;
+    reprioritised: number;
+    released: number;
+    consumed: number;
+    pendingBytes: number;
+    pending: number;
+    tracked: number;
+}
+declare class StreamPredictor {
+    readonly layer: PrefetchLayer;
+    readonly state: Uint8Array;
+    readonly priority: Uint8Array;
+    readonly time: Float64Array;
+    readonly stats: PredictorStats;
+    private readonly stamp;
+    private readonly slot;
+    private readonly tracked;
+    private readonly keys;
+    private readonly horizons;
+    private readonly reachCell;
+    private readonly local;
+    private readonly previous;
+    private readonly velocity;
+    private readonly s;
+    private readonly r;
+    private readonly tuning;
+    private readonly interval;
+    private readonly maxPending;
+    private readonly reach;
+    private assets;
+    private trackedCount;
+    private candidateCount;
+    private planId;
+    private frames;
+    private hasPrevious;
+    private idleMode;
+    private pendingCount;
+    private pendingBytes;
+    private readonly budget;
+    private inFlight;
+    private linkLoad;
+    private readonly maxSpeculative;
+    private prefetchAllowed;
+    constructor(layer: PrefetchLayer, assets: PrefetchAssets | null, options?: PredictorOptions);
+    attach(assets: PrefetchAssets | null): void;
+    set idle(on: boolean);
+    get idle(): boolean;
+    get stopTime(): number;
+    get bytesPending(): number;
+    get speed(): number;
+    velocityInto(out: Float64Array): void;
+    activeHorizons(depth: PrefetchDepth): number;
+    horizonLimit(depth: PrefetchDepth): number;
+    frame(eye: ArrayLike<number>, dtSeconds: number): void;
+    frameAt(eye: ArrayLike<number>, clock: Float64Array, slot: number): void;
+    get load(): number;
+    get throughput(): number;
+    private step;
+    private observe;
+    private plan;
+    private consider;
+    private candidate;
+    private measureLoad;
+    private refresh;
+    private issue;
+    private evict;
+    private track;
+    private untrack;
+    private untrackBytes;
+    releaseAll(): void;
+    reset(): void;
+}
+declare function cone(wx: number, wy: number, wz: number, vx: number, vy: number, vz: number, reach: number, sigma: number): number;
+
+interface ScenePrefetchDesc {
+    readonly assets?: readonly string[];
+    readonly next?: readonly string[];
+    readonly idle?: boolean;
+}
+interface PrefetchStreamOptions extends PredictorOptions {
+    readonly stalled?: () => boolean;
+    readonly assets?: PrefetchAssets | null;
+}
+interface PrefetchEye {
+    readCameraEye(out: Float32Array): boolean;
+}
+declare const NEXT_SCENE_BUDGET: number;
+declare class ScenePrefetch {
+    readonly name: string;
+    readonly paths: readonly string[];
+    private readonly owner;
+    private requestedCount;
+    private active;
+    constructor(name: string, paths: readonly string[], owner: GamePrefetch);
+    get requested(): number;
+    get total(): number;
+    get resident(): number;
+    get ready(): boolean;
+    get running(): boolean;
+    start(priority: number, limit: number): void;
+    cancel(): void;
+}
+declare class GamePrefetch {
+    private readonly scenes;
+    private readonly running;
+    private readonly streams;
+    private readonly stallChecks;
+    private readonly overrides;
+    private readonly eye;
+    private readonly position;
+    private readonly sizes;
+    private source;
+    private idleMode;
+    private enabled;
+    private current;
+    constructor(assets?: PrefetchAssets | null);
+    get assets(): PrefetchAssets | null;
+    get network(): NetworkHint | null;
+    get depth(): PrefetchDepth;
+    get streamCount(): number;
+    get idling(): boolean;
+    attach(assets: PrefetchAssets | null): void;
+    setEnabled(on: boolean): void;
+    sized(path: string, bytes: number): void;
+    stream(layer: PrefetchLayer | PrefetchLayerDesc, options?: PrefetchStreamOptions): StreamPredictor;
+    private streamAssets;
+    removeStream(predictor: StreamPredictor): void;
+    describe(name: string, desc: ScenePrefetchDesc): void;
+    scene(name: string, priority?: number): ScenePrefetch;
+    cancelScene(name: string): void;
+    idle(on: boolean): void;
+    get currentScene(): string | null;
+    entered(name: string): void;
+    private hintNext;
+    private limitFor;
+    frameAt(eye: PrefetchEye, clock: Float64Array, slot: number): boolean;
+    frame(eye: PrefetchEye | ArrayLike<number> | null, dtSeconds: number): boolean;
+    dispose(): void;
+}
+
+/**
+ * Reads package assets by path, as `ctx.assets` does inside an Interactive.
+ * Hosts that deliver lazy chunks on request also expose `requests`, `lazy` and `release`;
+ * scenery then keeps a bounded cache of chunk bytes and tells the host when it drops one.
+ */
+interface SceneryAssetReader extends PrefetchAssets {
+    take(path: string, priority?: number, stall?: boolean): Promise<Uint8Array>;
+    requests?(): boolean;
+    lazy?(path: string): boolean;
+    release?(path: string): void;
+    progressive?(path: string, listener: (output: Uint8Array) => void, priority?: number): {
+        readonly done: Promise<Uint8Array>;
+    };
+    isProgressive?(path: string): boolean;
+}
+/** Where a scenery manifest (`splats.cspm`) lives. Chunks are read from the same folder. */
+type ScenerySource = string | URL;
+interface SceneryLoadOptions {
+    /** Read the manifest and its chunks as package assets instead of fetching URLs. */
+    readonly assets?: SceneryAssetReader;
+    /** Bytes of lazily delivered chunks kept in the guest after the engine copied them (default 8 MiB). */
+    readonly cacheBytes?: number;
+    /** Region names from the bake report (`splats.json` regions), so `edit` and `drape` take names as well as numbers. */
+    readonly regions?: Readonly<Record<string, number>>;
+    /** Deformed splats allowed at each device tier, full to minimum. At a zero, a body asks for the stand-in and moving scenery holds still at its rest pose. */
+    readonly heroBudget?: readonly [number, number, number];
+    /** Shown while the device tier cannot afford this body: a mesh, a video or anything the caller owns. Moving scenery never needs one. */
+    readonly standIn?: SceneryStandIn;
+}
+interface SceneryStandIn {
+    show(): void;
+    hide(): void;
+}
+/** A colour and material edit applied to one baked region. Hue is in radians; saturation and gain scale from 1. */
+interface SceneryEdit {
+    readonly hue?: number;
+    readonly saturation?: number;
+    readonly gain?: number;
+}
+interface SceneryMotionOptions<S extends TableSchema> {
+    /** The table the kernel runs over. Its capacity must hold `Scenery.motionRows` splats. */
+    readonly table: EntityTable<S>;
+    /** Furthest any splat moves from its rest position, in metres. It widens the culling bounds. */
+    readonly reach: number;
+    /** Position offsets in metres in the body's own space. Used by default (`dx`, `dy`, `dz`) when no other channel is named. */
+    readonly offset?: readonly [string, string, string];
+    /** An extra rotation as a quaternion (x, y, z, w). A zero quaternion means no rotation. */
+    readonly rotation?: readonly [string, string, string, string];
+    /** Display-space colour added to each splat. */
+    readonly colour?: readonly [string, string, string];
+    /** Added to each splat's opacity, which then stays within 0 to 1. */
+    readonly opacity?: string;
+    /** Fields the engine fills with each splat's rest position when it arrives. */
+    readonly rest?: readonly [string, string, string];
+}
+interface SceneryDrapeOptions {
+    /** The baked mesh's vertices (x, y, z each), in the body's own space. Without it the cloth's starting mesh is taken, with the body's place when `drape` is called. */
+    readonly rest?: Float32Array;
+}
+interface SplatBodyOptions extends SceneryLoadOptions {
+    readonly manifest: ScenerySource;
+    /** The root node of a loaded model on the rig the body was baked against. Its animation mixer drives the pose. */
+    readonly rig: number;
+}
+interface QuatLike {
+    readonly x: number;
+    readonly y: number;
+    readonly z: number;
+    readonly w: number;
+}
+/** The engine_world cell grid the scenery was baked against, matching `WorldStream` cells. */
+interface SceneryGrid {
+    readonly cellSize: number;
+    /** World x and z of the grid's first cell corner. */
+    readonly origin: readonly [number, number];
+    readonly cols: number;
+    readonly rows: number;
+}
+interface SceneryStats {
+    readonly chunks: number;
+    readonly resident: number;
+    readonly requested: number;
+    readonly installed: number;
+    readonly evicted: number;
+    readonly deferred: number;
+    readonly failed: number;
+    readonly installedBytes: number;
+    readonly residentSplats: number;
+    readonly drawnSplats: number;
+    readonly listedPages: number;
+    readonly poolCapacity: number;
+    readonly poolFreePages: number;
+    readonly tier: number;
+    readonly updates: number;
+    /** Splats on deforming pages planned this frame, after the hero budget. */
+    readonly heroSplats: number;
+    /** Splats the hero budget removed this frame. */
+    readonly heroShed: number;
+    /** True while the tier's hero budget is zero and this scenery deforms. */
+    readonly standIn: boolean;
+    readonly deformedSplats: number;
+}
+declare const SCENERY_MANIFEST_MAGIC = 1297109827;
+declare const SCENERY_MANIFEST_VERSION = 1;
+declare const SCENERY_MANIFEST_VERSION_PARTS = 2;
+declare const SCENERY_PART_WHOLE = 255;
+declare const SCENERY_PART_COARSE = 0;
+declare const SCENERY_PART_MIDDLE = 1;
+declare const SCENERY_PART_FINE = 2;
+declare const SCENERY_CHUNK_EXTENSION = ".cspl";
+interface SceneryManifest {
+    readonly grid: SceneryGrid;
+    readonly chunks: readonly string[];
+    readonly bounds: Float32Array;
+    readonly bytes: Uint32Array;
+    readonly parts?: Uint8Array;
+    readonly groups?: Uint32Array;
+}
+type Manifest = SceneryManifest;
+type ManifestRows = Pick<SceneryManifest, "bounds" | "bytes" | "parts" | "groups">;
+declare function sceneryPartDrawLevel(part: number): number;
+declare function sceneryPartReach(part: number, radii: {
+    readonly near: number;
+    readonly far: number;
+}): number;
+declare function sceneryEntryRows(manifest: ManifestRows, count: number): Int32Array;
+declare const SCENERY_LOAD_SHARE = 1.1;
+declare const SCENERY_NEED_SHARE = 3;
+declare const SCENERY_TIER_RADII: readonly {
+    readonly near: number;
+    readonly far: number;
+}[];
+declare function sceneryTierRadii(tier: number): {
+    readonly near: number;
+    readonly far: number;
+};
+declare function sceneryPrefetchItems(manifest: ManifestRows, paths: readonly string[], radii?: {
+    readonly near: number;
+    readonly far: number;
+}): PrefetchItemDesc[];
+declare function sceneryFirstView(manifest: {
+    readonly bounds: Float32Array;
+    readonly bytes: Uint32Array;
+}, paths: readonly string[], view: readonly [number, number, number], radius: number): string[];
+declare function parseSceneryManifest(bytes: Uint8Array): Manifest;
+declare class SceneryChunks {
+    private readonly assets;
+    private readonly cacheBytes;
+    private readonly kept;
+    private readonly cache;
+    private cached;
+    constructor(assets: SceneryAssetReader | null, cacheBytes?: number);
+    private lazy;
+    read(path: string, priority?: number): Promise<Uint8Array>;
+    holds(path: string): boolean;
+    get reader(): SceneryAssetReader | null;
+    private retained;
+    delivered(path: string, bytes: Uint8Array): void;
+    reclaim(): boolean;
+    private evictColdest;
+    get cachedBytes(): number;
+    close(): void;
+}
+/**
+ * Photoreal Gaussian splat scenery streamed by the engine around the active camera.
+ * Chunks are fetched only when the engine asks for them; the handle is updated every frame.
+ */
+declare class Scenery {
+    private readonly port;
+    private readonly handle;
+    private readonly chunkPaths;
+    private readonly chunks;
+    private readonly owner;
+    /** The engine_world grid this scenery shares with `WorldStream` cells. */
+    readonly grid: SceneryGrid;
+    /** Live engine counters; all read zero after `remove()`. */
+    readonly stats: SceneryStats;
+    readonly layer: PrefetchLayer;
+    private readonly requests;
+    private readonly transform;
+    private readonly engineState;
+    private readonly lastEye;
+    private registers;
+    private predictor;
+    private hasEye;
+    private sweep;
+    private waiting;
+    private readonly entryRow;
+    private readonly rowBytes;
+    private readonly rowPart;
+    private readonly rowSphere;
+    private readonly flow;
+    private closed;
+    private readonly editValues;
+    private readonly regionNames;
+    private readonly standInTarget;
+    private standing;
+    private kernel;
+    constructor(port: SceneryPort, handle: number, manifest: Manifest, chunkPaths: readonly string[], chunks: SceneryChunks, owner: GraphicsScenery, options?: SceneryLoadOptions);
+    private tier;
+    get prefetcher(): StreamPredictor | null;
+    stream(prefetch: GamePrefetch): void;
+    stalled(): boolean;
+    /** True once `remove()` has run. */
+    get removed(): boolean;
+    /** Places the scenery in the world: translation, rotation (normalised by the engine) and a uniform scale above zero. */
+    setTransform(position: Vec3Like, rotation?: QuatLike, scale?: number): void;
+    private bodyPort;
+    private regionOf;
+    /** Recolours one baked region without recapture: hue in radians, saturation and gain as multipliers. */
+    edit(region: number | string, edit: SceneryEdit): void;
+    /** Drives this body from a model's pose on the rig it was baked against; null returns it to rest. Throws when the rig differs. */
+    bind(rig: number | null): void;
+    /** Splats in garment region `region` follow `cloth`, which must use the mesh the region was baked with. It may be called at any point in the cloth's run. */
+    drape(cloth: ClothSheet, region: number | string, options?: SceneryDrapeOptions): void;
+    /** Rows a motion table needs: one for every splat in the manifest, across all levels of detail. */
+    get motionRows(): number;
+    /**
+     * Runs a per-splat program. `kernel` is called once a frame, normally `() => game.kernels.run(wave, table, time)`;
+     * the engine reads what it writes before deforming, and pays only for the channels named here. Pass null to stop.
+     */
+    motion<S extends TableSchema>(kernel: ((table: EntityTable<S>) => void) | null, options?: SceneryMotionOptions<S>): void;
+    private follow;
+    /** Closes the scenery and frees its engine resources. Later calls on the handle do nothing. */
+    remove(): void;
+    update(eye: Float32Array): void;
+    private forget;
+    private fetch;
+    private deliver;
+    private upgrade;
+    private failed;
+    private mark;
+    private view;
+}
+/** `graphics.scenery`: loads Gaussian splat scenery on backends that draw it (the native engine). */
+declare class GraphicsScenery {
+    private readonly port;
+    private readonly eye;
+    private readonly live;
+    private readonly eyeBuffer;
+    private prefetch;
+    attachPrefetch(prefetch: GamePrefetch | null): void;
+    unstream(predictor: StreamPredictor): void;
+    constructor(port: SceneryPort | null, eye: (out: Float32Array) => boolean);
+    /** False when this backend or engine build cannot draw splat scenery; `load` then throws. */
+    get supported(): boolean;
+    /**
+     * Opens the scenery whose manifest is at `source` (a `splats.cspm` URL or, with `options.assets`, a package path).
+     * Chunk files `<sha256>.cspl` are read from the manifest's folder on demand.
+     * Throws `unsupported_feature` when `supported` is false.
+     */
+    load(source: ScenerySource, options?: SceneryLoadOptions): Promise<Scenery>;
+    /** Loads a splat body baked against a rig and binds it, so it follows that model's animation. */
+    splatBody(options: SplatBodyOptions): Promise<Scenery>;
+    private open;
+    /** Number of scenery handles currently loaded. */
+    get count(): number;
+    release(scenery: Scenery): void;
+    frame(): void;
+    dispose(): void;
+}
+
+declare const Renderable: ComponentType<{
+    readonly node: "u32";
+}>;
+interface InstancedBatch {
+    readonly node: NodeId;
+    readonly capacity: number;
+    readonly matrices: Float32Array;
+    readonly colors: Float32Array | null;
+}
+interface InstanceFeedFields {
+    readonly position: string | readonly [string, string, string];
+    readonly scale?: string;
+    readonly rotation?: string;
+    readonly animation?: string;
+}
+interface InstanceFeedOptions {
+    readonly hostReads?: boolean;
+}
+interface InstancePaletteDesc {
+    readonly skin?: number;
+    readonly firstClip?: number;
+    readonly clips: number;
+    readonly frames: number;
+}
+interface BatchedDraw extends InstancedBatch {
+    readonly slots: Uint32Array;
+    readonly ranges: Uint32Array;
+}
+declare class Graphics implements DespawnListener {
+    private readonly port;
+    private readonly transforms;
+    private readonly renderables;
+    private readonly nodeIds;
+    private readonly matrixRows;
+    private readonly world;
+    private readonly fed;
+    private readonly presentedByFeeds;
+    private readonly cameraMatrix;
+    private activeCamera;
+    /** Photoreal Gaussian splat scenery, streamed around the active camera every frame. */
+    readonly scenery: GraphicsScenery;
+    constructor(port: GraphicsPort, world: World, transforms: Transforms, scenery?: SceneryPort | null);
+    readCameraEye(out: Float32Array): boolean;
+    get capabilities(): GraphicsCapabilities;
+    get 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>;
+    upgradeModel(model: ModelId, source: AssetSource): Promise<ModelUpgrade>;
+    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>;
+    private vectorPort;
+    get vectorSurfaceCap(): number;
+    loadVector(bytes: Uint8Array): VectorAssetId;
+    unloadVector(asset: VectorAssetId): void;
+    vectorSurface(desc: VectorSurfaceDesc): VectorSurfaceId;
+    destroyVectorSurface(surface: VectorSurfaceId): void;
+    setVectorSurfaceNode(surface: VectorSurfaceId, node: NodeId | null): void;
+    playVectorSurface(surface: VectorSurfaceId, kind: VectorSurfacePlay, index?: number): void;
+    seekVectorSurface(surface: VectorSurfaceId, kind: VectorSurfaceSeek, index: number, seconds: number): void;
+    vectorSurfaceInput(surface: VectorSurfaceId, name: string): number;
+    setVectorSurfaceInput(surface: VectorSurfaceId, input: number, value: number | boolean): void;
+    vectorSurfaceData(surface: VectorSurfaceId, path: string): number;
+    setVectorSurfaceData(surface: VectorSurfaceId, handle: number, kind: "number" | "bool" | "color" | "id" | "fire", value?: number): void;
+    vectorSurfacePointer(surface: VectorSurfaceId, phase: VectorSurfacePhase, u: number, v: number): boolean;
+    pickVectorSurface(origin: ArrayLike<number>, direction: ArrayLike<number>, phase: VectorSurfacePhase, far?: number): VectorSurfaceId | null;
+    vectorSurfaceEvents(out?: VectorSurfaceEvent[]): VectorSurfaceEvent[];
+    vectorSurfaceStats(out?: VectorSurfaceStats): VectorSurfaceStats;
+    setVectorSurfaceTier(tier: VectorSurfaceTier): void;
+    createMaterial(desc: MaterialDesc): MaterialId;
+    setMaterialColor(material: MaterialId, color: number): void;
+    setMaterialRgb(material: MaterialId, r: number, g: number, b: number): void;
+    setMaterialOpacity(material: MaterialId, opacity: number): void;
+    setMaterialTexture(material: MaterialId, slot: MaterialTextureSlot, texture: TextureId | null): void;
+    setUniform(material: MaterialId, name: string, value: number): void;
+    setUniformVector(material: MaterialId, name: string, value: Float32Array): void;
+    setUniformTexture(material: MaterialId, name: string, texture: TextureId): void;
+    setMaterialState(material: MaterialId, state: MaterialStateDesc): void;
+    createEmitter(desc: EmitterDesc): EmitterId;
+    particles(entity: Entity, emitter: EmitterId): NodeId;
+    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;
+    lodLevels(levels: readonly {
+        readonly node: NodeId;
+        readonly distance: number;
+    }[], hysteresis?: number): void;
+    setSprite(node: NodeId, rotation: number, centerX?: number, centerY?: number): void;
+    setProbeCoefficients(light: NodeId, sh: Float32Array): void;
+    decal(entity: Entity, material: MaterialId, options?: {
+        readonly angleFade?: number;
+        readonly fade?: number;
+    }): NodeId;
+    setProjectionMatrix(camera: NodeId, matrix: Float32Array | null, near: number, far: number): void;
+    setViewOffset(camera: NodeId, offset: ViewOffset | null): void;
+    gpuStats(out: GpuStats): boolean;
+    attachNode(entity: Entity, node: NodeId): NodeId;
+    create(entity: Entity, desc: NodeDesc): NodeId;
+    createDetached(desc: NodeDesc): NodeId;
+    mesh(entity: Entity, geometry: GeometryId, material: MaterialId): NodeId;
+    camera(entity: Entity, fov?: number, near?: number, far?: number): NodeId;
+    instanced(desc: {
+        geometry: GeometryId;
+        material: MaterialId;
+        capacity: number;
+        colors?: boolean;
+    }): InstancedBatch;
+    batchedDraw(desc: {
+        geometry: GeometryId;
+        material: MaterialId;
+        capacity: number;
+        slots: number;
+        colors?: boolean;
+        castShadow?: boolean;
+        receiveShadow?: boolean;
+    }): BatchedDraw | null;
+    markBatch(batch: BatchedDraw): void;
+    setInstanceCount(batch: InstancedBatch, count: number): void;
+    markInstancesDirty(batch: InstancedBatch): void;
+    feedInstances(batch: InstancedBatch, table: EntityTable<TableSchema>, fields: InstanceFeedFields, options?: InstanceFeedOptions): boolean;
+    setInstancePalette(batch: InstancedBatch, model: ModelId, desc: InstancePaletteDesc | null): boolean;
+    stopFeedingInstances(batch: InstancedBatch): void;
+    private forget;
+    morphWeights(node: NodeId): Float32Array;
+    markMorphWeightsDirty(node: NodeId): void;
+    skeletonPose(node: NodeId): Float32Array;
+    markSkeletonDirty(node: NodeId): void;
+    setVisible(node: NodeId, visible: boolean): void;
+    setLayers(node: NodeId, mask: number): void;
+    setNodeMaterial(node: NodeId, material: MaterialId): void;
+    setText(node: NodeId, text: string): void;
+    loadFont(source: FontSource, family?: string): Promise<FontId>;
+    text3d(entity: Entity, font: FontId, text: string, style?: TextStyleDesc & {
+        readonly billboard?: boolean;
+    }): NodeId;
+    setTextStyle(node: NodeId, style: TextStyleDesc): void;
+    textBounds(node: NodeId, out: Float32Array): void;
+    raycast(origin: ArrayLike<number>, direction: ArrayLike<number>, out: PickHit, far?: number, layers?: number): boolean;
+    batchHandle(): number;
+    governorPressure(): number;
+    /** Pins the renderer's quality tier (0 full, 1 reduced, 2 minimum), or returns it to the governor with null. False when this renderer has no governor. */
+    forceQualityTier(tier: number | null): boolean;
+    qualityTier(): number;
+    setPerspective(camera: NodeId, fovDegrees: number, near: number, far: number): void;
+    setPerspectiveFrom(camera: NodeId, values: Float32Array | Float64Array, offset?: number): void;
+    setOrthographic(camera: NodeId, height: number, near: number, far: number): void;
+    setActiveCamera(camera: NodeId): void;
+    setLight(light: NodeId, color: number, intensity: number): void;
+    setEnvironment(desc: EnvironmentDesc): void;
+    createRenderTarget(desc: RenderTargetDesc): RenderTargetId;
+    renderTargetTexture(target: RenderTargetId): TextureId;
+    renderTargetAttachment(target: RenderTargetId, attachment: number): TextureId;
+    captureCube(target: RenderTargetId, camera: NodeId): readonly RenderPassId[];
+    createReflector(target: RenderTargetId, camera: NodeId, plane: readonly [number, number, number, number], order?: number): RenderPassId;
+    renderTargetDepthTexture(target: RenderTargetId): TextureId;
+    resizeRenderTarget(target: RenderTargetId, width: number, height: number): void;
+    createPostChain(desc: PostChainDesc): PostChainId;
+    setPostChain(chain: PostChainId | null): void;
+    setWeather(state: WeatherState): void;
+    setTimeOfDay(hours: number, latitude?: number, dayOfYear?: number): void;
+    mediaVolume(desc: MediumDesc): MediumVolume;
+    setPostUniform(chain: PostChainId, effect: number, name: string, value: number): void;
+    createRenderPass(desc: RenderPassDesc): RenderPassId;
+    setRenderPassEnabled(pass: RenderPassId, enabled: boolean): void;
+    loadModel(source: AssetSource): Promise<ModelInfo>;
+    loadClips(root: NodeId, source: AssetSource, options?: {
+        readonly rate?: number;
+    }): Promise<readonly string[]>;
+    setTint(node: NodeId, tint: KitTint | null): void;
+    instantiate(entity: Entity, model: ModelId): NodeId;
+    findNode(root: NodeId, name: string): NodeId | null;
+    playClip(root: NodeId, clip: string, loop?: boolean, fadeSeconds?: number, speed?: number): ClipActionId;
+    setClipWeight(action: ClipActionId, weight: number): void;
+    clipIndex(root: NodeId, clip: string): number;
+    playClipIndex(root: number, clip: number, loop: boolean, fadeSeconds: number, speed: number): number;
+    setIkTarget(chain: number, x: number, y: number, z: number, weight: number): void;
+    instanceBuffer(node: number, colours: boolean): Float32Array | null;
+    markInstances(node: number): void;
+    stopClip(action: ClipActionId, fadeSeconds?: number): void;
+    get clips(): ClipAnimationPort;
+    get hasClipAnimation(): boolean;
+    nodeOf(entity: Entity): NodeId | null;
+    entityOfNode(node: NodeId): Entity;
+    readNodeMatrix(node: NodeId, out: Float32Array, offset?: number): void;
+    stats(out: GraphicsStats): void;
+    onDespawn(entity: Entity): void;
+    sync(time: FrameTime): void;
+    render(time: FrameTime): void;
+    private checkNode;
+    private checkShader;
+    private unsupported;
+}
+
+interface GameSystem<G> {
+    fixedUpdate?(game: G): void;
+    update?(game: G): void;
+    adopt?(previous: GameSystem<G>): void;
+    reloaded?(game: G): void;
+}
+interface GameScene<G> extends GameSystem<G> {
+    readonly name: string;
+    readonly systems?: readonly GameSystem<G>[];
+    readonly prefetch?: ScenePrefetchDesc;
+    enter?(game: G): void;
+    exit?(game: G): void;
+}
+interface GameReload<G> {
+    readonly scenes?: readonly GameScene<G>[];
+    readonly systems?: readonly GameSystem<G>[];
+}
+interface ReloadReport {
+    readonly replaced: readonly string[];
+    readonly added: readonly string[];
+    readonly systems: number;
+}
+declare class SceneManager<G> {
+    private readonly scenes;
+    private readonly globalSystems;
+    private active;
+    private pending;
+    private readonly registered;
+    private readonly enterListeners;
+    private readonly registerListeners;
+    register(scene: GameScene<G>): void;
+    onEnter(listener: (scene: GameScene<G>) => void): void;
+    onRegister(listener: (scene: GameScene<G>) => void): void;
+    has(name: string): boolean;
+    addSystem(system: GameSystem<G>): void;
+    replace(scene: GameScene<G>): boolean;
+    replaceSystem(previous: GameSystem<G>, next: GameSystem<G>): boolean;
+    removeSystem(system: GameSystem<G>): boolean;
+    switchTo(name: string): void;
+    get current(): string | null;
+    applyPending(game: G): void;
+    reload(next: GameReload<G>, game: G): ReloadReport;
+    fixedUpdate(game: G): void;
+    update(game: G): void;
+}
+
+type FluidMaterial = "water" | "sand" | "jelly" | "snow" | "mud";
+interface FluidLook {
+    readonly color?: readonly [number, number, number];
+    readonly absorption?: readonly [number, number, number];
+    readonly refraction?: number;
+    readonly smoothing?: number;
+    readonly foam?: readonly [number, number, number];
+    readonly reflection?: readonly [number, number, number];
+    readonly radius?: number;
+    readonly resolution?: number;
+    readonly visible?: boolean;
+}
+interface FluidEmitterDesc {
+    readonly kind: "stream" | "box" | "sphere";
+    readonly position: Vec3Like;
+    readonly size?: Vec3Like;
+    readonly radius?: number;
+    readonly velocity?: Vec3Like;
+    readonly rate?: number;
+}
+interface FluidDesc {
+    readonly bounds: {
+        readonly min: Vec3Like;
+        readonly max: Vec3Like;
+    };
+    readonly material?: FluidMaterial;
+    readonly capacity?: number;
+    readonly cell?: number;
+    readonly restDensity?: number;
+    readonly stiffness?: number;
+    readonly viscosity?: number;
+    readonly friction?: number;
+    readonly gravity?: Vec3Like;
+    readonly maxStep?: number;
+    readonly foam?: number;
+    readonly plasticity?: number;
+    readonly look?: FluidLook;
+    readonly emitters?: readonly FluidEmitterDesc[];
+}
+/**
+ * A closed triangle mesh in the entity's own frame, baked once into a signed distance volume
+ * (`resolution` voxels along its longest side, default 32; grown by `padding` metres, default
+ * one fluid cell). Baking is load-time work, so add mesh colliders when a scene starts.
+ */
+interface FluidMesh {
+    readonly positions: Float32Array;
+    readonly indices: Uint32Array;
+    readonly resolution?: number;
+    readonly padding?: number;
+}
+type FluidShape = {
+    readonly sphere: number;
+} | {
+    readonly box: Vec3Like;
+} | {
+    readonly capsule: {
+        readonly radius: number;
+        readonly halfHeight: number;
+    };
+} | {
+    readonly mesh: FluidMesh;
+};
+interface FluidColliderOptions {
+    readonly friction?: number;
+    readonly feedback?: boolean;
+}
+interface FluidGridDesc {
+    readonly origin: Vec3Like;
+    readonly cell: number;
+    readonly cells: readonly [number, number, number];
+    readonly capacity?: number;
+    readonly material?: FluidMaterial;
+}
+declare class Fluid {
+    private readonly port;
+    private readonly transforms;
+    private readonly physics;
+    readonly material: FluidMaterial;
+    private readonly id;
+    private readonly desc;
+    private readonly look;
+    private readonly emitter;
+    private readonly block;
+    private readonly forces;
+    private readonly slots;
+    private readonly order;
+    private readonly used;
+    private readonly position;
+    private readonly rotation;
+    private readonly velocity;
+    private readonly spin;
+    private readonly impulse;
+    private readonly offset;
+    private readonly cell;
+    private feedback;
+    private disposed;
+    constructor(port: FluidPort, transforms: Transforms, physics: Physics, options: FluidDesc);
+    private writeParameters;
+    get count(): number;
+    setParameters(options: Partial<Omit<FluidDesc, "bounds" | "capacity" | "cell" | "material">>): void;
+    setLook(look: FluidLook): void;
+    emit(desc: FluidEmitterDesc): number;
+    pour(desc: Omit<FluidEmitterDesc, "rate">): void;
+    setEmitter(index: number, desc: FluidEmitterDesc | null): void;
+    collider(entity: Entity, shape: FluidShape, options?: FluidColliderOptions): number;
+    removeCollider(index: number): void;
+    private recount;
+    pause(paused: boolean): void;
+    clear(): void;
+    update(seconds: number): void;
+    dispose(): void;
+}
+
+export { Scenery as $, type ReachNav as A, type BatchedDraw as B, Cloths as C, DEFAULT_HORIZONS as D, EntryState as E, type FluidMaterial as F, type GameScene as G, Renderable as H, type InstancedBatch as I, SCENERY_CHUNK_EXTENSION as J, SCENERY_LOAD_SHARE as K, SCENERY_MANIFEST_MAGIC as L, SCENERY_MANIFEST_VERSION as M, NEXT_SCENE_BUDGET as N, SCENERY_MANIFEST_VERSION_PARTS as O, type PrefetchAssets as P, type QuatLike as Q, type ReloadReport as R, SceneManager as S, SCENERY_NEED_SHARE as T, SCENERY_PART_COARSE as U, SCENERY_PART_FINE as V, SCENERY_PART_MIDDLE as W, SCENERY_PART_WHOLE as X, SCENERY_TIER_RADII as Y, ScenePrefetch as Z, type ScenePrefetchDesc as _, type GameSystem as a, type SceneryAssetReader as a0, type SceneryDrapeOptions as a1, type SceneryGrid as a2, type SceneryLoadOptions as a3, type SceneryManifest as a4, type SceneryMotionOptions as a5, type ScenerySource as a6, type SceneryStandIn as a7, type SceneryStats as a8, type SplatBodyOptions as a9, StreamPredictor as aa, parseSceneryManifest as ab, cone as ac, sceneryEntryRows as ad, sceneryFirstView as ae, sceneryPartDrawLevel as af, sceneryPartReach as ag, sceneryPrefetchItems as ah, sceneryTierRadii as ai, Graphics as b, type FluidGridDesc as c, type FluidDesc as d, type FluidEmitterDesc as e, GamePrefetch as f, Fluid as g, type ClothShape as h, type ClothOptions as i, ClothSheet as j, type GameReload as k, type PredictorOptions as l, type SceneryEdit as m, CLOTH_DEFAULTS as n, type ClothCollider as o, type ClothPinning as p, DEFAULT_PREFETCH_BUDGET as q, type FluidColliderOptions as r, type FluidLook as s, type FluidShape as t, GraphicsScenery as u, type PredictorStats as v, type PrefetchEye as w, PrefetchReach as x, type PrefetchStreamOptions as y, type ReachGrid as z };