@cimplify/cli 0.15.2 → 0.16.0

package/dist/build-J4ZUIOPX.mjs

@@ -0,0 +1,625 @@
+#!/usr/bin/env node
+import { frameGates, browserRequired, economyGates } from './chunk-KMHORI4Y.mjs';
+import { writeBuildOutput, buildReport, locateChromium, startDevServer, HARDWARE_GPU_ARGS, BROWSER_ARGS, codeLogArgs, warmBrowser, measureCanvas, gateMisses, gateNotices, canvasMeasurements, softwareRenderer, measureLaunches, HOLD_PARAM, SILENT_PARAM } from './chunk-BYNE553A.mjs';
+import './chunk-NY4YT7O6.mjs';
+import './chunk-SF44L2OD.mjs';
+import './chunk-VSA44UKR.mjs';
+import './chunk-EGQIPYUN.mjs';
+import './chunk-SCKQ4XSD.mjs';
+import { readSourceSet, bakerFor, locateAudioPreviewer, buildInteractive, progressiveFromEnv, partsFromEnv, directoryContent, pinnedHermes, formatBytes, withBoot, BOOT_FORMAT_VERSION, MODULE_INDEX_PATH, splitModuleIndex, MODULE_MORE_PATH, requireInteractiveProject, workPath, PART_PATH_SEPARATOR } from './chunk-CPBESPWK.mjs';
+import { sceneCompilerFromFlag } from './chunk-VHK7WBO3.mjs';
+import './chunk-5HP2INMY.mjs';
+import './chunk-JKECUAAV.mjs';
+import { isEngineGame } from './chunk-T4MW3PD4.mjs';
+import './chunk-KQNZKV6E.mjs';
+import { refreshEngineRuntime } from './chunk-G2ZEFSQJ.mjs';
+import { locateToolchain } from './chunk-ZUCDXRFI.mjs';
+import './chunk-EYEMPIMP.mjs';
+import { approvedWasm, EMPTY_WASM_REGISTRY } from './chunk-AKACUJ3W.mjs';
+import './chunk-25ZPFHLF.mjs';
+import { formatDiagnostic } from './chunk-SGT5IJVW.mjs';
+import { parseArgs, flagString, flagBool } from './chunk-XQAHREKO.mjs';
+import './chunk-CLQYPTJ2.mjs';
+import './chunk-TT4YI33G.mjs';
+import { info, dim, failure, CliError, CLI_ERROR_CODE, success, bold, result } from './chunk-KOD4GBQ5.mjs';
+import fs from 'fs/promises';
+import path2 from 'path';
+import { LUAU_SCRIPTS_GROUP, isEngineRestGroup } from '@cimplify/sdk/interactives';
+import { declareEngineHeap, localSession, WebHost, workerEngines } from '@cimplify/sdk/interactives/web';
+import { mkdtempSync, rmSync } from 'fs';
+import { tmpdir } from 'os';
+
+var FIRST_RUN_GATE = "first run";
+var FIRST_RUN_BUDGET_MS = 1e4;
+var GUEST_SPECIFIER = "@cimplify/sdk/interactives/guest";
+var CODE_GROUP_ORDINAL = 0;
+var ADMISSION_LOCALE = {
+  currency: "USD",
+  decimal_separator: ".",
+  direction: "ltr",
+  first_day_of_week: "monday",
+  grouping_separator: ",",
+  hour_cycle: "h23",
+  language: "en",
+  measurement: "metric",
+  region: null,
+  time_zone: "UTC"
+};
+var ADMISSION_PERSONA = {
+  age_range: "adult",
+  avatar: null,
+  display_name: "Reviewer",
+  handle: "reviewer",
+  participant_id: "participant_admission"
+};
+function gate(status, detail) {
+  return { gates: [{ name: FIRST_RUN_GATE, status, detail }], measurements: null };
+}
+function describe(fault) {
+  return fault.source === "guest" ? `${fault.phase}: ${fault.message}` : `${fault.source}: ${fault.message}`;
+}
+function buildBodies(result4) {
+  const bodies = /* @__PURE__ */ new Map();
+  for (const chunk of result4.chunks) bodies.set(chunk.digest, Buffer.concat(chunk.parts));
+  return bodies;
+}
+function packageRefs(pkg) {
+  const seen = /* @__PURE__ */ new Set();
+  const chunks = [];
+  pkg.groups.forEach((group, ordinal) => {
+    for (const file of group.files) {
+      if (seen.has(file.chunk)) continue;
+      seen.add(file.chunk);
+      chunks.push({ digest: file.chunk, before_play: group.before_play, asset_group: group.name, size: file.bytes, lazy: isEngineRestGroup(group.name) });
+    }
+    if (ordinal !== CODE_GROUP_ORDINAL) return;
+    for (const module of pkg.runtime) {
+      if (seen.has(module.chunk)) continue;
+      seen.add(module.chunk);
+      chunks.push({ digest: module.chunk, before_play: group.before_play, asset_group: group.name, runtime: { name: module.name, version: module.version } });
+    }
+  });
+  return chunks;
+}
+async function firstRunGate(result4) {
+  const manifest = result4.manifest;
+  const pkg = result4.package;
+  if (manifest === null || pkg === null || manifest.profile.kind !== "native") return { gates: [], measurements: null };
+  if (!("Worker" in globalThis)) return gate("skipped", "the first-run gate needs a runtime with Web Workers");
+  const bodies = buildBodies(result4);
+  const chunks = packageRefs(pkg);
+  const session = localSession({
+    interactive_id: manifest.identity.id ?? "itv_admission",
+    profile: "native",
+    persona: ADMISSION_PERSONA
+  });
+  const faults = [];
+  const host = new WebHost({
+    engines: workerEngines(import.meta.resolve(GUEST_SPECIFIER)),
+    transport: session.transport,
+    hello: session.hello,
+    package: { chunks, ...pkg.engine_heap === void 0 ? {} : { engine_heap: pkg.engine_heap } },
+    chunks: {
+      async fetch(digest) {
+        const body = bodies.get(digest);
+        if (body === void 0) throw new Error(`chunk ${digest} is not in the build`);
+        return body;
+      }
+    },
+    locale: ADMISSION_LOCALE,
+    limits: { boot_ms: FIRST_RUN_BUDGET_MS },
+    on_fault: (fault) => faults.push(fault)
+  });
+  const rendered = new Promise((resolve) => {
+    const stop = host.tree.subscribe(() => {
+      if (host.tree.snapshot() === null) return;
+      stop();
+      resolve();
+    });
+  });
+  let timer = null;
+  const deadline = new Promise((_, reject) => {
+    timer = setTimeout(() => reject(new Error(`nothing rendered within ${FIRST_RUN_BUDGET_MS} ms`)), FIRST_RUN_BUDGET_MS);
+  });
+  try {
+    await Promise.race([Promise.all([host.start(), rendered]), deadline]);
+    return gate("passed", "the client entry started and rendered once");
+  } catch (error) {
+    const fault = faults[0];
+    return gate("failed", fault === void 0 ? String(error instanceof Error ? error.message : error) : describe(fault));
+  } finally {
+    if (timer !== null) clearTimeout(timer);
+    host.dispose();
+  }
+}
+var RECORD_GUEST = "@cimplify/sdk/interactives/record";
+var LOOKAHEAD_FRAMES = 180;
+var SETTLE_FRAMES = 30;
+var MAX_RECORD_FRAMES = 60 * 60;
+var RECORD_WALL_BUDGET_MS = 18e4;
+var RECORD_TIERS = ["low", "mid", "high"];
+var READY_MILESTONE = "ready_for_input";
+var FIRST_FRAME_MILESTONE = "first_frame_scheduled";
+var STACK_FRAMES = 6;
+var URGENT_PRIORITY = 0;
+var PREFETCH_KIND = 2;
+var PIPELINE_KIND = 3;
+var DEFERRED_KIND = 5;
+var DEFERRED_PREFIX = "deferred:";
+var PIPELINE_PREFIX = "pipeline:";
+var CHUNK_KIND = 4;
+var CHUNK_PREFIX = "chunk:";
+var BYTECODE_GROUP_PREFIX = "engine:hermes";
+var PART_SEPARATOR = "#part/";
+var CODE_GROUP_ORDINAL2 = 0;
+var SOURCE_SUFFIX = ".js";
+var RECORD_LOCALE = {
+  currency: "USD",
+  decimal_separator: ".",
+  direction: "ltr",
+  first_day_of_week: "monday",
+  grouping_separator: ",",
+  hour_cycle: "h23",
+  language: "en",
+  measurement: "metric",
+  region: null,
+  time_zone: "UTC"
+};
+var RECORD_PERSONA = {
+  age_range: "adult",
+  avatar: null,
+  display_name: "Recorder",
+  handle: "recorder",
+  participant_id: "participant_recorder"
+};
+function filesByPath(pkg) {
+  const out = /* @__PURE__ */ new Map();
+  for (const group of pkg.groups) for (const file of group.files) if (!out.has(file.path)) out.set(file.path, { path: file.path, digest: file.chunk, group: group.name, bytes: file.bytes });
+  return out;
+}
+function isSource(part) {
+  return part.path.endsWith(SOURCE_SUFFIX);
+}
+function codeParts(pkg) {
+  const code = pkg.groups[CODE_GROUP_ORDINAL2];
+  return code === void 0 ? [] : code.files.map((file) => ({ path: file.path, digest: file.chunk, group: code.name, bytes: file.bytes }));
+}
+function describe2(fault) {
+  return fault.source === "guest" ? `${fault.phase}: ${fault.message}${fault.stack ? ` (${fault.stack.split("\n").slice(0, STACK_FRAMES).join(" < ")})` : ""}` : `${fault.source}: ${fault.message}`;
+}
+var HOST_ENGINE_PREFIXES = ["engine:", "threads:"];
+var RECORD_ORDER = ["mid", "low", "high"];
+function hostSpecific(group) {
+  return isEngineRestGroup(group) || HOST_ENGINE_PREFIXES.some((prefix) => group.startsWith(prefix));
+}
+function touched(touch) {
+  if (touch.digest === null || touch.group === null || hostSpecific(touch.group)) return null;
+  return { path: touch.path, digest: touch.digest, group: touch.group, bytes: touch.bytes };
+}
+function eagerParts(pkg) {
+  const out = /* @__PURE__ */ new Map();
+  for (const group of pkg.groups) {
+    if (hostSpecific(group.name)) continue;
+    for (const file of group.files) {
+      const at = file.path.indexOf(PART_SEPARATOR);
+      if (at < 0 || file.refinement === true) continue;
+      const asset = file.path.slice(0, at);
+      const list = out.get(asset) ?? [];
+      list.push({ path: file.path, digest: file.chunk, group: group.name, bytes: file.bytes });
+      out.set(asset, list);
+    }
+  }
+  return out;
+}
+function bootSet(record, pkg) {
+  if (record.boot_frame === null) return { boot: [], follow: [] };
+  const eager = eagerParts(pkg);
+  const boot = record.code.filter((part) => !isSource(part));
+  const follow = [];
+  const seen = new Set(boot.map((part) => part.digest));
+  const add = (into, part) => {
+    if (seen.has(part.digest)) return;
+    seen.add(part.digest);
+    into.push(part);
+  };
+  for (const touch of record.touches) {
+    const part = touched(touch);
+    if (part === null || touch.frame > record.boot_frame + LOOKAHEAD_FRAMES) continue;
+    const into = touch.frame <= record.boot_frame && touch.priority === URGENT_PRIORITY ? boot : follow;
+    add(into, part);
+    for (const base of eager.get(touch.path) ?? []) add(into, base);
+  }
+  return { boot, follow };
+}
+function bootPlan(records, pkg) {
+  const usable = RECORD_ORDER.flatMap((tier) => records.filter((record) => record.tier === tier && record.boot_frame !== null));
+  if (usable.length === 0) return null;
+  const boot = [];
+  const follow = [];
+  const seen = /* @__PURE__ */ new Set();
+  const add = (into, part) => {
+    if (seen.has(part.digest)) return;
+    seen.add(part.digest);
+    into.push(part);
+  };
+  for (const record of usable) for (const part of bootSet(record, pkg).boot) add(boot, part);
+  for (const record of usable) for (const part of record.code.filter(isSource)) add(boot, part);
+  for (const group of pkg.groups) {
+    if (!group.name.startsWith(BYTECODE_GROUP_PREFIX)) continue;
+    for (const file of group.files) add(boot, { path: file.path, digest: file.chunk, group: group.name, bytes: file.bytes });
+  }
+  for (const group of pkg.groups) {
+    if (group.name !== LUAU_SCRIPTS_GROUP) continue;
+    for (const file of group.files) add(follow, { path: file.path, digest: file.chunk, group: group.name, bytes: file.bytes });
+  }
+  for (const record of usable) for (const part of bootSet(record, pkg).follow) add(follow, part);
+  const pipelines = [...new Set(usable.flatMap((record) => record.pipelines.filter((p) => p.frame <= (record.boot_frame ?? 0) + LOOKAHEAD_FRAMES).map((p) => p.key)))].sort();
+  return { boot, follow, pipelines };
+}
+function urgent(mark) {
+  return mark.touches.some((touch) => touch.kind !== PREFETCH_KIND && touch.kind !== PIPELINE_KIND && touch.priority === URGENT_PRIORITY);
+}
+async function recordBoot(result4, tier = "mid", guest = import.meta.resolve(RECORD_GUEST)) {
+  const pkg = result4.package;
+  const manifest = result4.manifest;
+  if (pkg === null || manifest === null) throw new Error("the build produced no package to record");
+  if (!("Worker" in globalThis)) throw new Error("recording a boot needs a runtime with Web Workers");
+  const bodies = buildBodies(result4);
+  const paths = filesByPath(pkg);
+  const digests = new Map([...paths.values()].map((part) => [part.digest, part]));
+  const touches = [];
+  const pipelines = [];
+  const seen = /* @__PURE__ */ new Set();
+  let frames = 0;
+  let heapPeak = 0;
+  const deferredHits = [];
+  let started = false;
+  let drawn = false;
+  let readyFrame = null;
+  let bootFrame = null;
+  let busyFrame = 0;
+  let end = null;
+  let fault = null;
+  let finish = () => {
+  };
+  const finished = new Promise((resolve) => {
+    finish = resolve;
+  });
+  const stop = (why) => {
+    if (end !== null) return;
+    end = why;
+    finish();
+  };
+  const body = (digest) => {
+    const found = bodies.get(digest);
+    if (found === void 0) throw new Error(`chunk ${digest} is not in the build`);
+    return found;
+  };
+  const chunks = {
+    fetch: async (digest) => body(digest),
+    fetchRun: async (digests2) => digests2.map(body)
+  };
+  const session = localSession({ interactive_id: manifest.identity.id ?? "itv_recorder", profile: "native", persona: RECORD_PERSONA });
+  const host = new WebHost({
+    engines: workerEngines(guest),
+    transport: session.transport,
+    hello: session.hello,
+    package: { chunks: packageRefs(pkg) },
+    chunks,
+    locale: RECORD_LOCALE,
+    device_tier: tier,
+    limits: { boot_ms: RECORD_WALL_BUDGET_MS },
+    on_fault: (raised) => {
+      fault ??= describe2(raised);
+      stop("fault");
+    },
+    on_milestone: (name) => {
+      if (name === READY_MILESTONE && readyFrame === null) readyFrame = frames;
+      if (name === FIRST_FRAME_MILESTONE) drawn = true;
+    },
+    on_frame_mark: (mark) => {
+      for (const touch of mark.touches) {
+        if (touch.kind === PIPELINE_KIND) {
+          pipelines.push({ key: touch.path.slice(PIPELINE_PREFIX.length), frame: mark.frame });
+          continue;
+        }
+        if (touch.kind === DEFERRED_KIND) {
+          deferredHits.push({ frame: mark.frame, total: Number(touch.path.slice(DEFERRED_PREFIX.length)) });
+          continue;
+        }
+        const part = touch.kind === CHUNK_KIND ? digests.get(touch.path.slice(CHUNK_PREFIX.length)) : paths.get(touch.path);
+        const key = part?.digest ?? touch.path;
+        if (seen.has(key)) continue;
+        seen.add(key);
+        touches.push({ path: part?.path ?? touch.path, frame: mark.frame, kind: touch.kind, priority: touch.priority, digest: part?.digest ?? null, group: part?.group ?? null, bytes: part?.bytes ?? 0 });
+      }
+      frames = mark.frame + 1;
+      heapPeak = Math.max(heapPeak, mark.heap ?? 0);
+      if (bootFrame === null && readyFrame !== null) bootFrame = readyFrame;
+      if (mark.outstanding > 0 || urgent(mark)) busyFrame = mark.frame;
+      if (bootFrame === null && started && drawn && mark.frame - busyFrame >= SETTLE_FRAMES) bootFrame = mark.frame;
+      if (bootFrame !== null && mark.frame >= bootFrame + LOOKAHEAD_FRAMES) stop(readyFrame !== null ? "ready" : "quiet");
+      else if (mark.frame >= MAX_RECORD_FRAMES) stop("limit");
+    }
+  });
+  const wall = setTimeout(() => stop("limit"), RECORD_WALL_BUDGET_MS);
+  try {
+    await Promise.race([
+      host.start().then(() => {
+        started = true;
+      }),
+      finished
+    ]);
+    await finished;
+  } catch (error) {
+    fault ??= error instanceof Error ? error.message : String(error);
+    stop("fault");
+  } finally {
+    clearTimeout(wall);
+    host.dispose();
+  }
+  const ended = end ?? "fault";
+  const boot_frame = ended === "fault" || ended === "limit" ? null : bootFrame;
+  const reached = (until) => deferredHits.filter((h) => h.frame <= until).reduce((most, h) => Math.max(most, h.total), 0);
+  const deferred = { before_input: reached(boot_frame ?? Number.MAX_SAFE_INTEGER), total: reached(Number.MAX_SAFE_INTEGER) };
+  return { tier, end: ended, boot_frame, frames, code: codeParts(pkg), touches, pipelines, fault, heap_peak: heapPeak, deferred };
+}
+var GATE = "canvas";
+var LOCAL_HOST = "127.0.0.1";
+var ANY_PORT = 0;
+var MISS_SEPARATOR = "; ";
+var THREADED = "isolated";
+var CODE_LOG_PREFIX = "cimplify-code-log-";
+var HARDWARE_LABEL = "hardware GPU";
+var SOFTWARE_LABEL = "SwiftShader";
+async function launchesIn(chromium, url, args, hardware) {
+  const browser = await chromium.launch({ headless: true, args });
+  try {
+    await warmBrowser(browser);
+    const page = await browser.newPage();
+    if (hardware && await softwareRenderer(page)) return null;
+    const launches = await measureLaunches(page, url);
+    await page.close();
+    return launches;
+  } finally {
+    await browser.close();
+  }
+}
+function launchSummary(label, launches) {
+  return `${label}: cold first frame ${launches.first_frame_ms} ms, warm first frame ${launches.warm.first_frame_ms} ms`;
+}
+function result2(status, detail) {
+  return { name: GATE, status, detail };
+}
+async function canvasGates(sourceDir, set, built, toolchain) {
+  if (toolchain === null) return { gates: [result2("failed", "the pinned SDK is not installed where the canvas harness can serve it")], measurements: null };
+  const chromium = locateChromium([toolchain.base, toolchain.sdkDir]);
+  if (typeof chromium === "string") return { gates: [result2("failed", chromium)], measurements: null };
+  const server = await startDevServer({
+    root: sourceDir,
+    host: LOCAL_HOST,
+    port: ANY_PORT,
+    watch: false,
+    build: { set, result: built, lockUpdated: false },
+    packagesRoot: toolchain.base
+  });
+  const threaded = built.package?.engine?.threads === THREADED;
+  const codeLogs = threaded ? mkdtempSync(path2.join(tmpdir(), CODE_LOG_PREFIX)) : null;
+  let browser = null;
+  try {
+    const hardware = await launchesIn(chromium, server.url, HARDWARE_GPU_ARGS, true);
+    const software = codeLogs === null ? null : await launchesIn(chromium, server.url, BROWSER_ARGS, false);
+    browser = await chromium.launch({ headless: true, args: [...BROWSER_ARGS, ...codeLogs === null ? [] : codeLogArgs(codeLogs)] });
+    await warmBrowser(browser);
+    const page = await browser.newPage();
+    const report = await measureCanvas(page, server.url, built.manifest?.identity.name ?? GATE, codeLogs, hardware ?? software);
+    await page.close();
+    const misses = gateMisses(report);
+    const notices = gateNotices(report);
+    const measured = canvasMeasurements(report);
+    const softwareLaunches = software ?? report.software_launches;
+    const launches = hardware === null ? [] : [launchSummary(HARDWARE_LABEL, hardware)];
+    if (softwareLaunches !== null) launches.push(launchSummary(SOFTWARE_LABEL, softwareLaunches));
+    const summary = [
+      `cold first frame ${report.first_frame_ms} ms, warm first frame ${report.warm.first_frame_ms} ms (${hardware === null ? SOFTWARE_LABEL : HARDWARE_LABEL}), frame work p99 ${measured.frame_micros_p99} \xB5s, longest collection ${measured.gc_pause_micros_p99} \xB5s`,
+      ...launches
+    ].join(MISS_SEPARATOR);
+    if (misses.length > 0) return { gates: [result2("failed", [summary, ...misses].join(MISS_SEPARATOR))], measurements: null };
+    return { gates: [result2("passed", [summary, ...notices].join(MISS_SEPARATOR))], measurements: measured };
+  } catch (error) {
+    return { gates: [result2("failed", `the canvas harness could not run the game: ${error instanceof Error ? error.message : String(error)}`)], measurements: null };
+  } finally {
+    await browser?.close();
+    await server.close();
+    if (codeLogs !== null) rmSync(codeLogs, { recursive: true, force: true });
+  }
+}
+
+// src/interactives/harness/offline.ts
+var OFFLINE_GATE = "offline launch";
+var OFFLINE_FIRST_FRAME_MS = 4e3;
+var LOCAL_HOST2 = "127.0.0.1";
+var ANY_PORT2 = 0;
+var LAUNCH_HOOK = "cimplifyLaunch";
+var HOST_START_MARK = "cimplify:host-start";
+var FIRST_FRAME_MARK = "cimplify:first_frame_scheduled";
+var POLL_MS = 20;
+var STEP_TIMEOUT_MS = 3e4;
+var ERRORS = "#errors";
+var NATIVE_ENGINE_FAULT = "needs WebAssembly, which this host does not provide";
+function result3(status, detail) {
+  return { name: OFFLINE_GATE, status, detail };
+}
+async function offlineFirstFrame(page, url, budgetMs) {
+  await page.goto(`${url}?${HOLD_PARAM}&${SILENT_PARAM}`);
+  await page.waitForFunction((hook) => typeof globalThis[hook] === "function", LAUNCH_HOOK, { polling: POLL_MS, timeout: STEP_TIMEOUT_MS });
+  await page.evaluate((hook) => {
+    void globalThis[hook]();
+  }, LAUNCH_HOOK);
+  const deadline = Date.now() + budgetMs + STEP_TIMEOUT_MS;
+  for (; ; ) {
+    const elapsed = await page.evaluate(
+      ([start, first]) => {
+        const begun = performance.getEntriesByName(start)[0];
+        const drawn = performance.getEntriesByName(first)[0];
+        return begun === void 0 || drawn === void 0 ? null : drawn.startTime - begun.startTime;
+      },
+      [HOST_START_MARK, FIRST_FRAME_MARK]
+    );
+    if (elapsed !== null) return Math.round(elapsed);
+    const fault = (await page.locator(ERRORS).textContent() ?? "").trim();
+    if (fault.length > 0) return fault;
+    if (Date.now() > deadline) return null;
+    await page.waitForTimeout(POLL_MS);
+  }
+}
+async function offlineLaunchGate(sourceDir, set, built, toolchain) {
+  if (built.manifest?.profile.game === null || built.manifest?.profile.game === void 0) return result3("skipped", "only games are launched offline");
+  if (toolchain === null) return result3("failed", "the pinned SDK is not installed where the offline launch can serve it");
+  const chromium = locateChromium([toolchain.base, toolchain.sdkDir]);
+  if (typeof chromium === "string") return result3("skipped", chromium);
+  const server = await startDevServer({ root: sourceDir, host: LOCAL_HOST2, port: ANY_PORT2, watch: false, build: { set, result: built, lockUpdated: false }, packagesRoot: toolchain.base });
+  const browser = await chromium.launch({ headless: true, args: [...BROWSER_ARGS] });
+  try {
+    await warmBrowser(browser);
+    const page = await browser.newPage();
+    const ms = await offlineFirstFrame(page, server.url, OFFLINE_FIRST_FRAME_MS);
+    await page.close();
+    const rule = `with a ctx host that never answers, the first frame is scheduled within ${OFFLINE_FIRST_FRAME_MS} ms of launch, so no service call stands between a player and play`;
+    if (typeof ms === "string" && ms.includes(NATIVE_ENGINE_FAULT)) return result3("skipped", "native engine games launch only in the device hosts, which answer every ctx request with unavailable within its deadline");
+    if (typeof ms === "string") return result3("failed", `the game faulted with no ctx answers: ${ms}`);
+    if (ms === null) return result3("failed", `no frame was ever scheduled; ${rule}: start the scene first and let services attach when they settle`);
+    if (ms > OFFLINE_FIRST_FRAME_MS) return result3("failed", `first frame after ${ms} ms; ${rule}: start the scene first and let services attach when they settle`);
+    return result3("passed", `first frame after ${ms} ms with no ctx answers (budget ${OFFLINE_FIRST_FRAME_MS} ms)`);
+  } catch (error) {
+    return result3("failed", `the offline launch could not run the game: ${error instanceof Error ? error.message : String(error)}`);
+  } finally {
+    await browser.close();
+    await server.close();
+  }
+}
+
+// src/interactives/commands/build.ts
+var BUILD_OUT_DIR = "build";
+var GATES_DIR = "gates";
+var BOOT_FILE = "boot.json";
+async function buildSourceDirectory(options) {
+  const set = await readSourceSet(options.sourceDir);
+  const wasm = options.approvedWasm.length > 0 ? approvedWasm(options.approvedWasm) : EMPTY_WASM_REGISTRY;
+  const toolchain = locateToolchain(null);
+  const bakeMode = options.publish ? "required" : "auto";
+  const { baker } = bakerFor(bakeMode);
+  const { previewer } = locateAudioPreviewer();
+  const built = buildInteractive(set, {
+    baker,
+    bakeMode,
+    audioPreviewer: previewer,
+    wasm,
+    toolchain,
+    bytecode: pinnedHermes(toolchain?.base ?? null),
+    content: directoryContent(options.sourceDir),
+    scenes: await sceneCompilerFromFlag(),
+    parts: partsFromEnv() ?? (options.publish === true || options.boot === true ? true : void 0),
+    progressive: progressiveFromEnv() ?? (options.publish === true || options.boot === true ? true : void 0)
+  });
+  let frames = null;
+  if (options.gates && built.ok) {
+    const first = await firstRunGate(built);
+    const runs = isEngineGame(built.manifest?.profile.game ?? null) ? await canvasGates(options.sourceDir, set, built, toolchain) : await frameGates(path2.join(options.outDir, GATES_DIR), built, toolchain, options.publish === true || browserRequired());
+    const offline = options.publish ? [await offlineLaunchGate(options.sourceDir, set, built, toolchain)] : [];
+    frames = { gates: [...economyGates(built.manifest), ...first.gates, ...runs.gates, ...offline], measurements: runs.measurements };
+  }
+  const final = options.boot === true && built.ok ? await recordAndPackBoot(options.outDir, built) : built;
+  await writeBuildOutput(options.outDir, final, frames);
+  return buildReport(final, frames);
+}
+var sum = (parts) => parts.reduce((total, part) => total + part.bytes, 0);
+async function recordAndPackBoot(outDir, built) {
+  const records = [];
+  for (const tier of RECORD_TIERS) {
+    const record = await recordBoot(built, tier);
+    const ranges = built.package === null ? { boot: [], follow: [] } : bootSet(record, built.package);
+    info(
+      dim(
+        `  boot ${tier.padEnd(4)} ${record.end.padEnd(5)} frame ${record.boot_frame ?? "none"}, ${ranges.boot.length} parts ${formatBytes(sum(ranges.boot))} then ${ranges.follow.length} parts ${formatBytes(sum(ranges.follow))}, ${record.pipelines.length} pipelines, engine heap ${formatBytes(record.heap_peak)}${record.deferred.total > 0 ? `, deferred engine code ran ${record.deferred.before_input} times before input and ${record.deferred.total} in all` : ""}${record.fault ? `, ${record.fault}` : ""}`
+      )
+    );
+    records.push(record);
+  }
+  await fs.mkdir(outDir, { recursive: true });
+  await fs.writeFile(path2.join(outDir, BOOT_FILE), `${JSON.stringify({ records }, null, 2)}
+`);
+  const recorded = built.package === null ? null : bootPlan(records, built.package);
+  const split = recorded === null ? null : withBootIndex(built, recorded);
+  const pkg = split?.pkg ?? built.package;
+  const plan = split?.plan ?? recorded;
+  const chunks = split?.chunks ?? built.chunks;
+  if (pkg === null || plan === null) return built;
+  const boot = { version: BOOT_FORMAT_VERSION, parts: [...plan.boot, ...plan.follow].map((part) => part.digest), follow: plan.boot.length, pipelines: plan.pipelines };
+  const peaks = Object.fromEntries(records.filter((record) => record.end !== "fault" && record.heap_peak > 0).map((record) => [record.tier, record.heap_peak]));
+  const packed = withBoot(pkg, boot, declareEngineHeap(peaks));
+  return { ...built, chunks, package: packed.manifest, packageBytes: packed.bytes, packageDigest: packed.digest };
+}
+function assetOf(part) {
+  const at = part.path.indexOf(PART_PATH_SEPARATOR);
+  return at < 0 ? part.path : part.path.slice(0, at);
+}
+function withBootIndex(built, plan) {
+  const pkg = built.package;
+  const file = pkg?.groups.flatMap((g) => g.files).find((f) => f.path === MODULE_INDEX_PATH);
+  const index = file === void 0 ? void 0 : built.chunks.find((c) => c.digest === file.chunk);
+  if (pkg === null || file === void 0 || index === void 0) return null;
+  const split = splitModuleIndex(index, new Set(plan.boot.map(assetOf)));
+  if (split === null) return null;
+  const [boot, more] = [split.boot, split.more];
+  const grown = boot.payloadBytes + more.payloadBytes - index.payloadBytes;
+  const groups = pkg.groups.map(
+    (g) => g.files.some((f) => f === file) ? { ...g, files: g.files.flatMap((f) => f === file ? [{ ...f, chunk: boot.digest, bytes: boot.payloadBytes }, { ...f, path: MODULE_MORE_PATH, chunk: more.digest, bytes: more.payloadBytes }] : [f]) } : g
+  );
+  const delivery = { ...pkg.delivery, total_bytes: pkg.delivery.total_bytes + grown, before_play_bytes: pkg.delivery.before_play_bytes + grown };
+  const swapped = (p) => p.digest === index.digest ? { ...p, digest: boot.digest, bytes: boot.payloadBytes } : p;
+  const follow = { path: MODULE_MORE_PATH, digest: more.digest, group: plan.boot.find((p) => p.digest === index.digest)?.group ?? "code", bytes: more.payloadBytes };
+  return {
+    pkg: { ...pkg, groups, delivery },
+    plan: { ...plan, boot: plan.boot.map(swapped), follow: [follow, ...plan.follow.map(swapped)] },
+    chunks: [...built.chunks.filter((c) => c !== index), boot, more]
+  };
+}
+async function run(argv) {
+  const args = parseArgs(argv);
+  const sourceDir = path2.resolve(args.positional[0] ?? process.cwd());
+  requireInteractiveProject(sourceDir, "build");
+  const outDir = path2.resolve(flagString(args, "out") ?? workPath(sourceDir, BUILD_OUT_DIR));
+  const wasmFlag = flagString(args, "approved-wasm");
+  await refreshEngineRuntime(sourceDir);
+  const report = await buildSourceDirectory({
+    sourceDir,
+    outDir,
+    approvedWasm: wasmFlag ? wasmFlag.split(",").filter((d) => d.length > 0) : [],
+    gates: flagBool(args, "gates"),
+    publish: flagBool(args, "publish"),
+    boot: flagBool(args, "boot")
+  });
+  for (const d of report.diagnostics) (d.severity === "error" ? failure : info)(formatDiagnostic(d));
+  for (const g of report.gates ?? []) (g.status === "failed" ? failure : info)(`${g.name}: ${g.detail}`);
+  if (!report.ok) {
+    throw new CliError(CLI_ERROR_CODE.BUILD_FAILED, `admission refused the source set; details in ${path2.join(outDir, "result.json")}`, { details: report });
+  }
+  success(`Built ${bold(report.package_digest ?? "")}`);
+  info(dim(`  ${report.stats.modules} modules, ${report.stats.assets} assets, ${report.stats.chunks} chunks, ${report.stats.total_bytes} bytes -> ${outDir}`));
+  for (const line of tierLines(report)) info(line);
+  result(report);
+}
+function tierLines(report) {
+  if (report.stats.tiers.length === 0) return [];
+  const lines = [dim("  tier   download              first play           on request   unique")];
+  for (const t of report.stats.tiers) {
+    const download = `${formatBytes(t.download_bytes)} / ${formatBytes(t.download_budget)}`;
+    const first = `${formatBytes(t.first_play_bytes)} / ${formatBytes(t.first_play_budget)}`;
+    const mark = t.fits ? "" : "  over budget";
+    lines.push(`  ${t.tier.padEnd(6)} ${download.padEnd(21)} ${first.padEnd(20)} ${formatBytes(t.lazy_bytes).padEnd(12)} ${formatBytes(t.unique_bytes)}${mark}`);
+  }
+  return lines;
+}
+
+export { BOOT_FILE, BUILD_OUT_DIR, GATES_DIR, buildSourceDirectory, run as default, tierLines };

package/dist/{cancel-ZHVVILOU.mjs → cancel-VGJHZJ4J.mjs}

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
-import { parseArgs } from './chunk-5KYR6WJB.mjs';
-import { ApiClient } from './chunk-NYXA6X56.mjs';
-import { readAuth, readProjectLink } from './chunk-MLE4MVYC.mjs';
-import { CliError, CLI_ERROR_CODE, success, result } from './chunk-3QUK5BPY.mjs';
+import { parseArgs } from './chunk-XQAHREKO.mjs';
+import { ApiClient } from './chunk-CLQYPTJ2.mjs';
+import { readAuth, readProjectLink } from './chunk-TT4YI33G.mjs';
+import { CliError, CLI_ERROR_CODE, success, result } from './chunk-KOD4GBQ5.mjs';
 
 // src/commands/cancel.ts
 function cancelEndpoint(businessId, projectId, deploymentId) {