@irtio/cli 0.1.0 → 0.2.0

package/dist/bundle.d.ts

@@ -5,6 +5,14 @@
  */
 /** Bare imports room code may use. Everything else (including node:*) is rejected. */
 declare const ALLOWED_IMPORTS: string[];
+/**
+ * D22: the one blessed engine. Unlike the irtio packages it is **not** inlined into the room
+ * bundle — the tenant's runtime already loaded and `init()`ed it, and a second bundled copy would
+ * be a second WASM instance with its own worlds. Left external, room code's
+ * `import RAPIER from '@dimforge/rapier3d-compat'` resolves at load time to the very module the
+ * runtime initialized.
+ */
+declare const EXTERNAL_IMPORTS: readonly string[];
 interface BundleOptions {
     /** The room entry file (must `export default defineRoom(...)`). */
     readonly entry: string;
@@ -33,4 +41,4 @@ declare class BundleError extends Error {
 /** Bundles the room entry; throws `BundleError` with the esbuild message on failure. */
 declare function bundleRoom(options: BundleOptions): Promise<BundleResult>;
 
-export { ALLOWED_IMPORTS, BundleError, type BundleOptions, type BundleResult, bundleRoom };
+export { ALLOWED_IMPORTS, BundleError, type BundleOptions, type BundleResult, EXTERNAL_IMPORTS, bundleRoom };

package/dist/bundle.js

@@ -1,10 +1,12 @@
 import {
   ALLOWED_IMPORTS,
   BundleError,
+  EXTERNAL_IMPORTS,
   bundleRoom
-} from "./chunk-ZWCLCYCS.js";
+} from "./chunk-KRQUAEN2.js";
 export {
   ALLOWED_IMPORTS,
   BundleError,
+  EXTERNAL_IMPORTS,
   bundleRoom
 };

package/dist/chunk-BPE452KF.js

@@ -0,0 +1,180 @@
+// ../store/dist/index.js
+import { mkdir, readFile, readdir, rename, rm, writeFile } from "fs/promises";
+import * as path from "path";
+var KV_LIMITS = {
+  /** Max UTF-8 bytes in one value. */
+  valueBytes: 16 * 1024,
+  /** Max UTF-8 bytes in one key. */
+  keyBytes: 256,
+  /** Max UTF-8 bytes in one player id. */
+  playerIdBytes: 256,
+  /** Max distinct keys one player may hold within one project. */
+  keysPerPlayer: 128,
+  /** Max rows one project may hold across all its players. */
+  rowsPerProject: 1e6
+};
+var PLAYER_ISSUER_RE = /^[a-z0-9._-]{1,64}$/;
+var KV_ERRORS = {
+  badKey: "E_KV_BAD_KEY",
+  badPlayer: "E_KV_BAD_PLAYER",
+  valueTooLarge: "E_KV_VALUE_TOO_LARGE",
+  tooManyKeys: "E_KV_TOO_MANY_KEYS",
+  projectFull: "E_KV_PROJECT_FULL",
+  forbidden: "E_KV_FORBIDDEN",
+  unavailable: "E_KV_UNAVAILABLE"
+};
+var SAVES_SEGMENT = "/saves/";
+var SAVE_ID_TIME_DIGITS = 17;
+var DEFAULT_SAVE_RETAIN = 10;
+var PRE_MIGRATION_SAVE_ID = "premigrate";
+function mintSaveId(nowMs, rand) {
+  const t = Math.max(0, Math.floor(nowMs));
+  const suffix = (Math.floor(Math.abs(rand)) & 65535).toString(16).padStart(4, "0");
+  return `${String(t).padStart(SAVE_ID_TIME_DIGITS, "0")}-${suffix}`;
+}
+function saveIdCreatedAt(saveId) {
+  if (saveId.length !== SAVE_ID_TIME_DIGITS + 5) return void 0;
+  if (saveId[SAVE_ID_TIME_DIGITS] !== "-") return void 0;
+  const time = saveId.slice(0, SAVE_ID_TIME_DIGITS);
+  if (!/^[0-9]+$/.test(time)) return void 0;
+  if (!/^[0-9a-f]{4}$/.test(saveId.slice(SAVE_ID_TIME_DIGITS + 1))) return void 0;
+  return Number(time);
+}
+function savesPrefix(liveKey) {
+  return `${liveKey}${SAVES_SEGMENT}`;
+}
+function saveKey(liveKey, saveId) {
+  return `${savesPrefix(liveKey)}${saveId}`;
+}
+function saveIdOf(liveKey, key) {
+  const prefix = savesPrefix(liveKey);
+  if (!key.startsWith(prefix)) return void 0;
+  const rest = key.slice(prefix.length);
+  if (rest === "" || rest.includes("/")) return void 0;
+  return rest;
+}
+async function listSaves(store, liveKey) {
+  const keys = await store.list(savesPrefix(liveKey));
+  const out = [];
+  for (const key of keys) {
+    const saveId = saveIdOf(liveKey, key);
+    if (saveId === void 0) continue;
+    const createdAt = saveIdCreatedAt(saveId);
+    if (createdAt === void 0) continue;
+    out.push({ saveId, key, createdAt });
+  }
+  out.sort((a, b) => a.saveId < b.saveId ? 1 : a.saveId > b.saveId ? -1 : 0);
+  return out;
+}
+function selectForPruning(saves, retain) {
+  const keep = Number.isFinite(retain) ? Math.max(1, Math.floor(retain)) : 1;
+  return saves.length <= keep ? [] : saves.slice(keep);
+}
+async function pruneSaves(store, saves, retain, log) {
+  const doomed = selectForPruning(saves, retain);
+  let deleted = 0;
+  for (const save of doomed) {
+    try {
+      await store.delete(save.key);
+      deleted++;
+    } catch (err) {
+      log("warn", `save retention: could not delete ${save.key}`, err);
+    }
+  }
+  return deleted;
+}
+var STATIC_LIMITS = {
+  /** Bytes per file. Big enough for a wasm build or a texture atlas; a video does not belong. */
+  maxFileBytes: 32 * 1024 * 1024,
+  /** Files per deploy. */
+  maxFiles: 2e3,
+  /** Total bytes per deploy. */
+  maxTotalBytes: 256 * 1024 * 1024
+};
+function staticPathProblem(path2) {
+  if (path2.length === 0 || path2.length > 512) return "path must be 1-512 characters";
+  if (path2.startsWith("/")) return "path must be relative (no leading slash)";
+  if (path2.includes("\\")) return "path must use forward slashes";
+  if (/[\x00-\x1f\x7f]/.test(path2)) return "path must not contain control characters";
+  for (const segment of path2.split("/")) {
+    if (segment === "" || segment === "." || segment === "..") {
+      return "path segments must be non-empty and not . or ..";
+    }
+  }
+  return void 0;
+}
+var DiskStore = class {
+  constructor(dir) {
+    this.dir = dir;
+  }
+  dir;
+  fileFor(key) {
+    if (!/^[A-Za-z0-9_.@/-]+$/.test(key) || key.includes("..")) {
+      throw new Error(`invalid object store key ${JSON.stringify(key)}`);
+    }
+    return path.join(this.dir, `${key}.snap`);
+  }
+  async put(key, bytes) {
+    const file = this.fileFor(key);
+    await mkdir(path.dirname(file), { recursive: true });
+    const tmp = `${file}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
+    await writeFile(tmp, bytes);
+    for (let attempt = 0; ; attempt++) {
+      try {
+        await rename(tmp, file);
+        return;
+      } catch (err) {
+        const code = err.code;
+        if ((code === "EPERM" || code === "EBUSY") && attempt < 10) {
+          await new Promise((resolve) => setTimeout(resolve, 5 * (attempt + 1)));
+          continue;
+        }
+        throw err;
+      }
+    }
+  }
+  async get(key) {
+    try {
+      return new Uint8Array(await readFile(this.fileFor(key)));
+    } catch (err) {
+      if (err.code === "ENOENT") return void 0;
+      throw err;
+    }
+  }
+  async delete(key) {
+    await rm(this.fileFor(key), { force: true });
+  }
+  async list(prefix) {
+    const out = [];
+    const walk = async (dir, rel) => {
+      let entries;
+      try {
+        entries = await readdir(dir, { withFileTypes: true });
+      } catch (err) {
+        if (err.code === "ENOENT") return;
+        throw err;
+      }
+      for (const e of entries) {
+        const r = rel ? `${rel}/${e.name}` : e.name;
+        if (e.isDirectory()) await walk(path.join(dir, e.name), r);
+        else if (e.name.endsWith(".snap")) out.push(r.slice(0, -".snap".length));
+      }
+    };
+    await walk(this.dir, "");
+    return out.filter((k) => k.startsWith(prefix)).sort();
+  }
+};
+
+export {
+  PLAYER_ISSUER_RE,
+  KV_ERRORS,
+  DEFAULT_SAVE_RETAIN,
+  PRE_MIGRATION_SAVE_ID,
+  mintSaveId,
+  saveKey,
+  listSaves,
+  pruneSaves,
+  STATIC_LIMITS,
+  staticPathProblem,
+  DiskStore
+};

package/dist/{chunk-J3G6AUJY.js → chunk-I37DLT7K.js}

@@ -1,6 +1,6 @@
 import {
   readCredential
-} from "./chunk-UYN5PWLT.js";
+} from "./chunk-NVUKSP5U.js";
 
 // src/api-client.ts
 var ApiClientError = class extends Error {

package/dist/{chunk-ZWCLCYCS.js → chunk-KRQUAEN2.js}

@@ -1,11 +1,12 @@
 // src/bundle.ts
-import { createHash } from "crypto";
-import { mkdir, writeFile } from "fs/promises";
+import { createHash, randomBytes } from "crypto";
+import { access, mkdir, rename, unlink, writeFile } from "fs/promises";
 import * as path from "path";
 import { pathToFileURL } from "url";
 import { Worker } from "worker_threads";
 import * as esbuild from "esbuild";
-var ALLOWED_IMPORTS = ["@irtio/server", "@irtio/schema"];
+var ALLOWED_IMPORTS = ["@irtio/server", "@irtio/schema", "@dimforge/rapier3d-compat"];
+var EXTERNAL_IMPORTS = ["@dimforge/rapier3d-compat"];
 var BundleError = class extends Error {
   name = "BundleError";
 };
@@ -17,6 +18,7 @@ function importMenuPlugin(allowed) {
         if (args.kind === "entry-point" || path.isAbsolute(args.path)) return null;
         const root = args.path.split("/")[0].startsWith("@") ? args.path.split("/").slice(0, 2).join("/") : args.path.split("/")[0];
         if (allowed.has(root)) {
+          if (EXTERNAL_IMPORTS.includes(root)) return { path: args.path, external: true };
           const redirect = allowed.get(root);
           if (redirect) return { path: redirect };
           return null;
@@ -71,6 +73,7 @@ async function bundleRoom(options) {
       write: false,
       outdir: options.outDir,
       plugins: [importMenuPlugin(allowed)],
+      metafile: true,
       logLevel: "silent",
       mainFields: ["module", "main"],
       conditions: ["import"]
@@ -82,14 +85,34 @@ async function bundleRoom(options) {
   const out = result.outputFiles[0];
   if (!out) throw new BundleError("esbuild produced no output");
   const warnings = result.warnings.map((w) => w.text);
+  const importsRapier = Object.values(result.metafile?.outputs ?? {}).some(
+    (o) => o.imports.some((i) => i.path === "@dimforge/rapier3d-compat")
+  );
   const hash = createHash("sha256").update(out.contents).digest("hex");
   const file = path.join(options.outDir, `room.${hash.slice(0, 16)}.mjs`);
   await mkdir(options.outDir, { recursive: true });
   const banner = `// irtio room bundle ${hash}
 `;
-  await writeFile(file, banner + out.text);
+  const tmp = path.join(
+    options.outDir,
+    `.room.${hash.slice(0, 16)}.${randomBytes(6).toString("hex")}.tmp`
+  );
+  await writeFile(tmp, banner + out.text);
+  try {
+    await rename(tmp, file);
+  } catch (err) {
+    const alreadyThere = await access(file).then(() => true).catch(() => false);
+    await unlink(tmp).catch(() => {
+    });
+    if (!alreadyThere) throw err;
+  }
   if (options.verify === false) return { file, hash, warnings };
   const verified = await verifyBundle(file);
+  if (importsRapier && !verified.physics) {
+    throw new BundleError(
+      "irtio: this room imports @dimforge/rapier3d-compat but declares no physics. Add\n  physics: { engine: 'rapier3d', gravity: { x: 0, y: -9.81, z: 0 }, bodies: { ... } }\nto defineRoom(...), and mark the body-backed fields with the schema's physics option. Without it the runtime never creates a world, and nothing you build with the engine steps."
+    );
+  }
   const fullHash = createHash("sha256").update(out.contents).update(verified.canonical).digest("hex");
   return {
     file,
@@ -110,7 +133,7 @@ async function verifyBundle(file) {
         parentPort.postMessage({ ok: false, reason:
           'the bundle\\'s default export is not a room \u2014 end your room file with: export default defineRoom(schema, {...})' });
       } else {
-        parentPort.postMessage({ ok: true, schemaHash: def.schema.hash, canonical: def.schema.canonical, mode: def.config.mode });
+        parentPort.postMessage({ ok: true, schemaHash: def.schema.hash, canonical: def.schema.canonical, mode: def.config.mode, physics: def.config.physics !== undefined });
       }
     } catch (err) {
       parentPort.postMessage({ ok: false, reason: String(err && err.stack || err) });
@@ -133,7 +156,12 @@ async function verifyBundle(file) {
       });
     });
     if (!msg.ok) throw new BundleError(`bundle failed to load: ${msg.reason}`);
-    return { schemaHash: msg.schemaHash, canonical: msg.canonical, mode: msg.mode };
+    return {
+      schemaHash: msg.schemaHash,
+      canonical: msg.canonical,
+      mode: msg.mode,
+      physics: msg.physics === true
+    };
   } finally {
     await worker.terminate();
   }
@@ -141,6 +169,7 @@ async function verifyBundle(file) {
 
 export {
   ALLOWED_IMPORTS,
+  EXTERNAL_IMPORTS,
   BundleError,
   bundleRoom
 };

package/dist/{chunk-UYN5PWLT.js → chunk-NVUKSP5U.js}

@@ -46,7 +46,9 @@ async function resolveControlUrlForUser(flag) {
   const explicit = flag ?? process.env.IRT_CONTROL_URL;
   if (explicit !== void 0) return explicit;
   const all = await readCredentials();
-  const urls = Object.keys(all);
+  const now = Date.now();
+  const live = Object.entries(all).filter(([, cred]) => new Date(cred.expiresAt).getTime() > now).map(([url]) => url);
+  const urls = live.length > 0 ? live : Object.keys(all);
   return urls.length === 1 ? urls[0] : DEFAULT_CONTROL_URL;
 }
 

package/dist/chunk-TQU6345E.js

@@ -0,0 +1,36 @@
+// src/client-graph.ts
+import * as path from "path";
+import * as esbuild from "esbuild";
+function externalizeBarePlugin() {
+  return {
+    name: "irtio-externalize-bare",
+    setup(build2) {
+      build2.onResolve({ filter: /^[^./]/ }, (args) => {
+        if (args.kind === "entry-point" || path.isAbsolute(args.path)) return null;
+        return { path: args.path, external: true };
+      });
+    }
+  };
+}
+async function clientImportsRoom(clientEntry, roomEntry) {
+  let result;
+  try {
+    result = await esbuild.build({
+      entryPoints: [clientEntry],
+      bundle: true,
+      write: false,
+      metafile: true,
+      logLevel: "silent",
+      platform: "neutral",
+      plugins: [externalizeBarePlugin()]
+    });
+  } catch {
+    return false;
+  }
+  const roomAbs = path.resolve(roomEntry);
+  return Object.keys(result.metafile.inputs).some((input) => path.resolve(input) === roomAbs);
+}
+
+export {
+  clientImportsRoom
+};

package/dist/{deploy-4W6AYYEW.js → deploy-6OM3UYNL.js}

@@ -1,19 +1,21 @@
+import {
+  clientImportsRoom
+} from "./chunk-TQU6345E.js";
 import {
   bundleRoom
-} from "./chunk-ZWCLCYCS.js";
+} from "./chunk-KRQUAEN2.js";
 import {
   ApiClientError,
   createApiClient,
   isLoginRequired
-} from "./chunk-J3G6AUJY.js";
+} from "./chunk-I37DLT7K.js";
 import {
   resolveControlUrlForUser
-} from "./chunk-UYN5PWLT.js";
+} from "./chunk-NVUKSP5U.js";
 
 // src/deploy.ts
 import { existsSync } from "fs";
-import { mkdtemp, readFile, readdir, rm } from "fs/promises";
-import { tmpdir } from "os";
+import { mkdir, readFile, readdir, rm } from "fs/promises";
 import * as path from "path";
 import { createInterface } from "readline/promises";
 import { pathToFileURL } from "url";
@@ -49,6 +51,14 @@ function parseDeployArgs(args) {
         parsed.room = value;
         break;
       }
+      case "--strategy": {
+        const value = args[++i];
+        if (value !== "drain" && value !== "migrate") {
+          throw new Error('irtio deploy: --strategy must be "drain" or "migrate"');
+        }
+        parsed.strategy = value;
+        break;
+      }
       default:
         throw new Error(`irtio deploy: unknown option ${JSON.stringify(arg)}`);
     }
@@ -96,6 +106,34 @@ async function readIrtioJsonProject(cwd) {
   }
   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);
+  if (client === void 0) return;
+  const clientFile = path.resolve(cwd, client);
+  if (await clientImportsRoom(clientFile, entry)) {
+    log(
+      pc.yellow(
+        `irtio: WARNING: the client entry ${client} imports the room file ${path.relative(cwd, entry)} \u2014 room code must never ship to clients; move shared code (e.g. the physics world builder) into its own module both sides import`
+      )
+    );
+  }
+}
 async function loadBundledSchema(file) {
   const mod = await import(pathToFileURL(file).href);
   return {
@@ -118,13 +156,16 @@ async function findMigrationFile(cwd, version) {
   const match = entries.find((f) => f.startsWith(`${version}_`) && f.endsWith(".ts"));
   return match ? path.join(dir, match) : void 0;
 }
+var DEPLOY_BUILD_DIR = path.join(".irtio", "deploy");
 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 entry = resolveEntry(cwd, options.room);
-  const outDir = await mkdtemp(path.join(tmpdir(), "irtio-deploy-"));
+  await warnIfClientImportsRoom(cwd, entry, log);
+  const outDir = path.join(cwd, DEPLOY_BUILD_DIR);
+  await mkdir(outDir, { recursive: true });
   let result;
   try {
     result = await bundleRoom({
@@ -158,16 +199,16 @@ async function runDeploy(options = {}) {
     await client.post("/v1/projects", { name, id: projectId });
     log(pc.dim(`created project ${projectId} (${name})`));
   }
-  const deployments = await client.get(
-    `/v1/projects/${projectId}/deployments`
-  );
-  const previous = deployments.reduce(
+  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);
   let allowBreaking = options.allowBreaking ?? false;
   let migrationFile;
-  const nextVersion = (previous?.version ?? 0) + 1;
+  const nextVersion = (newest?.version ?? 0) + 1;
   if (previous !== void 0) {
     const oldSchema = schemaFromCanonical(previous.schemaJson);
     const changes = diffSchemas(oldSchema, bundled.schema);
@@ -227,6 +268,20 @@ async function runDeploy(options = {}) {
     const answer = (await ask("production origin (localhost is always allowed) \u2014 leave blank to skip: ")).trim();
     if (answer.length > 0) origin = answer;
   }
+  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."
+      )
+    );
+  }
   let response;
   try {
     const created = await client.post(`/v1/projects/${projectId}/deployments`, {
@@ -236,13 +291,16 @@ async function runDeploy(options = {}) {
       schemaHash: result.schemaHash,
       ...migrationKey !== void 0 ? { migrationKey } : {},
       ...allowBreaking ? { allowBreaking: true } : {},
-      ...origin !== void 0 ? { origin } : {}
+      ...origin !== void 0 ? { origin } : {},
+      ...strategy !== "drain" ? { strategy } : {}
     });
     response = {
       project: projectId,
       version: created.version,
       url: created.url,
-      draining: created.draining
+      draining: created.draining,
+      ...created.applied !== void 0 ? { applied: created.applied } : {},
+      ...created.rooms !== void 0 ? { rooms: created.rooms } : {}
     };
   } catch (err) {
     if (err instanceof ApiClientError && err.code === "E_BREAKING_SCHEMA" && err.changes) {
@@ -259,8 +317,27 @@ async function runDeploy(options = {}) {
   });
   log(pc.green(`deployed v${response.version}`));
   log(pc.dim(`reachable at ${response.url}`));
-  if (previous !== void 0) {
-    log(pc.dim(`rooms already running finish on v${previous.version}`));
+  if (strategy === "migrate") {
+    if (response.applied === "live") {
+      const rooms = response.rooms ?? [];
+      if (rooms.length === 0) log(pc.dim("no live rooms to migrate"));
+      for (const r of rooms) {
+        const line = `  ${r.roomId}: ${r.outcome}${r.reason ? ` \u2014 ${r.reason}` : ""}`;
+        log(r.outcome === "failed" ? pc.red(line) : pc.dim(line));
+      }
+    } else {
+      log(pc.dim("no tenant is running; rooms migrate on their next wake"));
+    }
+  } else if (previous !== void 0) {
+    if (response.applied === "live") {
+      log(
+        pc.dim(
+          `rooms already running finish on v${previous.version}; new rooms start on v${response.version}`
+        )
+      );
+    } else {
+      log(pc.dim(`rooms already running finish on v${previous.version}`));
+    }
   }
   return response;
 }
@@ -281,6 +358,7 @@ async function deploy(args, deps = {}) {
       ...parsed.project !== void 0 ? { project: parsed.project } : {},
       ...parsed.url !== void 0 ? { controlUrl: parsed.url } : {},
       ...parsed.room !== void 0 ? { room: parsed.room } : {},
+      ...parsed.strategy !== void 0 ? { strategy: parsed.strategy } : {},
       ...deps.client !== void 0 ? { client: deps.client } : {},
       ...deps.cwd !== void 0 ? { cwd: deps.cwd } : {},
       ...deps.irtioPackages !== void 0 ? { irtioPackages: deps.irtioPackages } : {}