@irtio/runtime 0.1.0 → 0.2.0

package/dist/test/index.js

@@ -1,7 +1,9 @@
 import {
   RoomCore,
+  createVisibilityPolicy,
+  initPhysics,
   visibleNames
-} from "../chunk-X5S364FY.js";
+} from "../chunk-GKMD3ICD.js";
 
 // src/test/clock.ts
 var FakeClock = class {
@@ -66,6 +68,32 @@ var HarnessHost = class {
   /** Set by the harness: where an outbound frame goes. */
   onSend = () => {
   };
+  /**
+   * The core this host answers. Set by whoever built the pair — the host has to call back into
+   * `completeHostCall`/`fireAlarm`, which runs in the same direction `receive()` does.
+   */
+  core;
+  /** Every `room.save()` / `room.kv.*` the room asked for, in order. */
+  hostCalls = [];
+  /** Fake ms between a host call and its answer. 0 still means "a later event", not "inline". */
+  hostCallDelayMs = 0;
+  /** The in-memory player KV, keyed the way the real table's composite primary key is. */
+  kv = /* @__PURE__ */ new Map();
+  /** Save generations this host minted: `saveId` -> the bytes it was handed. */
+  saves = /* @__PURE__ */ new Map();
+  /** What `room.save()` serializes. The harness sets it to `() => core.snapshot()` — the bytes
+   *  without hibernation's side effects, exactly as the supervisor asks for them. */
+  serializeForSave;
+  /**
+   * Override the host-call backend. Return `undefined` to fall through to the built-in in-memory
+   * one; return a result to answer it yourself — how the limit and outage tests are written.
+   */
+  handleHostCall;
+  nextSaveId = 1;
+  /** D26: armed alarms, `name` -> due time on the fake clock. Host state, never room state. */
+  armedAlarms = /* @__PURE__ */ new Map();
+  /** Every alarm that fired, in order, as `name@dueMs`. */
+  firedAlarms = [];
   /** `true` once the runtime has asked to hibernate at least once. */
   get slept() {
     return this.sleeps > 0;
@@ -110,11 +138,76 @@ var HarnessHost = class {
   crashed(reason) {
     this.crashes.push(reason);
   }
+  // -------------------------------------------------------------------------
+  // Week 12: host calls (D24 save, D25 KV)
+  // -------------------------------------------------------------------------
+  hostCall(reqId, call) {
+    this.hostCalls.push({ reqId, call });
+    this.clock.setTimeout(() => {
+      const result = this.handleHostCall?.(call) ?? this.runHostCall(call);
+      this.core?.completeHostCall(reqId, result);
+    }, this.hostCallDelayMs);
+  }
+  runHostCall(call) {
+    switch (call.kind) {
+      case "save": {
+        const serialize = this.serializeForSave;
+        if (!serialize) {
+          return { ok: false, code: "E_SAVE_UNSUPPORTED", message: "no serializer wired" };
+        }
+        const saveId = String(this.nextSaveId++).padStart(6, "0");
+        this.saves.set(saveId, serialize());
+        return { ok: true, value: saveId };
+      }
+      case "kvGet": {
+        const value = this.kv.get(kvKey(call.playerId, call.key));
+        return value === void 0 ? { ok: true } : { ok: true, value };
+      }
+      case "kvSet":
+        this.kv.set(kvKey(call.playerId, call.key), call.value);
+        return { ok: true };
+      case "kvDelete":
+        this.kv.delete(kvKey(call.playerId, call.key));
+        return { ok: true };
+    }
+  }
+  // -------------------------------------------------------------------------
+  // Week 12: durable alarms (D26)
+  // -------------------------------------------------------------------------
+  setAlarm(name, atMs) {
+    if (atMs === void 0) this.armedAlarms.delete(name);
+    else this.armedAlarms.set(name, atMs);
+  }
+  /**
+   * Fires every alarm due at or before `now`, in **name order** (D34 determinism), removing each
+   * before it runs so a handler that re-arms its own name arms the *next* one rather than having
+   * this pass cancel it straight back out.
+   */
+  fireDue(now = this.clock.now()) {
+    const due = [...this.armedAlarms.entries()].filter(([, at]) => at <= now).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0);
+    const fired = [];
+    for (const [name, at] of due) {
+      this.armedAlarms.delete(name);
+      this.firedAlarms.push(`${name}@${at}`);
+      fired.push(name);
+      this.core?.fireAlarm(name);
+    }
+    return fired;
+  }
+  /** The earliest due time across armed alarms — what the supervisor reports to control. */
+  get dueAlarmAt() {
+    let best;
+    for (const at of this.armedAlarms.values()) if (best === void 0 || at < best) best = at;
+    return best;
+  }
   /** Logged messages of one level, flattened to strings (handy in assertions). */
   logsOf(level) {
     return this.logs.filter((l) => l.level === level).map((l) => l.args.map(String).join(" "));
   }
 };
+function kvKey(playerId, key) {
+  return `${playerId}\0${key}`;
+}
 
 // src/test/harness.ts
 import {
@@ -361,16 +454,25 @@ var FakeClientImpl = class {
   }
   /** Flags any collection the frame named that this client's role may not see. */
   checkFrameVisibility(delta) {
-    const keep = this.bridge.visible(this.role);
     for (const dc of delta.collections) {
-      if (keep.has(dc.name) || dc.ops.length === 0) continue;
+      const spatial = this.bridge.ext.collection(dc.name).visibility === "spatial-grid";
+      const leaked = dc.ops.filter((op) => {
+        if (!this.bridge.visible(this.role, this.id, dc.name)) return true;
+        if (!spatial) return false;
+        if (op.op === "remove") return !entityOf(this.view, dc.name).has(op.id);
+        return !this.bridge.visible(this.role, this.id, dc.name, op.id);
+      });
+      if (leaked.length === 0) continue;
+      const ids = leaked.map((o) => o.id);
+      const detail = this.bridge.spatialDetail(this.role, this.id, dc.name, ids);
       this.bridge.noteLeak({
         clientId: this.id,
         role: this.role,
         collection: dc.name,
         kind: "frame",
-        ids: dc.ops.map((o) => o.id),
-        tick: delta.tick
+        ids,
+        tick: delta.tick,
+        ...detail ? { detail } : {}
       });
     }
   }
@@ -489,6 +591,9 @@ function deepEqual(a, b) {
   for (const k of keys) if (!deepEqual(ra[k], rb[k])) return false;
   return true;
 }
+function detailOf(detail) {
+  return detail ? { detail } : {};
+}
 var Harness = class {
   constructor(definition, options) {
     this.definition = definition;
@@ -501,6 +606,8 @@ var Harness = class {
       ...options.publicUrl !== void 0 ? { publicUrl: options.publicUrl } : {},
       ...options.restoreFrom !== void 0 ? { restoreFrom: options.restoreFrom } : {}
     });
+    this.host.core = this.coreRef;
+    this.host.serializeForSave = () => this.coreRef.snapshot();
     this.coreRef.start();
     const self = this;
     this.bridge = {
@@ -523,7 +630,17 @@ var Harness = class {
       noteLeak: (leak) => {
         this.frameLeaks.push(leak);
       },
-      visible: (role) => visibleNames(this.coreRef.ext, role)
+      visible: (role, clientId, collection, id) => {
+        const desc = this.coreRef.ext.collection(collection);
+        const policy = createVisibilityPolicy(this.coreRef.ext, this.coreRef.plain, clientId, role);
+        return id === void 0 ? policy.maySeeCollection(desc) : policy.maySeeEntity(desc, id);
+      },
+      spatialDetail: (role, clientId, collection, ids) => createVisibilityPolicy(
+        this.coreRef.ext,
+        this.coreRef.plain,
+        clientId,
+        role
+      ).describeSpatial(this.coreRef.ext.collection(collection), ids)
     };
   }
   definition;
@@ -711,7 +828,24 @@ var Harness = class {
     const ext = this.coreRef.ext;
     for (const client of this.clientList) {
       const keep = visibleNames(ext, client.role);
+      const policy = createVisibilityPolicy(ext, this.coreRef.plain, client.id, client.role);
       for (const c of ext.collections) {
+        if (c.visibility === "spatial-grid") {
+          const coll = client.view[c.name];
+          const ids = coll ? [...coll.ids()].filter((id) => !policy.maySeeEntity(c, id)) : [];
+          if (ids.length > 0) {
+            leaks.push({
+              clientId: client.id,
+              role: client.role,
+              collection: c.name,
+              kind: "view",
+              ids,
+              tick: this.coreRef.tick,
+              ...detailOf(policy.describeSpatial(c, ids))
+            });
+          }
+          continue;
+        }
         if (keep.has(c.name)) continue;
         if (c.kind === "entity") {
           const coll = client.view[c.name];
@@ -770,5 +904,6 @@ export {
   FakeClock,
   HarnessHost,
   createRoomHarness,
-  frameTypeName
+  frameTypeName,
+  initPhysics
 };

package/dist/worker/index.d.ts

@@ -1,4 +1,4 @@
-import { L as LogLevel, h as RoomStats, R as RoomCoreApi, f as RoomHost } from '../contract-BhD88PGb.js';
+import { L as LogLevel, j as RoomStats, a as HostCall, b as HostCallResult, R as RoomCoreApi, h as RoomHost } from '../contract-B8QSO0MH.js';
 import { ErrorCodeName } from '@irtio/protocol';
 import { LeaveReason } from '@irtio/server';
 import '@irtio/schema';
@@ -40,6 +40,9 @@ type ToWorker = {
     clientId: string;
     role?: string;
     name?: string;
+    /** Week 13 (D27): the verified JWT subject — becomes `JoinOptions.playerId` and therefore
+     *  `ctx.playerId`. Absent for key joins, whose playerId stays the client id. */
+    playerId?: string;
     reconnecting?: boolean;
 } | {
     t: 'leave';
@@ -52,14 +55,33 @@ type ToWorker = {
     t: 'frame';
     clientId: string;
     bytes: Uint8Array;
-} | {
+}
+/** `forSave` (D24) asks for the bytes only: no `onSleep`, no timers cleared, nothing
+ *  rejected — the room keeps running. Absent means hibernation, as it always did. */
+ | {
     t: 'serialize';
     reqId: number;
+    forSave?: boolean;
 } | {
     t: 'inspect';
     reqId: number;
 } | {
     t: 'stats';
+}
+/**
+ * Week 12: the supervisor answering a `hostCall` (a D24 save, a D25 KV operation). It arrives
+ * as an ordinary worker message, which is precisely what makes the room's continuation "its
+ * own event between ticks" rather than something that ran inside the handler that asked.
+ */
+ | {
+    t: 'hostResult';
+    reqId: number;
+    result: HostCallResult;
+}
+/** D26: a durable alarm came due. The supervisor owns the timer; the worker just runs it. */
+ | {
+    t: 'alarm';
+    name: string;
 } | {
     t: 'stop';
 };
@@ -141,6 +163,22 @@ type FromWorker = {
     stats: Omit<RoomStats, 'bytesOutByClient'> & {
         bytesOutByClient: [string, number][];
     };
+}
+/** Week 12: the room asked for host-side async work; the supervisor answers `hostResult`. */
+ | {
+    t: 'hostCall';
+    reqId: number;
+    call: HostCall;
+}
+/**
+ * D26: `room.alarm(name, atMs)` / `room.cancelAlarm(name)` (`atMs` absent = cancel). Alarm
+ * state lives in the supervisor's `RoomRecord`, never in the hibernation blob — which is why
+ * the blob format is still v2.
+ */
+ | {
+    t: 'setAlarm';
+    name: string;
+    atMs?: number;
 } | {
     t: 'stopped';
 };

package/dist/worker/index.js

@@ -1,10 +1,11 @@
 import {
   migrateSnapshot
-} from "../chunk-3DQHT4CM.js";
+} from "../chunk-FA4IOC2Z.js";
 import {
   RoomCore,
-  RoomFullError
-} from "../chunk-X5S364FY.js";
+  RoomFullError,
+  initPhysics
+} from "../chunk-GKMD3ICD.js";
 
 // src/worker/index.ts
 import { isMainThread, parentPort } from "worker_threads";
@@ -55,6 +56,16 @@ function createWorkerHost(post) {
     },
     crashed(reason) {
       post({ t: "crashed", reason });
+    },
+    hostCall(reqId, call) {
+      post({ t: "hostCall", reqId, call });
+    },
+    setAlarm(name, atMs) {
+      if (atMs === void 0) {
+        post({ t: "setAlarm", name });
+        return;
+      }
+      post({ t: "setAlarm", name, atMs: Date.now() + (atMs - performance.now()) });
     }
   };
 }
@@ -100,6 +111,17 @@ async function handleMessage(state, host, post, msg) {
           post({ t: "initFailed", reason: String(err instanceof Error ? err.stack : err) });
           return;
         }
+        if (def.config.physics) {
+          try {
+            await initPhysics();
+          } catch (err) {
+            post({
+              t: "initFailed",
+              reason: `physics engine failed to load: ${String(err instanceof Error ? err.stack ?? err.message : err)}`
+            });
+            return;
+          }
+        }
         let snapshot = msg.snapshot;
         let migrated;
         if (snapshot && msg.migrate && msg.migrate.length > 0) {
@@ -169,6 +191,7 @@ async function handleMessage(state, host, post, msg) {
           const joinOptions = {
             ...msg.role !== void 0 ? { role: msg.role } : {},
             ...msg.name !== void 0 ? { name: msg.name } : {},
+            ...msg.playerId !== void 0 ? { playerId: msg.playerId } : {},
             ...msg.reconnecting !== void 0 ? { reconnecting: msg.reconnecting } : {}
           };
           const result = core.join(msg.clientId, joinOptions);
@@ -212,7 +235,7 @@ async function handleMessage(state, host, post, msg) {
       case "serialize": {
         const core = state.core;
         if (!core) return;
-        const bytes = ownBuffer(core.serialize());
+        const bytes = ownBuffer(msg.forSave === true ? core.snapshot() : core.serialize());
         post({ t: "serialized", reqId: msg.reqId, bytes }, [bytes.buffer]);
         return;
       }
@@ -236,6 +259,14 @@ async function handleMessage(state, host, post, msg) {
         post(statsPayload(core.stats));
         return;
       }
+      case "hostResult": {
+        state.core?.completeHostCall(msg.reqId, msg.result);
+        return;
+      }
+      case "alarm": {
+        state.core?.fireAlarm(msg.name);
+        return;
+      }
       case "stop": {
         state.core?.stop();
         post({ t: "stopped" });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@irtio/runtime",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "irtio room runtime: RoomCore, worker_threads host, in-process test harness",
   "license": "MIT",
   "publishConfig": {
@@ -28,9 +28,10 @@
     "dist"
   ],
   "dependencies": {
-    "@irtio/protocol": "0.1.0",
-    "@irtio/schema": "0.1.0",
-    "@irtio/server": "0.1.0"
+    "@dimforge/rapier3d-compat": "0.20.0",
+    "@irtio/protocol": "0.2.0",
+    "@irtio/schema": "0.2.0",
+    "@irtio/server": "0.2.0"
   },
   "scripts": {
     "build": "tsup",

package/dist/room-CBsSCueH.d.ts

@@ -1,246 +0,0 @@
-import { DirtySet, AnySchema, PlainState, Tracked, State } from '@irtio/schema';
-import { RoomDefinition, RoomMode, Room, Ctx, ResolvedRoomConfig, LeaveReason } from '@irtio/server';
-import { f as RoomHost, h as RoomStats, L as LogLevel, R as RoomCoreApi, b as RoomCoreOptions, d as RoomEventKind, g as RoomInspection, J as JoinOptions, a as JoinResult } from './contract-BhD88PGb.js';
-
-/**
- * `room.random()` — mulberry32 over a u32 seed. Deterministic, tiny, and serializable: the
- * generator's whole state is one u32, so `serialize()`/`restore()` round-trip it exactly.
- */
-declare class Mulberry32 {
-    /** Current internal state (u32). Survives hibernation. */
-    state: number;
-    constructor(seed: number);
-    /** Next float in `[0, 1)`. */
-    next(): number;
-}
-
-/**
- * The internal seam between `RoomCore` (core/room.ts) and the modules it delegates to
- * (`loop`, `views`, `writes`, `rpc`, `messages`, `room-api`). Nothing here is public API —
- * `src/contract.ts` is. `RoomCore` implements `RoomInternals` structurally, so the modules
- * take it as a parameter and never import `room.ts` (no cycles).
- */
-
-type AnyRecord = Record<string, unknown>;
-/** `${collection}\0${id}` → leaf-path key → the value the runtime wrote for that leaf. */
-type AcceptedWrites = Map<string, Map<string, unknown>>;
-/** One joined client. Presence is the wire truth; this is the runtime's bookkeeping. */
-interface ClientEntry {
-    readonly clientId: string;
-    role: string;
-    name: string;
-    connected: boolean;
-    /** Pending `CORRECT` mask, encoded from current state at the next flush. */
-    correction: DirtySet | undefined;
-    /** Leaves this client's own accepted `WRITE`s produced during the current flush window. */
-    readonly accepted: AcceptedWrites;
-    /**
-     * The tick stamped on the last `WRITE` this client sent (the client-local write counter in the
-     * delta header — week 8, D19), `0` before its first write. Every `CORRECT` sent to this client
-     * carries it as `clientTick`: "your writes through this tick are reflected in these values".
-     * An unprompted correction (a server-wins overwrite with no triggering write) echoes it
-     * unchanged — for a client that never wrote, that is `0`.
-     */
-    lastClientTick: number;
-    /**
-     * Set at `join`: this client's own record(s) — its presence row and whatever entities its own
-     * `onJoin` added, owned by it — as they stood right after join, per collection. Consumed once
-     * by the very next `flush()`, which strips exactly the ids whose value (and owner) still match
-     * this capture from this client's delta only — an id mutated again before that flush (e.g. a
-     * same-window `room.setRole`) is left alone, since the join snapshot never saw that value.
-     * Every other client's delta is unaffected.
-     */
-    pendingJoinAdds: Map<string, ReadonlyMap<string, JoinAddCapture>> | undefined;
-}
-/** What `join` captured for one of a client's own just-added records, for `flush`'s comparison. */
-interface JoinAddCapture {
-    readonly value: unknown;
-    readonly owner: string | undefined;
-}
-type GuardResult<T> = {
-    readonly ok: true;
-    readonly value: T;
-} | {
-    readonly ok: false;
-};
-/** One queued inbound frame (tick mode). */
-interface QueuedFrame {
-    readonly clientId: string;
-    readonly type: number;
-    readonly payload: Uint8Array;
-}
-interface LoopApi {
-    start(): void;
-    stop(): void;
-    /** Event mode: an inbound frame or a join re-arms the idle timer. */
-    noteActivity(): void;
-    /** `room.setTimeout` / `room.setInterval`. Returns a numeric handle. */
-    setTimer(ms: number, fn: () => void, repeat: boolean): number;
-    clearTimer(handle: number): void;
-    /** Drops every room timer (hibernation, stop). */
-    clearAllTimers(): void;
-    /** Internal one-shot on the host clock (RPC timeouts in event mode). */
-    after(ms: number, fn: () => void): void;
-}
-/** What the core modules are allowed to see of `RoomCore`. */
-interface RoomInternals {
-    readonly definition: RoomDefinition;
-    /** `withBuiltins(definition.schema)` — what every frame and the codec use. */
-    readonly ext: AnySchema;
-    readonly host: RoomHost;
-    readonly roomId: string;
-    readonly mode: RoomMode;
-    /** The plain state the tracked proxies wrap (what the codec reads). */
-    readonly plain: PlainState;
-    readonly tracked: Tracked<AnySchema>;
-    /** The tracked proxy tree, loosely typed for internal use. */
-    readonly anyState: AnyRecord;
-    readonly room: Room;
-    readonly rng: Mulberry32;
-    readonly stats: RoomStats;
-    /** Joined clients in join order. */
-    readonly clients: Map<string, ClientEntry>;
-    readonly loop: LoopApi;
-    tick: number;
-    stopped: boolean;
-    /** Runs a room handler; a throw is logged and counted, never rethrown. */
-    guard<T>(name: string, fn: () => T): T | undefined;
-    recordEvent(kind: 'join' | 'leave' | 'write' | 'write-rejected' | 'correct' | 'call' | 'reply' | 'msg' | 'error', clientId?: string, detail?: string): void;
-    /** `guard` that also reports whether the handler threw (the tick loop needs this). */
-    tryRun<T>(name: string, fn: () => T): GuardResult<T>;
-    log(level: LogLevel, ...args: unknown[]): void;
-    /** Sends one framed protocol frame to a connected client and counts it. */
-    send(clientId: string, frame: Uint8Array): void;
-    ctxFor(clientId: string, reconnecting?: boolean): Ctx;
-    /** The client's pending `CORRECT` dirty set, created on demand. */
-    correctionFor(clientId: string): DirtySet | undefined;
-    /** Flushes the tracked dirty set: corrections first, then one `DELTA` per distinct view. */
-    flush(): void;
-    /** Invalidates the cached `room.clients` array. */
-    invalidateClients(): void;
-}
-
-/**
- * Scheduling: the tick-mode fixed-step loop with catch-up, event-mode idle detection, and
- * `room.setTimeout` / `room.setInterval`.
- *
- * Tick mode: one host timeout re-armed every `1000 / tickRate` ms. Each wake accumulates real
- * elapsed time and runs up to `MAX_CATCHUP` ticks; a bigger backlog is dropped and counted as an
- * overrun (logged once per burst). Room timers are tick-granular: `setTimeout(ms)` fires on the
- * first tick at or after `now + ms`.
- *
- * Event mode: no tick timer. Room timers fire on the host clock, each firing advancing the tick
- * and flushing. After `idleMs` with no inbound frames and no connected clients the host is asked
- * to hibernate exactly once (re-armed by the next frame or join).
- */
-
-/** Most ticks one wake may run before the backlog is dropped. */
-declare const MAX_CATCHUP = 5;
-/** Consecutive `tick()` throws before the host is told the room crashed. */
-declare const CRASH_AFTER_THROWS = 3;
-declare class Loop implements LoopApi {
-    private readonly core;
-    readonly inbound: QueuedFrame[];
-    private readonly timers;
-    private readonly internal;
-    private nextTimerId;
-    private tickHandle;
-    private idleHandle;
-    private running;
-    private lastWake;
-    private accumulator;
-    private overrunLogged;
-    private consecutiveThrows;
-    private lastActivity;
-    private slept;
-    constructor(core: RoomInternals);
-    get intervalMs(): number;
-    start(): void;
-    stop(): void;
-    enqueue(frame: QueuedFrame): void;
-    dropFramesFor(clientId: string): void;
-    private drainInbound;
-    /** Applies one queued/immediate frame. Returns `false` on a malformed payload. */
-    applyFrame(f: QueuedFrame): boolean;
-    private scheduleTick;
-    private onWake;
-    /** One tick: inbound → room timers → `tick(state, dt, room)` → flush. */
-    runTick(): void;
-    private fireDueTimers;
-    /** Applies one frame as its own event: tick++, apply, flush. */
-    applyEvent(f: QueuedFrame): boolean;
-    noteActivity(): void;
-    private armIdle;
-    private onIdleCheck;
-    setTimer(ms: number, fn: () => void, repeat: boolean): number;
-    private armHostTimer;
-    clearTimer(handle: number): void;
-    clearAllTimers(): void;
-    after(ms: number, fn: () => void): void;
-}
-
-/**
- * `RoomCore` — the host-agnostic room runtime. It owns the extended schema, the
- * tracked authority state, presence, the loop, and the frame dispatch; everything outside comes
- * through `RoomHost` (`src/contract.ts`). The worker host and the test harness are adapters over
- * exactly this surface and produce byte-identical frames.
- */
-
-declare class RoomCore<S extends AnySchema = AnySchema> implements RoomCoreApi<S> {
-    readonly definition: RoomDefinition<S>;
-    readonly ext: AnySchema;
-    readonly host: RoomHost;
-    readonly roomId: string;
-    readonly mode: RoomMode;
-    readonly plain: PlainState;
-    readonly tracked: Tracked<AnySchema>;
-    readonly anyState: AnyRecord;
-    readonly rng: Mulberry32;
-    readonly clients: Map<string, ClientEntry>;
-    readonly loop: Loop;
-    readonly stats: RoomStats;
-    tick: number;
-    stopped: boolean;
-    private readonly seed;
-    private readonly api;
-    private readonly internals;
-    private started;
-    constructor(definition: RoomDefinition<S>, host: RoomHost, options: RoomCoreOptions);
-    /** 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;
-    get config(): ResolvedRoomConfig<S>;
-    get state(): State<S>;
-    get room(): Room<S>;
-    tryRun<T>(name: string, fn: () => T): GuardResult<T>;
-    private readonly events;
-    recordEvent(kind: RoomEventKind, clientId?: string, detail?: string): void;
-    /** Live JSON view of the room for the dev page / supervisor admin API. */
-    inspect(): RoomInspection;
-    guard<T>(name: string, fn: () => T): T | undefined;
-    log(level: LogLevel, ...args: unknown[]): void;
-    start(): void;
-    stop(): void;
-    serialize(): Uint8Array;
-    private get presence();
-    private resolveRole;
-    join(clientId: string, options?: JoinOptions): JoinResult;
-    /** Event mode only: presence/lifecycle changes are their own event. No-op in tick mode. */
-    private eventFlush;
-    leave(clientId: string, reason: LeaveReason): void;
-    markDisconnected(clientId: string): void;
-    ctxFor(clientId: string, reconnecting?: boolean): Ctx;
-    correctionFor(clientId: string): DirtySet | undefined;
-    invalidateClients(): void;
-    send(clientId: string, frame: Uint8Array): void;
-    private badFrame;
-    receive(clientId: string, frame: Uint8Array): void;
-    /**
-     * Hands the tracked dirty set out: server-wins corrections first, then per connected client its
-     * pending `CORRECT` (before the delta, so it sees the correction and then the broadcast) and
-     * its view's `DELTA` — encoded once per distinct view.
-     */
-    flush(): void;
-}
-
-export { CRASH_AFTER_THROWS as C, MAX_CATCHUP as M, RoomCore as R, Mulberry32 as a };