@cimplify/sdk 0.108.0 → 0.110.2

package/dist/world-qekkXjJv.d.mts

@@ -0,0 +1,2285 @@
+import { aL as NavPort, aM as NavDesc, aN as OffMeshLinkDesc, f as Vec3Like, aO as AgentDesc, aP as RoadGraphDesc, aQ as DriverDesc, F as FrameTime, aR as RayQuery, aS as RayHit, aT as SoaEngine, a9 as PickHit, aU as SoaBulkExports, aV as ShapeCastQuery, aW as RollbackState, aX as Scalar, aY as ArrayFor, aZ as ComponentMemory, a_ as TransformColumns, a$ as TransformPort, aw as Quat, V as Vec3, b0 as CurveTable, b1 as SoftBodyPort, i as GeometryId, b2 as SoftBodyInfo, b3 as CraftPort, b4 as WaterDesc, b5 as SeaState, b6 as OceanDesc, b7 as OceanCascades, b8 as PuddleOptions, b9 as RippleOptions, ba as WaterSample, bb as ColliderDesc, bc as PhysicsPort, bd as WorldRollbackDesc, be as SolverSettings, bf as SleepThresholds, bg as WorldSnapshots, bh as BodyDesc, bi as JointPort, bj as RagdollDesc, bk as Ragdoll, bl as JointDesc, bm as ContactRuleDesc, bn as CharacterControllerDesc, bo as CharacterMove, au as VehicleDesc, av as Vehicle, bp as WorldStreamingPort, j as MaterialId, D as DeviceTier, bq as KernelEngine } from './backend-gUCzs5Kg.mjs';
+import { K as KernelMeta } from './library-DXYaMFhi.mjs';
+
+type ColumnArray = Float32Array | Int32Array | Uint32Array | Uint8Array;
+interface SoaViews {
+    readonly header: Uint32Array;
+    readonly params: Float32Array;
+    readonly result: Float64Array;
+    readonly capacity: number;
+    readonly stride: number;
+    readonly kinds: readonly number[];
+    readonly columns: readonly ColumnArray[];
+    readonly bits: readonly (Uint32Array | null)[];
+    readonly lists: readonly Uint32Array[];
+    readonly cell: number;
+    readonly gridTable: number;
+}
+declare class SoaFallback {
+    private readonly v;
+    private keys;
+    private spareKeys;
+    private rows;
+    private spareRows;
+    private counts;
+    private readonly accumulators;
+    private points;
+    private gridRows;
+    private starts;
+    private cells;
+    private items;
+    private gridLen;
+    private slotItems;
+    private slotCounts;
+    private readonly inv;
+    private gathered;
+    private marks;
+    private mark;
+    private readonly center;
+    private readonly inverseCell;
+    private readonly mask;
+    constructor(views: SoaViews);
+    private count;
+    private listLen;
+    private guest;
+    private validList;
+    private f32;
+    turn(turn: number): number;
+    remove(row: number): number;
+    map(op: number, dst: number, a: number, b: number, list: number): number;
+    vector(op: number, dst: number, xc: number, yc: number, zc: number, list: number): number;
+    select(column: number, cmp: number, input: number, output: number): number;
+    reduce(op: number, column: number, list: number): number;
+    private blockedSum;
+    private blockedExtreme;
+    sort(key: number, input: number, output: number, descending: boolean): number;
+    private cellOf;
+    private hash;
+    grid(xc: number, yc: number, zc: number, list: number): number;
+    private query;
+    near(output: number): number;
+    nearest(exclude: number, output: number): number;
+    get gridPoints(): number;
+    get views(): SoaViews;
+    private ints;
+    private rowAt;
+    private rowsLen;
+    inventory(op: number, layout: number, a: number, b: number, out: number): number;
+    private optionalInts;
+    private optionalF32;
+    private collect;
+    effect(source: SoaFallback | null, sources: number, health: number, hits: number): number;
+}
+
+declare class NavPath {
+    readonly points: Float32Array;
+    count: number;
+    complete: boolean;
+    constructor(maxPoints?: number);
+}
+declare class Nav {
+    private readonly port;
+    private initialised;
+    private agentCount;
+    private roads;
+    private roadsOnly;
+    private readonly driver;
+    private readonly nearestOut;
+    constructor(port: NavPort);
+    get backend(): string;
+    get ready(): boolean;
+    init(desc: NavDesc): void;
+    addTile(bytes: Uint8Array): number;
+    removeTile(x: number, z: number): void;
+    addLink(desc: OffMeshLinkDesc): number;
+    removeLink(link: number): void;
+    agentLink(agent: number): number;
+    agentLinkProgress(agent: number): number;
+    setAreaCost(area: number, cost: number): void;
+    setIncludedAreas(low: number, high: number): void;
+    nearest(point: Vec3Like, out: Vec3Like): boolean;
+    batchHandle(): number;
+    findPath(from: Vec3Like, to: Vec3Like, out: NavPath): boolean;
+    addAgent(position: Vec3Like, desc?: AgentDesc): number;
+    removeAgent(agent: number): void;
+    setAgentTarget(agent: number, target: Vec3Like): void;
+    stopAgent(agent: number): void;
+    get agents(): Float32Array;
+    agentPosition(agent: number, out: Vec3Like): Vec3Like;
+    agentState(agent: number): number;
+    loadRoads(desc: RoadGraphDesc): void;
+    addVehicle(lane: number, position: number, speed?: number, driver?: DriverDesc): number;
+    removeVehicle(vehicle: number): void;
+    setExternalVehicle(vehicle: number, lane: number, position: number, speed: number): void;
+    get vehicles(): Float32Array;
+    vehicleOffset(vehicle: number): number;
+    signal(lane: number): number;
+    step(dt: number): void;
+    stepFixed(time: FrameTime): void;
+    dispose(): void;
+}
+
+declare const FALLOFFS: {
+    readonly constant: 0;
+    readonly linear: 1;
+    readonly quadratic: 2;
+    readonly smooth: 3;
+};
+type Falloff = keyof typeof FALLOFFS;
+interface BulkTable {
+    readonly id: number;
+    readonly native: boolean;
+    readonly header: Uint32Array;
+    readonly params: Float32Array;
+    readonly columns: readonly ColumnArray[];
+    readonly count: number;
+    readonly $bulk: Readonly<Record<string, ((...args: number[]) => number) | undefined>> | null;
+    readonly $fallback: SoaFallback;
+    $indices(field: string): readonly number[];
+    $kind(column: number): number;
+    $ready(): void;
+    $status(code: number): number;
+}
+interface BatchPhysics {
+    raycast(ray: RayQuery, hit: RayHit): boolean;
+    entityOfCollider(collider: number): number;
+    batchHandle?(): number;
+}
+interface BatchNav {
+    findPath(from: Vec3Like, to: Vec3Like, out: NavPath): boolean;
+    batchHandle?(): number;
+}
+declare class Inventory {
+    private readonly table;
+    private readonly layout;
+    private readonly limit;
+    constructor(table: BulkTable, items: string, counts: string, stackLimit: number);
+    private run;
+    give(item: number | string, amount: number | string, rows?: Selection | null, overflow?: Selection | null): number;
+    take(item: number | string, amount: number | string, rows?: Selection | null, short?: Selection | null): number;
+    transfer(from: Selection, to: Selection, item: number | string, amount: number | string, failed?: Selection | null): number;
+    move(fromSlot: number, toSlot: number, rows?: Selection | null, toRows?: Selection | null, failed?: Selection | null): number;
+    split(slot: number, amount: number | string, rows?: Selection | null, toRows?: Selection | null, failed?: Selection | null): number;
+    count(item: number | string, into?: string | null, atLeast?: number | string, rows?: Selection | null, has?: Selection | null): number;
+}
+interface AreaEffectDesc {
+    readonly position: string;
+    readonly radius: number | string;
+    readonly amount: number | string;
+    readonly falloff?: Falloff;
+    readonly multiplier?: string;
+    readonly min?: number;
+    readonly max?: number;
+    readonly skipSelf?: boolean;
+    readonly from?: BulkTable;
+}
+declare class AreaEffect {
+    private readonly table;
+    private readonly source;
+    private readonly health;
+    private readonly x;
+    private readonly y;
+    private readonly z;
+    private readonly radiusColumn;
+    private readonly radius;
+    private readonly amountColumn;
+    private readonly amount;
+    private readonly falloff;
+    private readonly multiplier;
+    private readonly low;
+    private readonly high;
+    private readonly flags;
+    constructor(table: BulkTable, health: string, desc: AreaEffectDesc);
+    apply(sources?: Selection | null, hits?: Selection | null): number;
+}
+interface RayBatchDesc {
+    readonly origin: string;
+    readonly direction?: string;
+    readonly target?: string;
+    readonly maxDistance?: number | string;
+    readonly solid?: boolean;
+    readonly sensors?: boolean;
+    readonly distance?: string;
+    readonly normal?: string;
+    readonly entity?: string;
+    readonly collider?: string;
+    readonly exclude?: string;
+    readonly hit?: string;
+}
+declare class RayBatch {
+    private readonly table;
+    private readonly physics;
+    private readonly sight;
+    private readonly origin;
+    private readonly toward;
+    private readonly maxColumn;
+    private readonly maxDistance;
+    private readonly flags;
+    private readonly distance;
+    private readonly normal;
+    private readonly entity;
+    private readonly collider;
+    private readonly exclude;
+    private readonly mask;
+    private readonly query;
+    private readonly result;
+    constructor(table: BulkTable, physics: BatchPhysics, desc: RayBatchDesc, sight: boolean);
+    cast(rows?: Selection | null, out?: Selection | null): number;
+    private fallback;
+}
+interface PathBatchDesc {
+    readonly start: string;
+    readonly goal: string;
+    readonly direction?: string;
+    readonly corner?: string;
+    readonly status?: string;
+    readonly length?: string;
+    readonly corners?: string;
+    readonly maxCorners?: number;
+    readonly budget?: number;
+}
+declare class PathBatch {
+    private readonly table;
+    private readonly nav;
+    private readonly start;
+    private readonly goal;
+    private readonly direction;
+    private readonly corner;
+    private readonly status;
+    private readonly length;
+    private readonly corners;
+    private readonly maxCorners;
+    private readonly budget;
+    private readonly path;
+    private readonly from;
+    private readonly to;
+    constructor(table: BulkTable, nav: BatchNav, desc: PathBatchDesc);
+    get pending(): boolean;
+    restart(): void;
+    run(rows?: Selection | null, budget?: number): number;
+    private fallback;
+    private write;
+}
+
+declare const FLOW_COST_BLOCKED = 0;
+declare const FLOW_COST_ONE = 16;
+interface FlowFieldDesc {
+    readonly origin?: readonly [number, number];
+    readonly cell: number;
+    readonly width: number;
+    readonly height: number;
+}
+interface FlowSteerDesc {
+    readonly position: string;
+    readonly direction: string;
+    readonly distance?: string;
+    readonly status?: string;
+    readonly smooth?: boolean;
+}
+interface FlowNav {
+    nearest(point: Vec3Like, out: Vec3Like): boolean;
+    batchHandle?(): number;
+}
+declare class FlowSample {
+    status: number;
+    x: number;
+    z: number;
+    distance: number;
+}
+declare function flowCost(multiplier: number): number;
+declare class JsFlow {
+    readonly width: number;
+    readonly height: number;
+    readonly cell: number;
+    readonly originX: number;
+    readonly originZ: number;
+    readonly costs: Uint8Array;
+    readonly integration: Uint32Array;
+    readonly dirs: Uint8Array;
+    private readonly next;
+    private readonly prev;
+    private readonly heads;
+    private readonly inverse;
+    private readonly metres;
+    private goalX;
+    private goalZ;
+    goalCell: number;
+    built: boolean;
+    constructor(originX: number, originZ: number, cell: number, width: number, height: number);
+    private walkable;
+    private step;
+    private snap;
+    private push;
+    private unlink;
+    build(x: number, y: number, z: number): number;
+    private vector;
+    private readonly scratch;
+    sample(x: number, z: number, smooth: boolean, out: FlowSample): boolean;
+}
+declare class FlowField {
+    readonly width: number;
+    readonly height: number;
+    readonly cell: number;
+    readonly originX: number;
+    readonly originZ: number;
+    private readonly engine;
+    private readonly exports;
+    private readonly js;
+    private handle;
+    private registers;
+    private costPointer;
+    private costView;
+    private readonly probe;
+    private readonly hit;
+    constructor(desc: FlowFieldDesc, engine?: SoaEngine | null);
+    get native(): boolean;
+    get $handle(): number;
+    get $js(): JsFlow | null;
+    get costs(): Uint8Array<ArrayBufferLike>;
+    fill(multiplier: number): void;
+    setCost(x: number, z: number, multiplier: number): void;
+    rasterize(nav: FlowNav, band?: readonly [number, number]): number;
+    build(goal: Vec3Like): number;
+    batchHandle(): number;
+    sample(x: number, z: number, smooth: boolean, out: FlowSample): boolean;
+    private check;
+    dispose(): void;
+}
+declare class FlowSteer {
+    private readonly table;
+    private readonly field;
+    private readonly position;
+    private readonly direction;
+    private readonly distance;
+    private readonly status;
+    private readonly flags;
+    private readonly sampled;
+    constructor(table: BulkTable, field: FlowField, desc: FlowSteerDesc);
+    run(rows?: Selection | null): number;
+}
+
+interface BatchGraphics {
+    raycast(origin: ArrayLike<number>, direction: ArrayLike<number>, out: PickHit, far?: number, layers?: number): boolean;
+    batchHandle?(): number;
+}
+interface PickBatchDesc {
+    readonly origin: string;
+    readonly direction?: string;
+    readonly target?: string;
+    readonly maxDistance?: number | string;
+    readonly layers?: number;
+    readonly distance?: string;
+    readonly point?: string;
+    readonly node?: string;
+    readonly instance?: string;
+    readonly triangle?: string;
+    readonly uv?: string;
+    readonly hit?: string;
+}
+declare class PickBatch {
+    private readonly table;
+    private readonly graphics;
+    private readonly sight;
+    private readonly origin;
+    private readonly toward;
+    private readonly maxColumn;
+    private readonly maxDistance;
+    private readonly layers;
+    private readonly distance;
+    private readonly point;
+    private readonly node;
+    private readonly instance;
+    private readonly triangle;
+    private readonly uv;
+    private readonly mask;
+    private readonly found;
+    private readonly from;
+    private readonly along;
+    constructor(table: BulkTable, graphics: BatchGraphics, desc: PickBatchDesc);
+    cast(rows?: Selection | null, out?: Selection | null): number;
+    private fallback;
+}
+
+type ScalarField = "f32" | "i32" | "u32" | "u8";
+type VectorField = "vec2" | "vec3" | "vec4";
+type ArrayField = `${ScalarField}[${number}]`;
+type WideField = "f64" | "u64";
+type TableField = ScalarField | VectorField | ArrayField | WideField;
+type TableSchema = Readonly<Record<string, TableField>>;
+interface SlotsView {
+    readonly length: number;
+    get(slot: number): number;
+    set(slot: number, value: number): void;
+}
+interface Vec2View {
+    x: number;
+    y: number;
+}
+interface Vec3View extends Vec2View {
+    z: number;
+}
+interface Vec4View extends Vec3View {
+    w: number;
+}
+type FieldView<F> = F extends "f64" ? number : F extends "u64" ? bigint : F extends "vec2" ? Vec2View : F extends "vec3" ? Vec3View : F extends "vec4" ? Vec4View : F extends ArrayField ? SlotsView : number;
+type EntityCursor<S extends TableSchema> = {
+    -readonly [K in keyof S]: FieldView<S[K]>;
+} & {
+    readonly row: number;
+};
+interface Vec2Columns {
+    readonly x: Float32Array;
+    readonly y: Float32Array;
+}
+interface Vec3Columns extends Vec2Columns {
+    readonly z: Float32Array;
+}
+interface Vec4Columns extends Vec3Columns {
+    readonly w: Float32Array;
+}
+type ScalarColumn<F> = F extends "i32" ? Int32Array : F extends "u32" ? Uint32Array : F extends "u8" ? Uint8Array : Float32Array;
+type FieldColumns<F> = F extends WideField ? readonly Uint32Array[] : F extends "vec2" ? Vec2Columns : F extends "vec3" ? Vec3Columns : F extends "vec4" ? Vec4Columns : F extends `${infer E}[${number}]` ? readonly ScalarColumn<E>[] : ScalarColumn<F>;
+type TableColumns<S extends TableSchema> = {
+    readonly [K in keyof S]: FieldColumns<S[K]>;
+};
+type FieldName<S extends TableSchema> = Extract<keyof S, string>;
+type ScalarName<S extends TableSchema> = {
+    [K in FieldName<S>]: S[K] extends ScalarField ? K : never;
+}[FieldName<S>];
+type Comparison = "<" | "<=" | ">" | ">=" | "==" | "!=" | "range" | "bits";
+interface EntityTableOptions {
+    readonly capacity: number;
+    readonly selections?: number;
+    readonly cell?: number;
+    readonly gridTable?: number;
+}
+declare class Selection {
+    readonly index: number;
+    readonly rows: Uint32Array;
+    private readonly header;
+    constructor(index: number, rows: Uint32Array, header: Uint32Array);
+    get length(): number;
+    set length(value: number);
+    at(k: number): number;
+}
+declare class EntityTable<S extends TableSchema> {
+    readonly schema: S;
+    readonly capacity: number;
+    readonly header: Uint32Array;
+    readonly params: Float32Array;
+    readonly columns: readonly ColumnArray[];
+    readonly selections: readonly Selection[];
+    readonly id: number;
+    readonly native: boolean;
+    private readonly fields;
+    private readonly first;
+    private readonly result;
+    private readonly generations;
+    private readonly slot;
+    private readonly generation;
+    private readonly engine;
+    private readonly fallback;
+    private readonly state;
+    private readonly accumulator;
+    private readonly scalarSlots;
+    private readonly vectorCursors;
+    private readonly slotCursors;
+    private readonly wideCursors;
+    private readonly cursorObject;
+    readonly cols: TableColumns<S>;
+    private disposed;
+    constructor(engine: SoaEngine | null, schema: S, options: EntityTableOptions);
+    private buildColumns;
+    private detachColumns;
+    private buildCursor;
+    get valid(): boolean;
+    get version(): number;
+    get frame(): number;
+    get count(): number;
+    set count(value: number);
+    private check;
+    column(field: FieldName<S>, component?: number): number;
+    f32(field: FieldName<S>, component?: number): Float32Array;
+    values(field: FieldName<S>, component?: number): ColumnArray;
+    at(row: number): EntityCursor<S>;
+    get cursor(): EntityCursor<S>;
+    spawn(): number;
+    remove(row: number): number;
+    handTo(turn: "guest" | "engine"): number;
+    private status;
+    $indices(field: string): readonly number[];
+    $kind(column: number): number;
+    $ready(): void;
+    $status(code: number): number;
+    get $bulk(): SoaBulkExports | null;
+    get $fallback(): SoaFallback;
+    inventory(items: FieldName<S>, counts: FieldName<S>, stackLimit?: number): Inventory;
+    areaEffect(health: FieldName<S>, desc: AreaEffectDesc): AreaEffect;
+    rays(physics: BatchPhysics, desc: RayBatchDesc): RayBatch;
+    lineOfSight(physics: BatchPhysics, desc: RayBatchDesc): RayBatch;
+    paths(nav: BatchNav, desc: PathBatchDesc): PathBatch;
+    picks(graphics: BatchGraphics, desc: PickBatchDesc): PickBatch;
+    flowField(desc: FlowFieldDesc): FlowField;
+    flow(field: FlowField, desc: FlowSteerDesc): FlowSteer;
+    private list;
+    private mapColumns;
+    fill(field: FieldName<S>, value: number, selection?: Selection | null): number;
+    copy(dst: FieldName<S>, src: FieldName<S>, selection?: Selection | null): number;
+    add(dst: FieldName<S>, a: FieldName<S>, b: FieldName<S>, selection?: Selection | null): number;
+    sub(dst: FieldName<S>, a: FieldName<S>, b: FieldName<S>, selection?: Selection | null): number;
+    mul(dst: FieldName<S>, a: FieldName<S>, b: FieldName<S>, selection?: Selection | null): number;
+    min(dst: FieldName<S>, a: FieldName<S>, b: FieldName<S>, selection?: Selection | null): number;
+    max(dst: FieldName<S>, a: FieldName<S>, b: FieldName<S>, selection?: Selection | null): number;
+    scale(dst: FieldName<S>, a: FieldName<S>, factor: number, selection?: Selection | null): number;
+    offset(dst: FieldName<S>, a: FieldName<S>, amount: number, selection?: Selection | null): number;
+    axpy(dst: FieldName<S>, a: FieldName<S>, b: FieldName<S>, factor: number, selection?: Selection | null): number;
+    integrate(position: FieldName<S>, velocity: FieldName<S>, dt: number, selection?: Selection | null): number;
+    clamp(dst: FieldName<S>, a: FieldName<S>, low: number, high: number, selection?: Selection | null): number;
+    abs(dst: FieldName<S>, a: FieldName<S>, selection?: Selection | null): number;
+    neg(dst: FieldName<S>, a: FieldName<S>, selection?: Selection | null): number;
+    lerp(dst: FieldName<S>, a: FieldName<S>, b: FieldName<S>, t: number, selection?: Selection | null): number;
+    private vectorOp;
+    length(dst: FieldName<S>, vector: FieldName<S>, selection?: Selection | null): number;
+    distance(dst: FieldName<S>, vector: FieldName<S>, x: number, y: number, z: number, selection?: Selection | null): number;
+    distanceSquared(dst: FieldName<S>, vector: FieldName<S>, x: number, y: number, z: number, selection?: Selection | null): number;
+    select(out: Selection, field: ScalarName<S>, comparison: Comparison, value: number, high?: number, from?: Selection | null): number;
+    private reduceOp;
+    sum(field: ScalarName<S>, selection?: Selection | null): number;
+    mean(field: ScalarName<S>, selection?: Selection | null): number;
+    minimum(field: ScalarName<S>, selection?: Selection | null): number;
+    maximum(field: ScalarName<S>, selection?: Selection | null): number;
+    argmin(field: ScalarName<S>, selection?: Selection | null): number;
+    argmax(field: ScalarName<S>, selection?: Selection | null): number;
+    countNonZero(field: ScalarName<S>, selection?: Selection | null): number;
+    sort(out: Selection, key: ScalarName<S>, descending?: boolean, from?: Selection | null): number;
+    buildGrid(position: FieldName<S>, selection?: Selection | null): number;
+    private center;
+    near(out: Selection, x: number, y: number, z: number, radius: number): number;
+    nearest(out: Selection, x: number, y: number, z: number, radius: number, exclude?: number): number;
+    each(visit: (row: number, cols: TableColumns<S>) => void, selection?: Selection | null): void;
+    forEach(visit: (entity: EntityCursor<S>, row: number) => void, selection?: Selection | null): void;
+    map(field: ScalarName<S>, compute: (entity: EntityCursor<S>, out: Float64Array, row: number) => void, selection?: Selection | null): void;
+    reduce(step: (total: Float64Array, entity: EntityCursor<S>, row: number) => void, initial?: number, selection?: Selection | null): number;
+    private reduceRows;
+    dispose(): void;
+}
+
+declare const ENGINE_COMPUTE_EXPORT_NAMES: readonly ["engine_compute_frame", "engine_compute_priority", "engine_compute_registers", "engine_compute_clear"];
+type KernelPriority = "simulation" | "presentation" | "optional";
+type ComputeCode = "frame_over" | "kernel_heavy" | "kernel_deferred" | "kernel_stopped" | "gpu_deferred" | "gpu_stall";
+type ComputeRoute = "interpreter" | "jit" | "prebuilt" | "native" | "gpu";
+interface ComputeDiagnostic {
+    readonly code: ComputeCode;
+    readonly kernel: string | null;
+    readonly route: ComputeRoute;
+    readonly ms: number;
+    readonly rows: number;
+    readonly frame: number;
+    readonly message: string;
+}
+interface ComputeFrame {
+    readonly budgetMs: number;
+    readonly spentMs: number;
+    readonly deferred: number;
+    readonly stopped: number;
+}
+declare function computeLogLine(d: ComputeDiagnostic): string;
+
+type EventFieldKind = "f32" | "i32" | "u32" | "bool";
+type EventFields = Readonly<Record<string, EventFieldKind>>;
+type EventPayload<F extends EventFields> = {
+    readonly [K in keyof F]: F[K] extends "bool" ? boolean : number;
+};
+type DrainedEvent<F extends EventFields> = EventPayload<F> & {
+    readonly row: number;
+};
+declare class EventChannel<F extends EventFields> {
+    readonly name: string;
+    readonly fields: F;
+    readonly capacity: number;
+    readonly names: readonly string[];
+    readonly kinds: readonly EventFieldKind[];
+    private readonly ring;
+    private readonly floats;
+    private readonly ints;
+    private count;
+    private lost;
+    private at;
+    private readonly event;
+    constructor(name: string, fields: F, capacity: number);
+    get pending(): number;
+    get dropped(): number;
+    emit(payload: EventPayload<F>): void;
+    accept(source: Uint32Array, entry: number): void;
+    addLost(count: number): void;
+    drain(visit: (event: DrainedEvent<F>) => void): number;
+}
+declare function events<const F extends EventFields>(name: string, fields: F, capacity?: number): EventChannel<F>;
+
+type f32 = number;
+type i32 = number;
+type u32 = number;
+interface FixedArray<T, N extends number> {
+    [index: number]: T;
+    readonly length: N;
+}
+interface Neighbours<E> {
+    [Symbol.iterator](): Iterator<E>;
+}
+interface QueryWhere {
+    readonly field: string;
+    readonly equals?: u32;
+    readonly any?: u32;
+    readonly none?: u32;
+    readonly mask?: u32;
+}
+interface QueryOptions {
+    readonly limit?: u32;
+    readonly cell?: f32;
+    readonly field?: string;
+    readonly where?: QueryWhere;
+}
+interface NearestFeatureOptions extends QueryOptions {
+    readonly velocity?: string;
+}
+interface KernelEntity<E> {
+    readonly row: i32;
+    readonly rank: u32;
+    nearestFeatures(k: u32, reach?: f32, options?: NearestFeatureOptions): FixedArray<f32, number>;
+    neighbours(radius: f32, field?: string): Neighbours<Each<E>>;
+    nearest(k: u32, reach?: f32, options?: QueryOptions): Neighbours<Each<E>>;
+    within(reach: f32, options?: QueryOptions): Neighbours<Each<E>>;
+    inCone(axis: vec2 | vec3, cosHalfAngle: f32, reach: f32, options?: QueryOptions): Neighbours<Each<E>>;
+    inBox(forward: vec2 | vec3, half: vec3, options?: QueryOptions): Neighbours<Each<E>>;
+    alongRay(dir: vec2 | vec3, length: f32, radius: f32, options?: QueryOptions): Neighbours<Each<E>>;
+}
+type Each<T> = T & KernelEntity<T>;
+type AnyVec = vec2 | vec3 | vec4;
+interface vec2 {
+    x: f32;
+    y: f32;
+}
+declare function vec2(x: f32, y: f32): vec2;
+interface vec3 {
+    x: f32;
+    y: f32;
+    z: f32;
+}
+declare function vec3(x: f32, y: f32, z: f32): vec3;
+interface vec4 {
+    x: f32;
+    y: f32;
+    z: f32;
+    w: f32;
+}
+declare function vec4(x: f32, y: f32, z: f32, w: f32): vec4;
+interface quat {
+    x: f32;
+    y: f32;
+    z: f32;
+    w: f32;
+}
+declare function quat(x: f32, y: f32, z: f32, w: f32): quat;
+declare function add(a: vec4, b: vec4): vec4;
+declare function add(a: vec3, b: vec3): vec3;
+declare function add(a: vec2, b: vec2): vec2;
+declare function sub(a: vec4, b: vec4): vec4;
+declare function sub(a: vec3, b: vec3): vec3;
+declare function sub(a: vec2, b: vec2): vec2;
+declare function mul(a: vec4, b: vec4): vec4;
+declare function mul(a: vec3, b: vec3): vec3;
+declare function mul(a: vec2, b: vec2): vec2;
+declare function div(a: vec4, b: vec4): vec4;
+declare function div(a: vec3, b: vec3): vec3;
+declare function div(a: vec2, b: vec2): vec2;
+declare function scale(a: vec4, s: f32): vec4;
+declare function scale(a: vec3, s: f32): vec3;
+declare function scale(a: vec2, s: f32): vec2;
+declare function negate(a: vec4): vec4;
+declare function negate(a: vec3): vec3;
+declare function negate(a: vec2): vec2;
+declare function dot(a: AnyVec, b: AnyVec): f32;
+declare function lenSq(a: AnyVec): f32;
+declare function len(a: AnyVec): f32;
+declare function dist(a: vec4, b: vec4): f32;
+declare function dist(a: vec3, b: vec3): f32;
+declare function dist(a: vec2, b: vec2): f32;
+declare function distSq(a: vec4, b: vec4): f32;
+declare function distSq(a: vec3, b: vec3): f32;
+declare function distSq(a: vec2, b: vec2): f32;
+declare function normalize(a: vec4): vec4;
+declare function normalize(a: vec3): vec3;
+declare function normalize(a: vec2): vec2;
+declare function cross(a: vec3, b: vec3): vec3;
+declare function lerp(a: f32, b: f32, t: f32): f32;
+declare function lerp(a: vec4, b: vec4, t: f32): vec4;
+declare function lerp(a: vec3, b: vec3, t: f32): vec3;
+declare function lerp(a: vec2, b: vec2, t: f32): vec2;
+declare function clamp(x: f32, low: f32, high: f32): f32;
+declare function clamp(x: vec4, low: f32, high: f32): vec4;
+declare function clamp(x: vec3, low: f32, high: f32): vec3;
+declare function clamp(x: vec2, low: f32, high: f32): vec2;
+declare function smoothstep(edge0: f32, edge1: f32, x: f32): f32;
+declare function qmul(a: quat, b: quat): quat;
+declare function qconj(q: quat): quat;
+declare function qaxis(axis: vec3, angle: f32): quat;
+declare function qrotate(q: quat, v: vec3): vec3;
+declare function hash32(a: u32, b: u32): u32;
+declare function rand01(seed: u32, stream: u32): f32;
+declare function noise2(x: f32, y: f32): f32;
+declare function noise3(x: f32, y: f32, z: f32): f32;
+declare const Status: {
+    readonly failure: 0;
+    readonly success: 1;
+    readonly running: 2;
+};
+type Status = (typeof Status)[keyof typeof Status];
+interface RayHitInfo {
+    readonly dist: f32;
+    readonly normal: vec3;
+    readonly entity: u32;
+    readonly hit: boolean;
+}
+interface NavStep {
+    readonly dir: vec3;
+    readonly status: u32;
+}
+interface FlowStep {
+    readonly dir: vec3;
+    readonly distance: f32;
+    readonly status: u32;
+}
+declare function raycast(origin: vec3, dir: vec3, maxDist: f32): RayHitInfo;
+declare function lineOfSight(from: vec3, to: vec3): boolean;
+declare function groundHeight(x: f32, z: f32): f32;
+declare function navNext(from: vec3, goal: vec3): NavStep;
+declare function flow(position: vec3): FlowStep;
+interface OverlapInfo {
+    readonly count: u32;
+    readonly entity: u32;
+}
+interface SweepHitInfo {
+    readonly dist: f32;
+    readonly normal: vec3;
+    readonly entity: u32;
+    readonly hit: boolean;
+}
+interface PickInfo {
+    readonly dist: f32;
+    readonly node: u32;
+    readonly instance: u32;
+    readonly hit: boolean;
+}
+interface VoxelInfo {
+    readonly material: u32;
+    readonly solid: boolean;
+}
+interface CellInfo {
+    readonly species: u32;
+    readonly kelvin: f32;
+    readonly amount: u32;
+}
+declare function applyForce(body: u32, force: vec3): void;
+declare function applyImpulse(body: u32, impulse: vec3): void;
+declare function setVelocity(body: u32, velocity: vec3): void;
+declare function overlap(center: vec3, radius: f32): OverlapInfo;
+declare function sweep(origin: vec3, dir: vec3, radius: f32, maxDist: f32, exclude?: u32): SweepHitInfo;
+declare function setClipWeight(action: u32, weight: f32): void;
+declare function playClip(root: u32, clip: u32, loop?: boolean, fadeSeconds?: f32, speed?: f32): u32;
+declare function setIkTarget(chain: u32, target: vec3, weight?: f32): void;
+declare function setInstance(node: u32, index: u32, position: vec3, rotation?: quat, size?: f32 | vec3): void;
+declare function setInstanceColour(node: u32, index: u32, colour: vec4): void;
+declare function setAnchor(node: u32, position: vec3): void;
+declare function playSound(sound: u32, bus: u32, position: vec3, gain?: f32): void;
+declare function pick(origin: vec3, dir: vec3, maxDist: f32): PickInfo;
+declare function voxelAt(position: vec3): VoxelInfo;
+declare function setVoxel(position: vec3, material: u32): void;
+declare function chemistryAt(x: u32, y: u32, z: u32): CellInfo;
+declare function spawn<T extends object>(values: T): void;
+declare function despawn(): void;
+
+interface KernelWorldPort {
+    call(service: number, args: Float64Array, out: Float64Array): boolean;
+    begin?(service: number): void;
+    end?(service: number): void;
+}
+interface KernelOverlap {
+    count: number;
+    entity: number;
+}
+interface KernelServicePhysics {
+    raycast(ray: RayQuery, hit: RayHit): boolean;
+    entityOfCollider(collider: number): number;
+    batchHandle?(): number;
+    writeBody?(op: number, body: number, x: number, y: number, z: number): void;
+    castShape?(query: ShapeCastQuery, hit: RayHit): boolean;
+    overlap?(x: number, y: number, z: number, radius: number, out: KernelOverlap): boolean;
+}
+interface KernelServiceGraphics {
+    batchHandle?(): number;
+    setClipWeight?(action: number, weight: number): void;
+    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;
+    raycast?(origin: ArrayLike<number>, direction: ArrayLike<number>, out: PickHit, far?: number, layers?: number): boolean;
+}
+interface KernelServiceUi {
+    setAnchor(node: number, x: number, y: number, z: number): void;
+    batchHandle?(): number;
+}
+interface KernelServiceAudio {
+    play(sound: number, bus: number, gain: number, rate: number, loop: boolean, spatial: boolean): number;
+    setVoicePosition(voice: number, matrix: Float32Array, offset: number): void;
+    batchHandle?(): number;
+}
+interface KernelVoxel {
+    material: number;
+    solid: boolean;
+}
+interface KernelServiceVoxels {
+    voxelAt(x: number, y: number, z: number, out: KernelVoxel): void;
+    setVoxel(x: number, y: number, z: number, material: number): void;
+    batchHandle?(): number;
+}
+interface KernelCell {
+    species: number;
+    kelvin: number;
+    amount: number;
+}
+interface KernelServiceChemistry {
+    cell(x: number, y: number, z: number, out: KernelCell): void;
+    batchHandle?(): number;
+}
+interface KernelServiceNav {
+    findPath(from: {
+        x: number;
+        y: number;
+        z: number;
+    }, to: {
+        x: number;
+        y: number;
+        z: number;
+    }, out: NavPath): boolean;
+    batchHandle?(): number;
+}
+interface KernelServiceFlow {
+    sample?(x: number, z: number, smooth: boolean, out: FlowSample): boolean;
+    batchHandle?(): number;
+}
+interface KernelServiceSources {
+    readonly physics?: KernelServicePhysics;
+    readonly nav?: KernelServiceNav;
+    readonly flow?: KernelServiceFlow;
+    readonly terrain?: {
+        heightAt(x: number, z: number): number;
+    };
+    readonly graphics?: KernelServiceGraphics;
+    readonly ui?: KernelServiceUi;
+    readonly audio?: KernelServiceAudio;
+    readonly voxels?: KernelServiceVoxels;
+    readonly chemistry?: KernelServiceChemistry;
+}
+interface KernelHandles {
+    physics: number;
+    nav: number;
+    flow: number;
+    render: number;
+    ui: number;
+    audio: number;
+    voxels: number;
+    chemistry: number;
+}
+declare class KernelWorld implements KernelWorldPort {
+    readonly sources: KernelServiceSources;
+    private readonly query;
+    private readonly hit;
+    private readonly path;
+    private readonly from;
+    private readonly to;
+    private readonly flowSample;
+    constructor(sources: KernelServiceSources);
+    private readonly ids;
+    private readonly cast;
+    private readonly overlapOut;
+    private readonly voxel;
+    private readonly cellOut;
+    private readonly pickHit;
+    private readonly pickFrom;
+    private readonly pickDir;
+    private readonly matrix;
+    private marked;
+    handles(): KernelHandles;
+    begin(service: number): void;
+    end(service: number): void;
+    call(service: number, args: Float64Array, out: Float64Array): boolean;
+    private sweep;
+    private pick;
+    private instance;
+    private ray;
+    private route;
+}
+declare function setKernelWorld(world: KernelWorldPort | null): KernelWorldPort | null;
+
+declare const spawnOverflow: EventChannel<{
+    readonly dropped: "u32";
+    readonly capacity: "u32";
+    readonly table: "u32";
+}>;
+interface KernelSpawnReport {
+    spawned: number;
+    dropped: number;
+    killed: number;
+}
+
+type Ref<T = unknown> = T extends never ? never : u32;
+declare const NO_REF = 4294967295;
+type Joined<T> = {
+    -readonly [K in keyof T]: T[K];
+} & {
+    readonly exists: boolean;
+};
+interface Rows<T> {
+    get(ref: u32): Joined<T>;
+    at(index: number): Joined<T>;
+    lookup(key: u32): Joined<T>;
+    readonly count: number;
+}
+interface List<T, K extends number = number> extends Iterable<T> {
+    readonly length: number;
+    readonly capacity?: K;
+    [index: number]: T;
+    push(value: T): boolean;
+    pop(): T;
+    get(index: number): T;
+    set(index: number, value: T): void;
+    indexOf(value: T): number;
+    includes(value: T): boolean;
+    removeAt(index: number): void;
+    swapRemove(index: number): void;
+    clear(): void;
+}
+declare function symbol(name: string): u32;
+declare function pickRows(n: number, when: boolean, seed: u32, tick: u32, weight?: number): void;
+declare function list(kind: "f32" | "i32" | "u32", capacity: number): {
+    readonly at: "u32";
+    readonly len: "u32";
+};
+type PoolArray = Float32Array | Int32Array | Uint32Array;
+declare function listPool(table: EntityTable<TableSchema>, field: string, capacity: number, kind?: "f32" | "i32" | "u32" | "bool", component?: number): PoolArray;
+declare function readList(table: EntityTable<TableSchema>, field: string, capacity: number, row: number, kind?: "f32" | "i32" | "u32"): number[];
+interface KernelDataReport {
+    readonly picks: readonly Uint32Array[];
+    readonly tallies: Readonly<Record<string, number>>;
+    readonly commands: {
+        readonly sent: number;
+        readonly applied: number;
+        readonly dropped: number;
+        readonly overflow: number;
+    };
+    readonly unplaced: number;
+}
+declare class Queue<F extends EventFields> extends EventChannel<F> {
+    readonly table: EntityTable<TableSchema>;
+    private overflow;
+    constructor(name: string, fields: F, table: EntityTable<TableSchema>);
+    accept(source: Uint32Array, entry: number): void;
+    emit(payload: EventPayload<F>): void;
+    push(payload: EventPayload<F>): void;
+    get dropped(): number;
+    clear(): void;
+}
+declare function queue<const F extends EventFields>(name: string, fields: F, table: EntityTable<TableSchema>): Queue<F>;
+
+declare const entityBrand: unique symbol;
+type Entity = number & {
+    readonly [entityBrand]: true;
+};
+declare const NO_ENTITY: Entity;
+declare function entityIndex(entity: Entity): number;
+declare function entityGeneration(entity: Entity): number;
+declare class EntityRegistry implements RollbackState {
+    readonly capacity: number;
+    private readonly generations;
+    private readonly live;
+    private readonly freeList;
+    private readonly counters;
+    private readonly views;
+    constructor(capacity: number);
+    get count(): number;
+    rollbackViews(): readonly ArrayBufferView[];
+    create(): Entity;
+    destroy(entity: Entity): boolean;
+    isAlive(entity: Entity): boolean;
+    assertAlive(entity: Entity): void;
+}
+
+type FieldSpec$1 = Scalar | readonly [Scalar, number];
+type ComponentSchema = Readonly<Record<string, FieldSpec$1>>;
+type FieldArray<F> = F extends readonly [infer S extends Scalar, number] ? ArrayFor<S> : F extends Scalar ? ArrayFor<F> : never;
+type ComponentFields<S extends ComponentSchema> = {
+    readonly [K in keyof S]: FieldArray<S[K]>;
+};
+interface ComponentType<S extends ComponentSchema = ComponentSchema> {
+    readonly id: number;
+    readonly name: string;
+    readonly schema: S;
+}
+declare function defineComponent<const S extends ComponentSchema>(name: string, schema: S): ComponentType<S>;
+declare class ComponentStore<S extends ComponentSchema = ComponentSchema> {
+    readonly type: ComponentType<S>;
+    readonly capacity: number;
+    readonly entities: Uint32Array;
+    readonly sparse: Int32Array;
+    readonly fields: ComponentFields<S>;
+    private readonly arrays;
+    private readonly arities;
+    private readonly counters;
+    private readonly views;
+    constructor(type: ComponentType<S>, capacity: number, entityCapacity: number, memory?: ComponentMemory);
+    get count(): number;
+    get version(): number;
+    rollbackViews(): readonly ArrayBufferView[];
+    row(entity: Entity): number;
+    has(entity: Entity): boolean;
+    require(entity: Entity): number;
+    add(entity: Entity): number;
+    remove(entity: Entity): boolean;
+    entityAt(row: number): Entity;
+}
+
+declare const Transform: ComponentType<{
+    readonly position: readonly ["f32", 3];
+    readonly rotation: readonly ["f32", 4];
+    readonly scale: readonly ["f32", 3];
+    readonly previousPosition: readonly ["f32", 3];
+    readonly previousRotation: readonly ["f32", 4];
+    readonly previousScale: readonly ["f32", 3];
+    readonly parent: "u32";
+    readonly render: readonly ["f32", 16];
+}>;
+type TransformSchema = (typeof Transform)["schema"];
+declare class Transforms implements DespawnListener {
+    readonly store: ComponentStore<TransformSchema>;
+    readonly columns: TransformColumns;
+    private readonly world;
+    private readonly port;
+    private hierarchyVersion;
+    constructor(world: World, port: TransformPort);
+    add(entity: Entity, x?: number, y?: number, z?: number): number;
+    onDespawn(entity: Entity): void;
+    row(entity: Entity): number;
+    setPosition(entity: Entity, x: number, y: number, z: number): void;
+    setRotation(entity: Entity, x: number, y: number, z: number, w: number): void;
+    setRotationQuat(entity: Entity, q: Quat): void;
+    setScale(entity: Entity, x: number, y: number, z: number): void;
+    translate(entity: Entity, delta: Vec3Like): void;
+    position(entity: Entity, out: Vec3): Vec3;
+    rotation(entity: Entity, out: Quat): Quat;
+    renderPosition(entity: Entity, out: Vec3): Vec3;
+    setParent(child: Entity, parent: Entity): void;
+    parentOf(entity: Entity): Entity;
+    teleport(entity: Entity): void;
+    snapshot(): void;
+    computeRender(time: FrameTime): void;
+    private teleportRow;
+}
+
+type Vec3Tuple = readonly [number, number, number];
+declare const CRAFT_CHANNELS = 16;
+declare const CRAFT_TELEMETRY_WORDS = 16;
+declare const NO_CHANNEL = 255;
+declare const MAX_FOILS = 16;
+declare const MAX_THRUSTERS = 8;
+declare const MAX_ROTORS = 8;
+declare const MAX_CRAFT_WHEELS = 8;
+declare const MAX_HULL_POINTS = 512;
+declare const MAX_HULL_RESOLUTION = 16;
+declare const MAX_AERO_TABLE = 64;
+declare const TELEMETRY_SPEED = 0;
+declare const TELEMETRY_SUBMERGED = 1;
+declare const TELEMETRY_PLANING = 2;
+declare const TELEMETRY_BANK = 3;
+declare const TELEMETRY_AIRSPEED = 4;
+declare const TELEMETRY_ALPHA = 5;
+declare const TELEMETRY_STALLED = 6;
+declare const TELEMETRY_GROUND_EFFECT = 7;
+declare const TELEMETRY_CONTACTS = 8;
+declare const TELEMETRY_GEAR = 9;
+declare const TELEMETRY_SPOOL = 10;
+declare const TELEMETRY_ROTOR = 11;
+declare const TELEMETRY_THRUST = 12;
+declare const TELEMETRY_CLIMB = 13;
+declare const TELEMETRY_APPARENT_WIND = 14;
+declare const TELEMETRY_PITCH = 15;
+declare const BOAT_THROTTLE = 0;
+declare const BOAT_STEER = 1;
+declare const BOAT_SHEET = 2;
+declare const FLIGHT_PITCH = 0;
+declare const FLIGHT_ROLL = 1;
+declare const FLIGHT_YAW = 2;
+declare const FLIGHT_THROTTLE = 3;
+declare const FLIGHT_FLAPS = 4;
+declare const FLIGHT_BRAKE = 5;
+declare const FLIGHT_GEAR = 6;
+declare const FLIGHT_TILT = 7;
+declare const ROTOR_COLLECTIVE = 0;
+declare const ROTOR_CYCLIC_PITCH = 1;
+declare const ROTOR_CYCLIC_ROLL = 2;
+declare const ROTOR_PEDAL = 3;
+declare const ROTOR_ENGINE = 4;
+type CraftPresetName = "canoe" | "speedboat" | "ferry" | "cargo_ship" | "sailboat" | "light_plane" | "jet" | "glider" | "helicopter" | "quadcopter" | "tiltrotor" | "blimp";
+declare const CRAFT_PRESETS: readonly CraftPresetName[];
+type BoatPresetName = "canoe" | "speedboat" | "ferry" | "cargo_ship" | "sailboat";
+type AircraftPresetName = "light_plane" | "jet" | "glider" | "tiltrotor";
+type HelicopterPresetName = "helicopter" | "quadcopter" | "blimp";
+type FlightMode = "arcade" | "sim";
+type Medium = "any" | "water" | "air";
+interface MixDesc {
+    readonly bias?: number;
+    readonly gains?: readonly number[];
+}
+type HullSource = {
+    readonly kind: "box";
+    readonly halfExtents: Vec3Tuple;
+    readonly resolution: Vec3Tuple;
+} | {
+    readonly kind: "boat";
+    readonly length: number;
+    readonly beam: number;
+    readonly depth: number;
+    readonly bow: number;
+    readonly resolution: Vec3Tuple;
+} | {
+    readonly kind: "ball";
+    readonly radius: number;
+    readonly resolution: Vec3Tuple;
+} | {
+    readonly kind: "mesh";
+    readonly vertices: Float32Array;
+    readonly indices: Uint32Array;
+    readonly resolution: Vec3Tuple;
+} | {
+    readonly kind: "points";
+    readonly samples: Float32Array;
+};
+type AeroCurveDesc = {
+    readonly kind: "wing";
+    readonly aspect: number;
+    readonly zeroLift?: number;
+    readonly stall: number;
+    readonly cd0: number;
+} | {
+    readonly kind: "analytic";
+    readonly slope: number;
+    readonly zeroLift?: number;
+    readonly stall: number;
+    readonly cd0: number;
+    readonly induced: number;
+} | {
+    readonly kind: "table";
+    readonly lift: CurveTable;
+    readonly drag: CurveTable;
+};
+interface HingeDesc {
+    readonly axis: Vec3Tuple;
+    readonly angle: MixDesc;
+    readonly maxAngle: number;
+    readonly rate?: number;
+}
+interface FoilDesc {
+    readonly position: Vec3Tuple;
+    readonly chord?: Vec3Tuple;
+    readonly normal?: Vec3Tuple;
+    readonly area: number;
+    readonly curve: AeroCurveDesc;
+    readonly deflection?: MixDesc;
+    readonly maxDeflection?: number;
+    readonly effectiveness?: number;
+    readonly rate?: number;
+    readonly deflectionDrag?: number;
+    readonly groundEffect?: boolean;
+    readonly leeward?: boolean;
+}
+interface ThrusterDesc {
+    readonly position: Vec3Tuple;
+    readonly axis?: Vec3Tuple;
+    readonly maxThrust: number;
+    readonly throttle: MixDesc;
+    readonly reverse?: number;
+    readonly spoolRate?: number;
+    readonly medium?: Medium;
+    readonly maxSpeed?: number;
+    readonly torque?: number;
+    readonly vector?: HingeDesc;
+}
+interface RotorDesc {
+    readonly position: Vec3Tuple;
+    readonly axis?: Vec3Tuple;
+    readonly radius: number;
+    readonly maxThrust: number;
+    readonly collective: MixDesc;
+    readonly cyclicPitch?: MixDesc;
+    readonly cyclicRoll?: MixDesc;
+    readonly cyclicTilt?: number;
+    readonly hubStiffness?: number;
+    readonly torqueReaction?: number;
+    readonly power?: MixDesc;
+    readonly governorRate?: number;
+    readonly rotorDrag?: number;
+    readonly autorotation?: number;
+    readonly inflow?: number;
+    readonly groundEffect?: number;
+    readonly tilt?: HingeDesc;
+}
+interface SpringDesc {
+    readonly stiffness: number;
+    readonly dampingCompression: number;
+    readonly dampingRelaxation: number;
+    readonly maxForce: number;
+}
+interface CraftWheelDesc {
+    readonly position: Vec3Tuple;
+    readonly restLength: number;
+    readonly radius: number;
+    readonly spring: SpringDesc;
+    readonly steer?: number;
+    readonly brake?: number;
+    readonly grip?: number;
+    readonly rolling?: number;
+}
+interface AssistDesc {
+    readonly level: number;
+    readonly rateDamping?: Vec3Tuple;
+    readonly autoLevel?: number;
+    readonly stallGuard?: number;
+    readonly coordination?: number;
+    readonly hoverHold?: number;
+    readonly pitch?: number;
+    readonly roll?: number;
+    readonly yaw?: number;
+    readonly lift?: number;
+}
+interface CraftDesc {
+    readonly hull?: HullSource;
+    readonly hydro?: {
+        readonly drag?: Vec3Tuple;
+        readonly linearDrag?: Vec3Tuple;
+        readonly angularDrag?: number;
+        readonly righting?: number;
+    };
+    readonly planing?: {
+        readonly speed: number;
+        readonly lift: number;
+        readonly dragFactor: number;
+        readonly position: Vec3Tuple;
+    };
+    readonly airDrag?: Vec3Tuple;
+    readonly gas?: {
+        readonly volume: number;
+        readonly netDensity: number;
+        readonly center?: Vec3Tuple;
+    };
+    readonly foils?: readonly FoilDesc[];
+    readonly thrusters?: readonly ThrusterDesc[];
+    readonly rotors?: readonly RotorDesc[];
+    readonly wheels?: readonly CraftWheelDesc[];
+    readonly gear?: {
+        readonly steer?: MixDesc;
+        readonly brake?: MixDesc;
+        readonly deploy?: MixDesc;
+        readonly retractRate?: number;
+    };
+    readonly assist?: AssistDesc;
+    readonly stall?: number;
+    readonly span?: number;
+    readonly groundEffect?: number;
+    readonly probeOffset?: number;
+}
+interface CraftBodyShape {
+    readonly halfExtents: Vec3Tuple;
+    readonly mass: number;
+    readonly wing?: Vec3Tuple;
+    readonly wingMass?: number;
+}
+interface CraftTuning {
+    readonly thrust?: number;
+    readonly drag?: number;
+    readonly response?: number;
+    readonly lift?: number;
+}
+interface CraftOptions {
+    readonly collider?: number;
+    readonly body?: CraftBodyShape;
+    readonly running?: boolean;
+}
+interface PresetOptions extends CraftTuning, CraftOptions {
+    readonly mode?: FlightMode;
+}
+interface BoatOptions extends PresetOptions {
+    readonly preset: BoatPresetName;
+}
+interface AircraftOptions extends PresetOptions {
+    readonly preset: AircraftPresetName;
+}
+interface HelicopterOptions extends PresetOptions {
+    readonly preset?: HelicopterPresetName;
+}
+declare function mix(channel: number, gain: number, bias?: number): MixDesc;
+declare function mixWith(base: MixDesc, channel: number, gain: number): MixDesc;
+declare function constant(bias: number): MixDesc;
+
+interface SoftPlastic {
+    readonly yieldStrain: number;
+    readonly creep?: number;
+    readonly limit?: number;
+}
+interface SoftBodyOptions {
+    readonly stretch?: number;
+    readonly bend?: number;
+    readonly volume?: number;
+    readonly damping?: number;
+    readonly gravity?: Vec3Like;
+    readonly substeps?: number;
+    readonly radius?: number;
+    readonly friction?: number;
+    readonly contraction?: number;
+    readonly fibre?: Vec3Like;
+    readonly plastic?: SoftPlastic;
+    readonly geometry?: GeometryId;
+}
+type SoftBodyShape = {
+    readonly lattice: {
+        readonly cells: readonly [number, number, number];
+        readonly size: Vec3Like;
+        readonly origin: Vec3Like;
+        readonly density?: number;
+    };
+    readonly surface?: Float32Array;
+} | {
+    readonly rope: {
+        readonly points: Float32Array;
+        readonly mass?: number;
+        readonly pinFirst?: boolean;
+    };
+} | {
+    readonly asset: Uint8Array;
+};
+type SoftCollider = {
+    readonly plane: {
+        readonly normal: Vec3Like;
+        readonly offset: number;
+    };
+} | {
+    readonly sphere: {
+        readonly center: Vec3Like;
+        readonly radius: number;
+    };
+} | {
+    readonly capsule: {
+        readonly a: Vec3Like;
+        readonly b: Vec3Like;
+        readonly radius: number;
+    };
+} | {
+    readonly box: {
+        readonly center: Vec3Like;
+        readonly half: Vec3Like;
+        readonly rotation?: {
+            readonly x: number;
+            readonly y: number;
+            readonly z: number;
+            readonly w: number;
+        };
+    };
+};
+interface CrumpleOptions {
+    readonly cells?: readonly [number, number, number];
+    readonly threshold?: number;
+    readonly crush?: number;
+    readonly maxDepth?: number;
+    readonly radius?: number;
+    readonly stiffness?: number;
+}
+declare class SoftBody {
+    private readonly port;
+    private readonly info;
+    readonly particles: number;
+    readonly skinned: number;
+    readonly tets: number;
+    private geometry;
+    private disposed;
+    constructor(port: SoftBodyPort, info: SoftBodyInfo, geometry: GeometryId | null);
+    get id(): number;
+    positions(): Float32Array;
+    attach(geometry: GeometryId | null): void;
+    setOptions(options: SoftBodyOptions): void;
+    setActivation(activation: number): void;
+    setAnchors(anchors: Float32Array): void;
+    push(offset: Vec3Like, velocity: Vec3Like): void;
+    present(): number;
+    dispose(): void;
+}
+declare class SoftBodies {
+    readonly port: SoftBodyPort;
+    private readonly bodies;
+    private readonly block;
+    constructor(port: SoftBodyPort);
+    create(shape: SoftBodyShape, options?: SoftBodyOptions): SoftBody;
+    remove(body: SoftBody): void;
+    setColliders(colliders: readonly SoftCollider[]): void;
+    couple(collider: number): number;
+    uncouple(slot: number): void;
+    get count(): number;
+    step(seconds: number): void;
+    present(): void;
+    digest(): bigint;
+    dispose(): void;
+}
+
+interface CraftBodyHost {
+    hasBody(entity: Entity): boolean;
+    bodyOf(entity: Entity): number;
+    addBody(entity: Entity, desc: {
+        readonly kind: "dynamic";
+        readonly canSleep: boolean;
+    }): number;
+    addCollider(entity: Entity, desc: ColliderDesc): number;
+}
+declare class Craft {
+    readonly id: number;
+    readonly entity: Entity;
+    protected readonly system: CraftSystem;
+    constructor(system: CraftSystem, id: number, entity: Entity);
+    setChannel(channel: number, value: number): void;
+    channel(channel: number): number;
+    telemetry(word: number): number;
+    get speed(): number;
+    get submerged(): number;
+    get planing(): number;
+    get bank(): number;
+    get pitchAttitude(): number;
+    get airspeed(): number;
+    get angleOfAttack(): number;
+    get stalled(): boolean;
+    get groundEffect(): number;
+    get onGround(): boolean;
+    get spool(): number;
+    get rotorSpeed(): number;
+    get thrust(): number;
+    get climb(): number;
+    get apparentWind(): number;
+    crumple(geometry: number, vertices: Float32Array, options?: CrumpleOptions): void;
+    impact(point: Vec3Like, severity: Vec3Like): boolean;
+    get damage(): number;
+    remove(): void;
+}
+declare class Boat extends Craft {
+    get throttle(): number;
+    set throttle(value: number);
+    get steer(): number;
+    set steer(value: number);
+    get sheet(): number;
+    set sheet(value: number);
+}
+declare class Aircraft extends Craft {
+    get pitch(): number;
+    set pitch(value: number);
+    get roll(): number;
+    set roll(value: number);
+    get yaw(): number;
+    set yaw(value: number);
+    get throttle(): number;
+    set throttle(value: number);
+    get flaps(): number;
+    set flaps(value: number);
+    get brake(): number;
+    set brake(value: number);
+    get gearDown(): boolean;
+    set gearDown(value: boolean);
+    get tilt(): number;
+    set tilt(value: number);
+}
+declare class Helicopter extends Craft {
+    get collective(): number;
+    set collective(value: number);
+    get cyclicPitch(): number;
+    set cyclicPitch(value: number);
+    get cyclicRoll(): number;
+    set cyclicRoll(value: number);
+    get pedal(): number;
+    set pedal(value: number);
+    get engine(): boolean;
+    set engine(value: boolean);
+}
+interface SeaOptions {
+    readonly windDirection?: number;
+    readonly seed?: number;
+}
+declare class WaterControls {
+    private readonly port;
+    private readonly one;
+    private readonly oneOut;
+    private level;
+    private currentX;
+    private currentZ;
+    private windX;
+    private windZ;
+    private gust;
+    private gustPeriod;
+    constructor(port: CraftPort);
+    configure(desc: WaterDesc): void;
+    sea(state: SeaState, options?: SeaOptions): WaterDesc;
+    ocean(desc: OceanDesc | null): void;
+    /** The FFT ocean, one desc for the eye and the hull: the water draws its cascades and every
+     * craft floats on the same waves (a CPU instance at `physicsSize`). `null` takes it away. */
+    cascades(desc: OceanCascades | null): void;
+    /** Puddles and streams over a bed: they flow downhill, pool and drain, and the water draws
+     * them. `null` takes them away. */
+    puddles(desc: PuddleOptions | null): void;
+    /** The ground under the puddles: one height per cell, row by row along x. */
+    setPuddleBed(heights: Float32Array): void;
+    /** Pours `volume` cubic metres at world x, z. */
+    pour(x: number, z: number, volume: number): void;
+    /** Rain and evaporation over the puddles, in metres per second. */
+    puddleWeather(rain: number, evaporation: number): void;
+    /** Ripples and wakes: every craft then floats on them and leaves its wake in them, and the
+     * water draws them. `null` takes them away. */
+    ripples(desc: RippleOptions | null): void;
+    /** Centres the ripple window on world x, z: call it with the camera or the player's boat. */
+    followRipples(x: number, z: number): void;
+    /** Pushes `amount` metres of water aside at world x, z: a splash, a stone, a paddle stroke. */
+    splash(x: number, z: number, amount: number): void;
+    setLevel(level: number): void;
+    setCurrent(x: number, z: number): void;
+    setWind(x: number, z: number, gust?: number, gustPeriod?: number): void;
+    height(x: number, z: number): number;
+    sample(x: number, z: number, out?: WaterSample): WaterSample;
+    sampleBatch(points: Float32Array, count: number, out: Float32Array): void;
+    private remember;
+    private flow;
+}
+declare class CraftSystem {
+    readonly water: WaterControls;
+    private readonly port;
+    private readonly handles;
+    private readonly crumpled;
+    private active;
+    constructor(port: CraftPort);
+    get backend(): string;
+    get count(): number;
+    controls(): Float32Array;
+    telemetry(): Float32Array;
+    create(host: CraftBodyHost, entity: Entity, desc: CraftDesc, options?: CraftOptions): Craft;
+    preset(host: CraftBodyHost, entity: Entity, name: CraftPresetName, options?: PresetOptions): Craft;
+    boat(host: CraftBodyHost, entity: Entity, options: BoatOptions): Boat;
+    aircraft(host: CraftBodyHost, entity: Entity, options: AircraftOptions): Aircraft;
+    helicopter(host: CraftBodyHost, entity: Entity, options?: HelicopterOptions): Helicopter;
+    remove(handle: Craft): void;
+    forget(entity: Entity): void;
+    step(): void;
+    crumple(handle: Craft, geometry: number, vertices: Float32Array, options?: CrumpleOptions): void;
+    impact(handle: Craft, point: Vec3Like, severity: Vec3Like): boolean;
+    damage(handle: Craft): number;
+    dispose(): void;
+    private fromPreset;
+    private build;
+    private attach;
+}
+
+declare const RigidBody: ComponentType<{
+    readonly body: "u32";
+    readonly kind: "u8";
+}>;
+interface PhysicsOptions {
+    readonly gravity?: readonly [number, number, number];
+    readonly maxBodies?: number;
+    readonly maxColliders?: number;
+    readonly maxJoints?: number;
+    readonly maxContactEvents?: number;
+    readonly maxCharacterControllers?: number;
+    readonly rollback?: WorldRollbackDesc;
+    readonly solver?: SolverSettings;
+}
+declare class Physics implements DespawnListener, RollbackState {
+    private readonly port;
+    private readonly world;
+    private readonly transforms;
+    private readonly bodies;
+    private readonly colliderEntity;
+    private readonly zero;
+    private readonly desc;
+    private readonly vehicleDesc;
+    private readonly vehicles;
+    readonly craft: CraftSystem;
+    private readonly craftHost;
+    private readonly rollbackStates;
+    private readonly views;
+    private enrolledIn;
+    private readonly solver;
+    constructor(port: PhysicsPort, world: World, transforms: Transforms, stepSeconds: number, options?: PhysicsOptions);
+    get backend(): string;
+    init(): Promise<void>;
+    setSolver(settings: SolverSettings): void;
+    setSoftCcd(entity: Entity, distance: number): void;
+    setSleepThresholds(entity: Entity, thresholds: SleepThresholds): void;
+    get rollback(): WorldSnapshots | null;
+    enrolRollback(...states: RollbackState[]): void;
+    rollbackViews(): readonly ArrayBufferView[];
+    setGravity(gravity: Vec3Like): void;
+    addBody(entity: Entity, desc: BodyDesc): number;
+    addCollider(entity: Entity, desc: ColliderDesc): number;
+    removeCollider(collider: number): void;
+    setColliderEnabled(collider: number, enabled: boolean): void;
+    overlap(x: number, y: number, z: number, radius: number, out: {
+        count: number;
+        entity: number;
+    }): boolean;
+    private readonly sphereOverlap;
+    entityOfCollider(collider: number): Entity;
+    hasBody(entity: Entity): boolean;
+    get joints(): JointPort;
+    ragdoll(desc: RagdollDesc): Ragdoll;
+    joint(a: Entity, b: Entity, desc: JointDesc): number;
+    setJointMotor(joint: number, targetVelocity: number, maxForce: number): void;
+    removeJoint(joint: number): void;
+    applyImpulse(entity: Entity, impulse: Vec3Like): void;
+    applyTorqueImpulse(entity: Entity, impulse: Vec3Like): void;
+    addForce(entity: Entity, force: Vec3Like): void;
+    applyImpulseAtPoint(entity: Entity, impulse: Vec3Like, point: Vec3Like): void;
+    addForceAtPoint(entity: Entity, force: Vec3Like, point: Vec3Like): void;
+    addTorque(entity: Entity, torque: Vec3Like): void;
+    velocityAtPoint(entity: Entity, point: Vec3Like, out: Vec3): Vec3;
+    setJointMotorPosition(joint: number, target: number, stiffness: number, damping: number): void;
+    castShape(query: ShapeCastQuery, hit: RayHit): boolean;
+    setColliderClass(collider: number, colliderClass: number): void;
+    setContactRule(platformClass: number, otherClass: number, rule: ContactRuleDesc): void;
+    setCollisionGroups(collider: number, membership: number, filter: number): void;
+    removeContactRule(platformClass: number, otherClass: number): void;
+    ignoreContacts(classA: number, classB: number): void;
+    oneWayPlatform(platformClass: number, otherClass: number, normal?: readonly [number, number, number]): void;
+    bodyId(entity: Entity): number;
+    resetForces(entity: Entity): void;
+    setLinearVelocity(entity: Entity, velocity: Vec3Like): void;
+    setAngularVelocity(entity: Entity, velocity: Vec3Like): void;
+    linearVelocity(entity: Entity, out: Vec3): Vec3;
+    angularVelocity(entity: Entity, out: Vec3): Vec3;
+    isSleeping(entity: Entity): boolean;
+    wake(entity: Entity): void;
+    teleport(entity: Entity, position: Vec3Like): void;
+    batchHandle(): number;
+    writeBody(op: number, body: number, x: number, y: number, z: number): void;
+    private readonly bodyWrite;
+    raycast(ray: RayQuery, hit: RayHit): boolean;
+    contactCount(): number;
+    contactEntityA(index: number): Entity;
+    contactEntityB(index: number): Entity;
+    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): CharacterMove;
+    get water(): WaterControls;
+    createCraft(entity: Entity, desc: CraftDesc, options?: CraftOptions): Craft;
+    createCraftPreset(entity: Entity, preset: CraftPresetName, options?: PresetOptions): Craft;
+    createBoat(entity: Entity, options: BoatOptions): Boat;
+    createAircraft(entity: Entity, options: AircraftOptions): Aircraft;
+    createHelicopter(entity: Entity, options?: HelicopterOptions): Helicopter;
+    createVehicle(entity: Entity, desc: VehicleDesc): Vehicle;
+    destroyVehicle(vehicle: Vehicle): void;
+    onDespawn(entity: Entity): void;
+    step(): void;
+    private bodyOf;
+}
+
+interface PrefetchLevelDesc {
+    readonly path: string;
+    readonly within?: number;
+    readonly bytes?: number;
+}
+interface PrefetchItemDesc {
+    readonly center: readonly [number, number, number];
+    readonly radius?: number;
+    readonly bytes?: number;
+    readonly levels: readonly PrefetchLevelDesc[];
+}
+type PrefetchDistance = number | (() => number);
+interface PrefetchLayerDesc {
+    readonly name?: string;
+    readonly items: readonly PrefetchItemDesc[];
+    readonly radius: PrefetchDistance;
+    readonly need?: PrefetchDistance;
+    readonly cellSize?: number;
+    readonly held?: (entry: number) => boolean;
+    readonly busy?: () => boolean;
+    readonly flow?: Float64Array;
+}
+declare const DEFAULT_PREFETCH_CELL = 32;
+declare const MAX_PREFETCH_LEVELS = 16;
+declare class PrefetchLayer {
+    readonly name: string;
+    readonly count: number;
+    readonly entries: number;
+    readonly x: Float64Array;
+    readonly y: Float64Array;
+    readonly z: Float64Array;
+    readonly radius: Float64Array;
+    readonly entryStart: Int32Array;
+    readonly entryItem: Int32Array;
+    readonly entryLevel: Uint8Array;
+    readonly entryWithin: Float64Array;
+    readonly entryBytes: Int32Array;
+    readonly paths: readonly string[];
+    readonly cellSize: number;
+    readonly originX: number;
+    readonly originZ: number;
+    readonly cols: number;
+    readonly rows: number;
+    readonly cellStart: Int32Array;
+    readonly cellItems: Int32Array;
+    readonly maxRadius: number;
+    readonly loadRadius: () => number;
+    readonly needRadius: () => number;
+    readonly held: ((entry: number) => boolean) | null;
+    readonly busy: (() => boolean) | null;
+    readonly flow: Float64Array | null;
+    readonly place: Float64Array<ArrayBuffer>;
+    private placed;
+    constructor(desc: PrefetchLayerDesc);
+    cellIndex(x: number, z: number): number;
+    get scale(): number;
+    setPlacement(transform: ArrayLike<number> | null): void;
+    toLocal(position: ArrayLike<number>, out: Float64Array, offset: number, point: boolean): void;
+}
+
+interface WorldColliderOptions {
+    readonly budget?: number;
+    readonly actors?: number;
+    readonly stepSeconds?: number;
+}
+/**
+ * Reads world packs as package assets, as `ctx.assets` does inside an Interactive.
+ * Hosts that deliver lazy chunks on request also expose `requests`, `lazy` and `release`.
+ */
+interface WorldPackReader {
+    take(path: string, priority?: number): 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;
+}
+interface WorldStreamOptions {
+    readonly world: Uint8Array;
+    /** Every pack, handed over up front (eager). Use `packPaths` with `assets` to stream packs on demand instead. */
+    readonly packs?: readonly (Uint8Array | Promise<Uint8Array>)[];
+    /** Package asset path of each pack, in pack index order (`street-00.cells`, `street-01.cells`, ...). */
+    readonly packPaths?: readonly string[];
+    /** Reads `packPaths`; with a host that takes requests, packs are fetched as the camera needs them and released when it leaves. */
+    readonly assets?: WorldPackReader;
+    readonly materials: readonly MaterialId[];
+    readonly tier?: DeviceTier;
+    readonly colliders?: WorldColliderOptions | false;
+}
+interface WorldStreamStats {
+    readonly live: number;
+    readonly loading: number;
+    readonly waiting: number;
+    readonly failed: number;
+    readonly inflight: number;
+    readonly installed: number;
+    readonly installedBytes: number;
+    readonly evicted: number;
+    readonly residentBytes: number;
+    readonly poolBytes: number;
+    readonly proxyBytes: number;
+    readonly sourceBytes: number;
+    readonly totalInstalls: number;
+}
+type WorldNavOptions = Omit<NavDesc, "tileWorld" | "origin">;
+interface WorldPrefetchOptions {
+    /** Package asset path of every pack: the mesh packs in index order, then the nav packs. */
+    readonly paths: readonly string[];
+    /** Bytes of each path, when the package index knows them; the predictor budgets by them. */
+    readonly bytes?: (path: string) => number | undefined;
+    readonly name?: string;
+}
+/**
+ * Describes a world's packs as a prefetch layer: one item per mesh pack centred on its cells, level 0 its meshes and
+ * level 1 its nav tiles, fetched only within the nav reach of the ground so fly-overs spend the link on meshes.
+ */
+declare function worldPrefetchLayer(world: Uint8Array, options: WorldPrefetchOptions): PrefetchLayerDesc;
+declare class WorldStream {
+    private readonly port;
+    private readonly handle;
+    private readonly physics;
+    private readonly world;
+    private readonly transforms;
+    private readonly lazy;
+    readonly ready: Promise<void>;
+    readonly stats: WorldStreamStats;
+    private readonly eye;
+    private readonly actorBuffer;
+    private readonly ops;
+    private readonly physicsOf;
+    private readonly collider;
+    private readonly extents;
+    private readonly offset;
+    private readonly rotation;
+    private readonly desc;
+    private actorCount;
+    private readonly waitingEager;
+    private collidersWaiting;
+    private closed;
+    private registers;
+    private anchor;
+    private readonly paths;
+    private readonly reader;
+    private readonly kept;
+    private readonly contended;
+    private readonly fetching;
+    private readonly dropped;
+    private readonly retryAt;
+    private readonly retryPriority;
+    private readonly backoff;
+    private frames;
+    private readonly shape;
+    private readonly worldBytes;
+    private readonly navHeld;
+    private readonly navLoaded;
+    private navTarget;
+    private navTileCount;
+    constructor(port: WorldStreamingPort, handle: number, options: WorldStreamOptions, physics: Physics | null, world: World, transforms: Transforms, colliders: number, lazy?: boolean);
+    private servePacks;
+    private request;
+    private providePack;
+    private holdNav;
+    private loadNavPack;
+    private dropNav;
+    private feed;
+    private provide;
+    private view;
+    update(eye: Vec3Like, velocity: Vec3Like): void;
+    /** True when packs stream on request from the host instead of being handed over up front. */
+    get streamsOnRequest(): boolean;
+    setActor(index: number, position: Vec3Like): void;
+    setActorCount(count: number): void;
+    /**
+     * Streams the world's baked nav tiles into `nav`: tiles arrive with their nav packs as the camera nears the ground
+     * and leave when the packs are released. Returns the tiles loaded so far; `navTiles` reads the count later.
+     */
+    loadNav(nav: Nav, options?: WorldNavOptions): number;
+    /** Nav tiles currently loaded into the nav given to `loadNav`. */
+    get navTiles(): number;
+    /**
+     * The world's packs as a prefetch layer over `packPaths`, for `game.prefetch.stream(layer, { stalled })`: the
+     * predictor fetches ahead of the camera by speed and heading, meshes before nav, and cancels what it leaves behind.
+     */
+    prefetchLayer(bytes?: (path: string) => number | undefined): PrefetchLayerDesc;
+    /** Mesh packs come first in `packPaths`, then nav packs; this is the index of nav pack 0. */
+    get navPackBase(): number;
+    /** True when the last collider step waited for a district of the world that has not arrived; that step changed nothing. */
+    get waitingForDistricts(): boolean;
+    stepColliders(): number;
+    private body;
+    private insert;
+    private remove;
+    dispose(): void;
+}
+declare class WorldStreamer {
+    private readonly port;
+    private readonly world;
+    private readonly transforms;
+    private readonly physics;
+    constructor(port: WorldStreamingPort | null, world: World, transforms: Transforms, physics: Physics | null);
+    get supported(): boolean;
+    stream(options: WorldStreamOptions): WorldStream;
+}
+
+type Leaf<E> = (entity: E, ...args: never[]) => boolean | number | void;
+type BehaviourNode<E> = {
+    readonly kind: "sequence";
+    readonly children: readonly BehaviourNode<E>[];
+} | {
+    readonly kind: "selector";
+    readonly children: readonly BehaviourNode<E>[];
+} | {
+    readonly kind: "invert";
+    readonly children: readonly BehaviourNode<E>[];
+} | {
+    readonly kind: "condition";
+    readonly leaf: Leaf<E>;
+} | {
+    readonly kind: "action";
+    readonly leaf: Leaf<E>;
+};
+declare function sequence<E>(...children: BehaviourNode<E>[]): BehaviourNode<E>;
+declare function selector<E>(...children: BehaviourNode<E>[]): BehaviourNode<E>;
+declare function invert<E>(child: BehaviourNode<E>): BehaviourNode<E>;
+declare function condition<E>(leaf: (entity: E, ...args: never[]) => boolean): BehaviourNode<E>;
+declare function action<E>(leaf: (entity: E, ...args: never[]) => boolean | number | void): BehaviourNode<E>;
+
+interface InspectorPool {
+    readonly live: number;
+    readonly highWater: number;
+    readonly capacity: number;
+}
+interface InspectorReadout {
+    readonly shown: boolean;
+    readonly refreshes: number;
+    readonly error: number;
+    readonly arena: {
+        readonly highWaterBytes: number;
+        readonly committedBytes: number;
+        readonly ceilingBytes: number;
+    };
+    readonly stream: {
+        readonly missing: number;
+        readonly urgent: number;
+        readonly starvedFrames: number;
+    };
+    readonly bodies: InspectorPool;
+    readonly colliders: InspectorPool;
+    readonly kernels: {
+        readonly budgetMs: number;
+        readonly spentMs: number;
+    };
+    readonly frameMs: number;
+}
+interface Dev {
+    inspector(on?: boolean): boolean;
+}
+declare const dev: Dev;
+
+type GpuDeviceClass = "unknown" | "mobile" | "desktop" | "discrete";
+type CpuBackend = "interpreter" | "cranelift" | "wasm";
+type RouteDevice = "cpu" | "gpu";
+interface KernelWork {
+    readonly rows: number;
+    readonly instructions: number;
+    readonly pairs: boolean;
+    readonly stages: number;
+    readonly columns: number;
+    readonly resident: boolean;
+    readonly readback: boolean;
+    readonly lanes: number;
+    readonly transcendentals: number;
+    readonly batched: boolean;
+}
+interface KernelMachine {
+    readonly class: GpuDeviceClass;
+    readonly backend: CpuBackend;
+    readonly budgetNs: number;
+    readonly pressure: number;
+}
+interface RouteEstimate {
+    cpuLaunch: number;
+    cpuRow: number;
+    cpuSerialRow: number;
+    lanes: number;
+    gpuFixed: number;
+    gpuRow: number;
+}
+interface RoutePin {
+    readonly cpu: number;
+    readonly gpu: number;
+}
+declare function kernelMachine(device: GpuDeviceClass, backend?: CpuBackend, budgetNs?: number, pressure?: number): KernelMachine;
+interface KernelSetShape {
+    readonly parts: number;
+    readonly instructions: number;
+    readonly gathers: number;
+    readonly transcendentals: number;
+    readonly stages: number;
+    readonly upload: number;
+    readonly readback: number;
+    readonly steps: number;
+}
+type SetCpuForm = "wasm" | "script";
+declare function chooseDevice(work: KernelWork, machine: KernelMachine): RouteDevice;
+declare function crossoverRows(work: KernelWork, machine: KernelMachine): number | null;
+declare function leaveBelowRows(work: KernelWork, machine: KernelMachine): number | null;
+declare class KernelRouter {
+    private machineState;
+    private readonly preset;
+    private current;
+    private decided;
+    private streak;
+    private switched;
+    private taken;
+    private pending;
+    private readonly cpuSamples;
+    private readonly gpuSamples;
+    private cpuLength;
+    private gpuLength;
+    private pinned;
+    private readonly scratch;
+    private readonly base;
+    private readonly runs;
+    private constructor();
+    static model(machine: KernelMachine): KernelRouter;
+    static calibrating(machine: KernelMachine, runs: number): KernelRouter;
+    static pinned(machine: KernelMachine, pin: RoutePin): KernelRouter;
+    static replaying(machine: KernelMachine, runs: number, pin: RoutePin): KernelRouter;
+    get machine(): KernelMachine;
+    set machine(next: KernelMachine);
+    get device(): RouteDevice;
+    get pin(): RoutePin | null;
+    get switches(): number;
+    get calibrating(): boolean;
+    get calibrationRuns(): number;
+    get sampling(): boolean;
+    route(work: KernelWork): RouteDevice;
+    routeEstimate(e: RouteEstimate, rows: number, rowBound?: number): RouteDevice;
+    record(device: RouteDevice, work: KernelWork, ns: number): void;
+    recordEstimate(device: RouteDevice, e: RouteEstimate, rows: number, ns: number): void;
+}
+
+declare const GPU_KERNEL_EXPORT_NAMES: readonly ["engine_kernel_gpu_ready", "engine_kernel_gpu_bind", "engine_kernel_gpu_unbind", "engine_kernel_gpu_run", "engine_kernel_gpu_frame", "engine_kernel_gpu_sync", "engine_kernel_gpu_touch", "engine_kernel_gpu_events", "engine_kernel_gpu_clear_events"];
+type KernelTarget = "auto" | "cpu" | "gpu";
+
+interface RunPlan {
+    readonly fn: ((entity: never, ...args: never[]) => unknown) | null;
+    readonly tree: BehaviourNode<never> | null;
+    readonly neighbours: boolean;
+}
+
+declare const KERNEL_INFO: unique symbol;
+declare function programDigest(program: Uint8Array): bigint;
+declare function nativeTwinOf(k: Kernel<unknown, unknown[]>): string | null;
+interface KernelInfo {
+    readonly name: string;
+    readonly plan: RunPlan;
+    readonly payload: string | null;
+    readonly device?: KernelTarget;
+    readonly feeds?: KernelFeed;
+    readonly priority?: KernelPriority;
+    compiled: {
+        readonly meta: KernelMeta;
+        readonly program: Uint8Array;
+    } | null | undefined;
+    runs: number;
+}
+type KernelFeed = "host" | "render" | "auto";
+interface KernelOptions {
+    readonly device?: KernelTarget;
+    readonly feeds?: KernelFeed;
+    readonly priority?: KernelPriority;
+}
+type Kernel<E, A extends unknown[] = []> = ((entity: E, ...args: A) => void) & {
+    readonly [KERNEL_INFO]: KernelInfo;
+};
+type KernelMode = "auto" | "native" | "vm" | "js" | "dev";
+interface KernelMismatch {
+    readonly kernel: string;
+    readonly field: string;
+    readonly component: number;
+    readonly row: number;
+    readonly js: number;
+    readonly native: number;
+    readonly source: string | null;
+}
+interface KernelSettings {
+    readonly mode: KernelMode;
+    readonly checkEvery: number;
+    readonly tolerance: number;
+    readonly report: (mismatch: KernelMismatch) => void;
+    readonly gpu: "auto" | "off";
+    readonly gpuRows: number;
+    readonly gpuClass: GpuDeviceClass;
+    readonly cpuLanes: number;
+    readonly cpuBackend: "auto" | CpuBackend;
+    readonly frameBudgetMs: number;
+    readonly gpuCalibrate: number;
+    readonly gpuPins: Readonly<Record<string, RoutePin>>;
+    readonly onRoute: ((report: KernelRouteReport) => void) | null;
+    readonly onCompute: ((diagnostic: ComputeDiagnostic) => void) | null;
+}
+interface KernelRouteReport {
+    readonly kernel: string;
+    readonly rows: number;
+    readonly machine: KernelMachine;
+    readonly pin: RoutePin;
+    readonly runs: number;
+}
+interface KernelPart {
+    readonly meta: KernelMeta;
+    readonly program: Uint8Array;
+}
+interface KernelPartSet {
+    readonly name: string;
+    readonly gpu: readonly KernelPart[];
+    readonly cpu: KernelSetShape;
+    readonly gpuShape: KernelSetShape;
+}
+interface KernelSetCpu {
+    readonly cpuForm: SetCpuForm;
+    runCpu(): void;
+}
+interface KernelSet<S extends TableSchema = TableSchema> {
+    readonly table: EntityTable<S>;
+    readonly selection: Selection | null;
+    readonly target?: KernelTarget;
+    readonly mirror?: readonly string[];
+    readonly spawns?: EntityTable<TableSchema>;
+}
+declare function spawnInto<S extends TableSchema>(table: EntityTable<S>, into: EntityTable<TableSchema>, selection?: Selection | null): KernelSet<S>;
+declare function configureKernels(next: Partial<KernelSettings>): KernelSettings;
+declare function kernel<E, A extends unknown[]>(fn: (entity: E, ...args: A) => void, options?: KernelOptions | string, payload?: string): Kernel<E, A>;
+declare function behaviour<E, A extends unknown[] = []>(root: BehaviourNode<E>, compiled?: string): Kernel<E, A>;
+declare function isKernel(value: unknown): value is Kernel<unknown, unknown[]>;
+declare function within<S extends TableSchema>(table: EntityTable<S>, selection: Selection | null, target?: KernelTarget): KernelSet<S>;
+declare function onGpu<S extends TableSchema>(table: EntityTable<S>, selection?: Selection | null, mirror?: readonly (keyof S & string)[]): KernelSet<S>;
+declare function compiledKernel(k: Kernel<unknown, unknown[]>): {
+    readonly meta: KernelMeta;
+    readonly program: Uint8Array;
+} | null;
+declare class KernelRunner {
+    private readonly js;
+    private readonly vm;
+    private readonly native;
+    private readonly args;
+    private readonly numericArgs;
+    private readonly gpu;
+    private readonly engine;
+    constructor(engine: KernelEngine | null);
+    private readonly compute;
+    private readonly inspector;
+    get inspectorReadout(): InspectorReadout | null;
+    get hasGpu(): boolean;
+    get computeFrame(): ComputeFrame | null;
+    frame(): void;
+    private gpuInFrame;
+    private pressure;
+    private readonly presented;
+    private readonly readers;
+    setGpuPressure(level: number): void;
+    get gpuPressure(): number;
+    present(table: EntityTable<TableSchema>, on?: boolean): void;
+    presents(table: EntityTable<TableSchema>): boolean;
+    readsOnHost(table: EntityTable<TableSchema>, fields: readonly string[]): void;
+    feedOf(info: KernelInfo, compiled: {
+        readonly meta: KernelMeta;
+        readonly program: Uint8Array;
+    } | null, table: EntityTable<TableSchema>): "host" | "render";
+    private noteCpuReads;
+    syncGpu(): void;
+    touchGpu(table: EntityTable<TableSchema>, field?: string, component?: number): void;
+    private onGpu;
+    private readonly routers;
+    private machineFor;
+    private machineValue;
+    private sampleRouter;
+    private sampleWork;
+    private sampleName;
+    private machine;
+    private routerFor;
+    private recordSample;
+    private readonly setRouters;
+    private readonly setMachines;
+    private setMachineBase;
+    private readonly setScratch;
+    partsTable<S extends TableSchema>(schema: S, capacity: number): EntityTable<S> | null;
+    gpuReady(): boolean;
+    gpuClass(): GpuDeviceClass;
+    runSet(set: KernelPartSet, table: EntityTable<TableSchema>, rows: number, target: KernelTarget, cpu: KernelSetCpu): RouteDevice;
+    private setOnGpu;
+    private setMachine;
+    private setRouterFor;
+    get hasEngine(): boolean;
+    compiled(): Promise<void>;
+    private world;
+    kernelServices(sources: KernelServiceSources | null): void;
+    private readonly sink;
+    private into;
+    get spawns(): Readonly<KernelSpawnReport>;
+    dataReport(k: Kernel<unknown, unknown[]>): KernelDataReport | null;
+    private plain;
+    run<E, A extends unknown[]>(k: Kernel<E, A>, set: EntityTable<TableSchema> | KernelSet, ...args: A): number;
+    runWith(k: Kernel<unknown, unknown[]>, set: EntityTable<TableSchema> | KernelSet, scratch: unknown[]): number;
+    private onCpu;
+    private check;
+    dispose(): void;
+}
+declare function setDefaultKernelEngine(engine: KernelEngine | null): void;
+declare function autoKernel(fn: (entity: never, ...args: never[]) => void, payload: string, table: EntityTable<TableSchema>, selection: Selection | null, a0?: unknown, a1?: unknown, a2?: unknown, a3?: unknown, a4?: unknown, a5?: unknown, a6?: unknown, a7?: unknown): number;
+type FieldSpec = TableField | {
+    readonly [name: string]: FieldSpec;
+} | readonly [FieldSpec, number];
+declare function fields<const T extends Readonly<Record<string, FieldSpec>>>(spec: T): TableSchema;
+
+interface KernelSystemSpec {
+    readonly name: string;
+    readonly kernel: Kernel<never, never[]>;
+    readonly set: EntityTable<TableSchema> | KernelSet;
+    readonly reads: readonly string[];
+    readonly writes: readonly string[];
+    readonly args?: unknown[];
+}
+declare class KernelSystems {
+    private readonly runner;
+    private readonly systems;
+    private stageOf;
+    private order;
+    constructor(runner: KernelRunner);
+    add(spec: KernelSystemSpec): this;
+    private build;
+    stages(): string[][];
+    run(): number;
+}
+
+interface DespawnListener {
+    onDespawn(entity: Entity): void;
+}
+declare class Query {
+    readonly entities: Uint32Array;
+    readonly rows: readonly Int32Array[];
+    private readonly stores;
+    private size;
+    constructor(stores: readonly ComponentStore[], capacity: number);
+    get count(): number;
+    entityAt(i: number): Entity;
+    update(): number;
+}
+declare class World implements RollbackState {
+    readonly entities: EntityRegistry;
+    readonly memory: ComponentMemory;
+    private readonly stores;
+    private readonly storeList;
+    private readonly listeners;
+    private streamer;
+    private kernels;
+    private readonly views;
+    constructor(capacity: number, memory?: ComponentMemory);
+    rollbackViews(): readonly ArrayBufferView[];
+    get capacity(): number;
+    attachKernels(runner: KernelRunner): void;
+    private services;
+    kernelServices(sources: KernelServiceSources | null): void;
+    kernelFrame(): void;
+    kernelGpuPressure(level: number): void;
+    presentKernels(table: EntityTable<TableSchema>, on?: boolean): void;
+    presentsKernels(table: EntityTable<TableSchema>): boolean;
+    hostReads(table: EntityTable<TableSchema>, fields: readonly string[]): void;
+    get kernelSpawns(): Readonly<KernelSpawnReport> | null;
+    kernelData<E, A extends unknown[]>(k: Kernel<E, A>): KernelDataReport | null;
+    kernelSystems(): KernelSystems;
+    run<E, A extends unknown[]>(k: Kernel<E, A>, set: EntityTable<TableSchema> | KernelSet, ...args: A): number;
+    attachStreamer(streamer: WorldStreamer): void;
+    stream(options: WorldStreamOptions): WorldStream;
+    register<S extends ComponentSchema>(type: ComponentType<S>, capacity?: number): ComponentStore<S>;
+    store<S extends ComponentSchema>(type: ComponentType<S>): ComponentStore<S>;
+    spawn(): Entity;
+    despawn(entity: Entity): boolean;
+    isAlive(entity: Entity): boolean;
+    add<S extends ComponentSchema>(entity: Entity, type: ComponentType<S>): number;
+    remove<S extends ComponentSchema>(entity: Entity, type: ComponentType<S>): boolean;
+    has<S extends ComponentSchema>(entity: Entity, type: ComponentType<S>): boolean;
+    query(...types: ComponentType[]): Query;
+    onDespawn(listener: DespawnListener): void;
+    indexOf(entity: Entity): number;
+}
+
+export { type BatchNav as $, Aircraft as A, Boat as B, type ComponentType as C, type DespawnListener as D, type Entity as E, type FixedArray as F, type GpuDeviceClass as G, type HullSource as H, type InspectorReadout as I, type AeroCurveDesc as J, KernelRunner as K, type AircraftOptions as L, type AircraftPresetName as M, Nav as N, AreaEffect as O, PrefetchLayer as P, type AreaEffectDesc as Q, type RouteDevice as R, SoftBodies as S, Transforms as T, type ArrayField as U, type AssistDesc as V, World as W, BOAT_SHEET as X, BOAT_STEER as Y, BOAT_THROTTLE as Z, type BatchGraphics as _, EntityTable as a, type KernelFeed as a$, type BatchPhysics as a0, type BehaviourNode as a1, type BoatOptions as a2, type BoatPresetName as a3, CRAFT_CHANNELS as a4, CRAFT_PRESETS as a5, CRAFT_TELEMETRY_WORDS as a6, type CellInfo as a7, type Comparison as a8, type ComponentFields as a9, FLIGHT_THROTTLE as aA, FLIGHT_TILT as aB, FLIGHT_YAW as aC, FLOW_COST_BLOCKED as aD, FLOW_COST_ONE as aE, type Falloff as aF, type FieldName as aG, type FieldSpec$1 as aH, type FlightMode as aI, FlowField as aJ, type FlowFieldDesc as aK, type FlowNav as aL, FlowSample as aM, FlowSteer as aN, type FlowSteerDesc as aO, type FlowStep as aP, type FoilDesc as aQ, GPU_KERNEL_EXPORT_NAMES as aR, type HelicopterOptions as aS, type HelicopterPresetName as aT, type HingeDesc as aU, type InspectorPool as aV, Inventory as aW, type Joined as aX, type KernelCell as aY, type KernelDataReport as aZ, type KernelEntity as a_, type ComponentSchema as aa, ComponentStore as ab, type ComputeCode as ac, type ComputeDiagnostic as ad, type ComputeFrame as ae, type ComputeRoute as af, type CpuBackend as ag, Craft as ah, type CraftOptions as ai, CraftSystem as aj, type CraftWheelDesc as ak, type CrumpleOptions as al, DEFAULT_PREFETCH_CELL as am, type Dev as an, type DrainedEvent as ao, ENGINE_COMPUTE_EXPORT_NAMES as ap, type EntityCursor as aq, EventChannel as ar, type EventFieldKind as as, type EventFields as at, type EventPayload as au, FLIGHT_BRAKE as av, FLIGHT_FLAPS as aw, FLIGHT_GEAR as ax, FLIGHT_PITCH as ay, FLIGHT_ROLL as az, type TableSchema as b, RigidBody as b$, type KernelHandles as b0, type KernelMachine as b1, type KernelMismatch as b2, type KernelMode as b3, type KernelOptions as b4, type KernelOverlap as b5, type KernelPriority as b6, type KernelRouteReport as b7, KernelRouter as b8, type KernelServiceAudio as b9, NO_ENTITY as bA, NO_REF as bB, type NavStep as bC, type NearestFeatureOptions as bD, type Neighbours as bE, type OverlapInfo as bF, PathBatch as bG, type PathBatchDesc as bH, PickBatch as bI, type PickBatchDesc as bJ, type PickInfo as bK, type PrefetchDistance as bL, type PrefetchLevelDesc as bM, type PresetOptions as bN, Query as bO, type QueryOptions as bP, type QueryWhere as bQ, Queue as bR, ROTOR_COLLECTIVE as bS, ROTOR_CYCLIC_PITCH as bT, ROTOR_CYCLIC_ROLL as bU, ROTOR_ENGINE as bV, ROTOR_PEDAL as bW, RayBatch as bX, type RayBatchDesc as bY, type RayHitInfo as bZ, type Ref as b_, type KernelServiceChemistry as ba, type KernelServiceGraphics as bb, type KernelServiceSources as bc, type KernelServiceUi as bd, type KernelServiceVoxels as be, type KernelSet as bf, type KernelSettings as bg, type KernelSpawnReport as bh, type KernelSystemSpec as bi, KernelSystems as bj, type KernelTarget as bk, type KernelVoxel as bl, type KernelWork as bm, KernelWorld as bn, type KernelWorldPort as bo, type List as bp, MAX_AERO_TABLE as bq, MAX_CRAFT_WHEELS as br, MAX_FOILS as bs, MAX_HULL_POINTS as bt, MAX_HULL_RESOLUTION as bu, MAX_PREFETCH_LEVELS as bv, MAX_ROTORS as bw, MAX_THRUSTERS as bx, type MixDesc as by, NO_CHANNEL as bz, type PrefetchLayerDesc as c, cross as c$, type RotorDesc as c0, type RoutePin as c1, type Rows as c2, type ScalarField as c3, type ScalarName as c4, type SeaOptions as c5, type SlotsView as c6, type SoftCollider as c7, type SoftPlastic as c8, Status as c9, type Vec4View as cA, type VectorField as cB, type VoxelInfo as cC, WaterControls as cD, type WorldColliderOptions as cE, type WorldPackReader as cF, type WorldPrefetchOptions as cG, WorldStream as cH, type WorldStreamOptions as cI, type WorldStreamStats as cJ, WorldStreamer as cK, action as cL, add as cM, applyForce as cN, applyImpulse as cO, autoKernel as cP, behaviour as cQ, chemistryAt as cR, chooseDevice as cS, clamp as cT, compiledKernel as cU, computeLogLine as cV, condition as cW, configureKernels as cX, constant as cY, mix as cZ, mixWith as c_, type SweepHitInfo as ca, TELEMETRY_AIRSPEED as cb, TELEMETRY_ALPHA as cc, TELEMETRY_APPARENT_WIND as cd, TELEMETRY_BANK as ce, TELEMETRY_CLIMB as cf, TELEMETRY_CONTACTS as cg, TELEMETRY_GEAR as ch, TELEMETRY_GROUND_EFFECT as ci, TELEMETRY_PITCH as cj, TELEMETRY_PLANING as ck, TELEMETRY_ROTOR as cl, TELEMETRY_SPEED as cm, TELEMETRY_SPOOL as cn, TELEMETRY_STALLED as co, TELEMETRY_SUBMERGED as cp, TELEMETRY_THRUST as cq, type TableColumns as cr, type TableField as cs, type ThrusterDesc as ct, Transform as cu, type Vec2Columns as cv, type Vec2View as cw, type Vec3Columns as cx, type Vec3View as cy, type Vec4Columns as cz, type PrefetchItemDesc as d, spawn as d$, crossoverRows as d0, defineComponent as d1, despawn as d2, dev as d3, dist as d4, distSq as d5, div as d6, dot as d7, entityGeneration as d8, entityIndex as d9, overlap as dA, pick as dB, pickRows as dC, playClip as dD, playSound as dE, programDigest as dF, qaxis as dG, qconj as dH, qmul as dI, qrotate as dJ, queue as dK, rand01 as dL, raycast as dM, readList as dN, scale as dO, selector as dP, sequence as dQ, setAnchor as dR, setClipWeight as dS, setDefaultKernelEngine as dT, setIkTarget as dU, setInstance as dV, setInstanceColour as dW, setKernelWorld as dX, setVelocity as dY, setVoxel as dZ, smoothstep as d_, events as da, fields as db, flow as dc, flowCost as dd, groundHeight as de, hash32 as df, invert as dg, isKernel as dh, kernel as di, kernelMachine as dj, leaveBelowRows as dk, len as dl, lenSq as dm, lerp as dn, lineOfSight as dp, list as dq, listPool as dr, mul as ds, nativeTwinOf as dt, navNext as du, negate as dv, noise2 as dw, noise3 as dx, normalize as dy, onGpu as dz, Physics as e, spawnInto as e0, spawnOverflow as e1, sub as e2, sweep as e3, symbol as e4, voxelAt as e5, within as e6, worldPrefetchLayer as e7, type PhysicsOptions as f, type SoftBodyShape as g, type SoftBodyOptions as h, SoftBody as i, type EntityTableOptions as j, type f32 as k, vec3 as l, type Each as m, vec2 as n, type i32 as o, type Kernel as p, Selection as q, quat as r, NavPath as s, type CraftPresetName as t, type u32 as u, vec4 as v, type CraftBodyShape as w, type CraftDesc as x, type CraftTuning as y, Helicopter as z };