@irtio/runtime 4.3.0 → 4.4.0

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 export { A as AdmissionError, D as DEFAULT_RECORDS_PER_COLLECTION, a as DEFAULT_TIMELINE_MAX_RECORDS, b as DEFAULT_TIMELINE_MAX_TICKS, E as EVENT_RING_SIZE, H as HOST_CALL_TIMEOUT_MS, c as HostCall, d as HostCallResult, J as JoinOptions, e as JoinResult, L as LogLevel, P as PHYSICS_STEP_EMA_ALPHA, R as RELAY_RECORDS_PER_COLLECTION, f as RELAY_STATE_BYTES, g as RELAY_WRITES_PER_SECOND, h as RELAY_WRITE_CAPS, i as RPC_TRACE_SIZE, j as RPC_TRACE_SUMMARY_MAX, k as RoomCoreApi, l as RoomCoreOptions, m as RoomEvent, n as RoomEventKind, o as RoomFullError, p as RoomHost, q as RoomInspection, r as RoomStats, s as RpcOutcome, t as RpcTraceDump, u as RpcTraceEntry, v as RpcTraceRing, S as StampLag, T as TimelineDump, w as TimelineFrame, x as TimelineRecorder, y as TimelineRecorderOptions, W as WriteCaps, z as inspectState, B as summarizeRpcResult } from './contract-DHWlURaq.js';
-export { C as CRASH_AFTER_THROWS, M as MAX_CATCHUP, a as MatterBodyRecord, b as MatterSection, c as Mulberry32, P as PhysicsEngineTag, d as PhysicsSection, R as RoomCore, e as decodeMatterBodies, f as decodeMatterSectionEnvelope, g as decodePhysicsSection, h as decodeRapier2dSectionEnvelope, i as encodeMatterBodies, j as encodeMatterSectionEnvelope, k as encodePhysicsSection, l as encodeRapier2dSectionEnvelope, m as initMatter, n as initPhysics, o as initRapier2d, p as loadedMatter, q as loadedPhysics, r as loadedRapier2d, s as physicsSectionEngine, t as resetMatterForTests, u as resetPhysicsForTests, v as resetRapier2dForTests } from './room-Bpo_nqlO.js';
+export { C as CRASH_AFTER_THROWS, M as MAX_CATCHUP, a as MatterBodyRecord, b as MatterSection, c as Mulberry32, P as PhysicsEngineTag, d as PhysicsSection, R as RoomCore, e as decodeMatterBodies, f as decodeMatterSectionEnvelope, g as decodePhysicsSection, h as decodeRapier2dSectionEnvelope, i as encodeMatterBodies, j as encodeMatterSectionEnvelope, k as encodePhysicsSection, l as encodeRapier2dSectionEnvelope, m as initMatter, n as initPhysics, o as initRapier2d, p as loadedMatter, q as loadedPhysics, r as loadedRapier2d, s as physicsSectionEngine, t as resetMatterForTests, u as resetPhysicsForTests, v as resetRapier2dForTests } from './room-BYhsLgQV.js';
 import { CollectionDesc, AnySchema, PlainState, DirtySet } from '@irtio/schema';
 import '@irtio/protocol';
 import '@irtio/server';
@@ -155,7 +155,7 @@ interface DecodedSave extends SnapshotHeader {
      * there is no section at all. A pre-D45 blob has no discriminant and reads as `'rapier3d'`,
      * which is what it is.
      */
-    readonly physicsEngine: 'rapier3d' | 'matter2d' | 'rapier2d' | undefined;
+    readonly physicsEngine: 'rapier3d' | 'matter2d' | 'rapier2d' | 'custom' | undefined;
     /**
      * The room's authoritative state, in exactly the shape `inspectState` and the recorded
      * timeline use: entity collections as `{ id: { owner, value } }`, singletons as their value.

package/dist/index.js

@@ -2,7 +2,7 @@ import {
   fromMigrationState,
   migrateSnapshot,
   toMigrationState
-} from "./chunk-ZGJY4E3G.js";
+} from "./chunk-GK53BSWK.js";
 import {
   AdmissionError,
   CRASH_AFTER_THROWS,
@@ -59,7 +59,7 @@ import {
   visibleNames,
   visibleTo,
   writeHibernationBlob
-} from "./chunk-KJN62J37.js";
+} from "./chunk-JFC5BQ2N.js";
 export {
   AdmissionError,
   CRASH_AFTER_THROWS,

package/dist/{room-Bpo_nqlO.d.ts → room-BYhsLgQV.d.ts}

@@ -1,6 +1,6 @@
 import { PlatformNotice, AttributeOptions, ProfileSnapshot } from '@irtio/protocol';
 import { DirtySet, AnySchema, PlainState, Tracked, State } from '@irtio/schema';
-import { RoomDefinition, RoomMode, Room, RewindView, Ctx, MatterModule, MatterEngine, MatterBody, RapierModule, RapierWorld, RapierRigidBody, Rapier2dModule, Rapier2dWorld, Rapier2dRigidBody, ResolvedRoomConfig, LeaveReason } from '@irtio/server';
+import { RoomDefinition, RoomMode, Room, RewindView, Ctx, CustomStepper, CustomPose, MatterModule, MatterEngine, MatterBody, RapierModule, RapierWorld, RapierRigidBody, Rapier2dModule, Rapier2dWorld, Rapier2dRigidBody, ResolvedRoomConfig, LeaveReason } from '@irtio/server';
 import { p as RoomHost, r as RoomStats, u as RpcTraceEntry, L as LogLevel, k as RoomCoreApi, l as RoomCoreOptions, n as RoomEventKind, y as TimelineRecorderOptions, T as TimelineDump, t as RpcTraceDump, q as RoomInspection, J as JoinOptions, e as JoinResult, d as HostCallResult } from './contract-DHWlURaq.js';
 
 declare class Mulberry32 {
@@ -123,10 +123,29 @@ interface UnsyncedRegistry {
     keys(): IterableIterator<string>;
     [Symbol.iterator](): IterableIterator<readonly [string, unknown]>;
 }
+/**
+ * One body's pose in the thirteen canonical channels. Structurally `Pose` in `core/history.ts` and
+ * `CustomPose` in `@irtio/server`; restated here so this seam declares no dependency on either.
+ */
+interface PosePlain {
+    x: number;
+    y: number;
+    z: number;
+    qx: number;
+    qy: number;
+    qz: number;
+    qw: number;
+    vx: number;
+    vy: number;
+    vz: number;
+    wx: number;
+    wy: number;
+    wz: number;
+}
 /** What the core modules may do with the physics world (`core/physics.ts` implements it). */
 interface PhysicsApi {
-    /** D45: which of the blessed engines this room is running. */
-    readonly engineKind: 'rapier3d' | 'matter2d' | 'rapier2d';
+    /** D45: which engine this room is running. `'custom'` is the game's own stepper, not an engine. */
+    readonly engineKind: 'rapier3d' | 'matter2d' | 'rapier2d' | 'custom';
     readonly timestep: number;
     /** Creates bodies for new instances, destroys bodies whose instance is gone. */
     reconcile(): void;
@@ -147,6 +166,12 @@ interface PhysicsApi {
      * `bodyFor`, and it never hands out the map itself.
      */
     eachTrackedBody(fn: (collection: string, id: string, body: unknown, instance: Record<string, unknown>) => void): void;
+    /**
+     * D72: this runtime's own engine-neutral pose read, when it has one. The pose history prefers it
+     * over its per-engine switch, which is how an engine the history file knows nothing about — the
+     * custom stepper — gets rewind without `history.ts` gaining a branch that can read a body.
+     */
+    readPose?(body: unknown, out: PosePlain): void;
     /** rapier3d and rapier2d: the engine namespace. `engineKind` says which module it is. */
     readonly rapier: unknown;
     /** rapier3d and rapier2d: the live `World`. */
@@ -247,6 +272,99 @@ interface RoomInternals {
     invalidateClients(): void;
 }
 
+/**
+ * The fourth engine: the game's own, as a plain-function stepper.
+ *
+ * It sits in exactly the place `core/physics.ts` describes — reconcile, step, sync, between the
+ * `tick()` handler and the flush — and writes the same schema channels. What differs is that there
+ * is no engine underneath at all, and three consequences follow.
+ *
+ * ## There is nothing to load and nothing to snapshot
+ *
+ * No WASM, no module, no `init*()` before the room is constructed: `config.world(room)` builds the
+ * stepper out of code the bundle already has. And there is no world state to serialize — a custom
+ * room's physics section is a tag and no payload. A woken room rebuilds its bodies from schema
+ * state on the first reconcile, which is faithful to whatever the body channels carry, and loses
+ * whatever the stepper kept that the schema does not name. That is the same contract a matter2d
+ * room already lives under, said with less machinery.
+ *
+ * ## Intents are applied here, unlike the blessed engines
+ *
+ * `physics.intents` on a Rapier or matter2d room is a *naming*: the runtime never calls it and the
+ * room's `tick()` does. A stepper's `applyIntent` is different — the runtime runs it over every
+ * tracked body immediately before `step()`. The reason is that the shared-code argument is the
+ * whole of why the field exists, and the client's predictor already calls `applyIntent` per body
+ * per step; a server that left it to `tick()` would make "same code both sides" a thing the room
+ * author has to get right by hand, on the one engine where nothing else is checkable. A room that
+ * would rather steer from `tick()` simply does not define `applyIntent`.
+ *
+ * ## Poses are the whole seam
+ *
+ * `readPose`/`writePose` speak the thirteen canonical channels by name, so `sync()` is a copy and
+ * the pose history needs no engine-specific reader — which is what makes `room.rewind` work here
+ * for free. See `core/history.ts`.
+ */
+
+interface CustomRuntimeOptions {
+    readonly defaultTimestep: number;
+}
+declare class CustomRuntime {
+    readonly engineKind: "custom";
+    /** The three blessed-engine handles, present so every runtime satisfies one internal shape. */
+    readonly rapier: undefined;
+    readonly world: undefined;
+    readonly matter: undefined;
+    readonly matterEngine: undefined;
+    /** Always: a custom room has no world snapshot, so its bodies are always rebuilt from state. */
+    readonly rebuilt = true;
+    readonly needsSetup = false;
+    private readonly core;
+    private readonly config;
+    private readonly collections;
+    private readonly stepSeconds;
+    private readonly bodies;
+    /** See `PhysicsRuntime.sourceRecords`: identity, so a pooled re-add rebuilds its body. */
+    private readonly sourceRecords;
+    private readonly skippedKeys;
+    private readonly scratch;
+    private stepper;
+    /**
+     * M7 pf3 (a): a custom room's unsynced bodies are the stepper's own — it created them, it steps
+     * them, and nothing here knows what one is — so the registry keeps names for them and calls no
+     * engine. It does not survive hibernation, for the same reason nothing else here does.
+     */
+    private readonly unsyncedBodies;
+    readonly unsynced: UnsyncedRegistry;
+    constructor(core: RoomInternals, options: CustomRuntimeOptions);
+    get timestep(): number;
+    /**
+     * Builds the stepper. Named `runSetup` because that is the hook `RoomCore` calls at the same
+     * point for every engine; for this one it is the world's construction and not a hook on top of
+     * one, which is why it runs before the first reconcile rather than optionally.
+     */
+    runSetup(room: Room): void;
+    free(): void;
+    /** `room.physicsCustom.stepper`. Throws rather than handing back `undefined` half a world. */
+    get liveStepper(): CustomStepper;
+    setSkipped(collection: string, id: string, on: boolean): void;
+    isSkipped(collection: string, id: string): boolean;
+    bodyFor(collection: string, id: string): object | undefined;
+    private create;
+    /** The schema's mapped channels, written onto the body over whatever it already held. */
+    private applyRecordToBody;
+    eachTrackedBody(fn: (collection: string, id: string, body: object, instance: Record<string, unknown>) => void): void;
+    /**
+     * D72's engine-neutral pose read, implemented rather than switched on. The history ring prefers
+     * this hook when a runtime carries one, which is what keeps `core/history.ts` from having to
+     * know what a custom body is.
+     */
+    readPose(body: unknown, out: CustomPose): void;
+    reconcile(): void;
+    step(): void;
+    /** Body → schema, through the tracked proxies, `Math.fround`ed for f32 fields as Rapier's is. */
+    sync(): void;
+}
+
 /**
  * Scheduling: the tick-mode fixed-step loop with catch-up, event-mode idle detection, and
  * `room.setTimeout` / `room.setInterval`.
@@ -617,7 +735,7 @@ declare function encodePhysicsSection(section: PhysicsSection): Uint8Array;
  * pre-D45 blob is therefore byte-identical and reads as Rapier without a version bump, which is
  * what the recommendation in the plan asked for and why format 3 was not needed.
  */
-type PhysicsEngineTag = 'rapier3d' | 'matter2d' | 'rapier2d';
+type PhysicsEngineTag = 'rapier3d' | 'matter2d' | 'rapier2d' | 'custom';
 /**
  * Reads the engine out of an encoded section without decoding the rest of it.
  *
@@ -941,7 +1059,7 @@ declare class RoomCore<S extends AnySchema = AnySchema> implements RoomCoreApi<S
      * where an unsynced body belongs — it is static geometry with a handle — and it is the only
      * place a matter2d room can put one and have it come back after a wake.
      */
-    physics: PhysicsRuntime | MatterRuntime | Rapier2dRuntime | undefined;
+    physics: PhysicsRuntime | MatterRuntime | Rapier2dRuntime | CustomRuntime | undefined;
     readonly stats: RoomStats;
     tick: number;
     stopped: boolean;
@@ -1049,6 +1167,12 @@ declare class RoomCore<S extends AnySchema = AnySchema> implements RoomCoreApi<S
      * again. The only thing that differs from `buildPhysics` is which engine and which envelope.
      */
     private buildRapier2d;
+    /**
+     * The custom half. There is no engine to check for, no world to restore and no `setup` beyond
+     * building the stepper itself, so this is the shortest of the four: build it, say so if a blob
+     * arrived carrying somebody else's world, reconcile the bodies out of schema state.
+     */
+    private buildCustom;
     /** Convenience for hosts: `RoomCore.restore(def, bytes, host, opts)`. */
     static restore<S2 extends AnySchema>(definition: RoomDefinition<S2>, bytes: Uint8Array, host: RoomHost, options: Omit<RoomCoreOptions, 'restoreFrom'>): RoomCore<S2>;
     get schema(): S;

package/dist/test/index.d.ts

@@ -1,5 +1,5 @@
-import { R as RoomCore } from '../room-Bpo_nqlO.js';
-export { m as initMatter, n as initPhysics, o as initRapier2d } from '../room-Bpo_nqlO.js';
+import { R as RoomCore } from '../room-BYhsLgQV.js';
+export { m as initMatter, n as initPhysics, o as initRapier2d } from '../room-BYhsLgQV.js';
 import { ErrorCodeName, FrameType } from '@irtio/protocol';
 import { NpcConfig, LeaveReason, Room, RoomDefinition } from '@irtio/server';
 import { p as RoomHost, L as LogLevel, k as RoomCoreApi, c as HostCall, d as HostCallResult, W as WriteCaps, r as RoomStats } from '../contract-DHWlURaq.js';

package/dist/test/index.js

@@ -6,7 +6,7 @@ import {
   initRapier2d,
   isPerClient,
   visibleNames
-} from "../chunk-KJN62J37.js";
+} from "../chunk-JFC5BQ2N.js";
 
 // src/test/clock.ts
 var FakeClock = class {

package/dist/worker/index.js

@@ -1,6 +1,6 @@
 import {
   migrateSnapshot
-} from "../chunk-ZGJY4E3G.js";
+} from "../chunk-GK53BSWK.js";
 import {
   AdmissionError,
   RoomCore,
@@ -10,7 +10,7 @@ import {
   initRapier2d,
   onFirstRapierStep,
   rapierHasStepped
-} from "../chunk-KJN62J37.js";
+} from "../chunk-JFC5BQ2N.js";
 
 // src/worker/index.ts
 import { getHeapStatistics } from "v8";
@@ -157,7 +157,8 @@ async function handleMessage(state, host, post, msg) {
         }
         if (def.config.physics) {
           try {
-            if (def.config.physics.engine === "matter2d") await initMatter();
+            if (def.config.physics.engine === "custom") {
+            } else if (def.config.physics.engine === "matter2d") await initMatter();
             else {
               if (def.config.physics.engine === "rapier2d") await initRapier2d();
               else await initPhysics();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@irtio/runtime",
-  "version": "4.3.0",
+  "version": "4.4.0",
   "description": "irtio room runtime: RoomCore, worker_threads host, in-process test harness",
   "license": "MIT",
   "repository": {
@@ -36,9 +36,9 @@
     "@dimforge/rapier2d-compat": "0.20.0",
     "@dimforge/rapier3d-compat": "0.20.0",
     "matter-js": "0.20.0",
-    "@irtio/protocol": "^4.3.0",
-    "@irtio/schema": "^4.3.0",
-    "@irtio/server": "^4.3.0"
+    "@irtio/protocol": "^4.4.0",
+    "@irtio/schema": "^4.4.0",
+    "@irtio/server": "^4.4.0"
   },
   "devDependencies": {
     "@types/matter-js": "0.20.2"