@irtio/cli 0.5.2 → 0.6.0

package/dist/credentials.d.ts

@@ -0,0 +1,61 @@
+/**
+ * The CLI's on-disk credential store. One JSON file, keyed by control URL so a machine
+ * that talks to more than one control plane (a local dev instance and the real one) keeps both
+ * tokens without clobbering each other.
+ *
+ * Location: `~/.config/irtio/credentials.json` on macOS/Linux, `%APPDATA%/irtio/credentials.json`
+ * on Windows. This follows the platform's own convention for CLI config rather than XDG
+ * everywhere (`os.homedir()` alone gets the wrong answer on Windows, where `~/.config` is not a
+ * thing anyone looks for) — `%APPDATA%` is what `git`, `npm` and most Windows CLIs already use.
+ *
+ * The file is written mode 0600 (owner read/write only): it holds a bearer token that is exactly
+ * as sensitive as a password for whatever it authorizes. `chmod` runs after `writeFile` too,
+ * belt-and-suspenders against an umask or an existing file with looser permissions.
+ */
+/** One control plane's worth of stored auth. `email` is best-effort (see `login.ts`). */
+interface StoredCredential {
+    readonly token: string;
+    readonly expiresAt: string;
+    readonly email?: string;
+}
+type CredentialsFile = Record<string, StoredCredential>;
+/**
+ * `~/.config/irtio/credentials.json`, or `%APPDATA%/irtio/credentials.json` on Windows.
+ *
+ * `IRT_CREDENTIALS_FILE` overrides this outright — the seam the test suite uses so `login`'s
+ * end-to-end tests never touch the real machine's home directory.
+ */
+declare function credentialsPath(): string;
+/** Reads the whole file. Missing or corrupt ⇒ empty (a corrupt file is not fatal, just unlucky). */
+declare function readCredentials(): Promise<CredentialsFile>;
+/** Reads the stored credential for one control URL, or `undefined` if there is none. */
+declare function readCredential(controlUrl: string): Promise<StoredCredential | undefined>;
+/** Merges one control URL's credential into the file and writes it back, mode 0600. */
+declare function writeCredential(controlUrl: string, credential: StoredCredential): Promise<string>;
+/** Removes one control URL's credential (used by tests; not currently wired to a command). */
+declare function deleteCredential(controlUrl: string): Promise<void>;
+/**
+ * The production control plane, used when nothing more specific is known. Since the single-origin
+ * merge the control API lives at the apex; `control.irt.io` has DNS but no certificate, so the
+ * old default died at the TLS handshake with a bare "fetch failed".
+ */
+declare const DEFAULT_CONTROL_URL = "https://irt.io";
+/** `--url`, else `IRT_CONTROL_URL`, else the production control plane. */
+declare function resolveControlUrl(flag: string | undefined): string;
+/**
+ * `resolveControlUrl`, plus the one thing a user always means: **if you signed in somewhere, talk
+ * to that somewhere.**
+ *
+ * `irtio login --url https://example.test` stores the credential under that URL, but every later
+ * command used to default to `https://control.irt.io` and answer `not logged in` while a perfectly
+ * good credential sat in the file under a different key. Real time was lost to exactly
+ * that during testing, escaped only by reading the CLI's compiled source.
+ *
+ * So: an explicit `--url` or `IRT_CONTROL_URL` still wins, and a file holding credentials for
+ * several control planes stays ambiguous and falls back to the default (guessing between two
+ * logins would be worse than the default). But the overwhelmingly common case — exactly one
+ * stored login — now resolves to that one.
+ */
+declare function resolveControlUrlForUser(flag: string | undefined): Promise<string>;
+
+export { type CredentialsFile, DEFAULT_CONTROL_URL, type StoredCredential, credentialsPath, deleteCredential, readCredential, readCredentials, resolveControlUrl, resolveControlUrlForUser, writeCredential };

package/dist/credentials.js

@@ -0,0 +1,20 @@
+import {
+  DEFAULT_CONTROL_URL,
+  credentialsPath,
+  deleteCredential,
+  readCredential,
+  readCredentials,
+  resolveControlUrl,
+  resolveControlUrlForUser,
+  writeCredential
+} from "./chunk-UPHQM6NZ.js";
+export {
+  DEFAULT_CONTROL_URL,
+  credentialsPath,
+  deleteCredential,
+  readCredential,
+  readCredentials,
+  resolveControlUrl,
+  resolveControlUrlForUser,
+  writeCredential
+};

package/dist/delete-project-VENS2B44.js

@@ -0,0 +1,118 @@
+import {
+  HelpRequested,
+  helpFor,
+  helpRequested
+} from "./chunk-ZD4ND6X6.js";
+import {
+  createApiClient,
+  isLoginRequired
+} from "./chunk-RNAH5T4W.js";
+import {
+  resolveControlUrlForUser
+} from "./chunk-UPHQM6NZ.js";
+
+// src/delete-project.ts
+import pc from "picocolors";
+var USAGE = `usage: irtio delete-project <id> --yes [options]
+
+Deletes a project and every record the control plane holds about it: origins, deployments,
+signing secrets, rooms, player KV, leaderboard rows, logs, metrics and usage. This cannot be
+undone. Stored
+objects (bundles, saves, static files) are not deleted here; the platform sweeps orphans later.
+
+A project whose tenant is currently live is refused; wait for its rooms to empty first.
+
+options:
+  --yes              actually delete. Without it the command only prints what would happen
+  --url <control>    control plane (default: your stored login)
+  -h, --help         print this
+`;
+function parseDeleteProjectArgs(args) {
+  if (helpRequested(args)) throw helpFor(USAGE);
+  let project;
+  let yes = false;
+  let url;
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    switch (arg) {
+      case "--yes":
+        yes = true;
+        break;
+      case "--url": {
+        const value = args[++i];
+        if (value === void 0) throw new Error("irtio delete-project: --url needs a value");
+        url = value;
+        break;
+      }
+      default:
+        if (arg.startsWith("-")) {
+          throw new Error(`irtio delete-project: unknown option ${JSON.stringify(arg)}`);
+        }
+        if (project !== void 0) {
+          throw new Error("irtio delete-project: takes exactly one project id");
+        }
+        project = arg;
+    }
+  }
+  if (project === void 0) {
+    throw new Error(
+      "irtio delete-project: needs a project id \u2014 it is never read from irtio.json, so the wrong directory cannot pick a victim"
+    );
+  }
+  return { project, yes, ...url !== void 0 ? { url } : {} };
+}
+async function runDeleteProject(options) {
+  const log = options.log ?? ((line) => console.log(line));
+  const controlUrl = await resolveControlUrlForUser(options.controlUrl);
+  const client = options.client ?? await createApiClient(controlUrl);
+  const project = await client.get(`/v1/projects/${options.project}`);
+  if (!options.yes) {
+    log(
+      `this would delete project ${pc.bold(project.id)} (${project.name}) and every record of it: origins, deployments, keys, rooms, player KV, leaderboard rows, logs, metrics and usage`
+    );
+    log(pc.dim("nothing was deleted. This cannot be undone once it runs"));
+    log(`to proceed: irtio delete-project ${project.id} --yes`);
+    return false;
+  }
+  await client.del(`/v1/projects/${project.id}`);
+  log(pc.green(`deleted project ${project.id} (${project.name})`));
+  log(
+    pc.dim(
+      "stored objects (bundles, saves, static files) are left for the orphan sweep; nothing serves them any more"
+    )
+  );
+  return true;
+}
+async function deleteProject(args, deps = {}) {
+  const log = deps.log ?? ((line) => console.log(line));
+  const errorLog = deps.errorLog ?? ((line) => console.error(line));
+  try {
+    const parsed = parseDeleteProjectArgs(args);
+    await runDeleteProject({
+      project: parsed.project,
+      yes: parsed.yes,
+      log,
+      ...parsed.url !== void 0 ? { controlUrl: parsed.url } : {},
+      ...deps.client !== void 0 ? { client: deps.client } : {}
+    });
+  } catch (err) {
+    if (err instanceof HelpRequested) {
+      log(err.usage);
+      return;
+    }
+    if (isLoginRequired(err)) {
+      errorLog(pc.red("not logged in"));
+      errorLog("run: irtio login");
+      process.exitCode = 1;
+      return;
+    }
+    errorLog(pc.red(err instanceof Error ? err.message : String(err)));
+    process.exitCode = 1;
+  }
+}
+export {
+  USAGE,
+  deleteProject,
+  parseDeleteProjectArgs,
+  runDeleteProject
+};

package/dist/deploy.d.ts

@@ -0,0 +1,149 @@
+import { SchemaChange } from '@irtio/schema';
+import { ApiClient } from './api.js';
+import { BundleOptions } from './bundle.js';
+
+/**
+ * `irtio deploy --static <dir>` (week 13, O8/D35): upload a BUILT client directory to the
+ * project's `static/<project>/<version>/` prefix and flip the pointer. No build step — the
+ * developer brings a built directory ("Not in Week 13"). Refuses nothing silently: everything
+ * skipped is named with its reason, and every limit is a named error the caller could have seen
+ * coming (`STATIC_LIMITS`, the week-12 KV-limits shape).
+ */
+
+interface RunStaticDeployResult {
+    readonly project: string;
+    readonly label: string;
+    readonly version: number;
+    readonly files: number;
+    readonly bytes: number;
+    readonly url?: string;
+    /** The origin the deploy added to the project's allow list, when the site has a URL. */
+    readonly origin?: string;
+}
+
+/**
+ * `irtio deploy`: bundle the room, classify the schema change against the last
+ * deployment, refuse anything breaking without a migration, and hand the bundle to the control
+ * plane through the artifact-upload + deployment-create handshake. The CLI never holds storage
+ * credentials — every byte goes up through `POST /v1/projects/:id/artifacts`.
+ *
+ * `bundleRoom` is reused verbatim, including for the migration file: `verify: false` skips
+ * its "default export is a RoomDefinition" check, which a migration module does not satisfy, so
+ * the same import-menu-enforced esbuild path bundles both without any change to `bundle.ts`.
+ * A migration only needs `MigrationState`/`MigrationHelpers` as *types* — `import type { ... }
+ * from '@irtio/runtime'` — which esbuild elides before the resolver plugin ever sees it, so the
+ * `@irtio/server` / `@irtio/schema` import fence is never in the migration author's way.
+ *
+ * `bundleRoom`'s public result deliberately does not expose the canonical schema JSON or the
+ * room's `project` id (`BundleResult` is `file`/`hash`/`schemaHash`/`mode`/`warnings` only), so
+ * once the bundle is verified this module re-imports the file it already wrote to read
+ * `def.schema.project` and `def.schema.canonical` directly, rather than changing `bundleRoom`'s
+ * contract for one caller.
+ */
+
+interface DeployArgs {
+    readonly allowBreaking: boolean;
+    readonly project?: string;
+    readonly url?: string;
+    readonly room?: string;
+    readonly strategy?: 'drain' | 'migrate';
+    readonly name?: string;
+    readonly config?: string;
+    readonly noStatic?: boolean;
+}
+declare const USAGE = "usage: irtio deploy [options]\n       irtio deploy --static [<dir>] [options]\n\nBundles the room, classifies the schema change against the last deployment, and uploads. A\nbreaking change is refused unless a migration covers it. With \"static\" in the project file the\nclient directory ships too, after the room.\n\noptions:\n  --allow-breaking          accept a breaking schema change that a migration covers\n  --strategy drain|migrate  drain (the default) lets running rooms finish on the old version;\n                            migrate moves live rooms onto the new one now\n  --room <file>             the room entry\n  --project <id>            project id (default: the project file)\n  --name <name>             the name a first deploy registers the project under\n  --no-static               deploy the room alone, even with \"static\" configured\n  -c, --config <f>          the project file to read (default irtio.json)\n  --url <control>           control plane (default: your stored login)\n  -h, --help                print this\n\nirtio deploy --static uploads a BUILT client directory and nothing else. It takes --label <label>\nplus --project, --name, --config and --url; the directory and label default to the project file.\n";
+declare function parseDeployArgs(args: readonly string[]): DeployArgs;
+interface RunDeployOptions {
+    readonly cwd?: string;
+    readonly allowBreaking?: boolean;
+    readonly project?: string;
+    /** The name to register a not-yet-existing project under. Otherwise the config file's `name`. */
+    readonly name?: string;
+    /** `-c/--config`: the project file to read, relative to `cwd`. Defaults to `irtio.json`. */
+    readonly config?: string;
+    /** `--no-static`: deploy the room only, leaving a configured static site as it is. */
+    readonly noStatic?: boolean;
+    readonly controlUrl?: string;
+    readonly room?: string;
+    /** Week 13 (D28): `migrate` moves live rooms onto the new version; default `drain`. */
+    readonly strategy?: 'drain' | 'migrate';
+    readonly irtioPackages?: BundleOptions['irtioPackages'];
+    readonly ask?: (question: string) => Promise<string>;
+    readonly log?: (line: string) => void;
+    /** @internal lets tests swap in a client bound to a fixed token instead of the credentials file. */
+    readonly client?: ApiClient;
+}
+interface RunDeployResult {
+    readonly project: string;
+    readonly version: number;
+    readonly url: string;
+    readonly draining: number;
+    readonly applied?: 'live' | 'pending';
+    readonly rooms?: readonly {
+        roomId: string;
+        outcome: string;
+        reason?: string;
+    }[];
+    /** Present when the project file configured a static site and this deploy shipped it too. */
+    readonly site?: RunStaticDeployResult;
+}
+/** The room entry, or undefined when the project has none. `--room` naming a missing file still
+ *  throws: that is a typo, not a project without a room. */
+declare function findRoomEntry(cwd: string, room: string | undefined): string | undefined;
+/** Every room type a project declares, resolved to entry files. */
+interface RoomTypeEntries {
+    /** The entry `resolveEntry` would have picked: what a plain roomId gets. */
+    readonly default: string;
+    /**
+     * Type name -> absolute entry, always including `DEFAULT_ROOM_TYPE`. A project with no
+     * `irtio/rooms/` directory has exactly one member, which is why its deploy is unchanged.
+     */
+    readonly types: Readonly<Record<string, string>>;
+}
+/**
+ * D58: resolve the project's room types.
+ *
+ * The default type is what a plain roomId means, so a project must always name one. `irtio/room.ts`
+ * (the pre-D58 single entry) stays the default when it is there, which is what keeps an existing
+ * project's deploy byte-identical after it grows an `irtio/rooms/` directory; otherwise
+ * `irtio/rooms/default.ts` is it. A project with `irtio/rooms/` and neither is refused rather than
+ * silently deploying types no plain roomId can reach.
+ *
+ * `room` (`--room`) replaces the default type's entry only. Extra types are a project layout fact,
+ * not something a flag naming one file can restate.
+ */
+declare function findRoomTypes(cwd: string, room?: string): RoomTypeEntries;
+/** The whole handshake. Throws on any refusal/error; `deploy()` turns that into exit 1. */
+declare function runDeploy(options?: RunDeployOptions): Promise<RunDeployResult>;
+/**
+ * Distinguishes an intentional refusal (already printed) from an unexpected throw.
+ *
+ * It carries the classification as well as printing it. For the CLI the printed lines are the
+ * whole story, but a non-terminal caller has no terminal to read: `@irtio/mcp` narrates this
+ * refusal into a tool result, and needs the same `changes` and `hint` the control plane's own 409
+ * carries. Without them the most informative failure in the whole deploy path arrives as the
+ * string "deploy refused", which is exactly the shape D40 says a tool result must never be.
+ *
+ * The no-argument form still works, so an older caller keeps compiling.
+ */
+declare class DeployRefusedError extends Error {
+    readonly name = "DeployRefusedError";
+    /** The breaking changes that caused the refusal, as the classifier reported them. */
+    readonly changes: readonly SchemaChange[];
+    /** The remedy, verbatim: normally `run: irtio migrate create <name>`. */
+    readonly hint: string | undefined;
+    constructor(reason?: {
+        changes?: readonly SchemaChange[];
+        hint?: string;
+    });
+}
+/** Thin CLI entry. `deps` is a test seam (log/errorLog capture, an injected client/cwd/aliases). */
+declare function deploy(args: readonly string[], deps?: {
+    log?: (line: string) => void;
+    errorLog?: (line: string) => void;
+    client?: ApiClient;
+    cwd?: string;
+    irtioPackages?: BundleOptions['irtioPackages'];
+}): Promise<void>;
+
+export { type DeployArgs, DeployRefusedError, type RoomTypeEntries, type RunDeployOptions, type RunDeployResult, USAGE, deploy, findRoomEntry, findRoomTypes, parseDeployArgs, runDeploy };

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

@@ -1,38 +1,44 @@
-import {
-  clientImportsRoom
-} from "./chunk-TQU6345E.js";
-import {
-  bundleRoom
-} from "./chunk-KRQUAEN2.js";
 import {
   logEnsured,
   runStaticDeploy
-} from "./chunk-GBNHBWES.js";
-import "./chunk-BPE452KF.js";
+} from "./chunk-3HQMVCYA.js";
+import {
+  clientImportsRoom
+} from "./chunk-TQU6345E.js";
+import "./chunk-RQSJZWQC.js";
 import {
   ensureProject,
   readProjectConfig
-} from "./chunk-32QTPKVT.js";
+} from "./chunk-DKWG7MGO.js";
+import {
+  bundleRoom
+} from "./chunk-OTSFRVJN.js";
 import {
-  ApiClientError,
   HelpRequested,
-  createApiClient,
   helpFor,
-  helpRequested,
-  isLoginRequired,
+  helpRequested
+} from "./chunk-ZD4ND6X6.js";
+import {
+  ApiClientError,
+  createApiClient,
+  isLoginRequired
+} from "./chunk-RNAH5T4W.js";
+import {
   resolveControlUrlForUser
-} from "./chunk-TV66QHFP.js";
+} from "./chunk-UPHQM6NZ.js";
 
 // src/deploy.ts
-import { existsSync } from "fs";
+import { existsSync, readdirSync } from "fs";
 import { mkdir, readFile, readdir, rm } from "fs/promises";
 import * as path from "path";
 import { createInterface } from "readline/promises";
 import { pathToFileURL } from "url";
+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 MIGRATIONS_DIR = "irtio/migrations";
+var ROOM_TYPES_DIR = "irtio/rooms";
 var USAGE = `usage: irtio deploy [options]
        irtio deploy --static [<dir>] [options]
 
@@ -148,6 +154,45 @@ function resolveEntry(cwd, room) {
   pass --room <file> if it lives elsewhere`
   );
 }
+function findRoomTypes(cwd, room) {
+  const dir = path.resolve(cwd, ROOM_TYPES_DIR);
+  const types = {};
+  if (existsSync(dir)) {
+    for (const name of readdirSync(dir).sort()) {
+      const ext = path.extname(name);
+      if (ext !== ".ts" && ext !== ".js") continue;
+      const type = name.slice(0, -ext.length);
+      if (!ROOM_TYPE_RE.test(type)) {
+        throw new Error(
+          `irtio deploy: ${path.join(ROOM_TYPES_DIR, name)} is not a usable room type name
+  a type name is lowercase letters, digits, "_" or "-", starting with a letter or digit, at most 24 characters
+  rename the file, or move it out of ${ROOM_TYPES_DIR}/ if it is not a room entry`
+        );
+      }
+      types[type] = path.join(dir, name);
+    }
+  }
+  const explicit = findRoomEntry(cwd, room);
+  if (explicit !== void 0) {
+    if (room === void 0 && types[DEFAULT_ROOM_TYPE] !== void 0) {
+      throw new Error(
+        `irtio deploy: this project names its default room type twice, in ${ROOM_CANDIDATES[0]} and in ${ROOM_TYPES_DIR}/default.ts
+  keep one of them: a plain roomId resolves to exactly one definition`
+      );
+    }
+    return { default: explicit, types: { ...types, [DEFAULT_ROOM_TYPE]: explicit } };
+  }
+  const fallback = types[DEFAULT_ROOM_TYPE];
+  if (fallback !== void 0) return { default: fallback, types };
+  if (Object.keys(types).length > 0) {
+    throw new Error(
+      `irtio deploy: ${ROOM_TYPES_DIR}/ declares ${Object.keys(types).join(", ")} but no default room type, and a roomId with no type prefix has to resolve to one
+  add ${ROOM_TYPES_DIR}/default.ts, or keep the single entry at ${ROOM_CANDIDATES[0]}`
+    );
+  }
+  const entry = resolveEntry(cwd, room);
+  return { default: entry, types: { [DEFAULT_ROOM_TYPE]: entry } };
+}
 async function warnIfClientImportsRoom(cwd, entry, config, log) {
   const client = config.client;
   if (client === void 0) return;
@@ -162,10 +207,17 @@ async function warnIfClientImportsRoom(cwd, entry, config, log) {
 }
 async function loadBundledSchema(file) {
   const mod = await import(pathToFileURL(file).href);
+  const config = mod.default.config;
   return {
     project: mod.default.schema.project,
     canonical: mod.default.schema.canonical,
-    schema: mod.default.schema
+    schema: mod.default.schema,
+    memoryMb: typeof config?.memoryMb === "number" ? config.memoryMb : void 0,
+    maxAwake: typeof config?.maxAwake === "number" ? config.maxAwake : void 0,
+    // The declared string, verbatim and unparsed. `defineRoom` already refused anything the
+    // grammar does not accept, and control refuses it again; the CLI's job is to carry what the
+    // bundle says rather than to have an opinion of its own about a duration.
+    retention: typeof config?.retention === "string" ? config.retention : void 0
   };
 }
 function printBreaking(log, breaking, hint) {
@@ -189,7 +241,8 @@ async function runDeploy(options = {}) {
   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);
+  const roomTypes = findRoomTypes(cwd, options.room);
+  const entry = roomTypes.default;
   await warnIfClientImportsRoom(cwd, entry, config, log);
   const outDir = path.join(cwd, DEPLOY_BUILD_DIR);
   await mkdir(outDir, { recursive: true });
@@ -228,25 +281,25 @@ async function runDeploy(options = {}) {
   const newest = newestOf(deployments);
   let allowBreaking = options.allowBreaking ?? false;
   let migrationFile;
+  let schemaChange = "none";
   const nextVersion = (newest?.version ?? 0) + 1;
   if (previous !== void 0) {
     const oldSchema = schemaFromCanonical(previous.schemaJson);
     const changes = diffSchemas(oldSchema, bundled.schema);
     const breaking = changes.filter((c) => c.kind === "breaking");
     const additive = changes.filter((c) => c.kind === "additive");
+    schemaChange = breaking.length > 0 ? "breaking" : additive.length > 0 ? "additive" : "none";
     if (breaking.length > 0) {
       if (!allowBreaking) {
-        printBreaking(log, breaking, "run: irtio migrate create <name>");
-        throw new DeployRefusedError();
+        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) {
-        printBreaking(
-          log,
-          breaking,
-          `--allow-breaking needs a migration for v${nextVersion} \u2014 run: irtio migrate create <name>`
-        );
-        throw new DeployRefusedError();
+        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}`);
@@ -259,7 +312,7 @@ async function runDeploy(options = {}) {
     }
     if (changes.length === 0) log(pc.dim("no schema changes"));
   } else {
-    log(pc.dim("no previous deployment \u2014 first deploy for this project"));
+    log(pc.dim("no previous deployment, so this is the first deploy for this project"));
   }
   let migrationKey;
   if (migrationFile !== void 0) {
@@ -283,6 +336,45 @@ async function runDeploy(options = {}) {
     roomBytes
   );
   log(pc.green("uploaded bundle"));
+  const extraRooms = {};
+  for (const [type, typeEntry] of Object.entries(roomTypes.types)) {
+    if (type === DEFAULT_ROOM_TYPE) continue;
+    let typeResult;
+    try {
+      typeResult = await bundleRoom({
+        entry: typeEntry,
+        outDir,
+        ...options.irtioPackages !== void 0 ? { irtioPackages: options.irtioPackages } : {}
+      });
+    } catch (err) {
+      throw new Error(
+        `irtio deploy: room type "${type}": ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+    if (typeResult.schemaHash === void 0) {
+      throw new Error(`irtio deploy: room type "${type}" bundled without a schema hash`);
+    }
+    const typeSchema = await loadBundledSchema(typeResult.file);
+    const uploaded = await client.postBytes(
+      `/v1/projects/${projectId}/artifacts`,
+      new Uint8Array(await readFile(typeResult.file))
+    );
+    extraRooms[type] = {
+      bundleHash: typeResult.hash,
+      bundleKey: uploaded.key,
+      schemaJson: typeSchema.canonical,
+      schemaHash: typeResult.schemaHash,
+      // M5 part 3.5: this type's sizing declarations travel with its bundle, so control and the
+      // host agent can size the VM before it boots. Spread, never null: a type that declares
+      // neither sends neither, and the env generation of a project that has never declared
+      // anything is unchanged.
+      ...typeSchema.memoryMb !== void 0 ? { memoryMb: typeSchema.memoryMb } : {},
+      ...typeSchema.maxAwake !== void 0 ? { maxAwake: typeSchema.maxAwake } : {},
+      ...typeSchema.retention !== void 0 ? { retention: typeSchema.retention } : {}
+    };
+    log(pc.green(`bundled and uploaded room type ${type} (${typeResult.hash.slice(0, 12)})`));
+  }
+  const hasExtraTypes = Object.keys(extraRooms).length > 0;
   let origin;
   if (previous === void 0) {
     const answer = (await ask("production origin (localhost is always allowed) \u2014 leave blank to skip: ")).trim();
@@ -290,17 +382,35 @@ async function runDeploy(options = {}) {
   }
   const strategy = options.strategy ?? "drain";
   if (strategy === "migrate") {
-    log(pc.yellow("strategy: migrate \u2014 live rooms move onto the new version now."));
-    log(
-      pc.yellow(
-        "Schema unchanged: connected clients see a short gap and a resync on the same socket."
-      )
-    );
-    log(
-      pc.yellow(
-        "Schema changed at all: EVERY connected client is disconnected with E_SCHEMA_MISMATCH and must reload."
-      )
+    log(pc.yellow("strategy: migrate. Live rooms move onto the new version now."));
+    const physics = bundled.schema.collections.some(
+      (c) => c.physics !== void 0
     );
+    if (schemaChange === "breaking") {
+      log(
+        pc.yellow(
+          "Breaking schema change: EVERY connected client is disconnected with E_SCHEMA_MISMATCH and must reload."
+        )
+      );
+    } else {
+      log(
+        pc.yellow(
+          schemaChange === "none" ? "Schema unchanged: connected clients see a short gap and a resync on the same socket." : "Additive schema change: connected clients see a short gap and a resync on the same socket, on the new schema."
+        )
+      );
+      if (physics) {
+        log(
+          pc.yellow(
+            "This schema has physics collections. A change touching one of those is treated as breaking for now, so those clients reload."
+          )
+        );
+      }
+      log(
+        pc.dim(
+          "Clients built before irtio 0.6 are still disconnected with E_SCHEMA_MISMATCH on any schema change."
+        )
+      );
+    }
   }
   let response;
   try {
@@ -309,6 +419,13 @@ async function runDeploy(options = {}) {
       bundleKey: uploadedRoom.key,
       schemaJson: bundled.canonical,
       schemaHash: result.schemaHash,
+      // M5 part 3.5: the default type's declarations, top-level beside its schema for the reason
+      // `DeploymentSpec` states — the default type is not in the `rooms` map, and putting it there
+      // would give every single-room project a `rooms` key and cold-boot the fleet.
+      ...bundled.memoryMb !== void 0 ? { memoryMb: bundled.memoryMb } : {},
+      ...bundled.maxAwake !== void 0 ? { maxAwake: bundled.maxAwake } : {},
+      ...bundled.retention !== void 0 ? { retention: bundled.retention } : {},
+      ...hasExtraTypes ? { rooms: extraRooms } : {},
       ...migrationKey !== void 0 ? { migrationKey } : {},
       ...allowBreaking ? { allowBreaking: true } : {},
       ...origin !== void 0 ? { origin } : {},
@@ -324,12 +441,10 @@ async function runDeploy(options = {}) {
     };
   } catch (err) {
     if (err instanceof ApiClientError && err.code === "E_BREAKING_SCHEMA" && err.changes) {
-      printBreaking(
-        log,
-        err.changes,
-        err.hint ?? "run: irtio migrate create <name>"
-      );
-      throw new DeployRefusedError();
+      const changes = err.changes;
+      const hint = err.hint ?? "run: irtio migrate create <name>";
+      printBreaking(log, changes, hint);
+      throw new DeployRefusedError({ changes, hint });
     }
     throw err;
   }
@@ -376,8 +491,14 @@ async function runDeploy(options = {}) {
 }
 var DeployRefusedError = class extends Error {
   name = "DeployRefusedError";
-  constructor() {
+  /** The breaking changes that caused the refusal, as the classifier reported them. */
+  changes;
+  /** The remedy, verbatim: normally `run: irtio migrate create <name>`. */
+  hint;
+  constructor(reason = {}) {
     super("deploy refused");
+    this.changes = reason.changes ?? [];
+    this.hint = reason.hint;
   }
 };
 async function deploy(args, deps = {}) {
@@ -388,7 +509,7 @@ async function deploy(args, deps = {}) {
     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"));
+      log(pc.dim("no room file, so deploying the static site only"));
       await runStaticDeploy({
         cwd,
         log,
@@ -440,6 +561,7 @@ export {
   USAGE,
   deploy,
   findRoomEntry,
+  findRoomTypes,
   parseDeployArgs,
   runDeploy
 };