@voltro/plugin-rooms 0.0.0-stage → 0.87.0

package/dist/transform.d.ts

@@ -0,0 +1,692 @@
+import { Result } from 'effect';
+import { Schema } from 'effect';
+import { YieldableError } from 'effect/Cause';
+
+export declare interface AttachedEntity2D extends AttachedTransform2D {
+    readonly id: string;
+}
+
+export declare const AttachedTransform2D: Schema.Struct<{
+    readonly t: Schema.Struct<{
+        readonly x: Schema.Number;
+        readonly y: Schema.Number;
+        readonly rot: Schema.Number;
+        readonly vx: Schema.optional<Schema.Number>;
+        readonly vy: Schema.optional<Schema.Number>;
+    }>;
+    readonly owner: Schema.optional<Schema.String>;
+    readonly attachedTo: Schema.optional<Schema.String>;
+}>;
+
+export declare type AttachedTransform2D = (typeof AttachedTransform2D)["Type"];
+
+export declare interface AttachedTransformOptions {
+    readonly maxEntities?: number;
+    readonly maxDepth?: number;
+}
+
+export declare const attachTransform2D: (offered: AttachedEntity2D, parentId: string, local: Transform2D) => AttachedEntity2D;
+
+export declare const BallisticProjectile2D: Schema.Struct<{
+    readonly spawnTick: Schema.Int;
+    readonly x: Schema.Number;
+    readonly y: Schema.Number;
+    readonly rot: Schema.Number;
+    readonly vx: Schema.Number;
+    readonly vy: Schema.Number;
+    readonly ax: Schema.Number;
+    readonly ay: Schema.Number;
+}>;
+
+export declare type BallisticProjectile2D = (typeof BallisticProjectile2D)["Type"];
+
+/** Capture native functions only when explicitly requested in a browser. */
+export declare const browserRoomAnimationFrames: () => RoomAnimationFramePort;
+
+/** Deterministic discrete collision helper; it never accepts player positions.
+ * Static tiles and dynamic bodies share the server-owned bounded broadphase.
+ * Continuous movement/world-geometry integration remains a separate layer. */
+export declare const collide: (transform: Transform2D, body: CollisionBody2D, world: CollisionWorld2D, exclude?: string) => CollisionResult2D;
+
+export declare type CollisionBody2D = {
+    readonly kind: 'circle';
+    readonly radius: number;
+} | {
+    readonly kind: 'aabb';
+    readonly halfWidth: number;
+    readonly halfHeight: number;
+};
+
+export declare interface CollisionEntity2D {
+    readonly position: SpatialPoint2D;
+    readonly body: CollisionBody2D;
+    readonly solid: boolean;
+}
+
+export declare interface CollisionResult2D {
+    readonly transform: Transform2D;
+    readonly collided: ReadonlyArray<string>;
+    readonly iterations: number;
+}
+
+/** Default world provider validates extents at insertion, before broadphase can
+ * hide an oversized body. Position has one source for geometry and cell keys. */
+export declare const collisionWorld: (options: SpatialGridOptions & {
+    readonly maxObstacleRadius: number;
+    readonly maxIterations: number;
+}) => Readonly<{
+    maxObstacleRadius: number;
+    maxIterations: number;
+    set: (id: string, entity: CollisionEntity2D) => void;
+    delete: (id: string) => boolean;
+    get: (id: string) => CollisionEntity2D | undefined;
+    nearby: (position: SpatialPoint2D, radius: number) => readonly {
+        readonly id: string;
+        readonly value: CollisionEntity2D;
+        readonly distance: number;
+    }[];
+}>;
+
+export declare interface CollisionWorld2D {
+    /** Maximum circumscribed obstacle radius, supplied by the world owner. */
+    readonly maxObstacleRadius: number;
+    readonly maxIterations: number;
+    nearby(position: SpatialPoint2D, radius: number): ReadonlyArray<{
+        readonly id: string;
+        readonly value: CollisionEntity2D;
+    }>;
+}
+
+/** Fixed little-endian 2-bit index + three unsigned quantized components. */
+export declare const decodeQuaternionSmallestThree: (bytes: Uint8Array, bits?: number) => Result.Result<QuaternionComponents, ProtocolError>;
+
+export declare const dequantize: (value: number, options: Quantization) => number;
+
+export declare const detachTransform2D: (offered: AttachedEntity2D, world: Transform2D) => AttachedEntity2D;
+
+/** Canonical hemisphere of a normalized rotation. No position/physics authority. */
+export declare const encodeQuaternionSmallestThree: (value: QuaternionComponents, bits?: number) => Result.Result<Uint8Array, ProtocolError>;
+
+export declare const fieldId: (id: number) => <S extends Schema.Codec<unknown, unknown>>(schema: S) => S;
+
+export declare const interpolate: (mode?: "linear" | "angle" | "none") => <S extends Schema.Codec<unknown, unknown>>(schema: S) => S;
+
+export declare const interpolateTransform2D: (a: Transform2D, b: Transform2D, fraction: number, durationSeconds: number, mode: TransformRules2D["interpolation"], deriveVelocity?: boolean) => Transform2D;
+
+/** Presentation-only interpolation. Position uses linear/Hermite; rotation uses
+ * shortest-arc normalized slerp. Optional endpoint velocities are local derived
+ * presentation data, never added to the seven-component wire transform. */
+export declare const interpolateTransform3D: (from: Transform3D, to: Transform3D, fraction: number, durationSeconds: number, mode: TransformRules3D["interpolation"], velocityFrom?: TransformVelocity3D, velocityTo?: TransformVelocity3D) => Transform3D;
+
+export declare const precision: (format: "f32" | "f64") => <S extends Schema.Codec<unknown, unknown>>(schema: S) => S;
+
+export declare interface PredictedInput<I> {
+    readonly seq: number;
+    readonly input: I;
+    readonly dt: number;
+}
+
+declare class ProtocolError extends ProtocolError_base {
+    get message(): string;
+}
+
+declare const ProtocolError_base: Schema.Class<ProtocolError, Schema.TaggedStruct<"ProtocolError", {
+    readonly detail: Schema.String;
+}>, YieldableError>;
+
+export declare interface Quantization {
+    readonly min: number;
+    readonly max: number;
+    readonly step?: number | undefined;
+    readonly bits?: number | undefined;
+}
+
+export declare const quantizationStep: (options: Quantization) => number;
+
+export declare const quantize: (value: number, options: Quantization) => number;
+
+export declare const quantized: (options: Quantization) => <S extends Schema.Codec<unknown, unknown>>(schema: S) => S;
+
+export declare const quaternionByteLength: (bits?: number) => number;
+
+export declare interface QuaternionComponents {
+    readonly qx: number;
+    readonly qy: number;
+    readonly qz: number;
+    readonly qw: number;
+}
+
+/** Resolve only the supplied server/player-projected graph. Parent-relative
+ * poses rotate/translate and compose linear velocities. No angular-velocity
+ * physics, hidden parent lookup or automatic prediction binding is implied. */
+export declare const resolveAttachedTransforms2D: (offered: ReadonlyArray<AttachedEntity2D>, options?: AttachedTransformOptions) => ReadonlyArray<ResolvedAttachedEntity2D>;
+
+export declare interface ResolvedAttachedEntity2D {
+    readonly id: string;
+    readonly owner: string | null;
+    readonly t: Transform2D;
+}
+
+/** One owned animation request or accepted callback; no borrowed resource close. */
+export declare class RoomAnimationFrameLoop {
+    private readonly request;
+    private readonly cancel;
+    private readonly onFrame;
+    private ticket;
+    private callbackTask;
+    private closingTask;
+    private running;
+    private closing;
+    private closed;
+    private currentError;
+    constructor(onFrame: (localTimeMs: number) => void | Promise<void>, frames?: RoomAnimationFramePort);
+    get error(): unknown;
+    get status(): 'idle' | 'running' | 'failed' | 'closing' | 'closed';
+    start(): void;
+    private schedule;
+    close(): Promise<void>;
+}
+
+export declare interface RoomAnimationFramePort {
+    request(callback: (localTimeMs: number) => void): number;
+    cancel(id: number): void;
+}
+
+declare interface RoomClock {
+    now(): number;
+}
+
+declare interface RoomDeliveredState<S> {
+    readonly epoch: number;
+    readonly tick: number;
+    /** Local transport observation, not an authoritative server timestamp. */
+    readonly receivedAt: number;
+    readonly state: S;
+}
+
+export declare const RoomFieldId: unique symbol;
+
+export declare const RoomInterpolation: unique symbol;
+
+export declare const RoomPrecision: unique symbol;
+
+export declare const RoomQuantization: unique symbol;
+
+export declare const RoomTransform: unique symbol;
+
+/** Dimension-specific history binding over the shared bounded collection owner. */
+export declare class RoomTransformCollection2D<S> extends RoomTransformCollectionCore<S, Transform2D> {
+    constructor(source: RoomTransformSource2D<S>, options: RoomTransformCollectionOptions2D<S>);
+}
+
+/** Dimension-specific history binding over the shared bounded collection owner. */
+export declare class RoomTransformCollection3D<S> extends RoomTransformCollectionCore<S, Transform3D> {
+    constructor(source: RoomTransformSource3D<S>, options: RoomTransformCollectionOptions3D<S>);
+}
+
+/** Framework-free subscribed render history. It owns no transport, timers or
+ * authority, and projects only already delivered player-visible state. */
+declare class RoomTransformCollectionCore<S, T> {
+    private entries;
+    private epoch;
+    private tick;
+    private previous;
+    private jitter;
+    private currentError;
+    private closing;
+    private closed;
+    private closeTask;
+    private readonly read;
+    private readonly serverTime;
+    private readonly release;
+    private readonly select;
+    private readonly timeAtTick;
+    private readonly makeHistory;
+    private readonly capacity;
+    private readonly maxEntities;
+    private readonly minDelay;
+    private readonly maxDelay;
+    private readonly interval;
+    private readonly maxLossIntervals;
+    private readonly loss;
+    private readonly jitterWindow;
+    private readonly jitterMultiplier;
+    constructor(source: RoomTransformSource<S>, options: RoomTransformCollectionCoreOptions<S, T>, makeHistory: (capacity: number) => RoomTransformHistory<T>);
+    private reset;
+    private observe;
+    get error(): unknown;
+    delayMs(): number;
+    ids(): ReadonlyArray<string>;
+    renderTime(): number | null;
+    at(id: string, renderTimeMs?: number): RoomTransformSample<T> | null;
+    close(): Promise<void>;
+}
+
+declare interface RoomTransformCollectionCoreOptions<S, T> {
+    readonly select: (state: S) => ReadonlyArray<RoomTransformEntity<T>>;
+    /** Explicit server timeline; local receivedAt cannot substitute for this. */
+    readonly timeAtTick: (epoch: number, tick: number) => number;
+    readonly capacity: number;
+    readonly maxEntities: number;
+    readonly maxRetainedSnapshots: number;
+    readonly sendIntervalMs: number;
+    readonly minDelayMs?: number;
+    readonly maxDelayMs?: number;
+    readonly jitterWindow?: number;
+    readonly jitterMultiplier?: number;
+    /** Extra send intervals of delay at most, added for reported datagram loss (default 2): one per 10 % loss, rounded. */
+    readonly maxLossIntervals?: number;
+}
+
+export declare interface RoomTransformCollectionOptions2D<S> extends RoomTransformCollectionCoreOptions<S, Transform2D> {
+    readonly rules: TransformRules2D;
+}
+
+export declare interface RoomTransformCollectionOptions3D<S> extends RoomTransformCollectionCoreOptions<S, Transform3D> {
+    readonly rules: TransformRules3D;
+}
+
+declare interface RoomTransformEntity<T> {
+    readonly id: string;
+    readonly transform: T;
+    readonly teleport?: boolean;
+    /** Animation or other presentation data, sampled at the same history time. */
+    readonly data?: unknown;
+}
+
+export declare interface RoomTransformEntity2D {
+    readonly id: string;
+    readonly transform: Transform2D;
+    readonly teleport?: boolean;
+    readonly data?: unknown;
+}
+
+export declare interface RoomTransformEntity3D {
+    readonly id: string;
+    readonly transform: Transform3D;
+    readonly teleport?: boolean;
+    readonly data?: unknown;
+}
+
+export declare interface RoomTransformFrame2D {
+    readonly localTimeMs: number;
+    readonly serverTimeMs: number | null;
+    readonly entities: ReadonlyArray<{
+        readonly id: string;
+        readonly sample: RoomTransformSample2D;
+    }>;
+}
+
+export declare interface RoomTransformFrame3D {
+    readonly localTimeMs: number;
+    readonly serverTimeMs: number | null;
+    readonly entities: ReadonlyArray<{
+        readonly id: string;
+        readonly sample: RoomTransformSample3D;
+    }>;
+}
+
+/** Shared scheduler with a single captured server render time for all entities. */
+export declare class RoomTransformFrameLoop2D extends RoomAnimationFrameLoop {
+    constructor(view: RoomTransformView2D, onFrame: (frame: RoomTransformFrame2D) => void | Promise<void>, frames?: RoomAnimationFramePort);
+}
+
+/** Same scheduler/cleanup and one captured server time for 3D presentation. */
+export declare class RoomTransformFrameLoop3D extends RoomAnimationFrameLoop {
+    constructor(view: RoomTransformView3D, onFrame: (frame: RoomTransformFrame3D) => void | Promise<void>, frames?: RoomAnimationFramePort);
+}
+
+declare interface RoomTransformHistory<T> {
+    copy(): RoomTransformHistory<T>;
+    push(snapshot: {
+        readonly tick: number;
+        readonly timeMs: number;
+        readonly transform: T;
+        readonly teleport: boolean;
+    }): boolean;
+    at(timeMs: number): {
+        readonly transform: T;
+        readonly stale: boolean;
+    } | null;
+}
+
+declare interface RoomTransformSample<T> {
+    readonly epoch: number;
+    readonly tick: number;
+    readonly transform: T;
+    readonly stale: boolean;
+    readonly data?: unknown;
+}
+
+export declare interface RoomTransformSample2D {
+    readonly epoch: number;
+    readonly tick: number;
+    readonly transform: Transform2D;
+    readonly stale: boolean;
+    readonly data?: unknown;
+}
+
+export declare interface RoomTransformSample3D {
+    readonly epoch: number;
+    readonly tick: number;
+    readonly transform: Transform3D;
+    readonly stale: boolean;
+    readonly data?: unknown;
+}
+
+declare interface RoomTransformSource<S> {
+    deliveredSnapshot(): RoomDeliveredState<S> | null;
+    serverNow(): number | null;
+    subscribe(listener: () => void): () => void | Promise<void>;
+    /** Estimated datagram loss (0–1, null until measured); a lossy client buffers longer. */
+    readonly lossRate?: number | null;
+}
+
+export declare interface RoomTransformSource2D<S> {
+    deliveredSnapshot(): RoomDeliveredState<S> | null;
+    serverNow(): number | null;
+    subscribe(listener: () => void): () => void | Promise<void>;
+    /** Estimated datagram loss (0–1, null until measured); a lossy client buffers longer. */
+    readonly lossRate?: number | null;
+}
+
+export declare interface RoomTransformSource3D<S> {
+    deliveredSnapshot(): RoomDeliveredState<S> | null;
+    serverNow(): number | null;
+    subscribe(listener: () => void): () => void | Promise<void>;
+    /** Estimated datagram loss (0–1, null until measured); a lossy client buffers longer. */
+    readonly lossRate?: number | null;
+}
+
+export declare interface RoomTransformView2D {
+    ids(): ReadonlyArray<string>;
+    renderTime(): number | null;
+    at(id: string, renderTimeMs: number): RoomTransformSample2D | null;
+}
+
+export declare interface RoomTransformView3D {
+    ids(): ReadonlyArray<string>;
+    renderTime(): number | null;
+    at(id: string, renderTimeMs: number): RoomTransformSample3D | null;
+}
+
+/** Constant acceleration from one server-owned spawn. Both sides compute the
+ * same pure pose; this helper has no hit authority, clock, RNG or persistence. */
+export declare const sampleBallisticProjectile2D: (projectile: BallisticProjectile2D, tick: number, tickRate: number) => Transform2D;
+
+/** Server authors update ordinary state with these detached values. Neither
+ * helper admits a player-supplied owner, parent or world pose. */
+export declare const setTransformOwner2D: (offered: AttachedEntity2D, owner: string | null) => AttachedEntity2D;
+
+export declare const spatialGrid: <A>(options: SpatialGridOptions) => SpatialGrid2D<A>;
+
+/** Bounded, deterministic in-memory spatial index. No persistence or timers. */
+export declare class SpatialGrid2D<A> {
+    private readonly entities;
+    private readonly cells;
+    readonly options: SpatialGridOptions;
+    constructor(options: SpatialGridOptions);
+    private coordinate;
+    key(position: SpatialPoint2D): string;
+    set(id: string, position: SpatialPoint2D, value: A): void;
+    private removeFromCell;
+    delete(id: string): boolean;
+    get(id: string): A | undefined;
+    nearby(position: SpatialPoint2D, radius: number, maxResults?: number): ReadonlyArray<{
+        readonly id: string;
+        readonly value: A;
+        readonly distance: number;
+    }>;
+    size(): number;
+    cellCount(): number;
+    clear(): void;
+}
+
+export declare interface SpatialGridOptions {
+    readonly cell: number;
+    readonly maxEntities: number;
+    readonly maxQueryCells: number;
+}
+
+/** Server-owned membership hysteresis; players supply neither the view nor its
+ * retained IDs. A hard entity budget resolves ties by distance, then id. */
+export declare class SpatialInterest2D<A> {
+    readonly grid: SpatialGrid2D<A>;
+    readonly radius: number;
+    readonly hysteresis: number;
+    readonly maxEntities: number;
+    private visible;
+    constructor(grid: SpatialGrid2D<A>, radius: number, hysteresis: number, maxEntities: number);
+    update(position: SpatialPoint2D): {
+        readonly entities: ReadonlyArray<{
+            readonly id: string;
+            readonly value: A;
+            readonly distance: number;
+        }>;
+        readonly entered: ReadonlyArray<string>;
+        readonly left: ReadonlyArray<string>;
+    };
+}
+
+export declare interface SpatialPoint2D {
+    readonly x: number;
+    readonly y: number;
+}
+
+/** Pure shared movement helper; a direction can never multiply movement speed. */
+export declare const stepTransform2D: (t: Transform2D, input: {
+    readonly dx: number;
+    readonly dy: number;
+}, dt: number, rules: TransformRules2D) => Transform2D;
+
+/** One captured static grid and the existing bounded dynamic broadphase. */
+export declare const tileCollisionWorld2D: (options: TileCollisionWorldOptions2D) => Readonly<{
+    maxObstacleRadius: number;
+    maxIterations: number;
+    set: (id: string, entity: CollisionEntity2D) => void;
+    delete: (id: string) => boolean;
+    get: (id: string) => CollisionEntity2D | undefined;
+    nearby: (position: SpatialPoint2D, radius: number) => readonly {
+        readonly id: string;
+        readonly value: CollisionEntity2D;
+        readonly distance: number;
+    }[];
+}>;
+
+export declare interface TileCollisionWorldOptions2D extends SpatialGridOptions {
+    readonly origin: SpatialPoint2D;
+    readonly tileSize: number;
+    readonly width: number;
+    readonly height: number;
+    /** Dense row-major occupancy, supplied by the world owner, never by an input. */
+    readonly solid: ReadonlyArray<boolean>;
+    readonly maxTiles: number;
+    readonly maxObstacleRadius: number;
+    readonly maxIterations: number;
+}
+
+export declare const transform: (rules: TransformRules) => <S extends Schema.Codec<unknown, unknown>>(schema: S) => S;
+
+export declare const Transform2D: Schema.Struct<{
+    readonly x: Schema.Number;
+    readonly y: Schema.Number;
+    readonly rot: Schema.Number;
+    readonly vx: Schema.optional<Schema.Number>;
+    readonly vy: Schema.optional<Schema.Number>;
+}>;
+
+export declare type Transform2D = (typeof Transform2D)["Type"];
+
+export declare const Transform3D: Schema.Struct<{
+    readonly x: Schema.Number;
+    readonly y: Schema.Number;
+    readonly z: Schema.Number;
+    readonly qx: Schema.Number;
+    readonly qy: Schema.Number;
+    readonly qz: Schema.Number;
+    readonly qw: Schema.Number;
+}>;
+
+export declare type Transform3D = (typeof Transform3D)["Type"];
+
+/** Bounded shared history for rendering and server-side rewind. */
+export declare class TransformHistory2D {
+    readonly capacity: number;
+    private readonly snapshots;
+    readonly rules: TransformRules2D;
+    constructor(capacity: number, rules: TransformRules2D);
+    copy(): TransformHistory2D;
+    push(snapshot: TransformSnapshot2D): boolean;
+    at(timeMs: number): (Transform2D & {
+        readonly stale: boolean;
+    }) | null;
+}
+
+/** Bounded renderer history, without physics authority. Velocity derives from
+ * position snapshots; extrapolation holds the last rotation and freezes after
+ * the declared position horizon. The wire schema and hashes are unchanged. */
+export declare class TransformHistory3D {
+    readonly capacity: number;
+    private readonly snapshots;
+    readonly rules: TransformRules3D;
+    constructor(capacity: number, rules: TransformRules3D);
+    copy(): TransformHistory3D;
+    push(snapshot: TransformSnapshot3D): boolean;
+    at(timeMs: number): (Transform3D & {
+        readonly stale: boolean;
+    }) | null;
+}
+
+/** Replays unacknowledged intentions from the server state, never from a client claim. */
+export declare class TransformPrediction2D<I, R> {
+    private readonly step;
+    readonly capacity: number;
+    private readonly pending;
+    private predicted;
+    private lastSeq;
+    private lastAck;
+    private readonly rules;
+    constructor(initial: Transform2D, rules: R, step: TransformStep<I, R>, capacity: number);
+    send(seq: number, input: I, dt: number): Transform2D;
+    reconcile(lastAppliedSeq: number, authoritative: Transform2D): Transform2D;
+    state(): Transform2D;
+    queued(): number;
+}
+
+/** Correct simulation immediately; decay only the detached presentation offset. */
+export declare class TransformRenderPrediction2D<I, R> {
+    private readonly prediction;
+    private readonly now;
+    private readonly threshold;
+    private readonly blendMs;
+    private lastTime;
+    private lastAck;
+    private correctionAt;
+    private offset;
+    constructor(initial: Transform2D, rules: R, step: TransformStep<I, R>, options: TransformRenderPredictionOptions);
+    private time;
+    private at;
+    send(seq: number, input: I, dt: number): Transform2D;
+    reconcile(lastAppliedSeq: number, authoritative: Transform2D, teleport?: boolean): Transform2D;
+    state(): Transform2D;
+    render(): Transform2D;
+    queued(): number;
+}
+
+/** Immediate simulation correction with detached positional/quaternion render
+ * offsets. Pure author step runs only on demand; no transport or frame owner. */
+export declare class TransformRenderPrediction3D<I, R> {
+    private pending;
+    private predicted;
+    private readonly rules;
+    private readonly step;
+    private readonly now;
+    private readonly capacity;
+    private readonly threshold;
+    private readonly blendMs;
+    private lastTime;
+    private lastSeq;
+    private lastAck;
+    private correctionAt;
+    private offset;
+    private rotationOffset;
+    private operation;
+    constructor(initial: Transform3D, rules: R, step: TransformStep3D<I, R>, options: TransformRenderPredictionOptions);
+    private enter;
+    private time;
+    private at;
+    send(seq: number, input: I, dt: number): Transform3D;
+    reconcile(lastAppliedSeq: number, authoritative: Transform3D, teleport?: boolean): Transform3D;
+    state(): Transform3D;
+    render(): Transform3D;
+    queued(): number;
+}
+
+export declare interface TransformRenderPredictionOptions {
+    readonly clock: RoomClock;
+    readonly capacity: number;
+    readonly teleportThreshold: number;
+    /** Author-selected render budget, not a measured latency guarantee. */
+    readonly correctionBlendMs?: number;
+}
+
+export declare type TransformRules = TransformRules2D | TransformRules3D;
+
+export declare interface TransformRules2D {
+    readonly bounds: {
+        readonly min: readonly [number, number];
+        readonly max: readonly [number, number];
+    };
+    readonly maxSpeed: number;
+    readonly maxAccel: number;
+    readonly precision: number;
+    readonly rotation?: {
+        readonly bits: number;
+    } | undefined;
+    readonly velocity?: 'send' | 'derive' | 'none' | undefined;
+    readonly interpolation: 'linear' | 'hermite' | 'none';
+    readonly extrapolateMs: number;
+    readonly teleportThreshold: number;
+}
+
+export declare interface TransformRules3D {
+    readonly bounds: {
+        readonly min: readonly [number, number, number];
+        readonly max: readonly [number, number, number];
+    };
+    readonly maxSpeed: number;
+    readonly maxAccel: number;
+    readonly precision: number;
+    readonly rotation?: {
+        readonly bits: number;
+    } | undefined;
+    readonly interpolation: 'linear' | 'hermite' | 'none';
+    readonly extrapolateMs: number;
+    readonly teleportThreshold: number;
+}
+
+export declare interface TransformSnapshot2D {
+    readonly tick: number;
+    readonly timeMs: number;
+    readonly transform: Transform2D;
+    readonly teleport: boolean;
+}
+
+export declare interface TransformSnapshot3D {
+    readonly tick: number;
+    readonly timeMs: number;
+    readonly transform: Transform3D;
+    readonly teleport: boolean;
+}
+
+export declare type TransformStep<I, R> = (state: Transform2D, input: I, dt: number, rules: R) => Transform2D;
+
+export declare type TransformStep3D<I, R> = (state: Transform3D, input: I, dt: number, rules: R) => Transform3D;
+
+export declare interface TransformVelocity3D {
+    readonly x: number;
+    readonly y: number;
+    readonly z: number;
+}
+
+export { }