@looop-games/cli 0.1.34 → 0.1.36

package/lib/replay-store.mjs

@@ -0,0 +1,440 @@
+// The dev recording store — where a session you just played is kept.
+//
+// In dev the room server, the game folder and the person who played are all on
+// one machine, so a recording has no reason to make a round trip: the room
+// posts each closed segment to the dev server (see sessionIngestUrlFor in
+// shared/ui/room/session-ingest.js) and it lands here, under the game's
+// `.looop/replays/<stream>/`. Watching a session back is then just reading
+// files that are already on disk — which is what makes `?replay=<id>` a URL
+// you paste rather than a fetch with credentials behind it.
+//
+// A PUBLISHED game is the other case entirely: its room is a Worker, the only
+// durable place is the platform, and segments go to /sessions/ingest (R2 +
+// D1). Nothing here is involved in that lane.
+import { mkdirSync, readdirSync, readFileSync, writeFileSync, existsSync, rmSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import { pathToFileURL } from 'node:url';
+
+// The stream id is minted room-side from a timestamp and a counter, and it is
+// interpolated into a filesystem path — so its charset is pinned here rather
+// than trusted. Anything with a separator, a dot segment, or nothing in it is
+// refused outright instead of being sanitized into something plausible.
+const STREAM_RE = /^[a-z0-9][a-z0-9-]{0,63}$/;
+
+// Where a dev room posts its closed segments. The engine derives the same path
+// in shared/ui/room/session-ingest.js (DEV_SEGMENT_PATH there) — the two ends
+// of one wire, kept spelled out in both so neither can drift silently.
+export const DEV_SEGMENT_PATH = '/__looop/segments';
+
+// Where the dev page asks what recordings exist, deletes one, or pins one
+// against the prune — the read half of the same lane. Spelled out in the
+// engine's Sessions tool too (shared/ui/sessions/sessions.js), for the same
+// reason as above: two ends of one wire, neither able to drift silently.
+export const DEV_REPLAYS_PATH = '/__looop/replays';
+
+export function replaysRoot(projectDir) {
+  return join(projectDir, '.looop', 'replays');
+}
+
+export function streamDir(projectDir, stream) {
+  if (!STREAM_RE.test(stream ?? '')) throw new Error(`invalid stream id: ${JSON.stringify(stream)}`);
+  return join(replaysRoot(projectDir), stream);
+}
+
+/**
+ * Persist one closed segment. The address is (stream, seq), the same pair the
+ * production index uses, so a room's bounded retry rewrites the same file
+ * rather than appending a duplicate.
+ * @param {string} projectDir - the game folder
+ * @param {{ slug?: string, room?: string, segment: object }} body - the room's POST body
+ * @returns {{ stored: true, stream: string, seq: number }}
+ */
+export function writeSegment(projectDir, body) {
+  const segment = body?.segment;
+  const header = segment?.header;
+  if (!header || typeof header !== 'object') throw new Error('not a segment: no header');
+  if (header.format !== 'looop-replay-seg/1') {
+    throw new Error(`not a segment: format ${JSON.stringify(header.format)}`);
+  }
+  // Bounded above as well as below: `seq` names the file, and while no number's
+  // string form can contain a separator, an unbounded one lets a sender pick
+  // arbitrary names in the stream directory (`1e21`, `9007199254740992`) that
+  // the reader's lexical sort then misorders. A stream that reaches a million
+  // segments is a bug, not a session.
+  //
+  // The bound is EXCLUSIVE because the filename is six digits: an accepted
+  // 1000000 would write `1000000.json`, which SEGMENT_FILE_RE never matches, so
+  // the store would answer `stored: true` (stopping the room's retries) to a
+  // segment no reader can see and no retention cap can ever sweep.
+  if (!Number.isInteger(header.seq) || header.seq < 0 || header.seq >= 1e6) {
+    throw new Error('not a segment: bad seq');
+  }
+  if (!Array.isArray(segment.events)) throw new Error('not a segment: no events');
+  const dir = streamDir(projectDir, header.stream);
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(join(dir, segmentFileName(header.seq)), JSON.stringify(segment));
+  updateIndex(dir, segment);
+  return { stored: true, stream: header.stream, seq: header.seq };
+}
+
+// ── the per-stream index ────────────────────────────────────────────────────
+//
+// The Sessions panel asks each recording when it was played, how long it ran
+// and how many inputs it carries. Every one of those lives in the segments, so
+// answering from the segments costs the whole recording — a five-minute session
+// is megabytes, and the panel asks about twenty of them at once, on a phone.
+// So each segment write also folds its own contribution into a small file
+// beside the segments, and reading a stream's headline facts is then one small
+// read instead of a full parse.
+//
+// The counts are held PER SEQ rather than as a running total because a segment
+// can legitimately arrive twice: a room's flush retries are idempotent by
+// (stream, seq) and rewrite the same file, so a running total would count that
+// segment's inputs again every time the network hiccuped.
+//
+// Keyed as an OBJECT rather than indexed into an array, because `seq` comes off
+// the wire from an endpoint nothing authenticates. An array indexed at seq
+// 999999 serialises 999999 holes as `null` — so a 160-byte POST would write
+// megabytes here, none of it visible to the retention caps, and every later
+// listing would reduce over a million elements inside the dev server's one
+// thread. An object costs one entry per segment that actually exists.
+//
+// The index is derived, never authoritative: it is rebuilt from the segments
+// whenever it is missing or was written by an older shape, so deleting it is a
+// safe thing for anyone to do and an older recording gains one on first read.
+const INDEX_FILE = 'index.json';
+const INDEX_VERSION = 2;
+
+// Segments are the six-digit files; everything else in the directory (this
+// index, the keep marker) is bookkeeping and is not a segment.
+const SEGMENT_FILE_RE = /^\d{6}\.json$/;
+
+function segmentFileName(seq) {
+  // Zero-padded so a directory listing is already in stream order — the same
+  // reason the R2 key is padded.
+  return `${String(seq).padStart(6, '0')}.json`;
+}
+
+function countInputs(segment) {
+  // A recorded INPUT is a `w` — an accepted wire send, the player doing
+  // something. Spawns, roster changes and checksums are the world's own
+  // bookkeeping and are not things anybody did.
+  return (segment?.events ?? []).reduce((n, e) => n + (e?.k === 'w' ? 1 : 0), 0);
+}
+
+function foldSegment(index, segment) {
+  const h = segment.header;
+  const seq = h.seq;
+  // Anchored on the SEQ alone. `startedAt` is null in a runtime with no Date
+  // (recorder.js writes it conditionally), and keying on "we have no stamp yet"
+  // would make every later segment re-anchor — so `startTick` would track the
+  // last segment written and the duration would collapse to one segment's span,
+  // or go negative.
+  if (seq < (index.firstSeq ?? Infinity)) {
+    index.firstSeq = seq;
+    index.startedAt = h.startedAt ?? null;
+    index.startTick = h.startTick ?? 0;
+  }
+  if (h.tickRate) index.tickRate = h.tickRate;
+  // Whether this stream can be ENTERED. A replay starts at a keyframe, so a
+  // stream that has not cut one yet is on disk and not yet watchable — a
+  // not-yet, not a corruption, and a different answer from "no such recording".
+  if (h.keyframe) index.hasKeyframe = true;
+  const end = segment.endTick ?? h.startTick ?? 0;
+  index.endTick = Math.max(index.endTick ?? -Infinity, end);
+  index.inputsBySeq[String(seq)] = countInputs(segment);
+  return index;
+}
+
+function emptyIndex(stream) {
+  return { v: INDEX_VERSION, stream, startedAt: null, firstSeq: null, startTick: 0, endTick: null,
+    tickRate: null, hasKeyframe: false, inputsBySeq: {} };
+}
+
+// Read every segment in a stream and fold them into a fresh index. The slow
+// path, taken once per stream: on the first write, and on the first read of a
+// recording made before this file existed.
+function rebuildIndex(dir, stream) {
+  const index = emptyIndex(stream);
+  for (const name of readdirSync(dir).sort()) {
+    if (!SEGMENT_FILE_RE.test(name)) continue;
+    try {
+      const seg = JSON.parse(readFileSync(join(dir, name), 'utf8'));
+      if (seg?.header?.format === 'looop-replay-seg/1') foldSegment(index, seg);
+    } catch {
+      // A half-written file (the dev server was killed mid-POST) must not cost
+      // the rest of the session — the same tolerance stitching has.
+    }
+  }
+  return index;
+}
+
+function readIndex(dir) {
+  try {
+    const index = JSON.parse(readFileSync(join(dir, INDEX_FILE), 'utf8'));
+    if (index?.v === INDEX_VERSION && index.inputsBySeq && typeof index.inputsBySeq === 'object'
+      && !Array.isArray(index.inputsBySeq)) return index;
+  } catch {
+    // Missing, half-written, or an older shape — all one case: rebuild.
+  }
+  return null;
+}
+
+function writeIndex(dir, index) {
+  try {
+    writeFileSync(join(dir, INDEX_FILE), JSON.stringify(index));
+  } catch {
+    // The index is a cache. A game folder that has gone read-only must not
+    // turn a recorded session into a failed POST.
+  }
+}
+
+function updateIndex(dir, segment) {
+  // Absent means rebuild rather than start over: an index deleted mid-stream
+  // would otherwise silently lose every segment written before it went.
+  const existing = readIndex(dir);
+  writeIndex(dir, existing ? foldSegment(existing, segment) : rebuildIndex(dir, segment.header.stream));
+}
+
+// ── the read side ───────────────────────────────────────────────────────────
+
+// Presence is the whole marker: a recording under triage must survive the
+// prune, and the flag lives in its own FILE rather than in the index because
+// the index is rewritten on every segment write — a keep toggled while that
+// stream is still recording would lose the race. Deleting the directory still
+// takes the marker with it.
+const KEEP_FILE = 'keep';
+
+/**
+ * Every recording this game has on disk, newest first.
+ *
+ * Each entry carries what the Sessions panel shows: when it was played, how
+ * long it ran, how many inputs it holds, what it weighs, and whether it is
+ * pinned against the prune. Cost is one small read and a stat per file — never
+ * a parse of the recordings themselves (see the index above).
+ *
+ * @param {string} projectDir - the game folder
+ * @returns {Array<{ stream: string, startedAt: number|null, durationMs: number|null,
+ *   inputs: number, segments: number, bytes: number, kept: boolean }>}
+ */
+export function listRecordings(projectDir) {
+  const root = replaysRoot(projectDir);
+  if (!existsSync(root)) return [];
+  const out = [];
+  for (const stream of readdirSync(root)) {
+    // Only names this store could have minted. A creator copying a teammate's
+    // recording in calls the directory whatever they like, and listing one made
+    // `deleteRecording` throw on a name `streamDir` refuses — inside a prune
+    // that runs before `looop dev` binds a port, so the whole stack failed to
+    // start over a directory name. The two functions agree on the charset here.
+    if (!STREAM_RE.test(stream)) continue;
+    const dir = join(root, stream);
+    let names;
+    try {
+      if (!statSync(dir).isDirectory()) continue;
+      names = readdirSync(dir);
+    } catch {
+      continue;
+    }
+    const segments = names.filter((n) => SEGMENT_FILE_RE.test(n));
+    if (!segments.length) continue;
+    let index = readIndex(dir);
+    if (!index) {
+      index = rebuildIndex(dir, stream);
+      writeIndex(dir, index);
+    }
+    // Every file, not only the segments: the caps exist to bound a folder, and
+    // anything left out of the measurement is something the prune can never
+    // reclaim however much of it there is.
+    let bytes = 0;
+    for (const name of names) {
+      try { bytes += statSync(join(dir, name)).size; } catch { /* the file vanished mid-scan */ }
+    }
+    const ticks = index.endTick == null ? null : index.endTick - (index.startTick ?? 0);
+    out.push({
+      stream,
+      startedAt: index.startedAt ?? null,
+      durationMs: ticks != null && index.tickRate ? (ticks / index.tickRate) * 1000 : null,
+      inputs: Object.values(index.inputsBySeq).reduce((n, v) => n + (v ?? 0), 0),
+      segments: segments.length,
+      bytes,
+      // A replay enters at a keyframe. A stream a few seconds old has not cut
+      // one yet, so it is on disk and not yet watchable.
+      watchable: index.hasKeyframe === true,
+      kept: existsSync(join(dir, KEEP_FILE)),
+    });
+  }
+  // Newest first, by the wall clock the room stamped rather than by mtime: a
+  // copied folder keeps its play order, and the list reads the way the person
+  // remembers playing. Streams with no stamp sort last rather than first.
+  return out.sort((a, b) => (b.startedAt ?? -Infinity) - (a.startedAt ?? -Infinity));
+}
+
+/**
+ * The most recent recording that can actually be WATCHED, or null.
+ *
+ * Newest-that-is-watchable rather than newest: a stream cuts its first keyframe
+ * a few seconds in, so the very newest recording is routinely not enterable
+ * yet — and `?replay=last` resolving to it would answer "no recording ... it is
+ * recorded on the machine that played it" while a perfectly watchable session
+ * sits right behind it, on the machine asking.
+ */
+export function latestRecording(projectDir) {
+  return listRecordings(projectDir).find((r) => r.watchable)?.stream ?? null;
+}
+
+/**
+ * Delete one recording, whole. Returns false when there was nothing there —
+ * deleting a session twice is not an error, it is the second tap.
+ */
+export function deleteRecording(projectDir, stream) {
+  const dir = streamDir(projectDir, stream);
+  if (!existsSync(dir)) return false;
+  rmSync(dir, { recursive: true, force: true });
+  return true;
+}
+
+/**
+ * Pin a recording against the prune, or unpin it. Returns false when there is
+ * no such recording.
+ */
+export function setKept(projectDir, stream, kept) {
+  const dir = streamDir(projectDir, stream);
+  if (!existsSync(dir)) return false;
+  const marker = join(dir, KEEP_FILE);
+  if (kept) writeFileSync(marker, '');
+  else rmSync(marker, { force: true });
+  return true;
+}
+
+// What a game's recordings may take up before the oldest start going. Two caps
+// because either one alone has a case it cannot see: a game with big worlds
+// hits the byte cap after a handful of sessions, and a small game would sit at
+// a few megabytes while accumulating hundreds of directories.
+export const MAX_RECORDINGS = 20;
+export const MAX_RECORDING_BYTES = 200 * 1024 * 1024;   // ~an hour of a real game at ~2.7 MB/minute
+
+/**
+ * Bring a game's recordings back under the caps, oldest first.
+ *
+ * Pinned recordings are never swept, and they still COUNT against the caps —
+ * pinning is "do not delete this", not "do not charge me for it". Pin
+ * everything and the caps simply stop having anything to take, which is the
+ * honest outcome: the alternative silently deletes an unpinned session the
+ * creator only just made.
+ *
+ * @param {string} projectDir - the game folder
+ * @param {{ maxCount?: number, maxBytes?: number }} [caps]
+ * @returns {{ removed: string[], bytes: number, count: number, caps: { maxCount: number, maxBytes: number } }}
+ *   what went, what is left, and the caps that decided it
+ */
+export function pruneRecordings(projectDir, { maxCount = MAX_RECORDINGS, maxBytes = MAX_RECORDING_BYTES } = {}) {
+  // Oldest first: the sweep order is the reverse of the reading order.
+  const all = listRecordings(projectDir).reverse();
+  let count = all.length;
+  let bytes = all.reduce((n, r) => n + r.bytes, 0);
+  const removed = [];
+  for (const rec of all) {
+    if (count <= maxCount && bytes <= maxBytes) break;
+    if (rec.kept) continue;
+    // A delete that fails for its own reason (a permission, a file held open)
+    // costs that one recording, never the startup this runs inside.
+    try {
+      if (!deleteRecording(projectDir, rec.stream)) continue;
+    } catch {
+      continue;
+    }
+    removed.push(rec.stream);
+    count -= 1;
+    bytes -= rec.bytes;
+  }
+  return { removed, bytes, count, caps: { maxCount, maxBytes } };
+}
+
+/**
+ * Read a whole stream back as the single playable recording the replay
+ * transport consumes, or null when there is nothing enterable there.
+ *
+ * Stitching goes through the ENGINE's `stitchSegments` rather than a copy: it
+ * is the same reassembler the recorder's own export() uses, which is what
+ * keeps "segments are just a slicing of the recording" true by construction.
+ * It is imported from the resolved engine bundle, so a recording is always
+ * read back by the engine that wrote it — from `entity/stitch.js`, which is
+ * the reassembler alone, rather than through the recorder and its runtime
+ * dependencies.
+ *
+ * @param {string} projectDir - the game folder
+ * @param {string} stream
+ * @param {string} sharedDir - the engine bundle's shared/ tree
+ * @returns {Promise<string|null>} the recording as JSON text
+ */
+export async function stitchStream(projectDir, stream, sharedDir) {
+  const dir = streamDir(projectDir, stream);
+  if (!existsSync(dir)) return null;
+  const segments = [];
+  for (const name of readdirSync(dir).sort()) {
+    if (!SEGMENT_FILE_RE.test(name)) continue;
+    try {
+      const seg = JSON.parse(readFileSync(join(dir, name), 'utf8'));
+      if (seg?.header?.format === 'looop-replay-seg/1') segments.push(seg);
+    } catch {
+      // A half-written file (the dev server was killed mid-POST) must not
+      // cost the rest of the session.
+    }
+  }
+  if (!segments.length) return null;
+  // The stitcher belongs to the ENGINE, and the engine a game is pinned to may
+  // predate recordings entirely — a creator on a new CLI and an old engine can
+  // record perfectly well (the room is the new engine's; the segments are on
+  // disk) and then find nothing to read them with. Said plainly here, because
+  // the alternative is a module-resolution error surfacing to that creator as
+  // "no recording", with the files sitting in front of them.
+  const stitcher = join(sharedDir, 'ui', 'room', 'entity', 'stitch.js');
+  if (!existsSync(stitcher)) {
+    throw new Error(
+      "this game's pinned engine predates session recordings, so it cannot read one back — "
+      + 'run `looop update` to watch this session',
+    );
+  }
+  const { stitchSegments } = await import(pathToFileURL(stitcher).href);
+  try {
+    return JSON.stringify(stitchSegments(segments));
+  } catch {
+    // The only way stitching refuses a contiguous range is "no keyframe
+    // segment in it" — a stream whose first cadence keyframe has not been cut
+    // yet. That is a not-yet, not a corruption.
+    return null;
+  }
+}
+
+/**
+ * The prune `looop dev` runs on the way up, and the line it prints.
+ *
+ * On start rather than on write: a sweep mid-session could delete the
+ * recording of the session the creator is in the middle of watching back, and
+ * the moment a stack starts is the one moment nobody is reading anything.
+ * Silent deletion is not an option either — a creator who goes looking for
+ * Tuesday's session deserves to have been told it went, so the line names the
+ * count and the caps that took it.
+ */
+export function pruneOnStart({ projectDir, log = () => {}, caps } = {}) {
+  // This runs before `looop dev` has bound a port. Housekeeping over old
+  // recordings is never a reason for the stack not to start, so whatever the
+  // disk does here costs the sweep and nothing else.
+  let result;
+  try {
+    result = pruneRecordings(projectDir, caps);
+  } catch (e) {
+    log(`→ replays     could not sweep old recordings: ${e?.message ?? e}`);
+    return { removed: [], bytes: 0, count: 0, caps: { maxCount: MAX_RECORDINGS, maxBytes: MAX_RECORDING_BYTES } };
+  }
+  if (result.removed.length) {
+    // The caps the sweep ACTUALLY applied, not the module defaults: a line that
+    // names limits a caller overrode would be telling the creator their session
+    // went for a reason that was not the reason.
+    log(`→ replays     swept ${result.removed.length} old recording(s) — keeping the newest `
+      + `${result.caps.maxCount} and up to ${Math.round(result.caps.maxBytes / 1024 / 1024)} MB `
+      + "(pin one in the toolbox's Sessions tool to keep it)");
+  }
+  return result;
+}

package/lib/room-server.mjs

@@ -158,6 +158,41 @@ export function renderEntityComponents(components) {
 // A relative path with forward slashes whichever host produced it.
 const posixPath = (p) => p.split('\\').join('/');
 
+// The first line of every generated room module, dev and publish alike.
+//
+// Installing deterministic transcendental math happens by import side effect,
+// so the guarantee is about ORDER: any module evaluated ahead of it can capture
+// a native `Math.sin` (or precompute a table with one) and go on using it for
+// the life of the process. A room whose math differs by one bit from the
+// browser's diverges from every replay of its ticks and every predicted tick,
+// hundreds of ticks after the difference is introduced.
+//
+// It is emitted by each caller rather than by the shared preamble so that
+// "first" is true of the emitted text itself. The dev entry would otherwise
+// inherit the install through `/shared/ui/room/server.js`, which is correct
+// today only because that file's own first import is this one — a guarantee
+// living in a different module, one reorder away from silently ending.
+const DETERMINISTIC_MATH_MODULE = 'ui/room/deterministic-math.js';
+const INSTALL_DETERMINISTIC_MATH = `import '/shared/${DETERMINISTIC_MATH_MODULE}';`;
+
+// …but only against an engine that HAS it.
+//
+// The CLI and the engine are separate releases, and a game pins the engine
+// exactly while taking the CLI through a caret range — so an ordinary `npm
+// install` routinely produces a new CLI driving an older engine. `/shared/…`
+// specifiers are resolved against that pinned engine's directory and bundled,
+// not left external, so emitting this import unconditionally makes esbuild fail
+// to read a file that release does not contain, and BOTH `looop dev` and
+// `looop publish` die at the bundle step for a game that was building fine.
+//
+// Feature-detecting the file is the whole fix: an older engine simply generates
+// the room it generated before. It also degrades in the right direction — such
+// a room runs on native math, which is what it was already doing.
+function installDeterministicMath(sharedDir) {
+  if (!sharedDir) return [];   // no engine to interrogate: emit nothing rather than a guess
+  return existsSync(join(sharedDir, DETERMINISTIC_MATH_MODULE)) ? [INSTALL_DETERMINISTIC_MATH] : [];
+}
+
 function renderV2Preamble(raw) {
   // Kind modules are game-relative paths the engine relativized on the
   // creator's machine. An engine whose framework build predates the
@@ -187,8 +222,9 @@ function renderV2Preamble(raw) {
   ];
 }
 
-export function renderV2Entry(skeleton) {
+export function renderV2Entry(skeleton, { sharedDir } = {}) {
   return [
+    ...installDeterministicMath(sharedDir),
     "import LooopRoom from '/shared/ui/room/server.js';",
     ...renderV2Preamble(skeleton),
     'const BUNDLE = { ...TRIO, config: GRAPH.config };',
@@ -257,7 +293,7 @@ export async function buildV2RoomServer({ projectDir, engine, esbuildImpl }) {
 
   const result = await esbuild.build({
     stdin: {
-      contents: renderV2Entry(skeleton),
+      contents: renderV2Entry(skeleton, { sharedDir: engine.sharedDir }),
       resolveDir: projectDir,
       sourcefile: 'looop-room-server.js',
       loader: 'js',
@@ -310,8 +346,9 @@ export async function buildV2RoomServer({ projectDir, engine, esbuildImpl }) {
 // and EXPORTS it as `frameworkV2Bundle`. The generated entry
 // (renderV2GameServerEntry, builder side) imports that export and wraps it with
 // the release's LooopRoom.
-export function renderV2RoomModule(skeleton) {
+export function renderV2RoomModule(skeleton, { sharedDir } = {}) {
   return [
+    ...installDeterministicMath(sharedDir),
     ...renderV2Preamble(skeleton),
     'export const frameworkV2Bundle = { ...TRIO, config: GRAPH.config };',
     '',
@@ -339,7 +376,7 @@ export async function buildV2PublishModule({ projectDir, engine, esbuildImpl })
   const esbuild = esbuildImpl ?? (await import('esbuild'));
   const result = await esbuild.build({
     stdin: {
-      contents: renderV2RoomModule(skeleton),
+      contents: renderV2RoomModule(skeleton, { sharedDir: engine.sharedDir }),
       resolveDir: projectDir,
       sourcefile: 'looop-v2-room.js',
       loader: 'js',
@@ -362,8 +399,12 @@ export async function buildV2PublishModule({ projectDir, engine, esbuildImpl })
 // the host the creator's primitives through the `extraPrimitives()` seam the
 // engine already reads (server.js). Identical in shape to what the publish
 // endpoint generates for the per-game Worker — one contract, two builders.
-function renderEntry(primitives, entityComponents) {
+export function renderV1Entry(primitives, entityComponents, { sharedDir } = {}) {
   return [
+    // Before the barrel and before the entity components — both of which emit
+    // imports of the CREATOR's own simulation code, which is exactly the code
+    // that must not be evaluated on native transcendental math.
+    ...installDeterministicMath(sharedDir),
     renderBarrel(primitives),
     renderEntityComponents(entityComponents),
     "import LooopRoom from '/shared/ui/room/server.js';",
@@ -413,7 +454,7 @@ export async function buildDevRoomServer({ projectDir, engine, esbuildImpl }) {
     // against the game root, so `./overrides/...` means what it says and no
     // machine-specific absolute path can leak into the output.
     stdin: {
-      contents: renderEntry(primitives, entityComponents),
+      contents: renderV1Entry(primitives, entityComponents, { sharedDir: engine.sharedDir }),
       resolveDir: projectDir,
       sourcefile: 'looop-room-server.js',
       loader: 'js',