@irtio/cli 0.6.0 → 0.8.0

package/dist/deploy.js

@@ -1,28 +1,28 @@
 import {
   logEnsured,
   runStaticDeploy
-} from "./chunk-3HQMVCYA.js";
+} from "./chunk-BQBOBFBO.js";
 import {
   clientImportsRoom
 } from "./chunk-TQU6345E.js";
-import "./chunk-RQSJZWQC.js";
+import "./chunk-WFMRNGO5.js";
 import {
   ensureProject,
   readProjectConfig
-} from "./chunk-DKWG7MGO.js";
+} from "./chunk-JL235KIE.js";
 import {
   bundleRoom
-} from "./chunk-OTSFRVJN.js";
+} from "./chunk-NOYGY3HA.js";
 import {
   HelpRequested,
   helpFor,
   helpRequested
-} from "./chunk-ZD4ND6X6.js";
+} from "./chunk-OCVALOGK.js";
 import {
   ApiClientError,
   createApiClient,
   isLoginRequired
-} from "./chunk-RNAH5T4W.js";
+} from "./chunk-IDF46P7R.js";
 import {
   resolveControlUrlForUser
 } from "./chunk-UPHQM6NZ.js";
@@ -37,6 +37,7 @@ import { DEFAULT_ROOM_TYPE, ROOM_TYPE_RE } from "@irtio/protocol";
 import { diffSchemas, schemaFromCanonical } from "@irtio/schema";
 import pc from "picocolors";
 var ROOM_CANDIDATES = ["irtio/room.ts", "irtio/room.js", "room.ts"];
+var SCHEMA_CANDIDATES = ["irtio/schema.ts", "irtio/schema.js"];
 var MIGRATIONS_DIR = "irtio/migrations";
 var ROOM_TYPES_DIR = "irtio/rooms";
 var USAGE = `usage: irtio deploy [options]
@@ -145,12 +146,20 @@ function findRoomEntry(cwd, room) {
   }
   return void 0;
 }
+function findSchemaEntry(cwd) {
+  for (const candidate of SCHEMA_CANDIDATES) {
+    const file = path.resolve(cwd, candidate);
+    if (existsSync(file)) return file;
+  }
+  return void 0;
+}
 function resolveEntry(cwd, room) {
   const entry = findRoomEntry(cwd, room);
   if (entry !== void 0) return entry;
   throw new Error(
     `irtio deploy: no room file found in ${cwd}
   looked for: ${ROOM_CANDIDATES.join(", ")}
+  or ${SCHEMA_CANDIDATES.join(" / ")}, to deploy a schema with no room code
   pass --room <file> if it lives elsewhere`
   );
 }
@@ -235,12 +244,160 @@ async function findMigrationFile(cwd, version) {
   return match ? path.join(dir, match) : void 0;
 }
 var DEPLOY_BUILD_DIR = path.join(".irtio", "deploy");
+function isSchemaOnly(cwd, room) {
+  if (room !== void 0) return false;
+  if (findRoomEntry(cwd, void 0) !== void 0) return false;
+  if (existsSync(path.resolve(cwd, ROOM_TYPES_DIR))) return false;
+  return findSchemaEntry(cwd) !== void 0;
+}
+async function loadDeployedSchema(entry, outDir, irtioPackages) {
+  const bundled = await bundleRoom({
+    entry,
+    outDir,
+    verify: false,
+    ...irtioPackages !== void 0 ? { irtioPackages } : {}
+  });
+  const mod = await import(pathToFileURL(bundled.file).href);
+  const schema = mod.schema ?? mod.default;
+  if (!schema || typeof schema.canonical !== "string" || typeof schema.hash !== "string") {
+    throw new Error(
+      `irtio deploy: ${path.basename(entry)} does not export a schema
+  it must export the value defineSchema(...) returned, as \`schema\` or as the default`
+    );
+  }
+  return schema;
+}
+async function runSchemaOnlyDeploy(options, cwd, log, ask, controlUrl, config) {
+  const entry = findSchemaEntry(cwd);
+  const outDir = path.join(cwd, DEPLOY_BUILD_DIR);
+  await mkdir(outDir, { recursive: true });
+  const schema = await loadDeployedSchema(entry, outDir, options.irtioPackages);
+  log(pc.green(`bundled ${path.relative(cwd, entry)} (schema ${schema.hash.slice(0, 12)})`));
+  const client = options.client ?? await createApiClient(controlUrl);
+  const projectId = options.project ?? config.project ?? schema.project;
+  if (projectId === void 0) {
+    throw new Error(
+      'irtio deploy: no project id \u2014 pass --project, add "project" to irtio.json, or set it in defineSchema(...)'
+    );
+  }
+  const ensured = await ensureProject(client, projectId, {
+    cwd,
+    config,
+    command: "irtio deploy",
+    ...options.name !== void 0 ? { name: options.name } : {}
+  });
+  logEnsured(log, projectId, ensured);
+  const deployments = await client.get(`/v1/projects/${projectId}/deployments`);
+  const newestOf = (list) => list.reduce(
+    (best, d) => best === void 0 || d.version > best.version ? d : best,
+    void 0
+  );
+  const previous = newestOf(deployments.filter((d) => d.rolledBackAt == null));
+  const newest = newestOf(deployments);
+  const nextVersion = (newest?.version ?? 0) + 1;
+  let allowBreaking = options.allowBreaking ?? false;
+  let migrationFile;
+  if (previous !== void 0) {
+    const changes = diffSchemas(schemaFromCanonical(previous.schemaJson), schema);
+    const breaking = changes.filter((c) => c.kind === "breaking");
+    const additive = changes.filter((c) => c.kind === "additive");
+    if (breaking.length > 0) {
+      if (!allowBreaking) {
+        const hint = "run: irtio migrate create <name>";
+        printBreaking(log, breaking, hint);
+        throw new DeployRefusedError({ changes: breaking, hint });
+      }
+      migrationFile = await findMigrationFile(cwd, nextVersion);
+      if (migrationFile === void 0) {
+        const hint = `--allow-breaking needs a migration for v${nextVersion}. Run: irtio migrate create <name>`;
+        printBreaking(log, breaking, hint);
+        throw new DeployRefusedError({ changes: breaking, hint });
+      }
+      log(pc.yellow(`${breaking.length} breaking change(s), proceeding with --allow-breaking:`));
+      for (const change of breaking) log(`  ${change.message}`);
+    } else {
+      allowBreaking = false;
+    }
+    if (additive.length > 0) {
+      log(pc.cyan(`${additive.length} additive change(s):`));
+      for (const change of additive) log(`  ${change.message}`);
+    }
+    if (changes.length === 0) log(pc.dim("no schema changes"));
+  } else {
+    log(pc.dim("no previous deployment, so this is the first deploy for this project"));
+  }
+  let migrationKey;
+  if (migrationFile !== void 0) {
+    const migrationBundle = await bundleRoom({
+      entry: migrationFile,
+      outDir,
+      verify: false,
+      ...options.irtioPackages !== void 0 ? { irtioPackages: options.irtioPackages } : {}
+    });
+    const uploaded = await client.postBytes(
+      `/v1/projects/${projectId}/artifacts`,
+      new Uint8Array(await readFile(migrationBundle.file))
+    );
+    migrationKey = uploaded.key;
+    log(pc.green(`bundled and uploaded migration ${path.basename(migrationFile)}`));
+  }
+  let origin;
+  if (previous === void 0) {
+    const answer = (await ask("production origin (localhost is always allowed) \u2014 leave blank to skip: ")).trim();
+    if (answer.length > 0) origin = answer;
+  }
+  let created;
+  try {
+    created = await client.post(`/v1/projects/${projectId}/deployments`, {
+      // No `bundleHash` and no `bundleKey`: that absence IS the schema-only deploy, and it is
+      // what makes control write a row `isRelayOnly` reads as relay-only.
+      schemaJson: schema.canonical,
+      schemaHash: schema.hash,
+      ...migrationKey !== void 0 ? { migrationKey } : {},
+      ...allowBreaking ? { allowBreaking: true } : {},
+      ...origin !== void 0 ? { origin } : {}
+    });
+  } catch (err) {
+    if (err instanceof ApiClientError && err.code === "E_BREAKING_SCHEMA" && err.changes) {
+      const changes = err.changes;
+      const hint = err.hint ?? "run: irtio migrate create <name>";
+      printBreaking(log, changes, hint);
+      throw new DeployRefusedError({ changes, hint });
+    }
+    if (isLoginRequired(err)) throw err;
+    throw err;
+  }
+  await rm(outDir, { recursive: true, force: true }).catch(() => {
+  });
+  log(pc.green(`deployed v${created.version}`));
+  log(pc.dim("schema-only deploy: this project runs as a relay tenant"));
+  log(pc.dim(`reachable at ${created.url}`));
+  const result = {
+    project: projectId,
+    version: created.version,
+    url: created.url,
+    draining: created.draining,
+    ...created.applied !== void 0 ? { applied: created.applied } : {}
+  };
+  if (config.static === void 0 || options.noStatic === true) return result;
+  const site = await runStaticDeploy({
+    cwd,
+    ...options.config !== void 0 ? { config: options.config } : {},
+    ...options.controlUrl !== void 0 ? { controlUrl: options.controlUrl } : {},
+    ...options.client !== void 0 ? { client: options.client } : {},
+    log
+  });
+  return { ...result, site };
+}
 async function runDeploy(options = {}) {
   const cwd = path.resolve(options.cwd ?? process.cwd());
   const log = options.log ?? ((line) => console.log(line));
   const ask = options.ask ?? defaultAsk;
   const controlUrl = await resolveControlUrlForUser(options.controlUrl);
   const config = await readProjectConfig(cwd, "irtio deploy", options.config);
+  if (isSchemaOnly(cwd, options.room)) {
+    return runSchemaOnlyDeploy(options, cwd, log, ask, controlUrl, config);
+  }
   const roomTypes = findRoomTypes(cwd, options.room);
   const entry = roomTypes.default;
   await warnIfClientImportsRoom(cwd, entry, config, log);
@@ -562,6 +719,7 @@ export {
   deploy,
   findRoomEntry,
   findRoomTypes,
+  findSchemaEntry,
   parseDeployArgs,
   runDeploy
 };

package/dist/{dev-QM26ONKS.js → dev-VJ2ATJTF.js}

@@ -23,20 +23,20 @@ import {
   ratingValueProblem,
   saveKey,
   verifyAssertion
-} from "./chunk-RQSJZWQC.js";
+} from "./chunk-WFMRNGO5.js";
 import {
   readProjectConfig
-} from "./chunk-DKWG7MGO.js";
+} from "./chunk-JL235KIE.js";
 import {
   BundleError,
   bundleRoom
-} from "./chunk-OTSFRVJN.js";
+} from "./chunk-NOYGY3HA.js";
 import {
   HelpRequested,
   helpFor,
   helpRequested
-} from "./chunk-ZD4ND6X6.js";
-import "./chunk-RNAH5T4W.js";
+} from "./chunk-OCVALOGK.js";
+import "./chunk-IDF46P7R.js";
 import "./chunk-UPHQM6NZ.js";
 
 // src/dev.ts
@@ -187,9 +187,11 @@ import {
   isMailboxAlarm,
   isOutboxAlarm,
   isRelayHash8,
+  isTypedMsg,
   isVoiceMsg,
   relaySchema as relaySchema2,
   schemaPayload,
+  typedMsgFromClientOk,
   withBuiltins
 } from "@irtio/protocol";
 import { inspectState } from "@irtio/runtime";
@@ -402,10 +404,12 @@ function relayForward(room, peer, type, payload) {
   }
   let target;
   let body;
+  let typed;
   try {
     const msg = decodeMsg(payload);
     target = msg.target;
     body = msg.payload;
+    typed = msg.typed;
   } catch {
     return { ok: false, reason: "malformed MSG" };
   }
@@ -415,7 +419,11 @@ function relayForward(room, peer, type, payload) {
   if (target.kind === "voice") return { ok: true, dropped: true };
   const out = encodeFrame(
     FrameType.MSG,
-    encodeMsg({ target: { kind: "client", clientId: peer.clientId }, payload: body })
+    encodeMsg({
+      target: { kind: "client", clientId: peer.clientId },
+      payload: body,
+      ...typed ? { typed } : {}
+    })
   );
   for (const other of room.peers()) {
     if (other === peer || other.state !== "joined") continue;
@@ -1738,6 +1746,33 @@ var RoomRecord = class {
    * which is the arena case and the common one.
    */
   backfillOpen = true;
+  // ---- M6 lane H: lobby front door ----
+  /**
+   * D75: whether this room is currently in control's public registry, and which queue under.
+   *
+   * On the record for `backfillOpen`'s reasons — out of the hibernation blob, and the supervisor's
+   * own bookkeeping — but NOT reset on a worker ready, and that difference is the whole point.
+   * `lobbyStarted` is a one-way door: a room whose game has started must never be advertised
+   * again, and a reset would re-offer it to a stranger on the first poll after a wake.
+   */
+  lobbyPublic = false;
+  lobbyQueue;
+  lobbyStarted = false;
+  /**
+   * Has this room said anything about its lobby yet?
+   *
+   * This is the difference between "private" and "not in the registry conversation", and getting it
+   * wrong was a real bug rather than a nicety. The first version reported the lobby fields only
+   * when `lobbyPublic` was true, so a `false` never left the box: control's deregister branch was
+   * unreachable, and a host who made a lobby public and then private kept receiving strangers while
+   * their own panel said private.
+   *
+   * The two states still have to stay apart, because absence is what an agent older than this lane
+   * sends for every room on its box and what every room without a lobby sends forever — control
+   * reads it as "leave this room's registry row alone". So the latch: once a room has spoken, every
+   * report carries its current answer, `false` included.
+   */
+  lobbySpoken = false;
   /**
    * The deployment version this room was created under. New rooms take the newest; rooms created
    * before a deploy keep theirs until they idle (per-room drain, plan §3.3).
@@ -1901,7 +1936,18 @@ var RoomRecord = class {
       // only when the room type declared it, so "absent" and "not a candidate" stay the same
       // thing all the way to control's nullable column.
       maxClients: this.config.maxClients,
-      ...this.config.backfill === true ? { backfill: this.backfillNow } : {}
+      ...this.config.backfill === true ? { backfill: this.backfillNow } : {},
+      // ---- M6 lane H: lobby front door ----
+      // Reported by a room that has said something about its lobby, and by no other room, so
+      // "absent" stays "not in the registry conversation at all" — the same shape `backfill` uses,
+      // and what keeps a mixed fleet degrading to "no public rooms from the old boxes".
+      //
+      // Once a room HAS spoken, its current answer goes out on every report including `false`. See
+      // `lobbySpoken` for the bug that came of only ever reporting `true`.
+      ...this.lobbyStarted ? { lobbyStarted: true } : this.lobbySpoken ? {
+        public: this.lobbyPublic,
+        ...this.lobbyQueue !== void 0 ? { queue: this.lobbyQueue } : {}
+      } : {}
     };
   }
 };
@@ -2441,6 +2487,7 @@ var IDENTITY_KEY_WAIT_MS = 2e3;
 var MAX_IDENTITY_KEY_WAITERS = 64;
 var RESUME_TOKEN_TTL_MS = 24 * 60 * 60 * 1e3;
 var BUS_SEEN_MAX = 256;
+var LOBBY_QUEUE_RE = /^[a-z0-9][a-z0-9._-]{0,31}$/;
 var SHARD_ASSIGNMENT_RETRY_MS = [1e3, 3e4];
 var KvUnavailable = class extends Error {
   code = KV_ERRORS.unavailable;
@@ -3008,9 +3055,29 @@ var SupervisorImpl = class {
    *
    * They go into a ring under the reserved id `__tenant` (D38), so the whole existing pipeline
    * carries them with no new route and no new frame.
+   *
+   * bug #53 (D67-g, which recorded the gap rather than closing it): on a **sharded** tenant every
+   * ring line is tagged `[shard n]`. Every shard of a project ships its `__tenant` ring under the
+   * same project and the same reserved room id, `log_events` has no shard column, and control
+   * drops the frame's shard before the insert, so without the tag `irtio logs` shows two shards'
+   * boot lines interleaved by time and calls them one restart. The tag is written here, at the
+   * source, because this process is the only thing that knows which shard it is without being
+   * told, and one string in the message beats a schema change on an append-only table.
+   *
+   * It is the mirror of `roomLog` below, and for the same reason: a ring line carries whatever its
+   * stream's identity does not. A room's ring is keyed by the room, so its lines stay bare and the
+   * console gets the `[room]` prefix; the tenant ring is keyed by `__tenant` alone, so its lines
+   * carry the shard and the console stays bare — each shard is its own VM with its own console
+   * file, which already says which shard is talking.
+   *
+   * A single-shard tenant (every tenant that exists today) takes the same bare `args` it always
+   * did, byte for byte: `single-shard-pin.test.ts` holds that.
    */
   log(level, ...args) {
-    this.tenantLogs.push(level, args);
+    this.tenantLogs.push(
+      level,
+      this.isSharded() ? [`[shard ${this.config.shard ?? 0}]`, ...args] : args
+    );
     this.emit(level, args);
   }
   /** The console/config sink, with no ring behind it. */
@@ -3047,9 +3114,20 @@ var SupervisorImpl = class {
    * shape, so a dev tenant's existing snapshots stay readable.
    */
   /**
-   * The read-only admin API the host agent polls from outside the VM (week 5). It exists only
-   * when `adminToken` is configured, and every route is a projection of `SupervisorAdmin` — the
-   * agent must not be able to *change* anything about a tenant it is shipping telemetry for.
+   * The admin API the host agent polls from outside the VM (week 5). It exists only when
+   * `adminToken` is configured.
+   *
+   * Its original rule was that every route is a projection of `SupervisorAdmin` and the agent must
+   * not be able to *change* anything about a tenant it is shipping telemetry for. That rule now
+   * has five exceptions, each added deliberately and each documented at its own `case`:
+   * `/admin/resume` (D31, the post-restore wall clock), `/admin/deploy` (the in-place deploy),
+   * `/admin/caps` (D48), `/admin/identity-keys` (D53), `/admin/bus/deliver` (D67-e) and
+   * `/admin/rooms/evict` (M6 lane A, D68-d). The surviving half of the rule is the part that
+   * matters and it is unchanged: every one of them is a **push from control**, arriving over the
+   * fleet socket and relayed by the agent with the derived admin token. None of them is something
+   * a guest, a tenant or anything else that can reach this port may originate.
+   *
+   * `/admin/rooms/evict` is the one that disconnects players, so it is the one to read carefully.
    */
   serveAdmin(req, res) {
     const token = this.config.adminToken;
@@ -3317,6 +3395,55 @@ var SupervisorImpl = class {
         });
         return true;
       }
+      // ---- M6 lane A: rooms API ----
+      // D68-d: the FIFTH write on this surface, and the only one that disconnects players. A
+      // `DELETE ?force=true` on the rooms API reached control, control authorized it, and this is
+      // control telling the guest to let the room go before the objects are removed underneath it.
+      //
+      // Same `adminToken` gate as every other route here, which is the whole access story: the
+      // token is derived per project from the agent's own fleet token and never leaves the box, so
+      // a tenant cannot forge it, and the frame that triggers this is `ControlToAgent` — a
+      // direction a guest cannot speak on the fleet socket at all.
+      //
+      // Answers `{ outcome }`, never an error for "not here": a room this tenant is not holding is
+      // `absent`, and control deletes the family either way.
+      case "/admin/rooms/evict": {
+        if (req.method !== "POST") {
+          res.writeHead(405, { "content-type": "application/json" });
+          res.end('{"error":"POST only"}');
+          return true;
+        }
+        let body = "";
+        req.on("data", (d) => {
+          body += d.toString();
+        });
+        req.on("end", () => {
+          void (async () => {
+            let parsed;
+            try {
+              parsed = JSON.parse(body || "{}");
+            } catch {
+              res.writeHead(400, { "content-type": "application/json" });
+              res.end('{"error":"body is not JSON"}');
+              return;
+            }
+            if (typeof parsed.roomId !== "string" || parsed.roomId.length === 0) {
+              res.writeHead(400, { "content-type": "application/json" });
+              res.end('{"error":"roomId must be a non-empty string"}');
+              return;
+            }
+            try {
+              json({ outcome: await this.evictRoom(parsed.roomId) });
+            } catch (err) {
+              this.log("error", "admin room evict failed", err);
+              res.writeHead(500, { "content-type": "application/json" });
+              res.end(JSON.stringify({ error: err instanceof Error ? err.message : String(err) }));
+            }
+          })();
+        });
+        return true;
+      }
+      // ---- end M6 lane A ----
       case "/admin/caps": {
         if (req.method === "GET") {
           const state = this.caps.current();
@@ -4403,7 +4530,7 @@ var SupervisorImpl = class {
             message: `${call.playerId} is not a client of room ${room.id}; leaderboard submits are only accepted for players currently in the room`
           };
         }
-        await this.requireLeaderboard().submit(call.board, call.playerId, call.score);
+        await this.requireLeaderboard().submit(call.board, call.playerId, call.score, call.bucket);
         return { ok: true };
       }
       case "ratingReport": {
@@ -5106,6 +5233,43 @@ var SupervisorImpl = class {
     });
     this.roomLog(room, "info", `room closed: ${message}`);
   }
+  // ---- M6 lane A: rooms API ----
+  /**
+   * M6 lane A (D68-d): stop one room and remove its stored keys, because control is about to
+   * delete the rest of its family.
+   *
+   * Answers `'absent'` when this tenant is not holding the room, which is not a failure and is
+   * most of the real cases: the room went to sleep, or this tenant restarted, and control's row
+   * was a poll behind. Control deletes the family either way.
+   *
+   * **The race this exists to close, and why the `await` is the fix.** `closeRoom` already deletes
+   * the live key and the alarm sidecar, and refuses to run twice. What it cannot do on its own is
+   * stop a hibernation that is *already in flight*: by then `hibernateRoom` has read the worker's
+   * snapshot and is inside `putSnapshotWithRetry`, so its `store.put` lands after `closeRoom`'s
+   * `store.delete` and after control's `deleteRoomFamily` — and the room is resurrected as a live
+   * key nothing will ever delete again, because its row is gone, so the reaper cannot see it and
+   * `irtio rooms` cannot list it. Awaiting `room.transition` first removes that window: every path
+   * that can write a snapshot (`hibernateRoom`, `hibernateRelay`, `migrateRoom`, `wakeRoom`)
+   * publishes itself there and settles before the deletes run, and no NEW one can start, because
+   * they all early-return on a state that is not `running` and `closeRoom` has set `closed`.
+   *
+   * The two deletes are awaited, unlike `closeRoom`'s own fire-and-forget pair, for the same
+   * reason: control lists the bucket the instant this answers.
+   *
+   * `flushAll` (tenant idle) needs no guard of its own: `closeRoom` removes the record from the
+   * registry and the flush walks the registry.
+   */
+  async evictRoom(roomId) {
+    const room = this.registry.get(roomId);
+    if (room === void 0) return "absent";
+    await room.transition.catch(() => void 0);
+    this.closeRoom(room, "E_ROOM_DELETED", `room ${roomId} was deleted by an operator`);
+    const key = this.storeKey(room);
+    await this.store.delete(key).catch(() => void 0);
+    await this.store.delete(alarmsKey(key)).catch(() => void 0);
+    return "evicted";
+  }
+  // ---- end M6 lane A ----
   // -------------------------------------------------------------------------
   // Joining
   // -------------------------------------------------------------------------
@@ -5351,6 +5515,9 @@ var SupervisorImpl = class {
       this.handleVoiceFrame(room, session, payload.subarray(1));
       return;
     }
+    if (type === FrameType3.MSG && isTypedMsg(payload) && !typedMsgFromClientOk(payload)) {
+      return;
+    }
     if (room.relay) {
       this.relayFrame(room, session, type, payload);
       return;
@@ -5551,6 +5718,38 @@ var SupervisorImpl = class {
       case "setBackfill":
         room.backfillOpen = msg.open;
         return;
+      // ---- M6 lane H: lobby front door ----
+      case "setLobby": {
+        if (room.config.lobby !== true) {
+          this.roomLog(
+            room,
+            "warn",
+            "refusing setLobby: this room type declared no lobby, so it cannot enter the public registry"
+          );
+          return;
+        }
+        if (msg.started === true) {
+          room.lobbySpoken = true;
+          room.lobbyStarted = true;
+          room.lobbyPublic = false;
+          return;
+        }
+        if (room.lobbyStarted) return;
+        if (msg.queue !== void 0) {
+          if (!LOBBY_QUEUE_RE.test(msg.queue)) {
+            this.roomLog(
+              room,
+              "warn",
+              `refusing setLobby: queue ${JSON.stringify(msg.queue)} must be 1-32 of a-z 0-9 . _ - and start with a letter or digit`
+            );
+            return;
+          }
+          room.lobbyQueue = msg.queue;
+        }
+        room.lobbySpoken = true;
+        if (msg.public !== void 0) room.lobbyPublic = msg.public;
+        return;
+      }
       case "setAlarm":
         if (isMailboxAlarm(msg.name)) {
           this.roomLog(
@@ -5735,6 +5934,7 @@ var SupervisorImpl = class {
         room.metrics.ticks = stats.ticks;
         room.metrics.maxTickMs = stats.maxTickMs;
         room.metrics.overruns = stats.overruns;
+        room.metrics.messagesDropped = stats.messagesDropped;
         if (msg.heap !== void 0) {
           this.recordHeap(room, msg.heap.usedBytes, msg.heap.limitBytes);
         }
@@ -6142,7 +6342,7 @@ async function resolveWorkerEntry2(outDir) {
   }
   const outfile = path.join(outDir, "worker.mjs");
   const runtimeDir = path.join(packagesDir, "runtime");
-  const enginePlugins = ["@dimforge/rapier3d-compat", "matter-js"].map((pkg) => engineAbsolutePlugin(runtimeDir, pkg)).filter((p) => p !== void 0);
+  const enginePlugins = ["@dimforge/rapier3d-compat", "matter-js", "@dimforge/rapier2d-compat"].map((pkg) => engineAbsolutePlugin(runtimeDir, pkg)).filter((p) => p !== void 0);
   await esbuild.build({
     entryPoints: [source],
     bundle: true,
@@ -6161,7 +6361,13 @@ async function resolveWorkerEntry2(outDir) {
     // bundle resolves via node_modules. `rapierPlugin` (above) already externalizes it at an
     // absolute path when `@irtio/runtime`'s own copy can be found; this string entry is the
     // fallback for a published install where that resolution comes for free from node_modules.
-    external: ["node:worker_threads", "node:url", "@dimforge/rapier3d-compat", "matter-js"]
+    external: [
+      "node:worker_threads",
+      "node:url",
+      "@dimforge/rapier3d-compat",
+      "matter-js",
+      "@dimforge/rapier2d-compat"
+    ]
   });
   return outfile;
 }