@irtio/runtime 0.5.1 → 0.6.0

package/dist/worker/index.d.ts

@@ -1,6 +1,6 @@
-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 { L as LogLevel, T as TimelineDump, k as RoomStats, b as HostCall, c as HostCallResult, R as RoomCoreApi, i as RoomHost } from '../contract-BjMsoJIV.js';
+import { ErrorCodeName, ProfileSnapshot } from '@irtio/protocol';
+import { NpcConfig, LeaveReason } from '@irtio/server';
 import '@irtio/schema';
 
 /**
@@ -35,6 +35,11 @@ type ToWorker = {
      * the one `bundleUrl` implements.
      */
     migrate?: MigrationChainStep[];
+    /**
+     * D65: run this room with a bandwidth ledger. Absent means off, which is the shape every
+     * existing supervisor already sends, and a room without it pays nothing.
+     */
+    profile?: boolean;
 } | {
     t: 'join';
     clientId: string;
@@ -44,6 +49,8 @@ type ToWorker = {
      *  `ctx.playerId`. Absent for key joins, whose playerId stays the client id. */
     playerId?: string;
     reconnecting?: boolean;
+    /** D44: this join is a scripted NPC's loopback session. */
+    npc?: boolean;
 } | {
     t: 'leave';
     clientId: string;
@@ -65,8 +72,29 @@ type ToWorker = {
 } | {
     t: 'inspect';
     reqId: number;
+}
+/**
+ * D41: arm (or re-arm) the authoritative timeline recorder, and read it back. Two messages
+ * rather than a flag on `inspect`, because recording is a room-lifetime decision and reading is
+ * a per-request one. Both are additive: a supervisor that never sends them costs a room nothing.
+ */
+ | {
+    t: 'record';
+    reqId: number;
+    maxTicks?: number;
+    maxRecords?: number;
 } | {
+    t: 'timeline';
+    reqId: number;
+}
+/**
+ * D36: `reqId` correlates the answer, so a caller can *await* one room's counters instead of
+ * waiting for a periodic push. Optional and echoed back when present, so a host that asks
+ * without one still gets the uncorrelated message it expects.
+ */
+ | {
     t: 'stats';
+    reqId?: number;
 }
 /**
  * Week 12: the supervisor answering a `hostCall` (a D24 save, a D25 KV operation). It arrives
@@ -82,6 +110,28 @@ type ToWorker = {
  | {
     t: 'alarm';
     name: string;
+}
+/**
+ * D59: a published message reaching a channel this room is subscribed to. A separate message
+ * from `alarm` because an alarm carries only a name, and the whole point of the bus is the
+ * payload. `from` is stamped by the supervisor off the publishing room's own record, so a room
+ * cannot forge a source.
+ */
+ | {
+    t: 'busEvent';
+    channel: string;
+    from: string;
+    payload: string;
+}
+/**
+ * D59: a directed `room.bus.send` being delivered. At-least-once: the supervisor re-arms an
+ * entry it could not deliver, so the same message can arrive twice.
+ */
+ | {
+    t: 'busMessage';
+    name: string;
+    from: string;
+    payload: string;
 } | {
     t: 'stop';
 };
@@ -98,6 +148,12 @@ type FromWorker = {
         idleMs: number;
         reconnectGraceMs: number;
         maxClients: number;
+        /** D63-e: the room type's declared backfill eligibility. The ceiling on
+         *  `room.backfill.set`, and `false` for every room that declares nothing. */
+        backfill?: boolean;
+        /** D47: the physics engine this room runs, when it declares one. Reported so room-hours
+         *  rows carry the engine as a dimension; the supervisor never acts on it. */
+        engine?: string;
     };
     /** Present when `init.migrate` ran; the supervisor re-snapshots on the strength of it. */
     migrated?: {
@@ -158,11 +214,56 @@ type FromWorker = {
     }[];
     /** Worker process RSS in bytes. */
     rss: number;
+}
+/** D41: the recorder is armed. `ok: false` when there is no room core to arm. */
+ | {
+    t: 'recording';
+    reqId: number;
+    ok: boolean;
+}
+/** D41: the recorded timeline. `dump` absent when nobody armed the recorder. */
+ | {
+    t: 'timeline';
+    reqId: number;
+    dump?: TimelineDump;
 } | {
     t: 'stats';
+    /** Echoed from the request when it carried one (D36). */
+    reqId?: number;
     stats: Omit<RoomStats, 'bytesOutByClient'> & {
         bytesOutByClient: [string, number][];
     };
+    /**
+     * D55: the worker thread's own V8 heap, sampled at reply time. It rides this existing
+     * round trip rather than adding a protocol surface, and it is deliberately not part of
+     * `RoomStats` — `RoomStats` is the room's own counters, and this is a fact about the
+     * thread the room happens to be running in.
+     *
+     * `limitBytes` is V8's `heap_size_limit`, which inside a worker reflects the
+     * `resourceLimits` the host spawned it with, so the supervisor does not have to remember
+     * what cap it handed out to know how close the room is to it. Absent when the worker's
+     * V8 could not be sampled, which the supervisor must report as unread rather than as
+     * zero, for the same reason `ticks`/`overruns` are optional.
+     */
+    heap?: {
+        usedBytes: number;
+        limitBytes: number;
+    };
+    /**
+     * D56: `true` once any Rapier world in this worker process has stepped, which is the point
+     * V8 has tier-compiled the physics WASM and paid its RSS transient. It rides `stats`
+     * because that round trip already exists; the worker also pushes one uncorrelated `stats`
+     * the first time it flips, so the supervisor learns it without having to be polling at the
+     * right moment. Absent means "not yet" (or an older worker), never "no".
+     */
+    physicsStepped?: boolean;
+    /**
+     * D65: the room's bandwidth ledger, when it was started with one. It rides `stats` for the
+     * same reason D55's `heap` does — the round trip already exists — and stays off
+     * `RoomStats`, which is a fixed shape the harness and the hibernation path both pin.
+     * Absent means "this room is not profiling", never "no bytes".
+     */
+    profile?: ProfileSnapshot;
 }
 /** Week 12: the room asked for host-side async work; the supervisor answers `hostResult`. */
  | {
@@ -179,6 +280,58 @@ type FromWorker = {
     t: 'setAlarm';
     name: string;
     atMs?: number;
+}
+/**
+ * D63-e: `room.backfill.set(open)`. Fire-and-forget: the room gets no result, because the only
+ * thing that could go wrong is that the room never declared `backfill` at all, which is a fact
+ * the room already knows about itself.
+ */
+ | {
+    t: 'setBackfill';
+    open: boolean;
+}
+/**
+ * D59: `room.bus.publish(channel, payload)`. Fire-and-forget by design — the room gets no
+ * result, because the only honest answer is "delivered to whoever happened to be awake", and a
+ * refusal (an oversized payload, a rate limit) comes back as a log line rather than as a value
+ * the room would have no useful response to.
+ */
+ | {
+    t: 'busPublish';
+    channel: string;
+    payload: string;
+}
+/** D59: `room.bus.subscribe`/`unsubscribe`, and the automatic subscribe of declared channels. */
+ | {
+    t: 'busSubscribe';
+    channel: string;
+    subscribed: boolean;
+}
+/**
+ * D59: the room ran (or knowingly discarded) the mailbox entry called `name`.
+ *
+ * This is what clears the entry. The supervisor re-arms an entry for a visibility timeout at the
+ * moment it posts the `busMessage`, so a delivery that is posted but never runs comes due again
+ * instead of vanishing. Without this ack, at-least-once would be at-most-once wearing its name.
+ */
+ | {
+    t: 'busAck';
+    name: string;
+}
+/**
+ * D44: `room.spawnNPC(config)` / the handle's `despawn()`. The room minted `clientId`, so the
+ * handle is usable synchronously; the supervisor opens the loopback session under it and runs
+ * the named entry of the definition's `npcs` map — which it can, because it imported the same
+ * bundle to read the config out of. Only the *name* crosses this boundary; the function stays
+ * on the side that can call it. Additive, like every other message here.
+ */
+ | {
+    t: 'spawnNpc';
+    clientId: string;
+    config: NpcConfig;
+} | {
+    t: 'despawnNpc';
+    clientId: string;
 } | {
     t: 'stopped';
 };

package/dist/worker/index.js

@@ -1,13 +1,17 @@
 import {
   migrateSnapshot
-} from "../chunk-HFOMXKSO.js";
+} from "../chunk-VMCE3LRO.js";
 import {
   RoomCore,
   RoomFullError,
-  initPhysics
-} from "../chunk-5ZDQAAFJ.js";
+  initMatter,
+  initPhysics,
+  onFirstRapierStep,
+  rapierHasStepped
+} from "../chunk-K42HA75G.js";
 
 // src/worker/index.ts
+import { getHeapStatistics } from "v8";
 import { isMainThread, parentPort } from "worker_threads";
 import { isRoomDefinition } from "@irtio/server";
 
@@ -60,6 +64,21 @@ function createWorkerHost(post) {
     hostCall(reqId, call) {
       post({ t: "hostCall", reqId, call });
     },
+    spawnNpc(clientId, config) {
+      post({ t: "spawnNpc", clientId, config });
+    },
+    despawnNpc(clientId) {
+      post({ t: "despawnNpc", clientId });
+    },
+    busPublish(channel, payload) {
+      post({ t: "busPublish", channel, payload });
+    },
+    busSubscribe(channel, subscribed) {
+      post({ t: "busSubscribe", channel, subscribed });
+    },
+    setBackfill(open) {
+      post({ t: "setBackfill", open });
+    },
     setAlarm(name, atMs) {
       if (atMs === void 0) {
         post({ t: "setAlarm", name });
@@ -91,9 +110,28 @@ async function loadChain(steps) {
   }
   return out;
 }
-function statsPayload(stats) {
+function heapSample() {
+  try {
+    const s = getHeapStatistics();
+    if (!Number.isFinite(s.used_heap_size) || !Number.isFinite(s.heap_size_limit)) return void 0;
+    if (s.heap_size_limit <= 0) return void 0;
+    return { usedBytes: s.used_heap_size, limitBytes: s.heap_size_limit };
+  } catch {
+    return void 0;
+  }
+}
+function statsPayload(stats, reqId, profile) {
   const { bytesOutByClient, ...rest } = stats;
-  return { t: "stats", stats: { ...rest, bytesOutByClient: [...bytesOutByClient.entries()] } };
+  const heap = heapSample();
+  return {
+    t: "stats",
+    ...reqId !== void 0 ? { reqId } : {},
+    stats: { ...rest, bytesOutByClient: [...bytesOutByClient.entries()] },
+    ...heap !== void 0 ? { heap } : {},
+    ...rapierHasStepped() ? { physicsStepped: true } : {},
+    // D65: absent unless this room was started with a ledger.
+    ...profile !== void 0 ? { profile } : {}
+  };
 }
 async function handleMessage(state, host, post, msg) {
   try {
@@ -113,7 +151,14 @@ async function handleMessage(state, host, post, msg) {
         }
         if (def.config.physics) {
           try {
-            await initPhysics();
+            if (def.config.physics.engine === "matter2d") await initMatter();
+            else {
+              await initPhysics();
+              onFirstRapierStep(() => {
+                const core = state.core;
+                if (core) post(statsPayload(core.stats, void 0, core.profile()));
+              });
+            }
           } catch (err) {
             post({
               t: "initFailed",
@@ -144,7 +189,8 @@ async function handleMessage(state, host, post, msg) {
           const options = {
             roomId: msg.roomId,
             ...msg.seed !== void 0 ? { seed: msg.seed } : {},
-            ...msg.publicUrl !== void 0 ? { publicUrl: msg.publicUrl } : {}
+            ...msg.publicUrl !== void 0 ? { publicUrl: msg.publicUrl } : {},
+            ...msg.profile === true ? { profile: true } : {}
           };
           const core = snapshot ? RoomCore.restore(def, snapshot, host, options) : new RoomCore(def, host, options);
           state.core = core;
@@ -160,7 +206,16 @@ async function handleMessage(state, host, post, msg) {
               tickRate: c.tickRate,
               idleMs: c.idleMs,
               reconnectGraceMs: c.reconnectGraceMs,
-              maxClients: c.maxClients
+              maxClients: c.maxClients,
+              // D63-e: the declared ceiling, carried on the same frame and for the same reason
+              // `engine` is: `ready.config` replaces the supervisor's copy, so a flag threaded
+              // only through `loadBundle` would be dropped the moment a worker started.
+              backfill: c.backfill === true,
+              // D47: `ready.config` REPLACES the supervisor's copy of the bundle config, so an
+              // engine threaded only through `loadBundle` would be dropped here the moment a
+              // worker started. That is exactly how the first known-shape run read `engine: none`
+              // against a matter2d room.
+              ...typeof c.physics?.engine === "string" ? { engine: c.physics.engine } : {}
             },
             ...migrated ? {
               migrated: {
@@ -192,7 +247,8 @@ async function handleMessage(state, host, post, msg) {
             ...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 } : {}
+            ...msg.reconnecting !== void 0 ? { reconnecting: msg.reconnecting } : {},
+            ...msg.npc === true ? { npc: true } : {}
           };
           const result = core.join(msg.clientId, joinOptions);
           const snapshot = ownBuffer(result.snapshot);
@@ -253,10 +309,28 @@ async function handleMessage(state, host, post, msg) {
         });
         return;
       }
+      case "record": {
+        const core = state.core;
+        if (!core) {
+          post({ t: "recording", reqId: msg.reqId, ok: false });
+          return;
+        }
+        core.startRecording({
+          ...msg.maxTicks !== void 0 ? { maxTicks: msg.maxTicks } : {},
+          ...msg.maxRecords !== void 0 ? { maxRecords: msg.maxRecords } : {}
+        });
+        post({ t: "recording", reqId: msg.reqId, ok: true });
+        return;
+      }
+      case "timeline": {
+        const dump = state.core?.recording();
+        post({ t: "timeline", reqId: msg.reqId, ...dump !== void 0 ? { dump } : {} });
+        return;
+      }
       case "stats": {
         const core = state.core;
         if (!core) return;
-        post(statsPayload(core.stats));
+        post(statsPayload(core.stats, msg.reqId, core.profile()));
         return;
       }
       case "hostResult": {
@@ -267,6 +341,18 @@ async function handleMessage(state, host, post, msg) {
         state.core?.fireAlarm(msg.name);
         return;
       }
+      case "busEvent": {
+        state.core?.deliverBusEvent(msg.channel, msg.from, msg.payload);
+        return;
+      }
+      case "busMessage": {
+        try {
+          state.core?.deliverBusMessage(msg.from, msg.payload);
+        } finally {
+          post({ t: "busAck", name: msg.name });
+        }
+        return;
+      }
       case "stop": {
         state.core?.stop();
         post({ t: "stopped" });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@irtio/runtime",
-  "version": "0.5.1",
+  "version": "0.6.0",
   "description": "irtio room runtime: RoomCore, worker_threads host, in-process test harness",
   "license": "MIT",
   "publishConfig": {
@@ -29,9 +29,13 @@
   ],
   "dependencies": {
     "@dimforge/rapier3d-compat": "0.20.0",
-    "@irtio/schema": "0.5.1",
-    "@irtio/server": "0.5.1",
-    "@irtio/protocol": "0.5.1"
+    "matter-js": "0.20.0",
+    "@irtio/protocol": "0.6.0",
+    "@irtio/schema": "0.6.0",
+    "@irtio/server": "0.6.0"
+  },
+  "devDependencies": {
+    "@types/matter-js": "0.20.2"
   },
   "scripts": {
     "build": "tsup",

package/dist/contract-B8QSO0MH.d.ts

@@ -1,204 +0,0 @@
-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' | 'alarm' | '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';
-/**
- * Week 12: host-side async work a room asked for — a save generation (D24) or a player-KV
- * operation (D25). Room handlers are synchronous and there is no way to block one on I/O, so
- * every one of these is started by `RoomHost.hostCall` and *finished* by the host calling
- * `RoomCoreApi.completeHostCall` — the same way an inbound frame arrives. That is what makes
- * "the continuation runs as its own event between ticks" a structural property of the seam
- * rather than a promise the runtime makes and hopes the host keeps.
- */
-type HostCall = {
-    readonly kind: 'save';
-} | {
-    readonly kind: 'kvGet';
-    readonly playerId: string;
-    readonly key: string;
-} | {
-    readonly kind: 'kvSet';
-    readonly playerId: string;
-    readonly key: string;
-    readonly value: string;
-} | {
-    readonly kind: 'kvDelete';
-    readonly playerId: string;
-    readonly key: string;
-};
-/**
- * What a `HostCall` produced. `value` carries the save id for `save` and the stored string for
- * `kvGet` (absent = the key was never written, which resolves `undefined` rather than rejecting).
- * A failure carries a named `E_*` code so the room can tell a size limit from an outage.
- */
-type HostCallResult = {
-    readonly ok: true;
-    readonly value?: string;
-} | {
-    readonly ok: false;
-    readonly code: string;
-    readonly message: string;
-};
-/** How long a `HostCall` may stay outstanding before the runtime rejects it itself. */
-declare const HOST_CALL_TIMEOUT_MS = 10000;
-/** 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;
-    /**
-     * Week 12: start host-side async work (D24 save, D25 KV). The host **must** deliver the
-     * outcome by calling `RoomCoreApi.completeHostCall(reqId, result)` from its own event loop
-     * turn, never synchronously from inside this call — a handler is on the stack.
-     */
-    hostCall(reqId: number, call: HostCall): void;
-    /**
-     * D26: arm the durable alarm `name` for `atMs`, or cancel it when `atMs` is `undefined`.
-     * Arming a name that is already armed replaces its due time. Alarm state is the **host's**,
-     * not the room's: nothing about it goes into the hibernation blob, and the host fires one by
-     * calling `RoomCoreApi.fireAlarm(name)`.
-     */
-    setAlarm(name: string, atMs: number | undefined): 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;
-    /**
-     * D25: the identity `ctx.playerId` reports and `room.kv` is meant to be keyed by. Defaults to
-     * `clientId`, which — because a resume token carries the client id across a reconnect — is
-     * exactly the resume-token identity, and no more stable than that token. Week 13 (D27) passes
-     * a JWT subject here instead without anything else changing.
-     */
-    readonly playerId?: string;
-}
-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;
-    aoiEncodesLastFlush: number;
-    gridBuildMs: number;
-    gridQueryMs: number;
-    aoiEncodeMs: number;
-    visibleIdsTotal: number;
-    membershipEnters: number;
-    membershipLeaves: 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;
-    /**
-     * D24: the same bytes `serialize()` produces, with none of its side effects — the room carries
-     * on exactly as it was. This is what a save generation is written from; `serialize()` is what
-     * a room going to sleep is written from.
-     */
-    snapshot(): Uint8Array;
-    /** Live JSON view of the room (dev page / supervisor admin API). */
-    inspect(): RoomInspection;
-    /**
-     * Week 12: settles the promise `hostCall(reqId, …)` returned. The host calls this from its own
-     * turn; the runtime runs the continuation as a discrete event and flushes afterwards, so state
-     * a continuation mutated goes out exactly like state a handler mutated.
-     */
-    completeHostCall(reqId: number, result: HostCallResult): void;
-    /**
-     * D26: runs the `alarms[name]` handler as its own event between ticks, then flushes. Unknown
-     * names are logged and ignored — a room that dropped a handler in a redeploy must not crash on
-     * an alarm armed by the version before it.
-     */
-    fireAlarm(name: string): void;
-}
-
-export { EVENT_RING_SIZE as E, HOST_CALL_TIMEOUT_MS as H, type JoinOptions as J, type LogLevel as L, type RoomCoreApi as R, type HostCall as a, type HostCallResult as b, type JoinResult as c, type RoomCoreOptions as d, type RoomEvent as e, type RoomEventKind as f, RoomFullError as g, type RoomHost as h, type RoomInspection as i, type RoomStats as j, inspectState as k };