@irtio/cli 0.6.0 → 0.8.0

package/dist/simulate.js

@@ -6,8 +6,8 @@ import {
   helpFor,
   helpRequested,
   trailerFor
-} from "./chunk-ZD4ND6X6.js";
-import "./chunk-RNAH5T4W.js";
+} from "./chunk-OCVALOGK.js";
+import "./chunk-IDF46P7R.js";
 import "./chunk-UPHQM6NZ.js";
 
 // src/simulate.ts
@@ -76,7 +76,9 @@ async function loadScenario(options) {
       platform: "node",
       outfile,
       // The physics engine is resolved at runtime by whoever needs it, never bundled twice.
-      external: ["@dimforge/rapier3d-compat"],
+      // All three, not just the 3D one: a 2D scenario's engine is loaded by the runtime the same
+      // way, and bundling a copy here would be a second instance beside it.
+      external: ["@dimforge/rapier3d-compat", "matter-js", "@dimforge/rapier2d-compat"],
       ...Object.keys(alias).length > 0 ? { alias } : {}
     });
   } catch (err) {
@@ -276,6 +278,13 @@ options:
   --overruns-max <n>          fail above this many server tick overruns in the run window
                               (default 0; the count is read from the server, and the run says
                               so when it could not be read)
+  --queue <name>              queue for rooms through the matchmaker instead of creating one:
+                              every bot calls the real match API and joins the room its ticket
+                              names. Needs --control
+  --control <https://...>     the control plane the queue lives on. \`irtio dev\` runs none, so a
+                              queued run points at a real one (staging, or a test plane)
+  --party <n>                 group each n consecutive bots into one party, so they queue
+                              together and land in one room. Needs --queue
   --profile                   print where the run's bytes went, by collection and field, as the
                               bots saw them
   --profile-top <n>           rows in that table (default 12; implies --profile)
@@ -350,6 +359,21 @@ function parseSimulateArgs(args) {
       case "--truth":
         parsed.truth = true;
         break;
+      // ---- M6 lane E: testing parity ---- (D73-c)
+      case "--queue":
+        parsed.queue = value();
+        break;
+      case "--control":
+        parsed.control = value();
+        break;
+      case "--party": {
+        const size = positive(value(), "--party");
+        if (!Number.isInteger(size) || size < 2) {
+          throw new Error("irtio simulate: --party must be a whole number of bots, at least 2");
+        }
+        parsed.party = size;
+        break;
+      }
       case "--profile":
         parsed.profile = true;
         break;
@@ -378,6 +402,16 @@ function parseSimulateArgs(args) {
         throw new Error(`irtio simulate: unknown option ${JSON.stringify(arg)}`);
     }
   }
+  if (parsed.queue !== void 0 && parsed.control === void 0) {
+    throw new Error(
+      "irtio simulate: --queue needs --control. The matchmaker lives on the control plane and `irtio dev` runs none, so there is no queue at a dev server to join."
+    );
+  }
+  if (parsed.party !== void 0 && parsed.queue === void 0) {
+    throw new Error(
+      "irtio simulate: --party needs --queue. A party is a group that queues together, and a run that is not queueing has nothing to group."
+    );
+  }
   return parsed;
 }
 function monorepoPackages() {
@@ -423,16 +457,18 @@ async function loadProjectSchema(options) {
   }
   return { schema, file: entry };
 }
+function is2dWorld(world) {
+  return world !== void 0 && world.engine === "matter2d" && !("why" in world);
+}
+function isRapier2dWorld(world) {
+  return world !== void 0 && world.engine === "rapier2d" && !("why" in world);
+}
 function isUnpredictedWorld(world) {
-  return world !== void 0 && "unpredicted" in world;
+  return world !== void 0 && "why" in world;
 }
-async function loadProjectWorld(options) {
-  const entry = WORLD_CANDIDATES.map((c) => path2.resolve(options.cwd, c)).find(
-    (f) => existsSync2(f)
-  );
-  if (entry === void 0) return void 0;
+var ROOM_CANDIDATES = ["irtio/room.ts", "irtio/room.js", "room.ts"];
+async function bundleAndImport(entry, outfile, options) {
   await mkdir2(options.outDir, { recursive: true });
-  const outfile = path2.join(options.outDir, "world.mjs");
   const alias = options.irtioPackages ?? monorepoPackages();
   await esbuild2.build({
     entryPoints: [entry],
@@ -440,34 +476,106 @@ async function loadProjectWorld(options) {
     format: "esm",
     platform: "node",
     outfile,
-    external: ["@dimforge/rapier3d-compat"],
+    external: ["@dimforge/rapier3d-compat", "@dimforge/rapier2d-compat", "matter-js"],
     ...alias !== void 0 ? { alias } : {}
   });
-  const module = await import(`${pathToFileURL2(outfile).href}?v=${Date.now()}-${importSeq2++}`);
-  const gravity = module.gravity;
-  if (typeof gravity !== "object" || gravity === null || typeof gravity.x !== "number") {
-    throw new Error(
-      `irtio simulate: ${entry} does not export a { x, y, z } gravity.
-  the shared world-builder must export the same gravity the room config uses
-  (this is what \`irtio init --physics\` writes)`
-    );
+  return await import(`${pathToFileURL2(outfile).href}?v=${Date.now()}-${importSeq2++}`);
+}
+function hookMap(value) {
+  return typeof value === "object" && value !== null ? value : void 0;
+}
+async function detectRoomEngine(options) {
+  const entry = ROOM_CANDIDATES.map((c) => path2.resolve(options.cwd, c)).find((f) => existsSync2(f));
+  if (entry === void 0) return void 0;
+  let module;
+  try {
+    module = await bundleAndImport(entry, path2.join(options.outDir, "room-engine.mjs"), options);
+  } catch {
+    return void 0;
   }
-  if (typeof gravity.z !== "number") {
-    return { unpredicted: "matter2d", file: entry };
+  const definition = module.default ?? module.room;
+  const engine = definition?.config?.physics?.engine;
+  return typeof engine === "string" ? { engine, file: entry } : void 0;
+}
+async function detectMatter2dRoom(options) {
+  const declared = await detectRoomEngine(options);
+  return declared?.engine === "matter2d" ? declared.file : void 0;
+}
+function whyNotPredictable(world) {
+  if (world.bodies === void 0 || Object.keys(world.bodies).length === 0) {
+    return `${world.file} exports no \`bodies\`, so there are no shapes to build a local world from; bots run without client prediction.
+  export the body factories your client passes to \`joinRoom({ physics2d })\`.`;
+  }
+  const settle = world.engine === "matter2d" ? world.settle : void 0;
+  const steered = world.intents !== void 0 || settle !== void 0;
+  if (!steered && world.gravity.x === 0 && world.gravity.y === 0) {
+    const hooks = world.engine === "matter2d" ? "no `intents` and no `settle`" : "no `intents`";
+    return `${world.file} exports ${hooks}, and its gravity is zero, so nothing in a local world built from it could ever move a body; bots run without client prediction.
+  export the steering hooks your client passes to \`joinRoom({ physics2d })\` (a room that applies its forces inside \`tick()\` has none to share).`;
+  }
+  return void 0;
+}
+async function loadProjectWorld(options) {
+  const entry = WORLD_CANDIDATES.map((c) => path2.resolve(options.cwd, c)).find(
+    (f) => existsSync2(f)
+  );
+  const declared = await detectRoomEngine(options);
+  const planarRoom = (why) => declared === void 0 || declared.engine !== "matter2d" && declared.engine !== "rapier2d" ? void 0 : { engine: declared.engine, why: why(declared.file), file: declared.file };
+  if (entry === void 0) {
+    return planarRoom(
+      (room) => `${room} declares a ${declared?.engine ?? "2D"} room and there is no shared world module beside it, so bots run without client prediction.
+  export the \`physics2d\` block your client passes to \`joinRoom\` from \`irtio/world.ts\` to predict.`
+    );
   }
-  if (typeof gravity.y !== "number") {
-    throw new Error(
-      `irtio simulate: ${entry} does not export a { x, y, z } gravity.
+  const module = await bundleAndImport(entry, path2.join(options.outDir, "world.mjs"), options);
+  const gravity = module.gravity;
+  const notAWorld = new Error(
+    `irtio simulate: ${entry} does not export a { x, y, z } gravity.
   the shared world-builder must export the same gravity the room config uses
   (this is what \`irtio init --physics\` writes)`
+  );
+  if (typeof gravity !== "object" || gravity === null || typeof gravity.x !== "number") {
+    const recognised = planarRoom(
+      () => `${entry} exports no gravity, so it is not the client world a ${declared?.engine ?? "2D"} room predicts from; bots run without client prediction.
+  export the \`physics2d\` block your client passes to \`joinRoom\` from this module to predict.`
     );
+    if (recognised !== void 0) return recognised;
+    throw notAWorld;
+  }
+  const planarEngine = declared?.engine === "rapier2d" ? "rapier2d" : declared?.engine === "matter2d" ? "matter2d" : declared === void 0 && typeof gravity.z !== "number" ? "matter2d" : void 0;
+  if (planarEngine !== void 0) {
+    if (typeof gravity.y !== "number") throw notAWorld;
+    const common = {
+      gravity: { x: gravity.x, y: gravity.y },
+      ...typeof module.timestep === "number" ? { timestep: module.timestep } : {},
+      ...hookMap(module.bodies) !== void 0 ? { bodies: module.bodies } : {},
+      ...hookMap(module.intents) !== void 0 ? { intents: module.intents } : {},
+      ...typeof module.epsilon === "number" ? { epsilon: module.epsilon } : {},
+      ...typeof module.maxPredictedBodies === "number" ? { maxPredictedBodies: module.maxPredictedBodies } : {},
+      ...typeof module.smoothingHalfLifeMs === "number" ? { smoothingHalfLifeMs: module.smoothingHalfLifeMs } : {},
+      file: entry
+    };
+    const planar = planarEngine === "rapier2d" ? {
+      engine: "rapier2d",
+      ...common,
+      ...typeof module.setup === "function" ? { setup: module.setup } : {}
+    } : {
+      engine: "matter2d",
+      ...common,
+      ...typeof module.setup === "function" ? { setup: module.setup } : {},
+      ...hookMap(module.settle) !== void 0 ? { settle: module.settle } : {}
+    };
+    const why = whyNotPredictable(planar);
+    return why === void 0 ? planar : { engine: planarEngine, why, file: entry };
   }
+  if (typeof gravity.y !== "number" || typeof gravity.z !== "number") throw notAWorld;
   return {
+    engine: "rapier3d",
     gravity,
     ...typeof module.timestep === "number" ? { timestep: module.timestep } : {},
     ...typeof module.setup === "function" ? { setup: module.setup } : {},
-    ...typeof module.bodies === "object" && module.bodies !== null ? { bodies: module.bodies } : {},
-    ...typeof module.intents === "object" && module.intents !== null ? { intents: module.intents } : {},
+    ...hookMap(module.bodies) !== void 0 ? { bodies: module.bodies } : {},
+    ...hookMap(module.intents) !== void 0 ? { intents: module.intents } : {},
     file: entry
   };
 }
@@ -493,6 +601,80 @@ function everyByteEqual(a, b) {
   for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false;
   return true;
 }
+var DETERMINISM_STEPS_2D = 60;
+function canonicalMatterWorld(matter, engine) {
+  return matter.Composite.allBodies(engine.world).map(
+    (b) => [b.position.x, b.position.y, b.angle, b.velocity.x, b.velocity.y, b.angularVelocity].join(
+      ","
+    )
+  ).join(";");
+}
+async function checkWorldRapier2dDeterminism(world, schema) {
+  const factories = world.bodies ?? {};
+  const exercised = schema ? schema.collections.filter(
+    (c) => c.physics !== void 0 && factories[c.name] !== void 0
+  ) : [];
+  if (!world.setup && exercised.length === 0) return void 0;
+  const { initRapier2d } = await import("@irtio/runtime");
+  const { defaultRecord } = await import("@irtio/schema");
+  const rapier = await initRapier2d();
+  const build3 = () => {
+    const w = new rapier.World({ x: world.gravity.x, y: world.gravity.y });
+    try {
+      world.setup?.(w, rapier);
+      for (const desc of exercised) {
+        try {
+          const spec = factories[desc.name](rapier, defaultRecord(desc), "irtio-determinism-check");
+          if (spec?.body === void 0) continue;
+          const body = w.createRigidBody(spec.body);
+          for (const collider of spec.colliders ?? []) w.createCollider(collider, body);
+        } catch {
+        }
+      }
+      return w.takeSnapshot();
+    } finally {
+      w.free();
+    }
+  };
+  const first = build3();
+  const second = build3();
+  if (first.length === second.length && everyByteEqual(first, second)) return void 0;
+  return `the world builder is not deterministic: two builds of ${world.file} disagree. It must be pure over synced inputs \u2014 no Math.random(), no clock, no module state; put seeds and level parameters in synced state instead.`;
+}
+async function checkWorld2dDeterminism(world, schema) {
+  const factories = world.bodies ?? {};
+  const exercised = schema ? schema.collections.filter(
+    (c) => c.physics !== void 0 && factories[c.name] !== void 0
+  ) : [];
+  if (!world.setup && exercised.length === 0) return void 0;
+  const { initMatter } = await import("@irtio/runtime");
+  const { defaultRecord } = await import("@irtio/schema");
+  const matter = await initMatter();
+  const stepMs = (world.timestep ?? 1 / 60) * 1e3;
+  const build3 = () => {
+    const engine = matter.Engine.create();
+    engine.gravity.x = world.gravity.x;
+    engine.gravity.y = world.gravity.y;
+    try {
+      world.setup?.(engine, matter);
+      for (const desc of exercised) {
+        try {
+          const spec = factories[desc.name](matter, defaultRecord(desc), "irtio-determinism-check");
+          if (spec?.body !== void 0) matter.Composite.add(engine.world, spec.body);
+        } catch {
+        }
+      }
+      for (let i = 0; i < DETERMINISM_STEPS_2D; i++) matter.Engine.update(engine, stepMs);
+      return canonicalMatterWorld(matter, engine);
+    } finally {
+      matter.Engine.clear(engine);
+    }
+  };
+  const first = build3();
+  const second = build3();
+  if (first === second) return void 0;
+  return `the world builder is not deterministic: two builds of ${world.file} disagree after ${DETERMINISM_STEPS_2D} steps. It must be pure over synced inputs \u2014 no Math.random(), no clock, no module state; put seeds and level parameters in synced state instead.`;
+}
 var TICK_HEALTH_TIMEOUT_MS = 2e3;
 function stateUrlFor(wsUrl) {
   let parsed;
@@ -647,11 +829,30 @@ function formatReport(report, schemaLoaded) {
   const convergence = report.convergenceLagMs === void 0 ? "convergence not sampled" : `convergence ${report.convergenceLagMs} ms (p50 of ${report.convergence?.samples ?? 0})`;
   const { mispredictions, mispredictionMagnitude, mispredictionMax, snaps } = report.totals;
   const misprediction = mispredictions === 0 ? "misprediction 0" : `misprediction mean ${(mispredictionMagnitude / mispredictions).toFixed(1)} max ${mispredictionMax.toFixed(1)}`;
+  const { messagesSent, messagesReceived, messagesDropped } = report.totals;
+  const messages = messagesSent + messagesReceived + messagesDropped === 0 ? "" : ` \xB7 ${messagesSent} msg out / ${messagesReceived} in` + (messagesDropped > 0 ? ` / ${messagesDropped} dropped` : "");
   lines.push(
     pc.dim(
-      `  ${report.framesPerSecond} frames/s \xB7 in ${rate(report.bytesInPerSecondPerBot)}/bot \xB7 out ${rate(report.bytesOutPerSecondPerBot)}/bot \xB7 ${report.totals.corrections} corrections \xB7 ${misprediction} \xB7 ${snaps} snap(s) \xB7 ${convergence}`
+      `  ${report.framesPerSecond} frames/s \xB7 in ${rate(report.bytesInPerSecondPerBot)}/bot \xB7 out ${rate(report.bytesOutPerSecondPerBot)}/bot \xB7 ${report.totals.corrections} corrections \xB7 ${misprediction} \xB7 ${snaps} snap(s) \xB7 ${convergence}${messages}`
     )
   );
+  const prediction = report.prediction;
+  if (prediction !== void 0) {
+    const { syncCorrections, proxiedCorrections, suppressedCorrections } = report.totals;
+    lines.push(
+      pc.dim(
+        `  prediction: ${prediction.bots}/${report.bots} bot(s) held a local world \xB7 peak ${prediction.proxies} proxied, ${prediction.absent} absent \xB7 ${mispredictions} misprediction(s), ${suppressedCorrections} within-epsilon, ${proxiedCorrections} proxied, ${syncCorrections} body-sync`
+      )
+    );
+    if (prediction.absent > 0) {
+      lines.push(
+        pc.yellow(
+          `  ${prediction.absent} instance(s) had no body in a local world at once, so predicted bodies passed through them.
+  raise maxProxyBodies, or give the collection a body factory on the client.`
+        )
+      );
+    }
+  }
   if (report.tracePath !== void 0) lines.push(pc.dim(`  trace: ${report.tracePath}`));
   lines.push("");
   const failed = report.invariants.filter((i) => !i.ok);
@@ -742,7 +943,8 @@ function formatHits(rows) {
     `  ${pc.bold("hit registration")} ${pc.dim(`(${rows.length} shot(s))`)}`
   ];
   for (const row of rows) {
-    const at = row.serverTick === void 0 ? "no tick" : `tick ${row.serverTick}${row.estimated ? " (estimated)" : ""}`;
+    const marks = [row.estimated ? "estimated" : void 0, row.rewound ? "rewound" : void 0].filter((m) => m !== void 0).map((m) => ` (${m})`).join("");
+    const at = row.serverTick === void 0 ? "no tick" : `tick ${row.serverTick}${marks}`;
     if (row.missDistance === void 0) {
       lines.push(
         pc.yellow(
@@ -758,14 +960,48 @@ function formatHits(rows) {
   const measured = rows.filter((r) => r.missDistance !== void 0);
   if (measured.length > 0) {
     const mean = measured.reduce((s, r) => s + (r.missDistance ?? 0), 0) / measured.length;
+    const worst = Math.max(...measured.map((r) => r.missDistance ?? 0));
+    const rewound = measured.filter((r) => r.rewound === true).length;
+    const verdict = rewound === 0 ? "Nothing here compensates for lag; this is what a player at this latency would experience." : `${rewound} of ${measured.length} shot(s) were resolved through room.rewind, against the world the shooter was looking at.`;
     lines.push(
       pc.dim(
-        `  mean miss ${mean.toFixed(2)} over ${measured.length} shot(s). Nothing here compensates for lag; this is what a player at this latency would experience.`
+        `  mean miss ${mean.toFixed(2)}, worst ${worst.toFixed(2)} over ${measured.length} shot(s). ${verdict}`
       )
     );
   }
   return lines;
 }
+function formatMatchmaking(summary, failures) {
+  const lines = ["", `  ${pc.bold("matchmaking")}`];
+  lines.push(
+    pc.dim(
+      `  ${summary.tickets} ticket(s), ${summary.rooms} room(s), wait p50 ${summary.waitP50Ms} ms p95 ${summary.waitP95Ms} ms max ${summary.waitMaxMs} ms, ${summary.timeouts} timeout(s)` + (summary.backfills > 0 ? `, ${summary.backfills} backfill(s)` : "") + (summary.parties > 0 ? `, parties intact ${summary.partiesIntact}/${summary.parties}` : "")
+    )
+  );
+  for (const split of summary.splitParties) {
+    lines.push(
+      pc.red(
+        `  FAIL party ${split.party} was split across ${split.rooms.length} rooms: ` + split.rooms.join(", ")
+      )
+    );
+  }
+  for (const room of summary.overfullRooms) {
+    lines.push(
+      pc.red(
+        `  FAIL room ${room.room} holds ${room.bots} bots on a ticket that seats ${room.size}`
+      )
+    );
+  }
+  for (const failure of failures) {
+    lines.push(
+      pc.red(`  FAIL bot ${failure.requested} got no ticket: ${failure.code} \u2014 ${failure.message}`)
+    );
+  }
+  if (summary.splitParties.length === 0 && summary.overfullRooms.length === 0 && failures.length === 0) {
+    lines.push(pc.green("  every bot was answered, and every party landed in one room."));
+  }
+  return lines;
+}
 function point(p) {
   const parts = Object.entries(p).map(([k, v]) => `${k} ${Math.round(v * 100) / 100}`);
   return parts.length === 0 ? "(none)" : `(${parts.join(", ")})`;
@@ -856,15 +1092,23 @@ async function runSimulation(options = {}) {
     (c) => c.physics !== void 0
   );
   const loadedWorld = hasPhysics ? await loadProjectWorld({ cwd, outDir, irtioPackages: options.irtioPackages }) : void 0;
-  if (isUnpredictedWorld(loadedWorld)) {
-    log(
-      `physics: ${loadedWorld.file} is a 2D (matter2d) world; bots run without client prediction`
-    );
+  const world2d = is2dWorld(loadedWorld) ? loadedWorld : void 0;
+  const worldR2d = isRapier2dWorld(loadedWorld) ? loadedWorld : void 0;
+  const world = is2dWorld(loadedWorld) || isRapier2dWorld(loadedWorld) || isUnpredictedWorld(loadedWorld) ? void 0 : loadedWorld;
+  if (world2d !== void 0) {
+    log(`physics: ${world2d.file} is a matter2d world; bots predict with physics2d`);
+  } else if (worldR2d !== void 0) {
+    log(`physics: ${worldR2d.file} is a rapier2d world; bots predict with physics2d`);
+  } else if (isUnpredictedWorld(loadedWorld)) {
+    log(pc.yellow(`physics: ${loadedWorld.why}`));
   }
-  const world = isUnpredictedWorld(loadedWorld) ? void 0 : loadedWorld;
   let worldError;
   if (world) {
     worldError = await checkWorldDeterminism(world);
+  } else if (world2d) {
+    worldError = await checkWorld2dDeterminism(world2d, loaded?.schema);
+  } else if (worldR2d) {
+    worldError = await checkWorldRapier2dDeterminism(worldR2d, loaded?.schema);
   }
   const conditionsSpec = scenario?.conditions ?? conditionsFrom(options);
   const cheatSpec = scenario?.cheat ?? cheatFrom(options);
@@ -883,9 +1127,27 @@ async function runSimulation(options = {}) {
     ...options.overrunsMax !== void 0 ? { overrunsMax: options.overrunsMax } : {},
     ...options.profile === true ? { profile: true } : {}
   };
-  const predicted = world !== void 0 && worldError === void 0;
+  const predicted = (world !== void 0 || world2d !== void 0 || worldR2d !== void 0) && worldError === void 0;
+  const projectKey = options.key ?? loaded?.schema?.project;
+  if (options.queue !== void 0 && (projectKey === void 0 || projectKey === "")) {
+    throw new RunNotPerformedError(
+      "irtio simulate: --queue needs a project key, and this schema carries none.\n  build the schema with `irtio` so it names its project, or pass --key."
+    );
+  }
+  const match = options.queue !== void 0 && options.control !== void 0 ? {
+    controlUrl: options.control,
+    project: projectKey,
+    queue: options.queue,
+    ...options.matchTimeoutMs !== void 0 ? { timeoutMs: options.matchTimeoutMs } : {},
+    ...options.party !== void 0 ? (
+      // Consecutive groups of `n`: bots 0..n-1 are party 0, n..2n-1 are party 1. A
+      // trailing group smaller than `n` is still a party, of whatever is left.
+      { party: (index) => Math.floor(index / options.party) }
+    ) : {}
+  } : void 0;
   const spawn = {
     ...common,
+    ...match !== void 0 ? { match } : {},
     ...options.joinTimeoutMs !== void 0 ? { joinTimeoutMs: options.joinTimeoutMs } : {},
     ...options.roomGoneGraceMs !== void 0 ? { roomGoneGraceMs: options.roomGoneGraceMs } : {}
   };
@@ -895,7 +1157,7 @@ async function runSimulation(options = {}) {
       ...spawn,
       schema: loaded.schema,
       script: scenario?.script ?? randomScript(loaded.schema, { cheat: cheatSpec ?? false }),
-      ...predicted ? {
+      ...predicted && world !== void 0 ? {
         physics: {
           gravity: world.gravity,
           ...world.timestep !== void 0 ? { timestep: world.timestep } : {},
@@ -903,6 +1165,35 @@ async function runSimulation(options = {}) {
           ...world.bodies !== void 0 ? { bodies: world.bodies } : {},
           ...world.intents !== void 0 ? { intents: world.intents } : {}
         }
+      } : {},
+      // ---- M6 lane E: testing parity ---- (D73-a)
+      ...predicted && world2d !== void 0 ? {
+        physics2d: {
+          gravity: world2d.gravity,
+          ...world2d.timestep !== void 0 ? { timestep: world2d.timestep } : {},
+          ...world2d.setup !== void 0 ? { setup: world2d.setup } : {},
+          ...world2d.bodies !== void 0 ? { bodies: world2d.bodies } : {},
+          ...world2d.intents !== void 0 ? { intents: world2d.intents } : {},
+          ...world2d.settle !== void 0 ? { settle: world2d.settle } : {},
+          ...world2d.epsilon !== void 0 ? { epsilon: world2d.epsilon } : {},
+          ...world2d.maxPredictedBodies !== void 0 ? { maxPredictedBodies: world2d.maxPredictedBodies } : {},
+          ...world2d.smoothingHalfLifeMs !== void 0 ? { smoothingHalfLifeMs: world2d.smoothingHalfLifeMs } : {}
+        }
+      } : {},
+      // The same `physics2d` option, under the engine discriminant: one planar option, two
+      // engines, and the client dispatches on the name rather than on the gravity's shape.
+      ...predicted && worldR2d !== void 0 ? {
+        physics2d: {
+          engine: "rapier2d",
+          gravity: worldR2d.gravity,
+          ...worldR2d.timestep !== void 0 ? { timestep: worldR2d.timestep } : {},
+          ...worldR2d.setup !== void 0 ? { setup: worldR2d.setup } : {},
+          ...worldR2d.bodies !== void 0 ? { bodies: worldR2d.bodies } : {},
+          ...worldR2d.intents !== void 0 ? { intents: worldR2d.intents } : {},
+          ...worldR2d.epsilon !== void 0 ? { epsilon: worldR2d.epsilon } : {},
+          ...worldR2d.maxPredictedBodies !== void 0 ? { maxPredictedBodies: worldR2d.maxPredictedBodies } : {},
+          ...worldR2d.smoothingHalfLifeMs !== void 0 ? { smoothingHalfLifeMs: worldR2d.smoothingHalfLifeMs } : {}
+        }
       } : {}
     }) : await spawnBots(bots, { ...spawn, script: relayEchoScript() });
   } catch (err) {
@@ -1049,6 +1340,9 @@ async function runSimulation(options = {}) {
   if (report.profile !== void 0) {
     for (const line of formatRunProfile(report, options.profileTop)) log(line);
   }
+  if (report.matchmaking !== void 0) {
+    for (const line of formatMatchmaking(report.matchmaking, runner.matchFailures)) log(line);
+  }
   if (adversarial !== void 0) for (const line of formatAdversarial(adversarial)) log(line);
   if (hits.length > 0) for (const line of formatHits(hits)) log(line);
   if (truth !== void 0) for (const line of formatTruth(truth)) log(line);
@@ -1059,11 +1353,14 @@ async function runSimulation(options = {}) {
     log(pc.red(`  FAIL world-builder: ${worldError}`));
   } else if (predicted) {
     const suppressed = report.totals.suppressedCorrections;
+    const engine = world2d !== void 0 ? "matter2d" : worldR2d !== void 0 ? "rapier2d" : "rapier3d";
     log(
       pc.dim(
-        `  bots predicted physics from ${path2.relative(cwd, world?.file ?? "")} (build-twice check held; ${suppressed} within-epsilon correction(s) suppressed)`
+        `  bots predicted ${engine} physics from ${path2.relative(cwd, world?.file ?? world2d?.file ?? worldR2d?.file ?? "")} (build-twice check held; ${suppressed} within-epsilon correction(s) suppressed)`
       )
     );
+  } else if (hasPhysics && isUnpredictedWorld(loadedWorld)) {
+    log(pc.yellow("  bots interpolated instead of predicting; see the physics line above."));
   } else if (hasPhysics) {
     log(
       pc.yellow(
@@ -1075,7 +1372,10 @@ async function runSimulation(options = {}) {
     log(pc.red(`  bot ${failure.bot} script failed: ${String(failure.error)}`));
   }
   if (fatal !== void 0) log(pc.red(`  run ended early: ${fatal}`));
-  const exitCode = endedBy === "ceiling" ? 2 : !report.ok || worldError !== void 0 || runner.scriptErrors.length > 0 || scenarioRun?.ok === false || // D43: a difference between what the clients held and what the save says the server
+  const exitCode = endedBy === "ceiling" ? 2 : !report.ok || worldError !== void 0 || runner.scriptErrors.length > 0 || // D73-c: a bot that never got a ticket is a measured failure of the front door, so it
+  // is exit 1 like every other one. The run still happened for the bots that got in, and
+  // the matchmaking section names the ones that did not.
+  runner.matchFailures.length > 0 || scenarioRun?.ok === false || // D43: a difference between what the clients held and what the save says the server
   // held is a measured violation, so it is exit 1 like every other one. A run that could
   // not take a save at all is not: nothing was measured, and the section says so in
   // words rather than turning "unread" into a verdict, which is D36's `unavailable` rule
@@ -1091,6 +1391,7 @@ async function runSimulation(options = {}) {
     ...truth !== void 0 ? { truth } : {},
     schema: loaded !== void 0,
     predicted,
+    matchFailures: runner.matchFailures,
     ...worldError !== void 0 ? { worldError } : {},
     endedBy,
     ...fatal !== void 0 ? { fatal } : {},
@@ -1129,8 +1430,14 @@ export {
   ScenarioNotRunError,
   USAGE,
   ceilingFor,
+  checkWorld2dDeterminism,
   checkWorldDeterminism,
+  checkWorldRapier2dDeterminism,
+  detectMatter2dRoom,
+  detectRoomEngine,
   formatBuildIdentity,
+  is2dWorld,
+  isRapier2dWorld,
   isUnpredictedWorld,
   loadProjectSchema,
   loadProjectWorld,

package/dist/{static-deploy-KOWFKWZA.js → static-deploy-7UCYINJB.js}

@@ -4,11 +4,11 @@ import {
   runStaticDeploy,
   staticDeploy,
   walkStaticDir
-} from "./chunk-3HQMVCYA.js";
-import "./chunk-RQSJZWQC.js";
-import "./chunk-DKWG7MGO.js";
-import "./chunk-ZD4ND6X6.js";
-import "./chunk-RNAH5T4W.js";
+} from "./chunk-BQBOBFBO.js";
+import "./chunk-WFMRNGO5.js";
+import "./chunk-JL235KIE.js";
+import "./chunk-OCVALOGK.js";
+import "./chunk-IDF46P7R.js";
 import "./chunk-UPHQM6NZ.js";
 export {
   USAGE,

package/dist/{status-HF3ZEKB7.js → status-JZGKH2P6.js}

@@ -1,15 +1,15 @@
 import {
   readProjectConfig
-} from "./chunk-DKWG7MGO.js";
+} from "./chunk-JL235KIE.js";
 import {
   HelpRequested,
   helpFor,
   helpRequested
-} from "./chunk-ZD4ND6X6.js";
+} from "./chunk-OCVALOGK.js";
 import {
   createApiClient,
   isLoginRequired
-} from "./chunk-RNAH5T4W.js";
+} from "./chunk-IDF46P7R.js";
 import {
   resolveControlUrlForUser
 } from "./chunk-UPHQM6NZ.js";

package/dist/{usage-4G23QXCH.js → usage-7S447INI.js}

@@ -1,15 +1,15 @@
 import {
   readProjectConfig
-} from "./chunk-DKWG7MGO.js";
+} from "./chunk-JL235KIE.js";
 import {
   HelpRequested,
   helpFor,
   helpRequested
-} from "./chunk-ZD4ND6X6.js";
+} from "./chunk-OCVALOGK.js";
 import {
   createApiClient,
   isLoginRequired
-} from "./chunk-RNAH5T4W.js";
+} from "./chunk-IDF46P7R.js";
 import {
   resolveControlUrlForUser
 } from "./chunk-UPHQM6NZ.js";

package/dist/{whoami-KTMTQNHM.js → whoami-UFSWPWK6.js}

@@ -2,11 +2,11 @@ import {
   HelpRequested,
   helpFor,
   helpRequested
-} from "./chunk-ZD4ND6X6.js";
+} from "./chunk-OCVALOGK.js";
 import {
   createApiClient,
   isLoginRequired
-} from "./chunk-RNAH5T4W.js";
+} from "./chunk-IDF46P7R.js";
 import {
   resolveControlUrlForUser
 } from "./chunk-UPHQM6NZ.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@irtio/cli",
-  "version": "0.6.0",
+  "version": "0.8.0",
   "description": "irtio CLI: local dev server, room scaffolding, bot simulation, deploy, logs and rooms",
   "license": "MIT",
   "publishConfig": {
@@ -45,16 +45,17 @@
     "esbuild": "^0.27.3",
     "picocolors": "^1.1.1",
     "ws": "^8.18.0",
-    "@irtio/client": "0.6.0",
-    "@irtio/bots": "0.6.0",
-    "@irtio/protocol": "0.6.0",
-    "@irtio/server": "0.6.0",
-    "@irtio/runtime": "0.6.0",
-    "@irtio/schema": "0.6.0"
+    "@irtio/bots": "0.8.0",
+    "@irtio/client": "0.8.0",
+    "@irtio/runtime": "0.8.0",
+    "@irtio/schema": "0.8.0",
+    "@irtio/server": "0.8.0",
+    "@irtio/protocol": "0.8.0"
   },
   "devDependencies": {
     "@types/ws": "^8.5.13",
     "@dimforge/rapier3d-compat": "0.20.0",
+    "@dimforge/rapier2d-compat": "0.20.0",
     "@irtio/store": "0.0.0",
     "@irtio/supervisor": "0.0.0"
   },