@irtio/cli 0.5.0 → 0.5.2

package/dist/{deploy-6OM3UYNL.js → deploy-3SABPL3T.js}

@@ -4,14 +4,24 @@ import {
 import {
   bundleRoom
 } from "./chunk-KRQUAEN2.js";
+import {
+  logEnsured,
+  runStaticDeploy
+} from "./chunk-GBNHBWES.js";
+import "./chunk-BPE452KF.js";
+import {
+  ensureProject,
+  readProjectConfig
+} from "./chunk-32QTPKVT.js";
 import {
   ApiClientError,
+  HelpRequested,
   createApiClient,
-  isLoginRequired
-} from "./chunk-I37DLT7K.js";
-import {
+  helpFor,
+  helpRequested,
+  isLoginRequired,
   resolveControlUrlForUser
-} from "./chunk-NVUKSP5U.js";
+} from "./chunk-TV66QHFP.js";
 
 // src/deploy.ts
 import { existsSync } from "fs";
@@ -23,7 +33,30 @@ import { diffSchemas, schemaFromCanonical } from "@irtio/schema";
 import pc from "picocolors";
 var ROOM_CANDIDATES = ["irtio/room.ts", "irtio/room.js", "room.ts"];
 var MIGRATIONS_DIR = "irtio/migrations";
+var USAGE = `usage: irtio deploy [options]
+       irtio deploy --static [<dir>] [options]
+
+Bundles the room, classifies the schema change against the last deployment, and uploads. A
+breaking change is refused unless a migration covers it. With "static" in the project file the
+client directory ships too, after the room.
+
+options:
+  --allow-breaking          accept a breaking schema change that a migration covers
+  --strategy drain|migrate  drain (the default) lets running rooms finish on the old version;
+                            migrate moves live rooms onto the new one now
+  --room <file>             the room entry
+  --project <id>            project id (default: the project file)
+  --name <name>             the name a first deploy registers the project under
+  --no-static               deploy the room alone, even with "static" configured
+  -c, --config <f>          the project file to read (default irtio.json)
+  --url <control>           control plane (default: your stored login)
+  -h, --help                print this
+
+irtio deploy --static uploads a BUILT client directory and nothing else. It takes --label <label>
+plus --project, --name, --config and --url; the directory and label default to the project file.
+`;
 function parseDeployArgs(args) {
+  if (helpRequested(args)) throw helpFor(USAGE);
   const parsed = {
     allowBreaking: false
   };
@@ -33,12 +66,32 @@ function parseDeployArgs(args) {
       case "--allow-breaking":
         parsed.allowBreaking = true;
         break;
+      case "--no-static":
+        parsed.noStatic = true;
+        break;
       case "--project": {
         const value = args[++i];
         if (value === void 0) throw new Error("irtio deploy: --project needs a value");
         parsed.project = value;
         break;
       }
+      case "--name": {
+        const value = args[++i];
+        if (value === void 0 || value === "") {
+          throw new Error("irtio deploy: --name needs a value");
+        }
+        parsed.name = value;
+        break;
+      }
+      case "-c":
+      case "--config": {
+        const value = args[++i];
+        if (value === void 0 || value === "") {
+          throw new Error("irtio deploy: --config needs a value");
+        }
+        parsed.config = value;
+        break;
+      }
       case "--url": {
         const value = args[++i];
         if (value === void 0) throw new Error("irtio deploy: --url needs a value");
@@ -74,7 +127,7 @@ async function defaultAsk(question) {
     rl.close();
   }
 }
-function resolveEntry(cwd, room) {
+function findRoomEntry(cwd, room) {
   if (room !== void 0) {
     const file = path.resolve(cwd, room);
     if (!existsSync(file)) throw new Error(`irtio deploy: no room file at ${file}`);
@@ -84,46 +137,19 @@ function resolveEntry(cwd, room) {
     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(", ")}
   pass --room <file> if it lives elsewhere`
   );
 }
-async function readIrtioJsonProject(cwd) {
-  const file = path.join(cwd, "irtio.json");
-  if (!existsSync(file)) return void 0;
-  let parsed;
-  try {
-    parsed = JSON.parse(await readFile(file, "utf8"));
-  } catch (err) {
-    throw new Error(`irtio deploy: ${file} is not valid JSON: ${String(err)}`);
-  }
-  const project = parsed?.project;
-  if (project === void 0) return void 0;
-  if (typeof project !== "string" || project.length === 0) {
-    throw new Error(`irtio deploy: ${file} has a "project" that is not a non-empty string`);
-  }
-  return project;
-}
-async function readIrtioJsonClient(cwd) {
-  const file = path.join(cwd, "irtio.json");
-  if (!existsSync(file)) return void 0;
-  let parsed;
-  try {
-    parsed = JSON.parse(await readFile(file, "utf8"));
-  } catch (err) {
-    throw new Error(`irtio deploy: ${file} is not valid JSON: ${String(err)}`);
-  }
-  const client = parsed?.client;
-  if (client === void 0) return void 0;
-  if (typeof client !== "string" || client.length === 0) {
-    throw new Error(`irtio deploy: ${file} has a "client" that is not a non-empty string`);
-  }
-  return client;
-}
-async function warnIfClientImportsRoom(cwd, entry, log) {
-  const client = await readIrtioJsonClient(cwd);
+async function warnIfClientImportsRoom(cwd, entry, config, log) {
+  const client = config.client;
   if (client === void 0) return;
   const clientFile = path.resolve(cwd, client);
   if (await clientImportsRoom(clientFile, entry)) {
@@ -162,8 +188,9 @@ async function runDeploy(options = {}) {
   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);
   const entry = resolveEntry(cwd, options.room);
-  await warnIfClientImportsRoom(cwd, entry, log);
+  await warnIfClientImportsRoom(cwd, entry, config, log);
   const outDir = path.join(cwd, DEPLOY_BUILD_DIR);
   await mkdir(outDir, { recursive: true });
   let result;
@@ -179,26 +206,19 @@ async function runDeploy(options = {}) {
   log(pc.green(`bundled ${path.basename(result.file)} (${result.hash.slice(0, 12)})`));
   const bundled = await loadBundledSchema(result.file);
   const client = options.client ?? await createApiClient(controlUrl);
-  const projectId = options.project ?? await readIrtioJsonProject(cwd) ?? bundled.project;
+  const projectId = options.project ?? config.project ?? bundled.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(...)'
     );
   }
-  let projectExists = true;
-  try {
-    await client.get(`/v1/projects/${projectId}`);
-  } catch (err) {
-    if (err instanceof ApiClientError && err.status === 404) projectExists = false;
-    else throw err;
-  }
-  if (!projectExists) {
-    const defaultName = path.basename(cwd);
-    const answer = (await ask(`project ${projectId} does not exist yet \u2014 name it [${defaultName}]: `)).trim();
-    const name = answer.length > 0 ? answer : defaultName;
-    await client.post("/v1/projects", { name, id: projectId });
-    log(pc.dim(`created project ${projectId} (${name})`));
-  }
+  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,
@@ -339,6 +359,19 @@ async function runDeploy(options = {}) {
       log(pc.dim(`rooms already running finish on v${previous.version}`));
     }
   }
+  if (config.static !== void 0 && options.noStatic !== true) {
+    const site = await runStaticDeploy({
+      cwd,
+      project: projectId,
+      log,
+      client,
+      controlUrl,
+      dir: config.static.dir,
+      ...config.static.label !== void 0 ? { label: config.static.label } : {},
+      ...options.config !== void 0 ? { config: options.config } : {}
+    });
+    return { ...response, site };
+  }
   return response;
 }
 var DeployRefusedError = class extends Error {
@@ -352,10 +385,30 @@ async function deploy(args, deps = {}) {
   const errorLog = deps.errorLog ?? ((line) => console.error(line));
   try {
     const parsed = parseDeployArgs(args);
+    const cwd = path.resolve(deps.cwd ?? process.cwd());
+    const config = await readProjectConfig(cwd, "irtio deploy", parsed.config);
+    if (parsed.room === void 0 && parsed.noStatic !== true && config.static !== void 0 && findRoomEntry(cwd, void 0) === void 0) {
+      log(pc.dim("no room file \u2014 deploying the static site only"));
+      await runStaticDeploy({
+        cwd,
+        log,
+        dir: config.static.dir,
+        ...config.static.label !== void 0 ? { label: config.static.label } : {},
+        ...parsed.project !== void 0 ? { project: parsed.project } : {},
+        ...parsed.name !== void 0 ? { name: parsed.name } : {},
+        ...parsed.config !== void 0 ? { config: parsed.config } : {},
+        ...parsed.url !== void 0 ? { controlUrl: parsed.url } : {},
+        ...deps.client !== void 0 ? { client: deps.client } : {}
+      });
+      return;
+    }
     await runDeploy({
       allowBreaking: parsed.allowBreaking,
       log,
       ...parsed.project !== void 0 ? { project: parsed.project } : {},
+      ...parsed.name !== void 0 ? { name: parsed.name } : {},
+      ...parsed.config !== void 0 ? { config: parsed.config } : {},
+      ...parsed.noStatic !== void 0 ? { noStatic: parsed.noStatic } : {},
       ...parsed.url !== void 0 ? { controlUrl: parsed.url } : {},
       ...parsed.room !== void 0 ? { room: parsed.room } : {},
       ...parsed.strategy !== void 0 ? { strategy: parsed.strategy } : {},
@@ -364,6 +417,10 @@ async function deploy(args, deps = {}) {
       ...deps.irtioPackages !== void 0 ? { irtioPackages: deps.irtioPackages } : {}
     });
   } catch (err) {
+    if (err instanceof HelpRequested) {
+      log(err.usage);
+      return;
+    }
     if (err instanceof DeployRefusedError) {
       process.exitCode = 1;
       return;
@@ -380,7 +437,9 @@ async function deploy(args, deps = {}) {
 }
 export {
   DeployRefusedError,
+  USAGE,
   deploy,
+  findRoomEntry,
   parseDeployArgs,
   runDeploy
 };

package/dist/{dev-7UZZGE4U.js → dev-QJOGXLKM.js}

@@ -16,11 +16,19 @@ import {
   pruneSaves,
   saveKey
 } from "./chunk-BPE452KF.js";
+import {
+  readProjectConfig
+} from "./chunk-32QTPKVT.js";
+import {
+  HelpRequested,
+  helpFor,
+  helpRequested
+} from "./chunk-TV66QHFP.js";
 
 // src/dev.ts
 import { existsSync } from "fs";
 import { watch } from "fs";
-import { mkdir, readFile } from "fs/promises";
+import { mkdir } from "fs/promises";
 import { createRequire } from "module";
 import * as path from "path";
 import { fileURLToPath, pathToFileURL as pathToFileURL3 } from "url";
@@ -43,6 +51,46 @@ var DEFAULT_LIMITS = {
   saveRetain: DEFAULT_SAVE_RETAIN
 };
 
+// ../supervisor/src/codes.ts
+import { randomInt } from "crypto";
+var CODE_ALPHABET = "ABCDEFGHJKLMNPQRSTUVWXYZ23456789";
+var ROOM_ID_RE = /^[A-Za-z0-9_-]{1,32}$/;
+var TENANT_ROOM_ID = "__tenant";
+var CODE_SHAPE_RE = /^[A-Za-z0-9]{4,5}$/;
+function pick(n) {
+  let out = "";
+  for (let i = 0; i < n; i++) out += CODE_ALPHABET[randomInt(CODE_ALPHABET.length)];
+  return out;
+}
+function newRoomCode(taken) {
+  for (let len = 4; len <= 8; len++) {
+    for (let attempt = 0; attempt < 64; attempt++) {
+      const code = pick(len);
+      if (!taken(code)) return code;
+    }
+  }
+  throw new Error("newRoomCode: exhausted the room code space");
+}
+function newClientId(taken) {
+  for (let attempt = 0; attempt < 128; attempt++) {
+    const id = `c${pick(10)}`;
+    if (!taken(id)) return id;
+  }
+  throw new Error("newClientId: could not allocate a unique client id");
+}
+function looksLikeRoomCode(id) {
+  if (!CODE_SHAPE_RE.test(id)) return false;
+  for (const ch of id.toUpperCase()) {
+    if (!CODE_ALPHABET.includes(ch)) return false;
+  }
+  return true;
+}
+function normalizeRoomId(raw) {
+  if (!ROOM_ID_RE.test(raw)) return void 0;
+  if (raw === TENANT_ROOM_ID) return void 0;
+  return looksLikeRoomCode(raw) ? raw.toUpperCase() : raw;
+}
+
 // ../supervisor/src/resilience.ts
 var SNAPSHOT_FLUSH_MAX_RETRIES = 3;
 var SNAPSHOT_FLUSH_RETRY_DELAYS_MS = [100, 200, 400];
@@ -409,44 +457,6 @@ function verifyResume(secret, token, now = Date.now()) {
   return { clientId, roomId, role, expMs };
 }
 
-// ../supervisor/src/codes.ts
-import { randomInt } from "crypto";
-var CODE_ALPHABET = "ABCDEFGHJKLMNPQRSTUVWXYZ23456789";
-var ROOM_ID_RE = /^[A-Za-z0-9_-]{1,32}$/;
-var CODE_SHAPE_RE = /^[A-Za-z0-9]{4,5}$/;
-function pick(n) {
-  let out = "";
-  for (let i = 0; i < n; i++) out += CODE_ALPHABET[randomInt(CODE_ALPHABET.length)];
-  return out;
-}
-function newRoomCode(taken) {
-  for (let len = 4; len <= 8; len++) {
-    for (let attempt = 0; attempt < 64; attempt++) {
-      const code = pick(len);
-      if (!taken(code)) return code;
-    }
-  }
-  throw new Error("newRoomCode: exhausted the room code space");
-}
-function newClientId(taken) {
-  for (let attempt = 0; attempt < 128; attempt++) {
-    const id = `c${pick(10)}`;
-    if (!taken(id)) return id;
-  }
-  throw new Error("newClientId: could not allocate a unique client id");
-}
-function looksLikeRoomCode(id) {
-  if (!CODE_SHAPE_RE.test(id)) return false;
-  for (const ch of id.toUpperCase()) {
-    if (!CODE_ALPHABET.includes(ch)) return false;
-  }
-  return true;
-}
-function normalizeRoomId(raw) {
-  if (!ROOM_ID_RE.test(raw)) return void 0;
-  return looksLikeRoomCode(raw) ? raw.toUpperCase() : raw;
-}
-
 // ../supervisor/src/relay.ts
 import { PRESENCE_COLLECTION, relaySchema } from "@irtio/protocol";
 import {
@@ -1180,7 +1190,7 @@ var WorkerHost = class {
     }
   }
   onMessage(msg) {
-    if ((msg.t === "serialized" || msg.t === "inspected") && this.pending.has(msg.reqId)) {
+    if ((msg.t === "serialized" || msg.t === "inspected" || msg.t === "stats") && msg.reqId !== void 0 && this.pending.has(msg.reqId)) {
       const resolve2 = this.pending.get(msg.reqId);
       this.pending.delete(msg.reqId);
       resolve2?.(msg);
@@ -1251,6 +1261,19 @@ var WorkerHost = class {
     );
     return msg?.t === "inspected" ? msg : void 0;
   }
+  /**
+   * D36: the room's own tick counters — `overruns` and `maxTickMs` above all. `undefined` when
+   * the worker died or did not answer in time, and the caller must report that as *unavailable*
+   * rather than as zero: a room shedding ticks and a room nobody asked look identical otherwise,
+   * and that is exactly the lie the `tick-health` invariant exists to prevent.
+   */
+  async stats(timeoutMs = 2e3) {
+    const msg = await this.request(
+      (reqId) => ({ t: "stats", reqId }),
+      timeoutMs
+    );
+    return msg?.t === "stats" ? msg.stats : void 0;
+  }
   /** Intentional shutdown: `onDead` is not fired. */
   async terminate() {
     if (this.disposed) return;
@@ -1370,6 +1393,11 @@ var SupervisorImpl = class {
   limits;
   store;
   processMetrics = newProcessMetrics();
+  /**
+   * D38: the ring behind the reserved `__tenant` room id. Same bounded ring every room gets, so
+   * a noisy boot costs the same as a noisy room and nothing here can grow without limit.
+   */
+  tenantLogs = new LogRing();
   /** The newest runnable deployment; every new room is created under it. */
   bundle;
   schemaHash;
@@ -1601,13 +1629,31 @@ var SupervisorImpl = class {
   // -------------------------------------------------------------------------
   // Logging
   // -------------------------------------------------------------------------
+  /**
+   * D38: a tenant-level event now enters the log pipeline instead of only reaching the console.
+   *
+   * `/admin/logs` reads per-room rings, so before this every event that was not about a room —
+   * boot, resume, deploy, placement, alarm recovery, storage failures — was invisible to the host
+   * agent, to the control plane, and to `irtio logs`. Those are precisely the lines somebody
+   * reaches for when a project is not working, and the only way to see them was to be on the box
+   * reading the guest console.
+   *
+   * 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.
+   */
   log(level, ...args) {
+    this.tenantLogs.push(level, args);
+    this.emit(level, args);
+  }
+  /** The console/config sink, with no ring behind it. */
+  emit(level, args) {
     if (this.config.log) this.config.log(level, ...args);
     else console[level === "info" ? "log" : level]("[irtio]", ...args);
   }
+  /** A room event: it belongs in that room's ring, and nowhere near the `__tenant` one. */
   roomLog(room, level, ...args) {
     room.log(level, ...args);
-    this.log(level, `[${room.id}]`, ...args);
+    this.emit(level, [`[${room.id}]`, ...args]);
   }
   /**
    * Week-5 snapshot keys carry the deployment version (`@v3`); version `0` keeps the week-3 key
@@ -1654,11 +1700,18 @@ var SupervisorImpl = class {
         json({ rooms: this.rooms(), deploymentVersion: this.deploymentVersion });
         return true;
       case "/admin/metrics":
-        json({
-          at: Date.now(),
-          metrics: this.metrics(),
-          rooms: this.rooms().map((r) => r.metrics)
-        });
+        void this.refreshTickHealth().then(
+          () => json({
+            at: Date.now(),
+            metrics: this.metrics(),
+            rooms: this.rooms().map((r) => r.metrics)
+          }),
+          () => json({
+            at: Date.now(),
+            metrics: this.metrics(),
+            rooms: this.rooms().map((r) => r.metrics)
+          })
+        );
         return true;
       // D31 (week 7): the ONE write on this otherwise read-only surface, and a deliberate
       // exception to its "the agent must not be able to change anything" rule: after a
@@ -1800,13 +1853,14 @@ var SupervisorImpl = class {
         const since = Number(url.searchParams.get("since") ?? 0) || 0;
         const limit = Math.min(Number(url.searchParams.get("limit") ?? 200) || 200, 1e3);
         const entries = [];
-        for (const room of this.registry.values()) {
-          for (const entry of this.logs(room.id)) {
+        const streams = [TENANT_ROOM_ID, ...this.registry.values().map((r) => r.id)];
+        for (const roomId of streams) {
+          for (const entry of this.logs(roomId)) {
             if (entry.at <= since) continue;
             entries.push({
               at: entry.at,
               level: entry.level,
-              roomId: room.id,
+              roomId,
               message: entry.args.map((x) => typeof x === "string" ? x : String(x)).join(" ")
             });
           }
@@ -3127,8 +3181,35 @@ var SupervisorImpl = class {
     };
   }
   logs(roomId) {
+    if (roomId === TENANT_ROOM_ID) return this.tenantLogs.list();
     return this.registry.get(roomId)?.logs.list() ?? [];
   }
+  /**
+   * D36: pull every live room's tick counters out of its worker and into `RoomMetrics`.
+   *
+   * The counters exist already — `RoomCore.stats.overruns` has been incremented next to the
+   * `tick overrun` log line since week 2 — but they never left the worker thread, so the one
+   * signal that says "this room is shedding work" reached nothing a client, a CLI or an operator
+   * could read. Every `overruns` a report shows now came through here.
+   *
+   * A room that does not answer is left exactly as it was, with `overruns` still `undefined` if
+   * it has never answered. That is the whole point of the field being optional: `tick-health`
+   * reports `unavailable` for it, rather than a zero nobody measured.
+   */
+  async refreshTickHealth(timeoutMs = 2e3) {
+    const live = this.registry.values().filter((r) => r.worker?.alive === true);
+    const answered = await Promise.all(
+      live.map(async (room) => {
+        const stats = await room.worker?.stats(timeoutMs);
+        if (!stats) return void 0;
+        room.metrics.ticks = stats.ticks;
+        room.metrics.maxTickMs = stats.maxTickMs;
+        room.metrics.overruns = stats.overruns;
+        return room.id;
+      })
+    );
+    return answered.filter((id) => id !== void 0);
+  }
   async inspect(roomId) {
     const room = this.registry.get(roomId);
     if (!room) return void 0;
@@ -3402,40 +3483,8 @@ function resolveEntry(cwd, room) {
   create one (export default defineRoom(schema, {...})) or pass --room <file>`
   );
 }
-async function readProjectId(cwd) {
-  const file = path.join(cwd, "irtio.json");
-  if (!existsSync(file)) return "dev";
-  let parsed;
-  try {
-    parsed = JSON.parse(await readFile(file, "utf8"));
-  } catch (err) {
-    throw new Error(`irtio dev: ${file} is not valid JSON: ${String(err)}`);
-  }
-  const project = parsed?.project;
-  if (project === void 0) return "dev";
-  if (typeof project !== "string" || project.length === 0) {
-    throw new Error(`irtio dev: ${file} has a "project" that is not a non-empty string`);
-  }
-  return project;
-}
-async function readClientEntry(cwd) {
-  const file = path.join(cwd, "irtio.json");
-  if (!existsSync(file)) return void 0;
-  let parsed;
-  try {
-    parsed = JSON.parse(await readFile(file, "utf8"));
-  } catch (err) {
-    throw new Error(`irtio dev: ${file} is not valid JSON: ${String(err)}`);
-  }
-  const client = parsed?.client;
-  if (client === void 0) return void 0;
-  if (typeof client !== "string" || client.length === 0) {
-    throw new Error(`irtio dev: ${file} has a "client" that is not a non-empty string`);
-  }
-  return client;
-}
-async function warnIfClientImportsRoom(cwd, entry, log) {
-  const client = await readClientEntry(cwd);
+async function warnIfClientImportsRoom(cwd, entry, config, log) {
+  const client = config.client;
   if (client === void 0) return;
   const clientFile = path.resolve(cwd, client);
   if (await clientImportsRoom(clientFile, entry)) {
@@ -3508,13 +3557,14 @@ async function resolveWorkerEntry2(outDir) {
   return outfile;
 }
 async function buildState(supervisor, projectId, bundle) {
+  await supervisor.refreshTickHealth().catch(() => []);
   const infos = supervisor.rooms();
   const inspects = await Promise.all(
     infos.map((room) => supervisor.inspect(room.id).catch(() => void 0))
   );
   const logs = [];
-  for (const room of infos) {
-    for (const entry of supervisor.logs(room.id)) logs.push({ ...entry, roomId: room.id });
+  for (const roomId of [TENANT_ROOM_ID, ...infos.map((r) => r.id)]) {
+    for (const entry of supervisor.logs(roomId)) logs.push({ ...entry, roomId });
   }
   logs.sort((a, b) => a.at - b.at);
   return {
@@ -3550,11 +3600,12 @@ async function startDev(options = {}) {
   const cwd = path.resolve(options.cwd ?? process.cwd());
   const log = options.log ?? ((line) => console.log(line));
   const entry = resolveEntry(cwd, options.room);
-  const projectId = await readProjectId(cwd);
+  const config = await readProjectConfig(cwd, "irtio dev", options.config);
+  const projectId = config.project ?? "dev";
   const outDir = path.join(cwd, ".irtio", "dev");
   const port = options.port ?? DEFAULT_PORT;
   await mkdir(outDir, { recursive: true });
-  await warnIfClientImportsRoom(cwd, entry, log);
+  await warnIfClientImportsRoom(cwd, entry, config, log);
   const bundleOptions = {
     entry,
     outDir,
@@ -3685,7 +3736,20 @@ async function startDev(options = {}) {
     }
   };
 }
+var USAGE = `usage: irtio dev [options]
+
+Bundles the room file, runs a real supervisor on it locally, and serves the inspector on the same
+port. Rebuilds and resets the rooms whenever the room code changes.
+
+options:
+  --room <file>      the room entry (default: irtio/room.ts, irtio/room.js, room.ts)
+  --port <n>         port to listen on (default 7070; 0 picks a free one)
+  --no-watch         do not rebuild on change
+  -c, --config <f>   the project file to read (default irtio.json)
+  -h, --help         print this
+`;
 function parseDevArgs(args) {
+  if (helpRequested(args)) throw helpFor(USAGE);
   const parsed = { watch: true };
   for (let i = 0; i < args.length; i++) {
     const arg = args[i];
@@ -3712,6 +3776,10 @@ function parseDevArgs(args) {
       case "--no-watch":
         parsed.watch = false;
         break;
+      case "-c":
+      case "--config":
+        parsed.config = value();
+        break;
       default:
         throw new Error(`irtio dev: unknown option ${JSON.stringify(arg)}`);
     }
@@ -3719,15 +3787,21 @@ function parseDevArgs(args) {
   return parsed;
 }
 async function dev(args) {
-  const parsed = parseDevArgs(args);
+  let parsed;
   let server;
   try {
+    parsed = parseDevArgs(args);
     server = await startDev({
       watch: parsed.watch,
       ...parsed.room !== void 0 ? { room: parsed.room } : {},
-      ...parsed.port !== void 0 ? { port: parsed.port } : {}
+      ...parsed.port !== void 0 ? { port: parsed.port } : {},
+      ...parsed.config !== void 0 ? { config: parsed.config } : {}
     });
   } catch (err) {
+    if (err instanceof HelpRequested) {
+      console.log(err.usage);
+      return;
+    }
     console.error(pc.red(err instanceof Error ? err.message : String(err)));
     process.exitCode = 1;
     return;
@@ -3754,6 +3828,7 @@ async function dev(args) {
   });
 }
 export {
+  USAGE,
   dev,
   parseDevArgs,
   startDev