@irtio/server 0.8.0 → 0.9.0

package/dist/index.d.ts

@@ -674,6 +674,21 @@ interface ClientInfo {
 type TimerHandle = number;
 interface Room<S extends AnySchema = AnySchema> {
     readonly id: string;
+    /**
+     * The room's tracked state — the very object every handler already gets as its first argument.
+     *
+     * It is here for the one place that has a `room` and no `state` parameter: `physics.setup`.
+     * Static geometry that depends on what the room holds (a level chosen at create, a layout
+     * restored from a snapshot) had no way to read it, and the workaround was a module-level
+     * variable set by `onCreate` — which runs *after* setup on a fresh room, so it was empty
+     * exactly when it mattered.
+     *
+     * What it holds at setup time: on a wake that had to rebuild the world, the snapshot is already
+     * decoded, so restored state is fully readable. On a fresh room it is the schema's defaults with
+     * no entities: `onCreate` has not run yet. Do not reach for `room.physics` inside setup — the
+     * world being built is the one setup is holding.
+     */
+    readonly state: State<S>;
     /** Shareable URL (`?room=<id>`). */
     readonly link: string;
     readonly tick: number;
@@ -683,6 +698,12 @@ interface Room<S extends AnySchema = AnySchema> {
     readonly clients: readonly ClientInfo[];
     /** Seeded, recorded for replay. */
     random(): number;
+    /**
+     * The resolved RNG seed: `options.seed` when given, otherwise derived from the room id.
+     * Stable for the room's whole life, survives hibernation. Use it directly for procedural
+     * generation that every client must be able to reproduce.
+     */
+    readonly seed: number;
     send(target: MessageTarget, bytes: Uint8Array): void;
     /**
      * D70: `room.messages.<name>.send(target, value)` — one of the shapes the schema declares,
@@ -709,6 +730,16 @@ interface Room<S extends AnySchema = AnySchema> {
     call(clientId: string): ServerCallProxy<SchemaRpc<S>>;
     /** Server → client void RPCs to every connected client. */
     readonly broadcast: BroadcastProxy<SchemaRpc<S>>;
+    /**
+     * The same broadcast, minus the client(s) named — `room.broadcastExcept(ctx.clientId).hit({…})`.
+     *
+     * The thing it replaces: a `from` field on the payload, and a filter on receipt in every client.
+     * That shape sends the actor its own echo, costs a schema field per RPC, and gets the comparison
+     * wrong exactly once per game. Typed identically to `broadcast` — void client-direction RPCs
+     * only. An id that is not connected (or never existed) is skipped rather than refused, so
+     * "everyone except the player who just left" is safe to say.
+     */
+    broadcastExcept(clientId: string | readonly string[]): BroadcastProxy<SchemaRpc<S>>;
     /**
      * D24: write a retained, addressable snapshot generation of this room right now and resolve
      * with its save id. Like every promise-returning room API, the continuation runs as its own

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@irtio/server",
-  "version": "0.8.0",
+  "version": "0.9.0",
   "description": "irtio room-file API: defineRoom, handler and ctx types",
   "license": "MIT",
   "publishConfig": {
@@ -20,7 +20,7 @@
     "dist"
   ],
   "dependencies": {
-    "@irtio/schema": "0.8.0"
+    "@irtio/schema": "0.9.0"
   },
   "peerDependencies": {
     "@dimforge/rapier2d-compat": ">=0.20.0",