@irtio/runtime 0.1.0

package/dist/contract-BhD88PGb.d.ts

@@ -0,0 +1,120 @@
+import { AnySchema, PlainState, State, Tracked } from '@irtio/schema';
+import { ErrorCodeName } from '@irtio/protocol';
+import { RoomDefinition, Room, LeaveReason } from '@irtio/server';
+
+/**
+ * Live inspection for the dev page (`irtio dev`) and the supervisor admin API: a JSON view of
+ * the room's state plus a ring of recent events. Always on; recording is O(1) per event.
+ */
+
+type RoomEventKind = 'join' | 'leave' | 'write' | 'write-rejected' | 'correct' | 'call' | 'reply' | 'msg' | 'error';
+interface RoomEvent {
+    readonly tick: number;
+    readonly kind: RoomEventKind;
+    readonly clientId?: string;
+    readonly detail?: string;
+}
+declare const EVENT_RING_SIZE = 100;
+/** JSON-able view of a plain state: entities as `{id: {owner, value}}`, singletons as values. */
+declare function inspectState(schema: AnySchema, plain: PlainState): Record<string, unknown>;
+interface RoomInspection {
+    readonly tick: number;
+    readonly state: Record<string, unknown>;
+    readonly recent: readonly RoomEvent[];
+}
+
+type LogLevel = 'info' | 'warn' | 'error';
+/** Everything the room needs from the outside world. No timers, sockets, clocks, or console inside. */
+interface RoomHost {
+    /** Monotonic ms. Fake in the harness. */
+    now(): number;
+    setTimeout(fn: () => void, ms: number): unknown;
+    clearTimeout(handle: unknown): void;
+    /** Deliver one fully framed protocol frame (type byte + payload) to a client. */
+    send(clientId: string, frame: Uint8Array): void;
+    /** The room wants this client gone (`room.kick`, protocol violation). Host closes the socket. */
+    kick(clientId: string, code: ErrorCodeName, reason?: string): void;
+    /** `room.close()`: host disconnects everyone and tears the room down. */
+    close(reason?: string): void;
+    /** Event mode: idle or `room.sleep()` — host should `serialize()` then `stop()`. */
+    sleep(): void;
+    log(level: LogLevel, args: unknown[]): void;
+    /** N consecutive tick throws; the runtime does not recover itself. */
+    crashed(reason: string): void;
+}
+interface RoomCoreOptions {
+    readonly roomId: string;
+    /** Seed for `room.random()`; default 1. */
+    readonly seed?: number;
+    /** Base URL for `room.link` (`<publicUrl>?room=<id>`); default `http://localhost/`. */
+    readonly publicUrl?: string;
+    /** Bytes from a previous `serialize()`; skips `onCreate`, runs `onWake`. */
+    readonly restoreFrom?: Uint8Array;
+}
+interface JoinOptions {
+    /** Requested role; unknown/missing → `roles[0]` (logged) or `''` when the schema has no roles. */
+    readonly role?: string;
+    readonly name?: string;
+    /** A resumed session: presence record kept, `ctx.reconnecting = true`. */
+    readonly reconnecting?: boolean;
+}
+interface JoinResult {
+    readonly tick: number;
+    readonly role: string;
+    /** Snapshot bytes for this client's view (extended schema). The host builds `WELCOME`. */
+    readonly snapshot: Uint8Array;
+}
+declare class RoomFullError extends Error {
+    readonly maxClients: number;
+    readonly name = "RoomFullError";
+    constructor(maxClients: number);
+}
+interface RoomStats {
+    ticks: number;
+    lastTickMs: number;
+    maxTickMs: number;
+    overruns: number;
+    framesIn: number;
+    framesOut: number;
+    bytesOut: number;
+    /** Per connected client. */
+    bytesOutByClient: Map<string, number>;
+    handlerErrors: number;
+    encodesLastFlush: number;
+    corrections: number;
+}
+/** The surface the worker host and the harness drive. Implemented by `RoomCore`. */
+interface RoomCoreApi<S extends AnySchema = AnySchema> {
+    readonly definition: RoomDefinition<S>;
+    /** The builder's schema. */
+    readonly schema: S;
+    /** `withBuiltins(schema)`: what the codec and every frame use. */
+    readonly ext: AnySchema;
+    readonly roomId: string;
+    readonly tick: number;
+    /** Tracked authority (proxy tree incl. the built-in `clients` collection). */
+    readonly state: State<S>;
+    readonly tracked: Tracked<AnySchema>;
+    /** The `room` API object handed to handlers. */
+    readonly room: Room<S>;
+    readonly stats: RoomStats;
+    readonly mode: 'tick' | 'event';
+    /** Begin ticking (tick mode) / idle timer (event mode). Idempotent. */
+    start(): void;
+    /** Stop timers; no more frames are sent. */
+    stop(): void;
+    /** Throws `RoomFullError`. Runs `onJoin`, then snapshots the client's view. */
+    join(clientId: string, options?: JoinOptions): JoinResult;
+    /** Runs `onLeave`, removes presence, rejects pending RPCs for the client. */
+    leave(clientId: string, reason: LeaveReason): void;
+    /** Grace window opened by the host: presence `connected = false`; frames are no longer sent. */
+    markDisconnected(clientId: string): void;
+    /** One inbound protocol frame (`WRITE` | `CALL` | `REPLY` | `MSG`). Anything else → host.kick(E_BAD_FRAME). */
+    receive(clientId: string, frame: Uint8Array): void;
+    /** Full state + tick + rng for hibernation. Runs `onSleep`. Clears timers. */
+    serialize(): Uint8Array;
+    /** Live JSON view of the room (dev page / supervisor admin API). */
+    inspect(): RoomInspection;
+}
+
+export { EVENT_RING_SIZE as E, type JoinOptions as J, type LogLevel as L, type RoomCoreApi as R, type JoinResult as a, type RoomCoreOptions as b, type RoomEvent as c, type RoomEventKind as d, RoomFullError as e, type RoomHost as f, type RoomInspection as g, type RoomStats as h, inspectState as i };

package/dist/index.d.ts

@@ -0,0 +1,161 @@
+export { E as EVENT_RING_SIZE, J as JoinOptions, a as JoinResult, L as LogLevel, R as RoomCoreApi, b as RoomCoreOptions, c as RoomEvent, d as RoomEventKind, e as RoomFullError, f as RoomHost, g as RoomInspection, h as RoomStats, i as inspectState } from './contract-BhD88PGb.js';
+export { C as CRASH_AFTER_THROWS, M as MAX_CATCHUP, a as Mulberry32, R as RoomCore } from './room-CBsSCueH.js';
+import { AnySchema, PlainState, DirtySet, CollectionDesc } from '@irtio/schema';
+import '@irtio/protocol';
+import '@irtio/server';
+
+/**
+ * RPCs in both directions.
+ *
+ * client → server: `CALL` → `rpcByIdOf` → param decode + `validateValue` → the room's `rpc`
+ * implementation (or the built-in `requestOwnership`) → `REPLY`. A throw becomes an error reply;
+ * nothing escapes into the loop.
+ *
+ * server → client: `room.call(clientId).<name>(params)` returns a Promise resolved by the
+ * client's `REPLY`, rejected on a 5 s host-clock timeout or on disconnect.
+ * `room.broadcast.<name>(params)` fans one `CALL` out with no pending entry.
+ */
+
+/** Default server→client RPC timeout on the host clock. */
+declare const RPC_TIMEOUT_MS = 5000;
+
+/**
+ * Views: which collections a role sees, how clients bucket into distinct views (so one flush
+ * encodes one `DELTA` per view, not per client), the per-view snapshot taken at `join`, and
+ * the catch-up delta `room.setRole` sends.
+ *
+ * A collection with `visibility: 'role'` is visible only to the roles it names — including its
+ * adds and removes, so a client never learns such a record exists.
+ */
+
+/** Is `c` visible to `role`? */
+declare function isVisible(c: CollectionDesc, role: string): boolean;
+/** A `SnapshotOptions.collections` predicate for one role. */
+declare function visibleTo(role: string): (c: CollectionDesc) => boolean;
+/** Names of the collections `role` sees (memoised per schema + role). */
+declare function visibleNames(ext: AnySchema, role: string): ReadonlySet<string>;
+/**
+ * The view bucket for a role: `'all'` when the role is not named by any role-scoped collection
+ * (every such role sees exactly the same set), otherwise the role itself.
+ */
+declare function viewKeyFor(ext: AnySchema, role: string): string;
+/** The `join` snapshot: full state restricted to the client's view. */
+declare function encodeViewSnapshot(ext: AnySchema, plain: PlainState, role: string, tick: number): Uint8Array;
+/** One view's `DELTA` payload, or `null` when nothing visible to `role` changed. */
+declare function encodeViewDelta(ext: AnySchema, plain: PlainState, dirty: DirtySet, role: string, tick: number): Uint8Array | null;
+/**
+ * `room.setRole` catch-up: `add` ops for every record of a collection that just became visible
+ * and `remove` ops for every record of one that stopped being visible. A singleton that becomes
+ * visible is sent as a whole-record update; one that stops being visible cannot be un-sent (the
+ * format has no singleton remove), so it is left alone — the client keeps stale values it can no
+ * longer see updated. Returns an empty set when the two roles have the same view.
+ */
+declare function catchUpDirty(ext: AnySchema, plain: PlainState, fromRole: string, toRole: string): DirtySet;
+
+/**
+ * The hibernation blob envelope: a small fixed header the runtime writes around the codec
+ * snapshot, so a woken room gets its rng, tick and mode back.
+ *
+ *   u8  format version
+ *   u32 seed
+ *   u32 rng state
+ *   u32 tick
+ *   u8  mode (1 = event, 0 = tick)
+ *   ... encodeSnapshot(withBuiltins(schema), state)
+ *
+ * Note: the *deployment* version is deliberately **not** in here. It lives in the store
+ * key (`<project>/<room>@v<deployment>`), which keeps the blob format frozen — an old snapshot
+ * stays valid across deployments — and lets a wake path discover the version by listing keys
+ * instead of parsing bytes it may not yet know how to read.
+ */
+declare const SNAPSHOT_FORMAT_VERSION = 1;
+type SnapshotMode = 'tick' | 'event';
+interface SnapshotHeader {
+    readonly seed: number;
+    readonly rngState: number;
+    readonly tick: number;
+    readonly mode: SnapshotMode;
+}
+interface ParsedSnapshot extends SnapshotHeader {
+    /** The codec snapshot, encoded under `withBuiltins(schema)`. */
+    readonly snapshot: Uint8Array;
+}
+declare function parseHibernationBlob(bytes: Uint8Array): ParsedSnapshot;
+declare function writeHibernationBlob(header: SnapshotHeader, snapshot: Uint8Array): Uint8Array;
+
+/**
+ * Wake-time schema migration.
+ *
+ * A room hibernated under deployment v1 and woken under v3 has bytes on disk that only v1's
+ * schema can decode. `migrateSnapshot` decodes them with the *stored* canonical schema of the
+ * deployment they were written under, hands the plain state to each deployment's `up` transform
+ * in order, and re-encodes under the target schema. The supervisor re-snapshots immediately
+ * afterwards, so the chain runs exactly once per room ("migrate once").
+ *
+ * The state a migration sees is deliberately plain JSON-ish, not the tracked proxy tree:
+ *
+ *   { players: { 'c1': { owner: 'c1', value: { x: 1, y: 2 } } },   // entity
+ *     match:   { phase: 'lobby', round: 0 } }                      // singleton
+ *
+ * Entities are `{ id: { owner, value } }` maps; singletons are the record itself. The built-in
+ * `clients` presence collection is removed before `up` runs and comes back empty afterwards —
+ * presence is rebuilt from the sockets that rejoin, so a migration never has to think about it.
+ */
+
+interface MigrationRecord {
+    owner: string;
+    value: Record<string, unknown>;
+}
+/** An entity collection as a migration sees it: id → `{ owner, value }`. */
+type MigrationEntity = Record<string, MigrationRecord>;
+/** A whole room's state: entity maps and singleton records, keyed by collection name. */
+type MigrationState = Record<string, MigrationEntity | Record<string, unknown>>;
+/** Handed to `up` as its second argument. Small on purpose, to keep migrations honest. */
+interface MigrationHelpers {
+    /** The deployment version this migration produces. */
+    readonly version: number;
+    /** The deployment version its input was written under. */
+    readonly fromVersion: number;
+    /** The room being migrated. */
+    readonly roomId: string;
+    /** Goes to the room's log, prefixed with the version. */
+    log(...args: unknown[]): void;
+}
+interface MigrationModule {
+    up(state: MigrationState, s: MigrationHelpers): MigrationState | void;
+    /** Scaffolded by `irtio migrate create` and stored; unused until rollback ships. */
+    down?(state: MigrationState, s: MigrationHelpers): MigrationState | void;
+}
+/**
+ * One deployment in the chain the tenant was handed. `migration` is absent for versions whose
+ * schema change was purely additive — the codec fills new fields from their defaults, so there
+ * is nothing to transform.
+ */
+interface MigrationStep {
+    readonly version: number;
+    /** `schema.canonical` as stored on the deployment record. */
+    readonly schemaJson: string;
+    readonly migration?: MigrationModule;
+}
+interface MigrateOptions {
+    readonly roomId: string;
+    log?(level: 'info' | 'warn' | 'error', args: unknown[]): void;
+}
+interface MigrationOutcome {
+    /** A hibernation blob encoded under the last step's schema. */
+    readonly bytes: Uint8Array;
+    readonly fromVersion: number;
+    readonly toVersion: number;
+    /** Versions whose `up` actually ran. */
+    readonly applied: readonly number[];
+    readonly ms: number;
+}
+/**
+ * Runs the chain. `chain` must be sorted ascending and start with the deployment the snapshot
+ * was written under (its `up` is *not* run — it is only there to supply the decoding schema).
+ */
+declare function migrateSnapshot(blob: Uint8Array, chain: readonly MigrationStep[], options: MigrateOptions): MigrationOutcome;
+declare function toMigrationState(schema: AnySchema, plain: PlainState): MigrationState;
+declare function fromMigrationState(schema: AnySchema, state: MigrationState, version: number): PlainState;
+
+export { type MigrateOptions, type MigrationEntity, type MigrationHelpers, type MigrationModule, type MigrationOutcome, type MigrationRecord, type MigrationState, type MigrationStep, type ParsedSnapshot, RPC_TIMEOUT_MS, SNAPSHOT_FORMAT_VERSION, type SnapshotHeader, type SnapshotMode, catchUpDirty, encodeViewDelta, encodeViewSnapshot, fromMigrationState, isVisible, migrateSnapshot, parseHibernationBlob, toMigrationState, viewKeyFor, visibleNames, visibleTo, writeHibernationBlob };

package/dist/index.js

@@ -0,0 +1,48 @@
+import {
+  fromMigrationState,
+  migrateSnapshot,
+  toMigrationState
+} from "./chunk-3DQHT4CM.js";
+import {
+  CRASH_AFTER_THROWS,
+  EVENT_RING_SIZE,
+  MAX_CATCHUP,
+  Mulberry32,
+  RPC_TIMEOUT_MS,
+  RoomCore,
+  RoomFullError,
+  SNAPSHOT_FORMAT_VERSION,
+  catchUpDirty,
+  encodeViewDelta,
+  encodeViewSnapshot,
+  inspectState,
+  isVisible,
+  parseHibernationBlob,
+  viewKeyFor,
+  visibleNames,
+  visibleTo,
+  writeHibernationBlob
+} from "./chunk-X5S364FY.js";
+export {
+  CRASH_AFTER_THROWS,
+  EVENT_RING_SIZE,
+  MAX_CATCHUP,
+  Mulberry32,
+  RPC_TIMEOUT_MS,
+  RoomCore,
+  RoomFullError,
+  SNAPSHOT_FORMAT_VERSION,
+  catchUpDirty,
+  encodeViewDelta,
+  encodeViewSnapshot,
+  fromMigrationState,
+  inspectState,
+  isVisible,
+  migrateSnapshot,
+  parseHibernationBlob,
+  toMigrationState,
+  viewKeyFor,
+  visibleNames,
+  visibleTo,
+  writeHibernationBlob
+};

package/dist/room-CBsSCueH.d.ts

@@ -0,0 +1,246 @@
+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 };