@cimplify/cli 0.15.3 → 0.17.0

package/dist/chunk-XF3MGADK.mjs

@@ -0,0 +1,2946 @@
+#!/usr/bin/env node
+import { modelFromEnv, askAuthoring, buildCheck, trimHistory } from './chunk-74QZQSCL.mjs';
+import { LocalData, DEV_DATA_ROUTE, DATA_FAMILIES } from './chunk-NEB372WD.mjs';
+import { parseChannel, publishProject } from './chunk-TYR4Q37L.mjs';
+import { remoteFromEnv, signingKeyDir } from './chunk-XZG3DTXV.mjs';
+import { brotliTwinBytes, TICK_GUEST_PATH, TICK_GUEST_MAP_PATH, buildLocal, EXCLUDED_DIRECTORIES, outputPathOf, LAZY_GROUP_PREFIX, CODE_GROUP, TICK_GUEST_ORIGIN } from './chunk-BTNVYAC4.mjs';
+import { findPackageDir, readPackageJson, exportsMap, pickTarget, BROWSER_CONDITIONS, stripDotSlash, exportTarget } from './chunk-N2WZJX5P.mjs';
+import { LIBRARY_ALLOWLIST, SDK_PACKAGE } from './chunk-BGM7CH5G.mjs';
+import { digestHex } from './chunk-25ZPFHLF.mjs';
+import { formatDiagnostic } from './chunk-SGT5IJVW.mjs';
+import { CliError, CLI_ERROR_CODE } from './chunk-I7GEHLDD.mjs';
+import { promises, watch, existsSync, readdirSync, statSync, readFileSync } from 'fs';
+import path from 'path';
+import { HOST_PAGE_ISOLATION_HEADERS, FACE_LANDMARKER, parseContentOrigin, servesContent, serveContent, sha256Hex } from '@cimplify/sdk/interactives/web';
+import { createServer } from 'http';
+import { createHash } from 'crypto';
+import { SharedPartStore } from '@cimplify/sdk/interactives';
+import { spawn } from 'child_process';
+import { createInterface } from 'readline';
+import { fileURLToPath } from 'url';
+import { createRequire } from 'module';
+
+var RESULT_FILE = "result.json";
+var PACKAGE_FILE = "package.json";
+var CHUNK_DIR = "chunks";
+var FINDING_KINDS = {
+  "analysis.dynamic_code": "dynamic_code",
+  "analysis.dynamic_import": "dynamic_code",
+  "analysis.dynamic_global": "dynamic_code",
+  "analysis.require": "dynamic_code",
+  "analysis.wasm_runtime": "dynamic_code",
+  "analysis.game_dynamic_import": "dynamic_code",
+  "analysis.network": "forbidden_api",
+  "analysis.forbidden_api": "forbidden_api",
+  "analysis.native_dom": "forbidden_api",
+  "refusal.minified": "obfuscated",
+  "refusal.obfuscated": "obfuscated",
+  "refusal.binary": "prebuilt_binary",
+  "refusal.wasm": "prebuilt_binary",
+  "resolve.not_allowlisted": "dependency_not_allowed",
+  "resolve.not_locked": "dependency_not_allowed",
+  "resolve.profile": "dependency_not_allowed",
+  "resolve.builtin": "dependency_not_allowed",
+  "resolve.url": "dependency_not_allowed",
+  "analysis.game_engine_import": "dependency_not_allowed",
+  "analysis.game_foreign_engine_import": "dependency_not_allowed",
+  "analysis.game_backend_import": "dependency_not_allowed",
+  "analysis.credential_text": "credential_collection",
+  "analysis.payment_text": "payment_text",
+  "analysis.secure_entry": "secure_entry_field",
+  "analysis.url": "undeclared_provider"
+};
+var MANIFEST_PATH = "interactive.toml";
+function findingsOf(diagnostics) {
+  const out = [];
+  for (const d of diagnostics) {
+    if (d.severity !== "error") continue;
+    const kind = FINDING_KINDS[d.code];
+    if (kind !== void 0) out.push({ kind, path: d.file ?? MANIFEST_PATH, line: d.line ?? 0 });
+  }
+  return out;
+}
+function buildReport(result, frames = null) {
+  const gatesFailed = frames !== null && frames.gates.some((g) => g.status === "failed");
+  return {
+    ok: result.ok && !gatesFailed,
+    ...result.audioPreviews ? { audio_previews: { encoder: result.audioPreviews.encoder, sounds: result.audioPreviews.sounds } } : {},
+    gates: frames === null ? null : frames.gates,
+    measurements: frames === null ? null : frames.measurements,
+    source_digest: result.sourceDigest,
+    package_digest: result.packageDigest,
+    findings: findingsOf(result.diagnostics),
+    diagnostics: result.diagnostics,
+    stats: {
+      files: result.stats.files,
+      modules: result.stats.modules,
+      assets: result.stats.assets,
+      chunks: result.stats.chunks,
+      total_bytes: result.stats.totalBytes,
+      before_play_bytes: result.stats.beforePlayBytes,
+      lazy_bytes: result.stats.lazyBytes,
+      tiers: result.stats.tiers.map((t) => ({
+        tier: t.tier,
+        download_bytes: t.downloadBytes,
+        first_play_bytes: t.firstPlayBytes,
+        lazy_bytes: t.lazyBytes,
+        unique_bytes: t.uniqueBytes,
+        download_budget: t.downloadBudget,
+        first_play_budget: t.firstPlayBudget,
+        fits: t.fits
+      }))
+    },
+    chunks: result.chunks.map((c) => {
+      const twin = brotliTwinBytes(c);
+      return { digest: c.digest, kind: c.kind, bytes: c.totalBytes, ...c.payloadDigest === null ? {} : { payload_digest: c.payloadDigest }, ...twin === null ? {} : { brotli_bytes: twin } };
+    })
+  };
+}
+async function writeChunk(dir, chunk) {
+  const target = path.join(dir, digestHex(chunk.digest));
+  const handle = await promises.open(target, "w");
+  try {
+    await handle.writev(chunk.parts);
+  } finally {
+    await handle.close();
+  }
+}
+async function writeBuildOutput(outDir, result, frames = null) {
+  await promises.mkdir(outDir, { recursive: true });
+  if (result.ok && result.packageBytes !== null) {
+    const chunkDir = path.join(outDir, CHUNK_DIR);
+    await promises.mkdir(chunkDir, { recursive: true });
+    for (const chunk of result.chunks) await writeChunk(chunkDir, chunk);
+    await promises.writeFile(path.join(outDir, PACKAGE_FILE), result.packageBytes);
+    if (result.tickGuest) await writeTickGuest(outDir, result.tickGuest);
+  }
+  await promises.writeFile(path.join(outDir, RESULT_FILE), `${JSON.stringify(buildReport(result, frames), null, 2)}
+`);
+}
+async function writeTickGuest(outDir, bundle) {
+  const bundlePath = path.join(outDir, ...TICK_GUEST_PATH.split("/"));
+  const mapPath = path.join(outDir, ...TICK_GUEST_MAP_PATH.split("/"));
+  await promises.mkdir(path.dirname(bundlePath), { recursive: true });
+  await promises.writeFile(bundlePath, bundle.code);
+  await promises.writeFile(mapPath, bundle.map);
+  return { bundle: bundlePath, map: mapPath };
+}
+async function writeModuleTree(dir, modules) {
+  await promises.rm(dir, { recursive: true, force: true });
+  for (const m of modules) {
+    const target = path.join(dir, ...m.output.split("/"));
+    await promises.mkdir(path.dirname(target), { recursive: true });
+    await promises.writeFile(target, m.code);
+  }
+}
+
+// src/interactives/inspect/probe.ts
+var RECORD_MESSAGE = "__cimplify_record";
+var EMPTY_READINESS = { first_frame: -1, first_frame_ms: -1, bytes_before_first_play: 0, bytes_total: 0, frames: 0, stall_frames: 0, stalls: [] };
+function installProbe(config, scope) {
+  const GLOBAL = "__cimplify_probe";
+  const HOOK = "__cimplify_inspect";
+  const RECORD_KEY = "__cimplify_record";
+  const LANES = 1;
+  const WORKER_REFUSAL_TEXT = "capture and input recording refuse new Worker(...) and new SharedWorker(...): a worker's messages land on frames that depend on thread timing, so captures and replays would differ from run to run. The engine's own job threads are off in capture (navigator.hardwareConcurrency is 1); do this work on the game thread";
+  const BARE_STYLE = "body{display:block!important}#stage{display:block!important;padding:0!important}#phone{width:100vw!important;height:100vh!important;border:0!important;border-radius:0!important}#studio{display:none!important}#errors{opacity:0!important}";
+  const VIEW_WORDS = 7;
+  const RECORD_BYTES = 52;
+  const SETTLE_TURNS = 400;
+  const SETTLE_SLEEP_MS = 5;
+  const CHUNK = 32768;
+  const encode = (bytes) => {
+    let text = "";
+    for (let i = 0; i < bytes.length; i += CHUNK) text += String.fromCharCode.apply(null, Array.from(bytes.subarray(i, i + CHUNK)));
+    return scope.btoa(text);
+  };
+  const decode = (text) => {
+    const raw2 = scope.atob(text);
+    const out = new Uint8Array(raw2.length);
+    for (let i = 0; i < raw2.length; i++) out[i] = raw2.charCodeAt(i);
+    return out;
+  };
+  if (scope.top === void 0 || scope.top === scope) {
+    const document2 = scope.document;
+    if (config.bare && document2 !== void 0) {
+      const add = () => {
+        const style = document2.createElement("style");
+        style.textContent = BARE_STYLE;
+        (document2.head ?? document2.documentElement).appendChild(style);
+      };
+      if (document2.readyState === "loading") document2.addEventListener("DOMContentLoaded", add);
+      else add();
+    }
+    const host = {
+      guest: false,
+      ready: () => false,
+      step: async () => 0,
+      snapshot: () => ({ ready: false, frame: 0, clock_ms: 0, ui: false, viewport: null, patches: [], sites: [], exempt: [], scene: { requested: null, applied: null, current: null }, errors: [] }),
+      shadowOpen: () => false,
+      shadowApply: () => -1,
+      shadowFrame: () => null,
+      shadowClose: () => {
+      },
+      refused: () => null
+    };
+    scope[GLOBAL] = host;
+    return host;
+  }
+  let seed = config.seed >>> 0 || 1;
+  const random = () => {
+    seed = seed + 1831565813 >>> 0;
+    let t = seed;
+    t = Math.imul(t ^ t >>> 15, t | 1);
+    t ^= t + Math.imul(t ^ t >>> 7, t | 61);
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+  };
+  let clock = 0;
+  let frame = 0;
+  let manual = false;
+  let nextId = 1;
+  let inflight = 0;
+  const errors = [];
+  const queue = /* @__PURE__ */ new Map();
+  const realTimeout = scope.setTimeout.bind(scope);
+  const realRaf = typeof scope.requestAnimationFrame === "function" ? scope.requestAnimationFrame.bind(scope) : null;
+  scope.Math.random = random;
+  const crypto = scope.crypto;
+  if (crypto !== void 0) {
+    crypto.getRandomValues = (array) => {
+      const bytes = new Uint8Array(array.buffer, array.byteOffset, array.byteLength);
+      for (let i = 0; i < bytes.length; i++) bytes[i] = random() * 256 | 0;
+      return array;
+    };
+    crypto.randomUUID = () => {
+      const hex = (n) => Array.from({ length: n }, () => (random() * 16 | 0).toString(16)).join("");
+      return `${hex(8)}-${hex(4)}-4${hex(3)}-${(8 + random() * 4 | 0).toString(16)}${hex(3)}-${hex(12)}`;
+    };
+  }
+  const performance2 = scope.performance;
+  const realNow = performance2 === void 0 ? () => 0 : performance2.now.bind(performance2);
+  const loopSamples = {};
+  scope.__cimplify_loop_probe = {
+    enter: () => realNow(),
+    exit: (loop, at, rows) => {
+      let sample = loopSamples[loop];
+      if (sample === void 0) {
+        sample = [0, 0, 0];
+        loopSamples[loop] = sample;
+      }
+      sample[0] += realNow() - at;
+      sample[1] += 1;
+      sample[2] = rows < 0 || sample[2] < 0 ? -1 : sample[2] + rows;
+    },
+    samples: () => loopSamples
+  };
+  const READINESS_STALL_LIST = 64;
+  const installedAt = realNow();
+  const readiness = { first_frame: -1, first_frame_ms: -1, bytes_before_first_play: 0, bytes_total: 0, frames: 0, stall_frames: 0, stalls: [] };
+  scope.__cimplify_readiness_probe = {
+    chunk: (bytes) => {
+      readiness.bytes_total += bytes;
+      if (readiness.first_frame < 0) readiness.bytes_before_first_play += bytes;
+    },
+    frame: (stalled) => {
+      if (readiness.first_frame < 0) {
+        readiness.first_frame = frame;
+        readiness.first_frame_ms = Math.round((realNow() - installedAt) * 1e3) / 1e3;
+      } else if (stalled) {
+        readiness.stall_frames++;
+        if (readiness.stalls.length < READINESS_STALL_LIST) readiness.stalls.push(frame);
+      }
+      readiness.frames++;
+    },
+    report: () => ({ ...readiness, stalls: readiness.stalls.slice() })
+  };
+  if (performance2 !== void 0) performance2.now = () => clock;
+  scope.Date.now = () => config.epoch + clock;
+  const RealDate = scope.Date;
+  if (typeof RealDate === "function") {
+    scope.Date = new Proxy(RealDate, {
+      construct: (target, args, newTarget) => Reflect.construct(target, args.length === 0 ? [config.epoch + clock] : args, newTarget),
+      apply: (target) => String(Reflect.construct(target, [config.epoch + clock]))
+    });
+  }
+  let refusal = null;
+  const refuse = () => {
+    refusal = WORKER_REFUSAL_TEXT;
+    errors.push(WORKER_REFUSAL_TEXT);
+    throw new Error(WORKER_REFUSAL_TEXT);
+  };
+  const refusingWorker = function RefusedWorker() {
+    return refuse();
+  };
+  if (typeof scope.Worker === "function") scope.Worker = refusingWorker;
+  if (typeof scope.SharedWorker === "function") scope.SharedWorker = refusingWorker;
+  if (scope.navigator !== void 0) Object.defineProperty(scope.navigator, "hardwareConcurrency", { configurable: true, get: () => LANES });
+  if (scope.Event !== void 0) Object.defineProperty(scope.Event.prototype, "timeStamp", { configurable: true, get: () => clock });
+  scope.requestAnimationFrame = (callback) => {
+    const id = nextId++;
+    queue.set(id, callback);
+    if (!manual && realRaf !== null) {
+      realRaf(() => {
+        if (manual) return;
+        const due = queue.get(id);
+        if (due === void 0) return;
+        queue.delete(id);
+        due(clock);
+      });
+    }
+    return id;
+  };
+  scope.cancelAnimationFrame = (id) => {
+    queue.delete(id);
+  };
+  const realFetch = scope.fetch;
+  if (typeof realFetch === "function") {
+    const bound = realFetch.bind(scope);
+    scope.fetch = (...args) => {
+      inflight++;
+      return bound(...args).finally(() => {
+        inflight--;
+      });
+    };
+  }
+  let raw = null;
+  let memory = null;
+  let render2 = 0;
+  let maxNodes = config.max_nodes;
+  let active = 0;
+  let viewport = null;
+  const tracked = /* @__PURE__ */ new Map();
+  const sites = /* @__PURE__ */ new Map();
+  const exempt = [];
+  let sceneApplied = null;
+  let sceneCurrent = null;
+  let shadow = 0;
+  const bytesAt2 = (at, length) => new Uint8Array(memory.buffer, at, length).slice();
+  const wrapExports = (exports) => {
+    const out = {};
+    for (const name of Object.keys(exports)) out[name] = exports[name];
+    const wrap = (name, make) => {
+      const original = exports[name];
+      if (typeof original !== "function") return;
+      const replaced = make(original);
+      Object.defineProperty(replaced, "length", { value: original.length });
+      out[name] = replaced;
+    };
+    wrap("engine_ui_create", (original) => (r, max) => {
+      const handle = original(r, max);
+      if (handle !== 0) {
+        render2 = r;
+        if (max > 0) maxNodes = max;
+        active = handle;
+        tracked.set(handle, { patchAt: 0, patches: [] });
+      }
+      return handle;
+    });
+    wrap("engine_ui_destroy", (original) => (ui) => {
+      tracked.delete(ui);
+      if (active === ui) active = 0;
+      return original(ui);
+    });
+    wrap("engine_ui_patch_buffer", (original) => (ui, capacity) => {
+      const at = original(ui, capacity);
+      const entry = tracked.get(ui);
+      if (entry !== void 0) entry.patchAt = at;
+      return at;
+    });
+    wrap("engine_ui_apply", (original) => (ui, length) => {
+      const entry = tracked.get(ui);
+      if (entry !== void 0 && entry.patchAt !== 0 && length > 0) entry.patches.push(bytesAt2(entry.patchAt, length));
+      return original(ui, length);
+    });
+    wrap("engine_ui_apply_bytes", (original) => (ui, data, length) => {
+      const entry = tracked.get(ui);
+      if (entry !== void 0 && length > 0) entry.patches.push(bytesAt2(data, length));
+      return original(ui, data, length);
+    });
+    wrap("engine_ui_viewport", (original) => (ui, width, height, ratio, top, right, bottom, left) => {
+      const insets = config.insets;
+      const args = insets === null ? [width, height, ratio, top, right, bottom, left] : [width, height, ratio, insets.top, insets.right, insets.bottom, insets.left];
+      if (tracked.has(ui)) viewport = args;
+      return original(ui, args[0], args[1], args[2], args[3], args[4], args[5], args[6]);
+    });
+    return out;
+  };
+  const wasm = scope.WebAssembly;
+  if (wasm !== void 0 && typeof wasm.instantiate === "function") {
+    const realInstantiate = wasm.instantiate.bind(wasm);
+    wasm.instantiate = async (source, imports) => {
+      const result = await realInstantiate(source, imports);
+      const direct = result instanceof wasm.Instance;
+      const pair = result;
+      const instance = direct ? result : pair.instance;
+      const exports = instance.exports;
+      const mem = imports?.env?.memory ?? exports.memory;
+      if (raw !== null || typeof exports.engine_ui_create !== "function" || mem === void 0) return result;
+      raw = exports;
+      memory = mem;
+      manual = true;
+      if (config.record === true) {
+        startRecording();
+        return result;
+      }
+      const fake = { exports: Object.freeze(wrapExports(exports)) };
+      return direct ? fake : { module: pair.module, instance: fake };
+    };
+  }
+  scope[HOOK] = {
+    site(node, where, name) {
+      sites.set(node, [where, name]);
+    },
+    exempt(node, check, reason) {
+      exempt.push([node, check, reason]);
+    },
+    scene: () => sceneApplied === null ? config.scene : null,
+    sceneApplied(name) {
+      sceneApplied = name;
+    },
+    sceneEntered(name) {
+      sceneCurrent = name;
+    }
+  };
+  const round = (value) => Math.round((value ?? 0) * 100) / 100;
+  const post = (input) => {
+    try {
+      scope.parent?.postMessage({ [RECORD_KEY]: input }, "*");
+    } catch (error) {
+      errors.push(String(error));
+    }
+  };
+  const editable = (event) => {
+    const target = event.target;
+    if (target === null || target === void 0) return false;
+    return target.isContentEditable === true || target.tagName === "INPUT" || target.tagName === "TEXTAREA";
+  };
+  const startRecording = () => {
+    post({ kind: "start", width: scope.innerWidth ?? 0, height: scope.innerHeight ?? 0, scale: scope.devicePixelRatio ?? 1, seed: config.seed });
+    let pressed = false;
+    const held = /* @__PURE__ */ new Set();
+    const pointer = (kind, event) => post({ kind, frame, x: round(event.clientX), y: round(event.clientY) });
+    const listen = scope.addEventListener;
+    if (typeof listen === "function") {
+      const on = (type, listener) => listen.call(scope, type, listener, true);
+      on("pointerdown", (event) => {
+        if (event.isPrimary === false || (event.button ?? 0) !== 0 || pressed) return;
+        pressed = true;
+        pointer("down", event);
+      });
+      on("pointermove", (event) => {
+        if (pressed && event.isPrimary !== false) pointer("move", event);
+      });
+      const release = (event) => {
+        if (!pressed || event.isPrimary === false) return;
+        pressed = false;
+        pointer("up", event);
+      };
+      on("pointerup", release);
+      on("pointercancel", release);
+      on("keydown", (event) => {
+        const key = event.code || event.key || "";
+        if (event.repeat === true || key.length === 0 || held.has(key)) return;
+        if (editable(event) && (event.key ?? "").length === 1 && event.ctrlKey !== true && event.metaKey !== true && event.altKey !== true) return;
+        held.add(key);
+        post({ kind: "key_down", frame, key });
+      });
+      on("keyup", (event) => {
+        const key = event.code || event.key || "";
+        if (!held.delete(key)) return;
+        post({ kind: "key_up", frame, key });
+      });
+      on("input", (event) => {
+        if (typeof event.data === "string" && event.data.length > 0 && (event.inputType ?? "insertText").startsWith("insert")) post({ kind: "text", frame, text: event.data });
+      });
+    }
+    const next = () => {
+      if (realRaf !== null) realRaf(drive);
+      else realTimeout(drive, config.frame_ms);
+    };
+    const drive = () => {
+      probe.step(1).then(next, (error) => {
+        if (refusal === null) errors.push(String(error));
+      });
+    };
+    next();
+  };
+  const sleep = (ms) => new Promise((resolve) => {
+    realTimeout(resolve, ms);
+  });
+  const settle = async () => {
+    await sleep(0);
+    for (let i = 0; i < SETTLE_TURNS && inflight > 0; i++) await sleep(SETTLE_SLEEP_MS);
+  };
+  const exportView = (engine, handle) => {
+    const at = engine.engine_ui_accessibility_export(handle);
+    if (at === 0 || memory === null) return null;
+    const view = new Uint32Array(memory.buffer, at, VIEW_WORDS);
+    const count = view[2];
+    return { full: view[0] !== 0, count, records: encode(bytesAt2(view[1], count * RECORD_BYTES)), strings: encode(bytesAt2(view[5], view[6])) };
+  };
+  const applyTo = (engine, handle, bytes) => {
+    const at = engine.engine_ui_patch_buffer(handle, bytes.length);
+    if (at === 0 || memory === null) return -1;
+    new Uint8Array(memory.buffer, at, bytes.length).set(bytes);
+    return engine.engine_ui_apply(handle, bytes.length);
+  };
+  const probe = {
+    guest: true,
+    ready: () => raw !== null,
+    async step(frames) {
+      for (let i = 0; i < frames; i++) {
+        await settle();
+        if (refusal !== null) throw new Error(refusal);
+        clock += config.frame_ms;
+        frame++;
+        const due = Array.from(queue.values());
+        queue.clear();
+        for (const callback of due) {
+          try {
+            callback(clock);
+          } catch (error) {
+            errors.push(String(error instanceof Error && error.stack ? error.stack : error));
+          }
+        }
+      }
+      await settle();
+      if (refusal !== null) throw new Error(refusal);
+      return frame;
+    },
+    snapshot() {
+      const entry = tracked.get(active);
+      return {
+        ready: raw !== null,
+        frame,
+        clock_ms: clock,
+        ui: entry !== void 0,
+        viewport,
+        patches: entry === void 0 ? [] : entry.patches.map(encode),
+        sites: Array.from(sites.entries()).map(([node, site]) => [node, site[0], site[1]]),
+        exempt: exempt.slice(),
+        scene: { requested: config.scene, applied: sceneApplied, current: sceneCurrent },
+        errors: errors.slice()
+      };
+    },
+    refused: () => refusal,
+    shadowOpen() {
+      const engine = raw;
+      const entry = tracked.get(active);
+      if (engine === null || entry === void 0 || viewport === null) return false;
+      if (shadow !== 0) engine.engine_ui_destroy(shadow);
+      shadow = engine.engine_ui_create(render2, maxNodes);
+      if (shadow === 0) return false;
+      engine.engine_ui_accessibility(shadow, 1);
+      engine.engine_ui_viewport(shadow, viewport[0], viewport[1], viewport[2], viewport[3], viewport[4], viewport[5], viewport[6]);
+      for (const patch of entry.patches) applyTo(engine, shadow, patch);
+      return true;
+    },
+    shadowApply(patch) {
+      if (raw === null || shadow === 0) return -1;
+      return applyTo(raw, shadow, decode(patch));
+    },
+    shadowFrame(dtMicros, full) {
+      const engine = raw;
+      if (engine === null || shadow === 0) return null;
+      if (full) {
+        engine.engine_ui_accessibility(shadow, 0);
+        engine.engine_ui_accessibility(shadow, 1);
+      }
+      if (typeof engine.engine_ui_view_from_camera === "function") engine.engine_ui_view_from_camera(shadow, render2);
+      if (engine.engine_ui_frame(shadow, dtMicros) < 0) return null;
+      return exportView(engine, shadow);
+    },
+    shadowClose() {
+      if (raw !== null && shadow !== 0) raw.engine_ui_destroy(shadow);
+      shadow = 0;
+    }
+  };
+  scope[GLOBAL] = probe;
+  return probe;
+}
+function probeScript(config) {
+  return `(${installProbe.toString()})(${JSON.stringify(config)}, globalThis);`;
+}
+
+// src/interactives/dev/locale.ts
+var IMPERIAL_REGIONS = /* @__PURE__ */ new Set(["US", "LR", "MM"]);
+var UNITED_KINGDOM = "GB";
+var SUNDAY_REGIONS = /* @__PURE__ */ new Set(["US", "CA", "BR", "JP", "IL", "MX", "PH", "ZA", "KE", "IN", "SA"]);
+var RTL_LANGUAGES = /* @__PURE__ */ new Set(["ar", "he", "fa", "ur", "ps", "dv", "yi"]);
+var NUMBER_SAMPLE = 12345.6;
+var FALLBACK_LANGUAGE = "en-US";
+var FALLBACK_CURRENCY = "USD";
+var FALLBACK_ZONE = "UTC";
+var REGION_CURRENCIES = "AD:EUR AE:AED AF:AFN AG:XCD AI:XCD AL:ALL AM:AMD AO:AOA AR:ARS AS:USD AT:EUR AU:AUD AW:AWG AX:EUR AZ:AZN BA:BAM BB:BBD BD:BDT BE:EUR BF:XOF BG:BGN BH:BHD BI:BIF BJ:XOF BL:EUR BM:BMD BN:BND BO:BOB BQ:USD BR:BRL BS:BSD BT:BTN BW:BWP BY:BYN BZ:BZD CA:CAD CC:AUD CD:CDF CF:XAF CG:XAF CH:CHF CI:XOF CK:NZD CL:CLP CM:XAF CN:CNY CO:COP CR:CRC CU:CUP CV:CVE CW:ANG CX:AUD CY:EUR CZ:CZK DE:EUR DJ:DJF DK:DKK DM:XCD DO:DOP DZ:DZD EC:USD EE:EUR EG:EGP EH:MAD ER:ERN ES:EUR ET:ETB FI:EUR FJ:FJD FK:FKP FM:USD FO:DKK FR:EUR GA:XAF GB:GBP GD:XCD GE:GEL GF:EUR GG:GBP GH:GHS GI:GIP GL:DKK GM:GMD GN:GNF GP:EUR GQ:XAF GR:EUR GT:GTQ GU:USD GW:XOF GY:GYD HK:HKD HN:HNL HR:EUR HT:HTG HU:HUF ID:IDR IE:EUR IL:ILS IM:GBP IN:INR IO:USD IQ:IQD IR:IRR IS:ISK IT:EUR JE:GBP JM:JMD JO:JOD JP:JPY KE:KES KG:KGS KH:KHR KI:AUD KM:KMF KN:XCD KP:KPW KR:KRW KW:KWD KY:KYD KZ:KZT LA:LAK LB:LBP LC:XCD LI:CHF LK:LKR LR:LRD LS:LSL LT:EUR LU:EUR LV:EUR LY:LYD MA:MAD MC:EUR MD:MDL ME:EUR MF:EUR MG:MGA MH:USD MK:MKD ML:XOF MM:MMK MN:MNT MO:MOP MP:USD MQ:EUR MR:MRU MS:XCD MT:EUR MU:MUR MV:MVR MW:MWK MX:MXN MY:MYR MZ:MZN NA:NAD NC:XPF NE:XOF NF:AUD NG:NGN NI:NIO NL:EUR NO:NOK NP:NPR NR:AUD NU:NZD NZ:NZD OM:OMR PA:PAB PE:PEN PF:XPF PG:PGK PH:PHP PK:PKR PL:PLN PM:EUR PN:NZD PR:USD PS:ILS PT:EUR PW:USD PY:PYG QA:QAR RE:EUR RO:RON RS:RSD RU:RUB RW:RWF SA:SAR SB:SBD SC:SCR SD:SDG SE:SEK SG:SGD SH:SHP SI:EUR SK:EUR SL:SLE SM:EUR SN:XOF SO:SOS SR:SRD SS:SSP ST:STN SV:USD SX:ANG SY:SYP SZ:SZL TC:USD TD:XAF TG:XOF TH:THB TJ:TJS TK:NZD TL:USD TM:TMT TN:TND TO:TOP TR:TRY TT:TTD TV:AUD TW:TWD TZ:TZS UA:UAH UG:UGX US:USD UY:UYU UZ:UZS VA:EUR VC:XCD VE:VES VG:USD VI:USD VN:VND VU:VUV WF:XPF WS:WST XK:EUR YE:YER YT:EUR ZA:ZAR ZM:ZMW ZW:ZWG";
+var CURRENCY_OF = new Map(
+  REGION_CURRENCIES.split(" ").map((pair) => pair.split(":"))
+);
+function part(parts, type, fallback) {
+  return parts.find((entry) => entry.type === type)?.value ?? fallback;
+}
+function currencyOfRegion(region) {
+  return (region === null ? void 0 : CURRENCY_OF.get(region)) ?? FALLBACK_CURRENCY;
+}
+function language(value) {
+  try {
+    return new Intl.Locale(value);
+  } catch {
+    throw new CliError(
+      CLI_ERROR_CODE.INVALID_INPUT,
+      `--locale takes a language tag such as en-GB or fr-SN, got '${value}'`
+    );
+  }
+}
+function checkedZone(value) {
+  try {
+    new Intl.DateTimeFormat("en", { timeZone: value });
+    return value;
+  } catch {
+    throw new CliError(
+      CLI_ERROR_CODE.INVALID_INPUT,
+      `--time-zone takes a zone such as Europe/London, got '${value}'`
+    );
+  }
+}
+function checkedCurrency(value) {
+  const code = value.toUpperCase();
+  if (!Intl.supportedValuesOf("currency").includes(code)) {
+    throw new CliError(
+      CLI_ERROR_CODE.INVALID_INPUT,
+      `--currency takes an ISO currency code such as GBP, got '${value}'`
+    );
+  }
+  return code;
+}
+function devLocale(choice = {}) {
+  const system = new Intl.DateTimeFormat().resolvedOptions();
+  const locale = language(choice.language ?? (system.locale || FALLBACK_LANGUAGE));
+  const region = locale.region ?? locale.maximize().region ?? null;
+  const parts = new Intl.NumberFormat(locale.baseName).formatToParts(NUMBER_SAMPLE);
+  const hourCycle = new Intl.DateTimeFormat(locale.baseName, { hour: "numeric" }).resolvedOptions().hourCycle;
+  return {
+    currency: choice.currency === void 0 ? currencyOfRegion(region) : checkedCurrency(choice.currency),
+    decimal_separator: part(parts, "decimal", "."),
+    direction: RTL_LANGUAGES.has(locale.language) ? "rtl" : "ltr",
+    first_day_of_week: region !== null && SUNDAY_REGIONS.has(region) ? "sunday" : "monday",
+    grouping_separator: part(parts, "group", ","),
+    hour_cycle: hourCycle === "h11" || hourCycle === "h12" ? "h12" : "h23",
+    language: locale.baseName,
+    measurement: region === UNITED_KINGDOM ? "united_kingdom" : region !== null && IMPERIAL_REGIONS.has(region) ? "imperial" : "metric",
+    region,
+    time_zone: choice.timeZone === void 0 ? system.timeZone || FALLBACK_ZONE : checkedZone(choice.timeZone)
+  };
+}
+
+// src/interactives/dev/routes.ts
+var CHUNK_ROUTE = "/_chunks/";
+var NEXT_ROUTE = "/_next/";
+var TICK_ROUTE = "/_tick";
+var FEED_PACKAGES_ROUTE = "/v1/interactives/packages";
+var TICK_EVENT = "tick";
+var WEB_HOST_MODULE = "dist/interactives-web.mjs";
+var GUEST_WORKER_MODULE = "dist/interactives-guest.mjs";
+var RUNTIME_MODULE = "dist/interactives-runtime.mjs";
+var CANVAS_GUEST_MODULE = "dist/interactives-canvas.global.js";
+
+// src/interactives/dev/content.ts
+var LOCAL_ANCESTORS = ["http://localhost:*", "http://127.0.0.1:*"];
+var HOST_HEADER = "host";
+async function contentEdge(origin, packagesRoot, chunks, runtimePrefix = "") {
+  const parsed = parseContentOrigin(origin);
+  if (parsed === null) throw new Error(`${origin} is not a content origin: use a scheme and a registrable host such as http://cimplifyusercontent.localhost:8790`);
+  const sdk = findPackageDir(packagesRoot, SDK_PACKAGE);
+  const runtimeFile = sdk === null ? null : path.join(sdk, CANVAS_GUEST_MODULE);
+  const store = {
+    chunk: (digest2) => Promise.resolve(chunks().get(digest2) ?? null),
+    async runtime(digest2) {
+      if (runtimeFile === null) return null;
+      const file = await promises.readFile(runtimeFile);
+      const bytes = runtimePrefix.length === 0 ? new Uint8Array(file) : new Uint8Array(Buffer.concat([Buffer.from(runtimePrefix, "utf8"), file]));
+      return sha256Hex(bytes) === digest2 ? bytes : null;
+    }
+  };
+  return {
+    async serve(req, res) {
+      const host = req.headers[HOST_HEADER] ?? "";
+      if (!servesContent(parsed, host)) return false;
+      const headers = new Headers();
+      for (const [name, value] of Object.entries(req.headers)) if (typeof value === "string") headers.set(name, value);
+      const request = new Request(`${parsed.scheme}//${host}${req.url ?? "/"}`, { method: req.method ?? "GET", headers });
+      const response = await serveContent(request, store, { frame_ancestors: LOCAL_ANCESTORS });
+      res.writeHead(response.status, Object.fromEntries(response.headers.entries()));
+      res.end(Buffer.from(await response.arrayBuffer()));
+      return true;
+    }
+  };
+}
+var FACE_PARTS_DIR = [".cimplify", "dev", "face-landmarker"];
+var SHA256 = "sha256";
+var HEX = "hex";
+function digestOf(bytes) {
+  return createHash(SHA256).update(bytes).digest(HEX);
+}
+var FacePartCache = class {
+  constructor(dir, fetcher = fetch, parts = Object.values(FACE_LANDMARKER.parts)) {
+    this.dir = dir;
+    this.fetcher = fetcher;
+    this.parts = new Map(parts.map((part2) => [part2.sha256, part2]));
+  }
+  dir;
+  fetcher;
+  loading = /* @__PURE__ */ new Map();
+  parts;
+  pinned(digest2) {
+    return this.parts.has(digest2);
+  }
+  fetch(digest2) {
+    if (!this.parts.has(digest2)) return Promise.resolve(null);
+    let pending = this.loading.get(digest2);
+    if (pending === void 0) {
+      pending = this.load(digest2).finally(() => this.loading.delete(digest2));
+      this.loading.set(digest2, pending);
+    }
+    return pending;
+  }
+  async load(digest2) {
+    const file = path.join(this.dir, digest2);
+    const cached = await promises.readFile(file).catch(() => null);
+    if (cached !== null && digestOf(cached) === digest2) return cached;
+    const part2 = this.parts.get(digest2);
+    if (part2 === void 0) return null;
+    const response = await this.fetcher(part2.upstream);
+    if (!response.ok) throw new Error(`${part2.upstream} answered ${response.status}`);
+    const body = Buffer.from(await response.arrayBuffer());
+    if (digestOf(body) !== digest2) throw new Error(`${part2.upstream} does not match its pinned digest ${digest2}`);
+    await promises.mkdir(this.dir, { recursive: true });
+    const temp = `${file}.${process.pid}.tmp`;
+    await promises.writeFile(temp, body);
+    await promises.rename(temp, file);
+    return body;
+  }
+};
+var NPM_ROUTE = "/_npm/";
+function createNpmResolver(root) {
+  const importMap = {};
+  const packages = /* @__PURE__ */ new Map();
+  for (const library of LIBRARY_ALLOWLIST) {
+    const dir = findPackageDir(root, library.name);
+    if (dir === null) continue;
+    packages.set(library.name, dir);
+    const pkg = readPackageJson(dir);
+    const map = exportsMap(pkg);
+    for (const entry of library.entries) {
+      const subpath = `.${entry.specifier.slice(library.name.length)}`;
+      if (entry.prefix) {
+        const target2 = pickTarget(map?.[`${subpath}*`], BROWSER_CONDITIONS);
+        if (target2 !== null && target2.endsWith("*")) {
+          importMap[entry.specifier] = `${NPM_ROUTE}${library.name}/${stripDotSlash(target2.slice(0, -1))}`;
+        }
+        continue;
+      }
+      const target = exportTarget(pkg, subpath, BROWSER_CONDITIONS);
+      if (target !== null) importMap[entry.specifier] = `${NPM_ROUTE}${library.name}/${stripDotSlash(target)}`;
+    }
+  }
+  return {
+    importMap,
+    file(urlPath) {
+      if (!urlPath.startsWith(NPM_ROUTE)) return null;
+      const rest = decodeURIComponent(urlPath.slice(NPM_ROUTE.length));
+      for (const [name, dir] of packages) {
+        if (!rest.startsWith(`${name}/`)) continue;
+        const resolved = path.resolve(dir, rest.slice(name.length + 1));
+        return resolved.startsWith(dir + path.sep) ? resolved : null;
+      }
+      return null;
+    }
+  };
+}
+var DEV_AI_ROUTE = "/_ctx/ai";
+var DEV_AI_KEY_ENV = "ANTHROPIC_API_KEY";
+var DEV_AI_LOOPBACK = "[dev loopback] ";
+var ANTHROPIC_URL = "https://api.anthropic.com/v1/messages";
+var ANTHROPIC_VERSION = "2023-06-01";
+var QUALITY_MODELS = {
+  fast: "claude-haiku-4-5-20251001",
+  standard: "claude-sonnet-5-5",
+  best: "claude-opus-5-5"
+};
+var DEFAULT_QUALITY = "standard";
+var MAX_TOKENS = 1024;
+var RUN_PREFIX = "airun_dev_";
+var ROUTE = "server";
+var SYSTEM = "You are the in-game model for a Cimplify Interactive, running in the creator's local simulator. Follow the declared prompt exactly and answer with the requested output only.";
+var STRUCTURED_SYSTEM = " Reply with one JSON value that matches this JSON schema, and nothing else: ";
+var ACTIONS_SYSTEM = ' Reply with one JSON object {"line": string, "actions": [{"action": name, "args": object}]} choosing only from these actions: ';
+function asRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function asList(value) {
+  return Array.isArray(value) ? value : [];
+}
+function named(list, key, name) {
+  for (const item of list) {
+    const record = asRecord(item);
+    if (record !== null && record[key] === name) return record;
+  }
+  return null;
+}
+function invalid(field, problem) {
+  return { error: { code: "invalid_arguments", field, problem } };
+}
+function render(template, slots, playerText) {
+  let out = template;
+  for (const slot of slots) out = out.split(`{{${slot.name}}}`).join(String(slot.value));
+  if (playerText !== null && playerText.length > 0) out += `
+
+The player says: ${playerText}`;
+  return out;
+}
+function digest(value) {
+  return createHash("sha256").update(JSON.stringify(value)).digest("hex");
+}
+function placeholder(schema, depth) {
+  const record = asRecord(schema);
+  if (record === null || depth > 4) return null;
+  switch (record.type) {
+    case "object": {
+      const out = {};
+      const properties = asRecord(record.properties) ?? {};
+      for (const key of asList(record.required)) if (typeof key === "string") out[key] = placeholder(properties[key], depth + 1);
+      return out;
+    }
+    case "array":
+      return [];
+    case "integer":
+    case "number":
+      return typeof record.minimum === "number" ? record.minimum : 0;
+    case "boolean":
+      return false;
+    case "string":
+      return `${DEV_AI_LOOPBACK.trim()} text`;
+    default:
+      return null;
+  }
+}
+function parseJson(text) {
+  const start = text.search(/[[{]/);
+  if (start < 0) return null;
+  try {
+    return JSON.parse(text.slice(start));
+  } catch {
+    return null;
+  }
+}
+var DevAi = class {
+  constructor(declarations, model) {
+    this.declarations = declarations;
+    this.model = model;
+  }
+  declarations;
+  model;
+  runs = 0;
+  get live() {
+    return this.model !== null;
+  }
+  async answer(call) {
+    const ai = this.declarations();
+    if (ai === null) return { error: { code: "denied", reason: "policy" } };
+    const args = call.arguments;
+    const slots = Array.isArray(args.slots) ? args.slots : [];
+    const playerText = typeof args.player_text === "string" ? args.player_text : null;
+    const output = asRecord(args.output) ?? { kind: "text", max_units: MAX_TOKENS };
+    if (call.operation === "ai.generate") {
+      const prompt = named(asList(ai.prompts), "name", String(args.prompt));
+      if (prompt === null) return invalid("prompt", "not_declared");
+      const quality = typeof prompt.quality === "string" ? prompt.quality : DEFAULT_QUALITY;
+      return this.run(ai, output, quality, "", render(String(prompt.template ?? ""), slots, playerText));
+    }
+    if (call.operation === "ai.converse") {
+      const character = named(asList(ai.characters), "name", String(args.character));
+      if (character === null) return invalid("character", "not_declared");
+      const quality = typeof character.quality === "string" ? character.quality : DEFAULT_QUALITY;
+      const persona = typeof character.persona === "string" ? character.persona : "";
+      const context = slots.map((slot) => `${slot.name}: ${slot.value}`).join("\n");
+      return this.run(ai, output, quality, persona, [context, playerText ?? ""].filter((part2) => part2.length > 0).join("\n\n"));
+    }
+    if (call.operation === "ai.usage") return { result: { runs: this.runs, units: 0 } };
+    if (call.operation === "ai.content") return this.content(ai, args, slots);
+    if (call.operation === "ai.content_prefetch") {
+      const requests = Array.isArray(args.requests) ? args.requests.length : 0;
+      return { result: { accepted: 0, already_cached: 0, refused: requests } };
+    }
+    return { error: { code: "unavailable", family: "ai", retry_after_ms: null } };
+  }
+  async content(ai, args, slots) {
+    const prompt = named(asList(ai.prompts), "name", String(args.prompt));
+    if (prompt === null) return invalid("prompt", "not_declared");
+    const kind = String(args.kind);
+    const declared = asRecord(prompt.output);
+    const schema = declared?.kind === "structured" ? named(asList(ai.schemas), "name", String(declared.schema))?.schema : args.schema;
+    const seed = typeof args.seed === "number" ? args.seed : 0;
+    this.runs++;
+    const runId = `${RUN_PREFIX}${this.runs}`;
+    const base = { run_id: runId, kind, seed, attempts: 1, units: 0, display_token: null };
+    if (this.model === null) return { result: { ...base, outcome: "fallback", fallback: "unavailable", value: null, output_digest: null } };
+    const quality = typeof prompt.quality === "string" ? prompt.quality : DEFAULT_QUALITY;
+    const context = args.context === void 0 || args.context === null ? "" : `
+
+Game state: ${JSON.stringify(args.context)}`;
+    const system = schema === void 0 || schema === null ? SYSTEM : SYSTEM + STRUCTURED_SYSTEM + JSON.stringify(schema);
+    let text;
+    try {
+      text = await this.model.complete({ model: QUALITY_MODELS[quality] ?? QUALITY_MODELS[DEFAULT_QUALITY], system, prompt: render(String(prompt.template ?? ""), slots, null) + context, maxTokens: MAX_TOKENS });
+    } catch {
+      return { result: { ...base, outcome: "fallback", fallback: "unavailable", value: null, output_digest: null } };
+    }
+    const value = kind === "text" ? text.trim() : parseJson(text);
+    if (value === null) return { result: { ...base, outcome: "fallback", fallback: "invalid", value: null, output_digest: null } };
+    return { result: { ...base, outcome: "generated", fallback: null, value, output_digest: digest(value) } };
+  }
+  async run(ai, output, quality, persona, prompt) {
+    const kind = output.kind;
+    let system = persona.length > 0 ? `${SYSTEM}
+
+${persona}` : SYSTEM;
+    let schema;
+    let actions = [];
+    if (kind === "structured") {
+      schema = named(asList(ai.schemas), "name", String(output.schema))?.schema;
+      if (asRecord(schema) === null) return invalid("output.schema", "not_declared");
+      system += STRUCTURED_SYSTEM + JSON.stringify(schema);
+    } else if (kind === "actions") {
+      const set = named(asList(ai.actions), "set", String(output.set));
+      if (set === null) return invalid("output.set", "not_declared");
+      actions = asList(set.actions);
+      system += ACTIONS_SYSTEM + JSON.stringify(actions);
+    }
+    const maxTokens = kind === "text" && typeof output.max_units === "number" ? Math.max(1, Math.min(MAX_TOKENS, output.max_units)) : MAX_TOKENS;
+    let text;
+    if (this.model === null) text = `${DEV_AI_LOOPBACK}${prompt}`;
+    else {
+      try {
+        text = await this.model.complete({ model: QUALITY_MODELS[quality] ?? QUALITY_MODELS[DEFAULT_QUALITY], system, prompt, maxTokens });
+      } catch {
+        return { error: { code: "unavailable", family: "ai", retry_after_ms: null } };
+      }
+    }
+    const value = this.output(kind, text, schema, actions);
+    this.runs++;
+    const runId = `${RUN_PREFIX}${this.runs}`;
+    return {
+      result: {
+        run_id: runId,
+        status: "completed",
+        route: ROUTE,
+        result: { run_id: runId, route: ROUTE, units: 0, output_digest: digest(value), verdict: "approved", output: value }
+      }
+    };
+  }
+  output(kind, text, schema, actions) {
+    if (kind === "structured") {
+      const parsed = this.model === null ? null : parseJson(text);
+      return { kind: "structured", value: parsed ?? placeholder(schema, 0) };
+    }
+    if (kind === "actions") {
+      const parsed = asRecord(this.model === null ? null : parseJson(text));
+      if (parsed !== null && Array.isArray(parsed.actions)) return { kind: "actions", actions: parsed.actions, line: typeof parsed.line === "string" ? parsed.line : null };
+      const first = asRecord(actions[0]);
+      return { kind: "actions", actions: first === null ? [] : [{ action: String(first.name), args: {} }], line: text };
+    }
+    return { kind: "text", text };
+  }
+};
+function anthropicDevModel(apiKey, fetcher = fetch) {
+  return {
+    async complete({ model, system, prompt, maxTokens }) {
+      const response = await fetcher(ANTHROPIC_URL, {
+        method: "POST",
+        headers: { "content-type": "application/json", "x-api-key": apiKey, "anthropic-version": ANTHROPIC_VERSION },
+        body: JSON.stringify({ model, max_tokens: maxTokens, system, messages: [{ role: "user", content: prompt }] })
+      });
+      if (!response.ok) throw new Error(`the model answered ${response.status}`);
+      const body = await response.json();
+      return (body.content ?? []).filter((block) => block.type === "text").map((block) => block.text ?? "").join("");
+    }
+  };
+}
+function devAiFromEnv(declarations, env = process.env) {
+  const key = env[DEV_AI_KEY_ENV];
+  return new DevAi(declarations, key !== void 0 && key.length > 0 ? anthropicDevModel(key) : null);
+}
+
+// src/interactives/dev/page.ts
+var STYLE = `
+:root { color-scheme: light dark; --bg: #f4f4f5; --fg: #18181b; --card: #ffffff; --muted: #71717a; --line: #e4e4e7; --accent: #f2b33d; --accent-fg: #9a6209; --on-accent: #1a1205; }
+@media (prefers-color-scheme: dark) { :root { --bg: #09090b; --fg: #fafafa; --card: #18181b; --muted: #a1a1aa; --line: #27272a; --accent-fg: #f2b33d; } }
+* { box-sizing: border-box; }
+body { margin: 0; min-height: 100vh; display: grid; place-items: center; background: var(--bg); color: var(--fg); font: 15px/1.4 system-ui, sans-serif; }
+#phone { position: relative; width: min(390px, 100vw); height: min(780px, 100vh); background: var(--card); border: 1px solid var(--line); border-radius: 28px; overflow: hidden; }
+#screen { position: absolute; inset: 0; overflow: auto; padding: 16px; }
+#screen canvas { position: absolute; inset: 0; width: 100%; height: 100%; }
+#sheet { position: absolute; inset: 0; background: rgba(0, 0, 0, 0.4); display: flex; align-items: flex-end; }
+#sheet[hidden] { display: none; }
+#sheet > div { width: 100%; background: var(--card); border-radius: 20px 20px 0 0; padding: 16px; max-height: 90%; overflow: auto; }
+#toast { position: absolute; left: 16px; right: 16px; bottom: 16px; padding: 10px 14px; border-radius: 12px; background: var(--fg); color: var(--card); opacity: 0; transition: opacity 0.2s; pointer-events: none; }
+#toast.on { opacity: 1; }
+#errors { position: fixed; inset: auto 0 0 0; margin: 0; padding: 12px 16px; max-height: 40vh; overflow: auto; background: #7f1d1d; color: #fff; font: 12px/1.5 ui-monospace, monospace; white-space: pre-wrap; }
+#errors:empty { display: none; }
+.stack { display: flex; flex-direction: column; gap: 12px; }
+.stack.row { flex-direction: row; flex-wrap: wrap; }
+.card { border: 1px solid var(--line); border-radius: 16px; padding: 16px; display: flex; flex-direction: column; gap: 10px; }
+.card > h3, .sheet-title { margin: 0; font-size: 17px; }
+.t-display { font-size: 32px; font-weight: 700; } .t-heading { font-size: 24px; font-weight: 700; } .t-title { font-size: 19px; font-weight: 600; }
+.t-label { font-size: 13px; font-weight: 600; } .t-caption { font-size: 12px; color: var(--muted); }
+.kv { display: flex; justify-content: space-between; gap: 12px; } .kv span:first-child { color: var(--muted); }
+.stat b { display: block; font-size: 22px; } .stat span { color: var(--muted); font-size: 12px; }
+button { font: inherit; padding: 10px 14px; border-radius: 12px; border: 1px solid var(--line); background: var(--card); color: var(--fg); cursor: pointer; }
+button.primary { background: var(--accent); border-color: var(--accent); color: var(--on-accent); }
+button.on { border-color: var(--accent); color: var(--accent-fg); }
+.choice { display: flex; gap: 8px; flex-wrap: wrap; }
+.stepper { display: flex; align-items: center; justify-content: space-between; }
+.stepper div { display: flex; align-items: center; gap: 10px; }
+.progress { height: 6px; border-radius: 3px; background: var(--line); overflow: hidden; } .progress i { display: block; height: 100%; background: var(--accent); }
+.unknown { border: 1px dashed var(--muted); border-radius: 10px; padding: 8px; font: 12px ui-monospace, monospace; color: var(--muted); }
+hr { border: 0; border-top: 1px solid var(--line); margin: 0; width: 100%; }
+input, select { font: inherit; padding: 10px; border-radius: 10px; border: 1px solid var(--line); background: var(--card); color: var(--fg); width: 100%; }
+label.field { display: flex; flex-direction: column; gap: 6px; }
+.sheet-actions { display: flex; gap: 8px; justify-content: flex-end; margin-top: 16px; }
+#stage { display: flex; gap: 20px; align-items: flex-start; justify-content: center; flex-wrap: wrap; padding: 16px; box-sizing: border-box; width: 100%; }
+#studio { width: min(360px, calc(100vw - 32px)); display: flex; flex-direction: column; gap: 12px; }
+#studio section { background: var(--card); border: 1px solid var(--line); border-radius: 16px; padding: 14px; display: flex; flex-direction: column; gap: 10px; }
+#studio h2 { margin: 0; font-size: 15px; }
+#tick-log { max-height: 240px; overflow: auto; display: flex; flex-direction: column; gap: 4px; }
+#studio section[hidden] { display: none; }
+#ai-log { max-height: 360px; overflow: auto; display: flex; flex-direction: column; gap: 6px; font-size: 13px; }
+#ai-log:empty::before { content: "Describe a change, for example: add traffic on the loop, make the bus red, or add a horn on Space."; color: var(--muted); }
+.ai-me { align-self: flex-end; background: var(--accent); color: var(--on-accent); padding: 6px 10px; border-radius: 12px; max-width: 85%; white-space: pre-wrap; }
+.ai-say { white-space: pre-wrap; }
+.ai-step, .ai-file { color: var(--muted); font: 12px/1.4 ui-monospace, monospace; overflow-wrap: anywhere; }
+.ai-error { color: #dc2626; font: 12px/1.4 ui-monospace, monospace; white-space: pre-wrap; overflow-wrap: anywhere; }
+#ai-input { min-height: 72px; resize: vertical; font: inherit; padding: 10px; border-radius: 10px; border: 1px solid var(--line); background: var(--card); color: var(--fg); width: 100%; }
+.studio-row { display: flex; gap: 8px; flex-wrap: wrap; }
+#publish-result { font-size: 13px; display: flex; flex-direction: column; gap: 4px; }
+`;
+var SCRIPT = `
+import { createSimulatorCtx } from "@cimplify/sdk/interactives";
+const screen = document.getElementById("screen");
+const sheet = document.getElementById("sheet");
+const toastEl = document.getElementById("toast");
+const errors = document.getElementById("errors");
+const events = new EventSource("/_events");
+events.addEventListener("reload", () => { void swapOrReload(); });
+async function swapOrReload() {
+  const swap = globalThis.cimplifyHotSwap;
+  const result = typeof swap === "function" ? await swap().catch(() => ({ swapped: false })) : { swapped: false };
+  if (!result.swapped) { location.reload(); return; }
+  errors.textContent = "";
+}
+events.addEventListener("failed", (e) => { errors.textContent = JSON.parse(e.data).join("\\n"); });
+const tickPanel = document.getElementById("tick");
+const tickStatus = document.getElementById("tick-status");
+const tickBudget = document.getElementById("tick-budget");
+const tickDiff = document.getElementById("tick-diff");
+const tickLog = document.getElementById("tick-log");
+const MIB = 1048576;
+function tickNote(cls, text) {
+  const d = document.createElement("div");
+  d.className = cls;
+  d.textContent = text;
+  tickLog.append(d);
+  while (tickLog.childElementCount > 200) tickLog.firstElementChild.remove();
+  tickLog.scrollTop = tickLog.scrollHeight;
+}
+function bodyText(b) { return "seat " + b.seat + (b.alive ? " at " + b.x + ", " + b.y + ", " + b.z + " yaw " + b.yaw : " empty"); }
+events.addEventListener(TICK_EVENT, (e) => {
+  const t = JSON.parse(e.data);
+  tickPanel.hidden = false;
+  if (t.type === "ready") tickStatus.textContent = "Running " + t.seats + " seats at " + t.rate_hz + " Hz with " + t.state_bytes + " state bytes";
+  else if (t.type === "budget") tickBudget.textContent = "tick " + t.tick + ": " + t.percent.toFixed(1) + "% of the " + t.deadline_ns / 1e6 + " ms budget, heap " + (t.heap_used_bytes / MIB).toFixed(1) + " of " + (t.heap_limit_bytes / MIB).toFixed(0) + " MiB";
+  else if (t.type === "diff") tickDiff.textContent = "tick " + t.tick + ": " + t.bodies.map(bodyText).join("; ") + (t.state.length > 0 ? " | state " + t.state.map((r) => "@" + r.offset + " " + r.bytes).join(" ") : "");
+  else if (t.type === "log") tickNote("ai-step", "[" + t.tick + "] " + t.message);
+  else if (t.type === "error") tickNote("ai-error", t.kind.replaceAll("_", " ") + " at tick " + t.tick + ": " + t.message + (t.source ? "\\n  at " + t.source : ""));
+  else if (t.type === "unavailable") tickStatus.textContent = t.message;
+  else if (t.type === "exit") tickStatus.textContent = t.code ? "The tick room stopped with code " + t.code : "The tick room stopped";
+});
+function tickSend(body) { fetch(TICK_ROUTE, { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify(body) }).catch(() => {}); }
+document.getElementById("tick-join").addEventListener("click", () => tickSend({ type: "join", seat: 0 }));
+document.getElementById("tick-leave").addEventListener("click", () => tickSend({ type: "leave", seat: 0 }));
+const aiLog = document.getElementById("ai-log");
+const aiInput = document.getElementById("ai-input");
+const aiAsk = document.getElementById("ai-ask");
+const publishResult = document.getElementById("publish-result");
+const publishButtons = [document.getElementById("publish-test"), document.getElementById("publish-live")];
+function note(cls, text) { const d = el("div", cls, text); aiLog.append(d); aiLog.scrollTop = aiLog.scrollHeight; return d; }
+function diagnosticLines(list) { return list.map((d) => (d.file ? d.file + (d.line ? ":" + d.line : "") + ": " : "") + d.message).join("\\n"); }
+function showTurn(turn) {
+  note("ai-me", turn.request);
+  for (const c of turn.changed) note("ai-file", (c.kind === "delete" ? "deleted " : "changed ") + c.path);
+  if (turn.summary) note("ai-say", turn.summary);
+  if (turn.error) note("ai-error", turn.error);
+  if (turn.end === "refused") note("ai-error", "The model declined this request.");
+  if (turn.end === "steps" || turn.end === "truncated") note("ai-error", "The AI stopped before finishing; ask it to continue.");
+  if (turn.diagnostics.length > 0) note("ai-error", diagnosticLines(turn.diagnostics));
+}
+function describeProgress(e) {
+  if (e.kind === "check") return e.errors === 0 ? "build passed" : "build found " + e.errors + " errors, repairing";
+  if (e.kind !== "tool") return null;
+  if (e.name === "write_file") return "editing " + e.path;
+  if (e.name === "delete_file") return "deleting " + e.path;
+  if (e.name === "read_file") return "reading " + e.path;
+  if (e.name === "read_guide") return "reading the Interactives guide";
+  if (e.name === "check") return "building";
+  return null;
+}
+function setBusy(busy) { aiAsk.disabled = busy; aiAsk.textContent = busy ? "Working..." : "Ask"; }
+function showPublish(p) {
+  publishResult.replaceChildren();
+  if (!p.ok) publishResult.append(el("div", "ai-error", (p.error || "publish failed") + (p.remediation ? "\\n" + p.remediation : "")));
+  else publishResult.append(el("div", "", (p.state === "in_review" ? "Revision " + p.revision + " passed admission and waits for review before release to " + p.channel : "Published " + p.revision + " to " + p.channel) + " (" + p.uploaded + " uploaded, " + p.skipped + " unchanged)"));
+  for (const log of p.logs) publishResult.append(el("div", log.level === "error" ? "ai-error" : "ai-step", log.message));
+}
+async function ask() {
+  const text = aiInput.value.trim();
+  if (!text || aiAsk.disabled) return;
+  setBusy(true);
+  const mine = note("ai-me", text);
+  aiInput.value = "";
+  const status = note("ai-step", "thinking");
+  try {
+    const res = await fetch("/_ai", { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify({ request: text }) });
+    if (!res.ok || !res.body) {
+      const body = await res.json().catch(() => ({ error: res.statusText, remediation: null }));
+      status.remove();
+      note("ai-error", body.error + (body.remediation ? "\\n" + body.remediation : ""));
+      return;
+    }
+    const reader = res.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    for (;;) {
+      const { value, done } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      let cut = buffer.indexOf("\\n\\n");
+      while (cut >= 0) {
+        const chunk = buffer.slice(0, cut);
+        buffer = buffer.slice(cut + 2);
+        cut = buffer.indexOf("\\n\\n");
+        let event = "message";
+        let data = "";
+        for (const line of chunk.split("\\n")) {
+          if (line.startsWith("event: ")) event = line.slice(7);
+          else if (line.startsWith("data: ")) data += line.slice(6);
+        }
+        if (!data) continue;
+        const payload = JSON.parse(data);
+        if (event === "progress") { const said = describeProgress(payload); if (said) status.textContent = said; }
+        else if (event === "done") { status.remove(); mine.remove(); showTurn(payload); }
+      }
+    }
+  } catch (err) {
+    note("ai-error", String(err));
+  } finally {
+    setBusy(false);
+  }
+}
+async function publish(channel) {
+  if (channel === "live" && !confirm("Publish this build to everyone?")) return;
+  for (const b of publishButtons) b.disabled = true;
+  publishResult.textContent = "Building and publishing to " + (channel === "live" ? "everyone" : "testers") + "...";
+  try {
+    const res = await fetch("/_publish", { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify({ channel }) });
+    showPublish(await res.json());
+  } catch (err) {
+    publishResult.textContent = String(err);
+  } finally {
+    for (const b of publishButtons) b.disabled = false;
+  }
+}
+aiAsk.onclick = ask;
+aiInput.addEventListener("keydown", (e) => { if (e.key === "Enter" && (e.metaKey || e.ctrlKey)) ask(); });
+document.getElementById("ai-reset").onclick = async () => {
+  await fetch("/_ai", { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify({ reset: true }) });
+  aiLog.replaceChildren();
+};
+publishButtons[0].onclick = () => publish("test");
+publishButtons[1].onclick = () => publish("live");
+(async () => {
+  try {
+    const state = await (await fetch("/_ai")).json();
+    for (const turn of state.turns) showTurn(turn);
+    setBusy(state.busy);
+    const published = await (await fetch("/_publish")).json();
+    if (published.last) showPublish(published.last);
+  } catch (err) {
+    note("ai-error", String(err));
+  }
+})();
+function el(tag, cls, text) {
+  const node = document.createElement(tag);
+  if (cls) node.className = cls;
+  if (text !== undefined && text !== null) node.textContent = String(text);
+  return node;
+}
+let sim = null;
+function bound(name) { return typeof name === "string" && name.startsWith("$") ? name.slice(1) : null; }
+function actionName(action) { return typeof action === "string" && action.startsWith("action:") ? action.slice(7) : null; }
+function act(node, action, trigger, scope) {
+  const name = actionName(action);
+  if (name === null) { toast("action steps run on the host"); return; }
+  const values = scope ? Object.entries(scope).map(([binding, value]) => ({ binding, value })) : null;
+  dispatchUi({ kind: "action", action: name, element: node.key ?? name, trigger, values });
+}
+let dispatchUi = () => {};
+function optionsOf(options) {
+  return (Array.isArray(options) ? options : []).map((o) => typeof o === "object" && o !== null ? { value: String(o.value), label: String(o.label ?? o.value), available: o.available !== false } : { value: String(o), label: String(o), available: true });
+}
+function render(node, form) {
+  if (node === null || typeof node !== "object") return el("span", "", node);
+  const p = node.props || {};
+  const scope = node.type === "Form" ? {} : form;
+  const kids = (node.children || []).map((c) => render(c, scope));
+  const key = bound(p.value);
+  switch (node.type) {
+    case "Stack": case "Grid": { const d = el("div", p.direction === "row" ? "stack row" : "stack"); d.append(...kids); return d; }
+    case "Card": { const d = el("div", "card"); if (p.title) d.append(el("h3", "", p.title)); d.append(...kids); return d; }
+    case "Form": {
+      const d = el("div", "card"); if (p.title) d.append(el("h3", "", p.title)); if (p.subtitle) d.append(el("div", "t-caption", p.subtitle));
+      const submit = el("button", "primary", p.submitLabel ?? "Submit"); submit.type = "button";
+      submit.onclick = () => act(node, p.submit, "submit", scope);
+      d.append(...kids, submit); return d;
+    }
+    case "TextContent": return el("div", "t-" + (p.size || "body"), p.text);
+    case "Stat": case "Metric": { const d = el("div", "stat"); d.append(el("span", "", p.label), el("b", "", p.value)); if (p.sub) d.append(el("span", "", p.sub)); return d; }
+    case "KeyValue": case "Money": { const d = el("div", "kv"); d.append(el("span", "", p.label ?? ""), el("span", "", p.value ?? p.amount)); return d; }
+    case "Divider": return el("hr");
+    case "Badge": case "Callout": case "Banner": return el("div", "card t-caption", p.text ?? p.title ?? p.label);
+    case "EmptyState": { const d = el("div", "card"); d.append(el("div", "t-title", p.title), el("div", "t-caption", p.message ?? p.subtitle)); return d; }
+    case "Progress": { const d = el("div", "progress"); const i = el("i"); i.style.width = Math.round(Math.max(0, Math.min(1, Number(p.value) || 0)) * 100) + "%"; d.append(i); return d; }
+    case "Image": { const img = el("img"); img.src = p.src ?? p.url ?? ""; img.alt = p.alt ?? ""; img.style.maxWidth = "100%"; return img; }
+    case "Button": { const b = el("button", p.variant === "primary" || p.variant === "cta" ? "primary" : "", p.label); b.onclick = () => act(node, p.action, "tap", null); return b; }
+    case "Buttons": { const d = el("div", "stack row"); d.append(...kids); return d; }
+    case "Choice": {
+      const wrap = el("label", "field"); wrap.append(el("span", "t-label", p.label));
+      const row = el("div", "choice");
+      for (const o of optionsOf(p.options)) {
+        const b = el("button", "", o.label); b.disabled = !o.available; b.type = "button";
+        b.onclick = () => { if (key) form[key] = o.value; for (const x of row.children) x.classList.remove("on"); b.classList.add("on"); };
+        row.append(b);
+      }
+      wrap.append(row); return wrap;
+    }
+    case "Select": {
+      const wrap = el("label", "field"); wrap.append(el("span", "t-label", p.label));
+      const s = el("select"); s.append(el("option", "", p.placeholder ?? "Choose"));
+      for (const o of optionsOf(p.options)) { const opt = el("option", "", o.label); opt.value = o.value; opt.disabled = !o.available; s.append(opt); }
+      s.onchange = () => { if (key) form[key] = s.value; };
+      wrap.append(s); return wrap;
+    }
+    case "Stepper": {
+      const min = Number(p.min ?? 0); const max = Number(p.max ?? 99); const step = Number(p.step ?? 1);
+      if (key && form[key] === undefined) form[key] = min;
+      const d = el("div", "stepper"); const value = el("b", "", key ? form[key] : min);
+      const minus = el("button", "", "-"); const plus = el("button", "", "+"); minus.type = plus.type = "button";
+      minus.onclick = () => { if (key) { form[key] = Math.max(min, form[key] - step); value.textContent = form[key]; } };
+      plus.onclick = () => { if (key) { form[key] = Math.min(max, form[key] + step); value.textContent = form[key]; } };
+      const ctl = el("div"); ctl.append(minus, value, plus); d.append(el("span", "", p.label), ctl); return d;
+    }
+    case "Toggle": {
+      const wrap = el("label", "kv"); const box = el("input"); box.type = "checkbox"; box.style.width = "auto";
+      if (key) form[key] = false; box.onchange = () => { if (key) form[key] = box.checked; };
+      wrap.append(el("span", "", p.label), box); return wrap;
+    }
+    case "Input": {
+      const wrap = el("label", "field"); wrap.append(el("span", "t-label", p.label));
+      const input = el("input"); input.placeholder = p.placeholder ?? ""; input.type = p.kind === "number" || p.kind === "money" ? "number" : p.kind === "email" ? "email" : "text";
+      input.oninput = () => { if (key) form[key] = input.type === "number" ? Number(input.value) : input.value; };
+      wrap.append(input); return wrap;
+    }
+    default: { const d = el("div", "unknown", node.type + " " + JSON.stringify(p)); d.append(...kids); return d; }
+  }
+}
+let toastTimer = 0;
+function toast(text) { toastEl.textContent = text; toastEl.classList.add("on"); clearTimeout(toastTimer); toastTimer = setTimeout(() => toastEl.classList.remove("on"), 1800); }
+const host = {
+  render(tree) { const canvas = screen.querySelector("canvas"); screen.replaceChildren(render(tree, {})); if (canvas) screen.append(canvas); },
+  openSheet(request) {
+    return new Promise((resolve) => {
+      const form = {};
+      const panel = el("div");
+      panel.append(el("h3", "sheet-title", request.title), render(request.tree, form));
+      const actions = el("div", "sheet-actions");
+      const close = (result) => { sheet.hidden = true; sheet.replaceChildren(); resolve(result); };
+      if (request.dismissible) { const c = el("button", "", "Cancel"); c.onclick = () => close({ status: "dismissed" }); actions.append(c); }
+      const ok = el("button", "primary", "Done"); ok.onclick = () => close({ status: "submitted", value: { ...form } }); actions.append(ok);
+      panel.append(actions); sheet.replaceChildren(panel); sheet.hidden = false;
+    });
+  },
+  toast,
+  async acquireSurface(options) {
+    const canvas = el("canvas");
+    const ratio = Math.min(devicePixelRatio || 1, options.pixel_ratio_cap || 1);
+    screen.style.padding = "0"; screen.append(canvas);
+    const width = screen.clientWidth; const height = screen.clientHeight;
+    canvas.width = Math.round(width * ratio); canvas.height = Math.round(height * ratio);
+    canvas.getContext("2d")?.scale(ratio, ratio);
+    return { canvas, width, height, pixel_ratio: ratio, on_resize() { return () => {}; }, release() { canvas.remove(); } };
+  },
+  requestFrame: (cb) => requestAnimationFrame(cb),
+  cancelFrame: (h) => cancelAnimationFrame(h),
+};
+const DEV_PERSONA = { age_range: "adult", avatar: null, display_name: "Local Player", handle: "local", participant_id: "participant_local" };
+function command(c) {
+  switch (c.kind) {
+    case "toast": case "announce": toast(c.text); return null;
+    case "open_sheet": return host.openSheet(c.request);
+    case "open_handoff": return { status: "cancelled" };
+    default: return null;
+  }
+}
+function showFault(f) {
+  errors.textContent = (f.source === "guest" ? f.phase : f.source) + ": " + f.message + (f.stack ? "\\n" + f.stack : "");
+}
+const nextFrame = () => new Promise((resolve) => requestAnimationFrame(() => resolve()));
+if (RECORD_PRELUDE !== null) {
+  let recorded = [];
+  let recordTimer = 0;
+  const sendRecorded = () => {
+    recordTimer = 0;
+    if (recorded.length === 0) return;
+    const body = JSON.stringify(recorded);
+    recorded = [];
+    fetch(RECORD_ROUTE, { method: "POST", headers: { "content-type": "application/json" }, body, keepalive: true }).catch(() => {});
+  };
+  addEventListener("message", (e) => {
+    const data = e.data;
+    if (data === null || typeof data !== "object" || !(RECORD_KEY in data)) return;
+    if (![...screen.querySelectorAll("iframe")].some((f) => f.contentWindow === e.source)) return;
+    recorded.push(data[RECORD_KEY]);
+    if (data[RECORD_KEY].kind === "start") sendRecorded();
+    else if (recordTimer === 0) recordTimer = setTimeout(sendRecorded, RECORD_FLUSH_MS);
+  });
+  addEventListener("pagehide", sendRecorded);
+}
+function askCtxAi(call) {
+  const family = call.operation.slice(0, call.operation.indexOf("."));
+  const route = family === "ai" ? CTX_AI_ROUTE : CTX_DATA_FAMILIES.includes(family) ? CTX_DATA_ROUTE : null;
+  if (route === null) return undefined;
+  return fetch(route, { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify({ operation: call.operation, arguments: call.arguments }) }).then((r) => r.json());
+}
+async function enginesFor(web, build, chunks) {
+  if (build.profile !== "canvas") return { engines: web.workerEngines(SDK_ROOT + GUEST_WORKER_MODULE), runtimes: undefined };
+  const runtime = (RECORD_PRELUDE ?? "") + (await (await fetch(SDK_ROOT + CANVAS_GUEST_MODULE)).text());
+  screen.style.padding = "0";
+  const content = CONTENT_ORIGIN === null ? null : web.parseContentOrigin(CONTENT_ORIGIN);
+  const camera = { runner: web.mediaPipeFaceRunner(chunks), container: document.getElementById("phone") };
+  const engines = web.iframeEngines({ container: screen, runtime, content, engine_session: ENGINE_SESSION, camera });
+  return { engines, runtimes: new web.RuntimePool(engines, chunks) };
+}
+async function runHosted(build) {
+  const web = await import(SDK_ROOT + WEB_HOST_MODULE);
+  const feedMode = new URLSearchParams(location.search).has(FEED_PARAM);
+  const feedCache = feedMode ? new web.ChunkCache((base) => web.httpChunks(new URL(base, location.origin).href)) : null;
+  const chunks = feedCache === null ? web.httpChunks(location.origin + CHUNK_ROUTE) : feedCache.from(CHUNK_ROUTE);
+  if (feedCache !== null) {
+    const feed = new web.PackagePrefetcher(web.httpRegistry(location.origin), feedCache, "live", web.IDLE_SCHEDULER);
+    globalThis.cimplifyFeed = feed;
+    feed.visible(build.interactive_id ?? LOCAL_INTERACTIVE);
+  }
+  const { engines, runtimes } = await enginesFor(web, build, chunks);
+  const partStore = await web.openWebPartStore().catch(() => undefined);
+  let hosted = null;
+  let overlay = false;
+  const overlayButton = document.getElementById("overlay");
+  document.getElementById("performance").hidden = false;
+  overlayButton.onclick = () => {
+    overlay = !overlay;
+    overlayButton.classList.toggle("on", overlay);
+    overlayButton.textContent = overlay ? "Hide performance overlay" : "Show performance overlay";
+    hosted?.setInspector(overlay);
+  };
+  const home = { build, chunks };
+  const launch = async (target = home) => {
+    const silent = new URLSearchParams(location.search).has(SILENT_PARAM);
+    const session = web.localSession({ interactive_id: target.build.interactive_id ?? LOCAL_INTERACTIVE, profile: target.build.profile, persona: DEV_PERSONA, answerAsync: silent ? () => new Promise(() => {}) : askCtxAi });
+    const next = new web.WebHost({
+      engines,
+      runtimes,
+      transport: session.transport,
+      hello: session.hello,
+      package: { chunks: target.build.chunks },
+      chunks: target.chunks,
+      part_store: partStore,
+      locale: DEV_LOCALE,
+      on_command: command,
+      on_fault: showFault,
+      on_milestone: (name) => performance.mark("cimplify:" + name),
+    });
+    hosted = next;
+    if (overlay) next.setInspector(true);
+    next.tree.subscribe(() => { const tree = next.tree.snapshot(); if (tree) host.render(tree); });
+    dispatchUi = (event) => next.dispatch(event);
+    await nextFrame();
+    performance.clearMarks();
+    performance.mark("cimplify:host-start");
+    globalThis.cimplifyFeed?.pause();
+    await next.start();
+  };
+  globalThis.cimplifyHotSwap = () => web.swapInPlace(hosted, async () => (await fetch("/_build")).json());
+  globalThis.cimplifyRelaunch = async () => {
+    const ending = hosted;
+    ending.dispose();
+    while (ending.phase !== "disposed") await nextFrame();
+    const warm = runtimes === undefined ? false : await runtimes.warmed(build.chunks, build.interactive_id ?? LOCAL_INTERACTIVE);
+    await launch();
+    return warm;
+  };
+  let showing = home;
+  let away = null;
+  globalThis.cimplifySwipe = async () => {
+    if (away === null) {
+      const nextBuild = await (await fetch(NEXT_ROUTE + "_build")).json();
+      away = { build: nextBuild, chunks: web.httpChunks(location.origin + NEXT_ROUTE.slice(0, -1) + CHUNK_ROUTE) };
+    }
+    const ending = hosted;
+    ending?.dispose();
+    while (ending !== null && ending.phase !== "disposed") await nextFrame();
+    showing = showing === home ? away : home;
+    await launch(showing);
+    return showing === away ? "next" : "home";
+  };
+  addEventListener("visibilitychange", () => hosted?.lifecycle(document.hidden ? "hidden" : "visible"));
+  addEventListener("pagehide", () => { hosted?.dispose(); runtimes?.drain(); });
+  if (feedMode || new URLSearchParams(location.search).has(HOLD_PARAM)) globalThis.cimplifyLaunch = launch;
+  else await launch();
+}
+const build = await (await fetch("/_build")).json();
+if (!build.ok) {
+  errors.textContent = build.diagnostics.join("\\n");
+} else if (build.host && build.chunks) {
+  if (build.warnings.length > 0) console.warn(build.warnings.join("\\n"));
+  runHosted(build).catch((err) => { errors.textContent = String(err && err.stack ? err.stack : err); });
+} else {
+  if (build.warnings.length > 0) console.warn(build.warnings.join("\\n"));
+  sim = createSimulatorCtx({ host, profile: build.profile, interactiveId: build.interactive_id ?? undefined });
+  dispatchUi = (event) => sim.dispatch(event);
+  addEventListener("visibilitychange", () => sim.emit(document.hidden ? "hidden" : "visible"));
+  addEventListener("pagehide", () => sim.dispose());
+  try {
+    const runtime = await import(SDK_ROOT + RUNTIME_MODULE);
+    const modules = await Promise.all(build.modules.map(async (m) => ({ path: m.path, imports: m.imports.map((i) => ({ ...i, export: null })), code: await (await fetch("/app/" + m.path)).text() })));
+    const compiler = runtime.blobCompiler(runtime.BLOB_URLS, (url) => import(url));
+    const slice = new runtime.Slice({ begin() {}, over: () => false });
+    const mod = await runtime.commonJsLinker(compiler).link(modules, build.entry, slice.tick);
+    await mod.default(sim.ctx);
+  } catch (err) {
+    errors.textContent = String(err && err.stack ? err.stack : err);
+  }
+}
+`;
+var LOCAL_INTERACTIVE = "itv_local";
+var HOLD_PARAM = "hold";
+var SILENT_PARAM = "silent";
+var FEED_PARAM = "feed";
+var RECORD_ROUTE = "/_record";
+var RECORD_FLUSH_MS = 200;
+function hostConstants(contentOrigin, engineSession, recordPrelude, locale) {
+  const constants = {
+    DEV_LOCALE: locale,
+    RECORD_PRELUDE: recordPrelude,
+    RECORD_ROUTE,
+    RECORD_KEY: RECORD_MESSAGE,
+    RECORD_FLUSH_MS,
+    CONTENT_ORIGIN: contentOrigin,
+    ENGINE_SESSION: engineSession,
+    LOCAL_INTERACTIVE,
+    HOLD_PARAM,
+    SILENT_PARAM,
+    FEED_PARAM,
+    SDK_ROOT: `${NPM_ROUTE}${SDK_PACKAGE}/`,
+    WEB_HOST_MODULE,
+    RUNTIME_MODULE,
+    GUEST_WORKER_MODULE,
+    CANVAS_GUEST_MODULE,
+    CHUNK_ROUTE,
+    NEXT_ROUTE,
+    CTX_AI_ROUTE: DEV_AI_ROUTE,
+    CTX_DATA_ROUTE: DEV_DATA_ROUTE,
+    CTX_DATA_FAMILIES: [...DATA_FAMILIES],
+    TICK_ROUTE,
+    TICK_EVENT
+  };
+  let out = "";
+  for (const [name, value] of Object.entries(constants))
+    out += `const ${name} = ${escapeJsonForHtml(JSON.stringify(value))};
+`;
+  return out;
+}
+function escapeJsonForHtml(value) {
+  return value.replaceAll("<", "\\u003c");
+}
+function simulatorPage(title, importMap, contentOrigin = null, engineSession = null, recordPrelude = null, locale = devLocale()) {
+  const map = escapeJsonForHtml(JSON.stringify({ imports: importMap }));
+  const safeTitle = title.replaceAll("&", "&amp;").replaceAll("<", "&lt;");
+  return `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>${safeTitle} simulator</title>
+<style>${STYLE}</style>
+<script type="importmap">${map}</script>
+</head>
+<body>
+<main id="stage">
+<div id="phone"><div id="screen"></div><div id="sheet" hidden></div><div id="toast"></div></div>
+<aside id="studio">
+<section><h2>Ask AI</h2><div id="ai-log"></div><textarea id="ai-input" placeholder="What should change? Ctrl or Cmd + Enter to send"></textarea><div class="studio-row"><button id="ai-ask" class="primary" type="button">Ask</button><button id="ai-reset" type="button">New chat</button></div></section>
+<section id="tick" hidden><h2>Tick room</h2><div id="tick-status" class="ai-step">Starting</div><div id="tick-budget" class="ai-step"></div><div id="tick-diff" class="ai-step"></div><div id="tick-log"></div><div class="studio-row"><button id="tick-join" type="button">Join seat 0</button><button id="tick-leave" type="button">Leave</button></div></section>
+<section id="performance" hidden><h2>Performance</h2><div class="studio-row"><button id="overlay" type="button">Show performance overlay</button></div></section>
+<section><h2>Publish</h2><div class="studio-row"><button id="publish-test" type="button">Publish to testers</button><button id="publish-live" class="primary" type="button">Publish live</button></div><div id="publish-result"></div></section>
+</aside>
+</main>
+<pre id="errors"></pre>
+<script type="module">${hostConstants(contentOrigin, engineSession, recordPrelude, locale)}${SCRIPT}</script>
+</body>
+</html>
+`;
+}
+var AI_ROUTE = "/_ai";
+var PUBLISH_ROUTE = "/_publish";
+var MAX_BODY_BYTES = 64 * 1024;
+var MAX_TURNS_KEPT = 30;
+var JSON_TYPE = "application/json; charset=utf-8";
+function sendJson(res, status, body) {
+  res.writeHead(status, { "content-type": JSON_TYPE, "cache-control": "no-store", ...HOST_PAGE_ISOLATION_HEADERS });
+  res.end(JSON.stringify(body));
+}
+async function readJsonBody(req) {
+  const chunks = [];
+  let size = 0;
+  for await (const chunk of req) {
+    const buffer = chunk;
+    size += buffer.length;
+    if (size > MAX_BODY_BYTES) throw new Error("the request body is too large");
+    chunks.push(buffer);
+  }
+  if (size === 0) return {};
+  const parsed = JSON.parse(Buffer.concat(chunks).toString("utf8"));
+  return parsed !== null && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+}
+function errorView(error) {
+  if (error instanceof CliError) return { error: error.message, remediation: error.remediation ?? null };
+  return { error: error instanceof Error ? error.message : String(error), remediation: null };
+}
+var Studio = class {
+  constructor(options) {
+    this.options = options;
+  }
+  options;
+  authoringNow = false;
+  publishingNow = false;
+  history = [];
+  turns = [];
+  lastPublish = null;
+  get quiet() {
+    return this.authoringNow || this.publishingNow;
+  }
+  async serve(req, res, route) {
+    if (route === AI_ROUTE) {
+      if (req.method === "POST") await this.ask(req, res);
+      else sendJson(res, 200, { busy: this.authoringNow, turns: this.turns });
+      return true;
+    }
+    if (route === PUBLISH_ROUTE) {
+      if (req.method === "POST") await this.publish(req, res);
+      else sendJson(res, 200, { busy: this.publishingNow, last: this.lastPublish });
+      return true;
+    }
+    return false;
+  }
+  remember(turn) {
+    this.turns.push(turn);
+    if (this.turns.length > MAX_TURNS_KEPT) this.turns.splice(0, this.turns.length - MAX_TURNS_KEPT);
+  }
+  async ask(req, res) {
+    let request = "";
+    try {
+      const body = await readJsonBody(req);
+      if (body.reset === true) {
+        this.history = [];
+        this.turns.length = 0;
+        sendJson(res, 200, { reset: true });
+        return;
+      }
+      request = typeof body.request === "string" ? body.request.trim() : "";
+    } catch (error) {
+      sendJson(res, 400, errorView(error));
+      return;
+    }
+    if (request.length === 0) {
+      sendJson(res, 400, { error: "say what to change", remediation: null });
+      return;
+    }
+    if (this.authoringNow || this.publishingNow) {
+      sendJson(res, 409, { error: "the AI or a publish is already running; wait for it to finish", remediation: null });
+      return;
+    }
+    let model;
+    try {
+      model = this.options.model();
+    } catch (error) {
+      sendJson(res, 400, errorView(error));
+      return;
+    }
+    this.authoringNow = true;
+    res.writeHead(200, { "content-type": "text/event-stream", "cache-control": "no-store", connection: "keep-alive", ...HOST_PAGE_ISOLATION_HEADERS });
+    const write = (event, data) => {
+      if (!res.writableEnded) res.write(`event: ${event}
+data: ${JSON.stringify(data)}
+
+`);
+    };
+    let changed = 0;
+    try {
+      const outcome = await askAuthoring(this.options.root, request, {
+        model,
+        history: this.history,
+        check: buildCheck(this.options.rebuild),
+        onEvent: (event) => write("progress", event)
+      });
+      this.history = trimHistory(outcome.messages);
+      changed = outcome.changed.length;
+      const turn = {
+        request,
+        summary: outcome.summary,
+        changed: outcome.changed,
+        diagnostics: outcome.diagnostics,
+        end: outcome.end,
+        error: null,
+        lines: outcome.lines,
+        lineDelta: outcome.lineDelta
+      };
+      this.remember(turn);
+      write("done", turn);
+    } catch (error) {
+      const turn = { request, summary: "", changed: [], diagnostics: [], end: "failed", error: errorView(error).error, lines: null, lineDelta: 0 };
+      this.remember(turn);
+      write("done", turn);
+    } finally {
+      this.authoringNow = false;
+      res.end();
+    }
+    if (changed > 0) await this.options.rebuild();
+  }
+  async publish(req, res) {
+    if (this.authoringNow || this.publishingNow) {
+      sendJson(res, 409, { ok: false, error: "the AI or a publish is already running; wait for it to finish", remediation: null });
+      return;
+    }
+    this.publishingNow = true;
+    try {
+      const body = await readJsonBody(req);
+      const channel = parseChannel(typeof body.channel === "string" ? body.channel : "test");
+      const summary = await publishProject(this.options.root, channel, { remote: await this.options.remote(), keyDir: this.options.keyDir });
+      const rev = summary.outcome.revision;
+      const view = {
+        ok: rev.state !== "refused",
+        channel,
+        interactive_id: summary.interactiveId,
+        revision: rev.revision,
+        state: rev.state,
+        package_digest: rev.packageDigest,
+        uploaded: summary.uploaded,
+        skipped: summary.skipped,
+        logs: summary.outcome.logs,
+        error: rev.state === "refused" ? `revision ${rev.revision} was refused at admission` : null,
+        remediation: null
+      };
+      this.lastPublish = view;
+      sendJson(res, 200, view);
+    } catch (error) {
+      const failed = errorView(error);
+      const view = {
+        ok: false,
+        channel: null,
+        interactive_id: null,
+        revision: null,
+        state: null,
+        package_digest: null,
+        uploaded: 0,
+        skipped: 0,
+        logs: [],
+        error: failed.error,
+        remediation: failed.remediation
+      };
+      this.lastPublish = view;
+      sendJson(res, error instanceof CliError ? 400 : 500, view);
+    } finally {
+      this.publishingNow = false;
+    }
+    await this.options.rebuild();
+  }
+};
+
+// src/interactives/dev/source-map.ts
+var BASE64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+var VLQ_SHIFT = 5;
+var VLQ_CONTINUE = 32;
+var VLQ_MASK = 31;
+var SEGMENT_SEPARATOR = ",";
+var LINE_SEPARATOR = ";";
+var DIGITS = new Map([...BASE64].map((c, i) => [c, i]));
+function decodeVlq(segment) {
+  const out = [];
+  let value = 0;
+  let shift = 0;
+  for (const c of segment) {
+    const digit = DIGITS.get(c);
+    if (digit === void 0) throw new Error(`'${c}' is not a base64 VLQ digit`);
+    value += (digit & VLQ_MASK) * 2 ** shift;
+    if (digit & VLQ_CONTINUE) {
+      shift += VLQ_SHIFT;
+      continue;
+    }
+    const magnitude = Math.floor(value / 2);
+    out.push(value % 2 === 1 ? -magnitude : magnitude);
+    value = 0;
+    shift = 0;
+  }
+  return out;
+}
+var SourceMapIndex = class _SourceMapIndex {
+  lines;
+  sources;
+  constructor(map) {
+    const root = map.sourceRoot ?? "";
+    this.sources = map.sources.map((s) => root + s);
+    const lines = [];
+    let source = 0;
+    let line = 0;
+    let originalColumn = 0;
+    for (const text of map.mappings.split(LINE_SEPARATOR)) {
+      const segments = [];
+      let column = 0;
+      if (text.length > 0) {
+        for (const raw of text.split(SEGMENT_SEPARATOR)) {
+          const fields = decodeVlq(raw);
+          column += fields[0];
+          if (fields.length < 4) continue;
+          source += fields[1];
+          line += fields[2];
+          originalColumn += fields[3];
+          segments.push({ column, source, line, originalColumn });
+        }
+      }
+      segments.sort((a, b) => a.column - b.column);
+      lines.push(segments);
+    }
+    this.lines = lines;
+  }
+  static parse(text) {
+    return new _SourceMapIndex(JSON.parse(text));
+  }
+  original(line, column) {
+    const segments = this.lines[line - 1];
+    if (segments === void 0 || segments.length === 0) return null;
+    const target = column - 1;
+    let low = 0;
+    let high = segments.length - 1;
+    let found = -1;
+    while (low <= high) {
+      const mid = low + high >> 1;
+      if (segments[mid].column <= target) {
+        found = mid;
+        low = mid + 1;
+      } else {
+        high = mid - 1;
+      }
+    }
+    const segment = segments[found === -1 ? 0 : found];
+    const source = this.sources[segment.source];
+    if (source === void 0) return null;
+    return { source, line: segment.line + 1, column: segment.originalColumn + 1 };
+  }
+};
+var PART_STORE_ENV = "CIMPLIFY_PART_STORE";
+var PARTS_ROUTE = "/_parts";
+var BODIES = "bodies";
+var INDEX = "index.json";
+var DIGEST = /^[0-9a-f]{64}$/;
+var FsPartBackend = class {
+  constructor(dir) {
+    this.dir = dir;
+  }
+  dir;
+  body(digest2) {
+    if (!DIGEST.test(digest2)) throw new Error(`'${digest2}' is not a part digest`);
+    return path.join(this.dir, BODIES, digest2);
+  }
+  async replace(file, bytes) {
+    await promises.mkdir(path.dirname(file), { recursive: true });
+    const temp = `${file}.${process.pid}.tmp`;
+    await promises.writeFile(temp, bytes);
+    await promises.rename(temp, file);
+  }
+  async read(digest2) {
+    try {
+      return new Uint8Array(await promises.readFile(this.body(digest2)));
+    } catch {
+      return null;
+    }
+  }
+  write(digest2, bytes) {
+    return this.replace(this.body(digest2), bytes);
+  }
+  async remove(digest2) {
+    await promises.rm(this.body(digest2), { force: true });
+  }
+  async load() {
+    try {
+      return JSON.parse(await promises.readFile(path.join(this.dir, INDEX), "utf8"));
+    } catch {
+      return null;
+    }
+  }
+  save(snapshot) {
+    return this.replace(path.join(this.dir, INDEX), JSON.stringify(snapshot));
+  }
+};
+function partStoreDir(option, env = process.env) {
+  if (option !== void 0) return option;
+  const value = env[PART_STORE_ENV];
+  return value === void 0 || value.length === 0 ? null : path.resolve(value);
+}
+async function openDevPartStore(dir, game, budgetBytes) {
+  const store = await SharedPartStore.open(new FsPartBackend(dir), {} );
+  let bodies = /* @__PURE__ */ new Map();
+  let last = { downloaded: 0, shared: 0 };
+  const source = {
+    fetch: (digest2) => {
+      const body = bodies.get(digest2);
+      return body === void 0 ? Promise.reject(new Error(`chunk ${digest2} is not in the current build`)) : Promise.resolve(body);
+    }
+  };
+  return {
+    store,
+    async install(digests, next) {
+      bodies = next;
+      const before = store.stats().downloaded_bytes;
+      let shared = 0;
+      await store.install(game, digests);
+      for (const digest2 of digests) {
+        const held = store.size(digest2);
+        if (held !== null) shared += held;
+        else await store.fetch(digest2, source);
+      }
+      await store.flush();
+      last = { downloaded: store.stats().downloaded_bytes - before, shared };
+      return last;
+    },
+    async fetch(digest2) {
+      if (!store.has(digest2) && !bodies.has(digest2)) return null;
+      return store.fetch(digest2, source);
+    },
+    report() {
+      return { game, unique_bytes: store.uniqueBytes(game), last_install: last, ...store.stats() };
+    }
+  };
+}
+var TICK_GUEST_DEV_BINARY = "tick-guest-dev";
+var TICK_GUEST_DEV_ENV = "CIMPLIFY_TICK_GUEST_DEV";
+var TICK_ROOM_UNAVAILABLE_MESSAGE = "The tick room doesn't run locally with this CLI, so the simulator keeps going without it. To play your tick room, run cimplify publish --channel test and open the test channel as one of your testers (cimplify testers add <account_id>).";
+var DEV_TICK_SEATS = 8;
+var DEV_TICK_RATE_HZ = 60;
+var DEV_TICK_SEED = 1n;
+var TARGET_PROFILES = ["release", "debug"];
+var CARGO_MANIFEST = "Cargo.toml";
+var TARGET_DIR = "target";
+var LOCATION_SEPARATOR = ":";
+var ERROR_KINDS = /* @__PURE__ */ new Set(["threw", "deadline", "memory", "fuel", "invalid_decision", "program"]);
+var HEX2 = /^(?:[0-9a-f]{2})*$/;
+function whole(value) {
+  return typeof value === "number" && Number.isInteger(value) && value >= 0;
+}
+function inRange(value, low, high) {
+  return typeof value === "number" && Number.isInteger(value) && value >= low && value <= high;
+}
+function bodyOf(value) {
+  if (value === null || typeof value !== "object") return null;
+  const b = value;
+  if (!whole(b.seat) || typeof b.alive !== "boolean" || !inRange(b.x, -2147483648, 2147483647) || !inRange(b.y, -2147483648, 2147483647) || !inRange(b.z, -2147483648, 2147483647)) return null;
+  if (!inRange(b.yaw, 0, 65535) || !inRange(b.animation, 0, 255) || !inRange(b.flags, 0, 255)) return null;
+  return { seat: b.seat, alive: b.alive, x: b.x, y: b.y, z: b.z, yaw: b.yaw, animation: b.animation, flags: b.flags };
+}
+function runOf(value) {
+  if (value === null || typeof value !== "object") return null;
+  const r = value;
+  return whole(r.offset) && typeof r.bytes === "string" && HEX2.test(r.bytes) ? { offset: r.offset, bytes: r.bytes } : null;
+}
+function listOf(value, read) {
+  if (!Array.isArray(value)) return null;
+  const out = [];
+  for (const item of value) {
+    const parsed = read(item);
+    if (parsed === null) return null;
+    out.push(parsed);
+  }
+  return out;
+}
+function parseRunnerLine(line) {
+  let raw;
+  try {
+    raw = JSON.parse(line);
+  } catch {
+    return null;
+  }
+  if (raw === null || typeof raw !== "object") return null;
+  const e = raw;
+  switch (e.type) {
+    case "ready":
+      return whole(e.state_bytes) && whole(e.seats) && whole(e.rate_hz) ? { type: "ready", state_bytes: e.state_bytes, seats: e.seats, rate_hz: e.rate_hz } : null;
+    case "log":
+      return whole(e.tick) && typeof e.message === "string" ? { type: "log", tick: e.tick, message: e.message } : null;
+    case "diff": {
+      const bodies = listOf(e.bodies, bodyOf);
+      const state = listOf(e.state, runOf);
+      return whole(e.tick) && bodies !== null && state !== null ? { type: "diff", tick: e.tick, bodies, state } : null;
+    }
+    case "budget":
+      return whole(e.tick) && whole(e.step_ns) && whole(e.deadline_ns) && whole(e.heap_used_bytes) && whole(e.heap_limit_bytes) ? { type: "budget", tick: e.tick, step_ns: e.step_ns, deadline_ns: e.deadline_ns, heap_used_bytes: e.heap_used_bytes, heap_limit_bytes: e.heap_limit_bytes } : null;
+    case "error":
+      if (!whole(e.tick) || typeof e.kind !== "string" || !ERROR_KINDS.has(e.kind) || typeof e.message !== "string") return null;
+      if (e.location !== null && typeof e.location !== "string") return null;
+      return { type: "error", tick: e.tick, kind: e.kind, message: e.message, location: e.location };
+    default:
+      return null;
+  }
+}
+function bundlePosition(location) {
+  if (!location.startsWith(`${TICK_GUEST_ORIGIN}${LOCATION_SEPARATOR}`)) return null;
+  const parts = location.slice(TICK_GUEST_ORIGIN.length + 1).split(LOCATION_SEPARATOR);
+  if (parts.length !== 2) return null;
+  const line = Number(parts[0]);
+  const column = Number(parts[1]);
+  return Number.isInteger(line) && line > 0 && Number.isInteger(column) && column > 0 ? { line, column } : null;
+}
+function mapLocation(location, map) {
+  if (location === null) return null;
+  const at = bundlePosition(location);
+  if (at === null || map === null) return location;
+  const original = map.original(at.line, at.column);
+  return original === null ? location : `${original.source}:${original.line}:${original.column}`;
+}
+function inspectEvent(event, map) {
+  if (event.type === "error") return { ...event, source: mapLocation(event.location, map) };
+  if (event.type === "budget") return { ...event, percent: event.deadline_ns === 0 ? 0 : event.step_ns / event.deadline_ns * 100 };
+  return event;
+}
+function repoRoots(start, exists) {
+  const out = [];
+  let dir = path.resolve(start);
+  for (; ; ) {
+    if (exists(path.join(dir, CARGO_MANIFEST))) out.push(dir);
+    const parent = path.dirname(dir);
+    if (parent === dir) return out;
+    dir = parent;
+  }
+}
+function resolveTickGuestBinary(probe) {
+  if (probe.env !== void 0 && probe.env.length > 0) return probe.exists(probe.env) ? probe.env : null;
+  for (const start of probe.starts) {
+    for (const root of repoRoots(start, probe.exists)) {
+      for (const profile of TARGET_PROFILES) {
+        const candidate = path.join(root, TARGET_DIR, profile, TICK_GUEST_DEV_BINARY);
+        if (probe.exists(candidate)) return candidate;
+      }
+    }
+  }
+  for (const dir of (probe.pathEnv ?? "").split(path.delimiter)) {
+    if (dir.length === 0) continue;
+    const candidate = path.join(dir, TICK_GUEST_DEV_BINARY);
+    if (probe.exists(candidate)) return candidate;
+  }
+  return null;
+}
+function defaultBinaryProbe(projectRoot) {
+  return {
+    env: process.env[TICK_GUEST_DEV_ENV],
+    starts: [projectRoot, path.dirname(fileURLToPath(import.meta.url))],
+    pathEnv: process.env.PATH,
+    exists: existsSync
+  };
+}
+var spawnRunner = (binary, args) => spawn(binary, [...args], { stdio: ["pipe", "pipe", "inherit"] });
+function runnerArgs(bundle, seats, rateHz, seed) {
+  return ["--bundle", bundle, "--seats", String(seats), "--rate", String(rateHz), "--seed", seed.toString()];
+}
+var TickRunner = class {
+  child;
+  exited = false;
+  constructor(options) {
+    const spawn = options.spawn ?? spawnRunner;
+    this.child = spawn(options.binary, runnerArgs(options.bundle, options.seats ?? DEV_TICK_SEATS, options.rateHz ?? DEV_TICK_RATE_HZ, options.seed ?? DEV_TICK_SEED));
+    const lines = createInterface({ input: this.child.stdout });
+    lines.on("line", (line) => {
+      const event = parseRunnerLine(line);
+      if (event !== null) options.onEvent(inspectEvent(event, options.map));
+    });
+    this.child.on("error", (error) => {
+      this.exited = true;
+      options.onEvent({ type: "unavailable", message: error.message });
+    });
+    this.child.on("exit", (code) => {
+      this.exited = true;
+      options.onEvent({ type: "exit", code });
+    });
+  }
+  get running() {
+    return !this.exited;
+  }
+  send(input) {
+    if (this.exited) return false;
+    this.child.stdin.write(`${JSON.stringify(input)}
+`);
+    return true;
+  }
+  stop() {
+    if (this.exited) return;
+    this.send({ type: "stop" });
+    this.child.stdin.end();
+    this.child.kill();
+  }
+};
+function parseRunnerInput(value) {
+  if (value === null || typeof value !== "object") return null;
+  const v = value;
+  switch (v.type) {
+    case "join":
+    case "leave":
+      return inRange(v.seat, 0, 65535) ? { type: v.type, seat: v.seat } : null;
+    case "input":
+      return inRange(v.seat, 0, 65535) && inRange(v.axis_x, -32768, 32767) && inRange(v.axis_z, -32768, 32767) && inRange(v.buttons, 0, 255) ? { type: "input", seat: v.seat, axis_x: v.axis_x, axis_z: v.axis_z, buttons: v.buttons } : null;
+    case "command":
+      return inRange(v.seat, 0, 65535) && inRange(v.action, 0, 65535) && typeof v.payload === "string" && HEX2.test(v.payload) ? { type: "command", seat: v.seat, action: v.action, payload: v.payload } : null;
+    case "stop":
+      return { type: "stop" };
+    default:
+      return null;
+  }
+}
+
+// src/interactives/dev/server.ts
+var MAX_AI_BODY_BYTES = 256 * 1024;
+var MAX_RECORD_BYTES = 1024 * 1024;
+async function readCall(req) {
+  const parts = [];
+  let size = 0;
+  for await (const part2 of req) {
+    const chunk = part2;
+    size += chunk.length;
+    if (size > MAX_AI_BODY_BYTES) return null;
+    parts.push(chunk);
+  }
+  try {
+    const call = JSON.parse(Buffer.concat(parts).toString("utf8"));
+    return typeof call.operation === "string" && call.arguments !== null && typeof call.arguments === "object" ? call : null;
+  } catch {
+    return null;
+  }
+}
+async function readJson(req, limit) {
+  const parts = [];
+  let size = 0;
+  for await (const part2 of req) {
+    const chunk = part2;
+    size += chunk.length;
+    if (size > limit) return null;
+    parts.push(chunk);
+  }
+  try {
+    return JSON.parse(Buffer.concat(parts).toString("utf8"));
+  } catch {
+    return null;
+  }
+}
+var TickDev = class {
+  constructor(root, options, broadcast) {
+    this.root = root;
+    this.options = options;
+    this.broadcast = broadcast;
+  }
+  root;
+  options;
+  broadcast;
+  runner = null;
+  code = null;
+  binary = void 0;
+  emit(event) {
+    this.broadcast(event);
+    this.options.onEvent?.(event);
+  }
+  async sync(build) {
+    const guest = build.result.tickGuest ?? null;
+    if (guest === null) {
+      if (build.result.ok || build.result.manifest?.entries.tick === null) this.stop();
+      return;
+    }
+    if (this.runner?.running && this.code !== null && this.code.equals(guest.code)) return;
+    this.stop();
+    this.code = guest.code;
+    if (this.binary === void 0) this.binary = resolveTickGuestBinary(this.options.probe ?? defaultBinaryProbe(this.root));
+    if (this.binary === null) {
+      this.emit({ type: "unavailable", message: TICK_ROOM_UNAVAILABLE_MESSAGE });
+      return;
+    }
+    const written = await writeTickGuest(path.join(this.root, ...TICK_DEV_DIR), guest);
+    let map = null;
+    try {
+      map = SourceMapIndex.parse(guest.map);
+    } catch {
+      map = null;
+    }
+    this.runner = new TickRunner({ binary: this.binary, bundle: written.bundle, map, spawn: this.options.spawn, onEvent: (event) => this.emit(event) });
+  }
+  send(input) {
+    return this.runner?.send(input) ?? false;
+  }
+  stop() {
+    this.runner?.stop();
+    this.runner = null;
+    this.code = null;
+  }
+};
+var APP_ROUTE = "/app/";
+var BUILD_ROUTE = "/_build";
+var EVENTS_ROUTE = "/_events";
+var TICK_DEV_DIR = [".cimplify", "dev"];
+var MAX_TICK_INPUT_BYTES = 4096;
+var REBUILD_DEBOUNCE_MS = 40;
+var KEEPALIVE_MS = 15e3;
+var CONTENT_TYPES = {
+  ".js": "text/javascript; charset=utf-8",
+  ".mjs": "text/javascript; charset=utf-8",
+  ".json": "application/json; charset=utf-8",
+  ".wasm": "application/wasm",
+  ".css": "text/css; charset=utf-8"
+};
+function payloadDigests(build) {
+  const out = /* @__PURE__ */ new Map();
+  for (const chunk of build.result.chunks) if (chunk.payloadDigest !== null) out.set(chunk.digest, chunk.payloadDigest);
+  return out;
+}
+function chunkSizes(build) {
+  const out = /* @__PURE__ */ new Map();
+  for (const chunk of build.result.chunks) out.set(chunk.digest, chunk.totalBytes);
+  return out;
+}
+function packageChunks(build) {
+  const pkg = build.result.package;
+  if (pkg === null) return null;
+  const payloads = payloadDigests(build);
+  const sizes = chunkSizes(build);
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const group of pkg.groups) {
+    const lazy = group.name.startsWith(LAZY_GROUP_PREFIX);
+    for (const file of group.files) {
+      if (file.guest !== void 0 || seen.has(file.chunk)) continue;
+      seen.add(file.chunk);
+      out.push({
+        digest: file.chunk,
+        before_play: group.before_play,
+        asset_group: group.name,
+        runtime: file.runtime ?? null,
+        payload_digest: payloads.get(file.chunk) ?? null,
+        lazy,
+        size: sizes.get(file.chunk) ?? null
+      });
+    }
+  }
+  for (const runtime of pkg.runtime) {
+    if (seen.has(runtime.chunk)) continue;
+    seen.add(runtime.chunk);
+    out.push({
+      digest: runtime.chunk,
+      before_play: true,
+      asset_group: CODE_GROUP,
+      runtime: { name: runtime.name, version: runtime.version },
+      payload_digest: payloads.get(runtime.chunk) ?? null,
+      lazy: false,
+      size: sizes.get(runtime.chunk) ?? null
+    });
+  }
+  return out;
+}
+function payloadOf(build, host) {
+  const r = build.result;
+  const manifest = r.manifest;
+  const hasModules = r.modules.length > 0;
+  return {
+    ok: r.ok || hasModules && !r.diagnostics.some((d) => d.severity === "error" && !d.code.startsWith("delivery.")),
+    digest: r.sourceDigest,
+    entry: manifest ? outputPathOf(manifest.entries.client) : null,
+    profile: manifest ? manifest.profile.kind : null,
+    interactive_id: manifest ? manifest.identity.id : null,
+    chunks: packageChunks(build),
+    modules: r.modules.map((m) => ({ path: m.output, imports: m.imports })),
+    host,
+    diagnostics: r.diagnostics.filter((d) => d.severity === "error").map(formatDiagnostic),
+    warnings: r.diagnostics.filter((d) => d.severity === "warning").map(formatDiagnostic)
+  };
+}
+var FEED_IDS_PARAM = "ids";
+var FEED_ID_SEPARATOR = ",";
+var LOCAL_REVISION = "local";
+function feedPackages(build, ids) {
+  const chunks = packageChunks(build);
+  const local = build.result.manifest?.identity.id ?? LOCAL_INTERACTIVE;
+  if (chunks === null) return [];
+  const sized = chunks.map((chunk) => ({ ...chunk, size: chunk.size ?? 0 }));
+  return ids.filter((id) => id === local).map((id) => ({ interactive_id: id, package: { revision_id: LOCAL_REVISION, package_digest: build.result.sourceDigest, chunk_base_url: CHUNK_ROUTE, chunks: sized } }));
+}
+function webHostAvailable(root) {
+  const sdk = findPackageDir(root, SDK_PACKAGE);
+  return sdk !== null && [WEB_HOST_MODULE, GUEST_WORKER_MODULE, RUNTIME_MODULE, CANVAS_GUEST_MODULE].every((module) => existsSync(path.join(sdk, module)));
+}
+function contentType(file) {
+  const dot = file.lastIndexOf(".");
+  return CONTENT_TYPES[dot >= 0 ? file.slice(dot) : ""] ?? "application/octet-stream";
+}
+function send(res, status, type, body) {
+  res.writeHead(status, { "content-type": type, "cache-control": "no-store", ...HOST_PAGE_ISOLATION_HEADERS });
+  res.end(body);
+}
+async function startDevServer(options) {
+  let build = options.build ?? await buildLocal(options.root);
+  const packagesRoot = options.packagesRoot ?? options.root;
+  let modules = /* @__PURE__ */ new Map();
+  let chunks = /* @__PURE__ */ new Map();
+  const index = (b) => {
+    const next = /* @__PURE__ */ new Map();
+    for (const m of b.result.modules) next.set(m.output, m.code);
+    modules = next;
+    const bodies = /* @__PURE__ */ new Map();
+    for (const c of b.result.chunks) bodies.set(c.digest, Buffer.concat(c.parts));
+    chunks = bodies;
+  };
+  index(build);
+  const storeDir = partStoreDir(options.partStore);
+  const partStore = storeDir === null ? null : await openDevPartStore(storeDir, options.root);
+  const faceParts = new FacePartCache(path.join(options.root, ...FACE_PARTS_DIR));
+  const installParts = async () => {
+    if (partStore !== null) await partStore.install([...chunks.keys()], chunks);
+  };
+  await installParts();
+  let npm = createNpmResolver(packagesRoot);
+  let host = webHostAvailable(packagesRoot);
+  const clients = /* @__PURE__ */ new Set();
+  const broadcast = (event, data) => {
+    for (const c of clients) c.write(`event: ${event}
+data: ${data}
+
+`);
+  };
+  const tick = options.tick === void 0 ? null : new TickDev(options.root, options.tick, (event) => broadcast(TICK_EVENT, JSON.stringify(event)));
+  await tick?.sync(build);
+  const rebuild = async () => {
+    build = await buildLocal(options.root);
+    index(build);
+    await installParts();
+    await tick?.sync(build);
+    npm = createNpmResolver(packagesRoot);
+    host = webHostAvailable(packagesRoot);
+    const payload = payloadOf(build, host);
+    if (!studio.quiet) {
+      if (payload.ok) broadcast("reload", JSON.stringify(payload.digest));
+      else broadcast("failed", JSON.stringify(payload.diagnostics));
+    }
+    options.onRebuild?.(build);
+    return build;
+  };
+  const studio = new Studio({
+    root: options.root,
+    rebuild,
+    model: options.authoringModel ?? (() => modelFromEnv()),
+    remote: options.publishRemote ?? remoteFromEnv,
+    keyDir: options.keyDir ?? signingKeyDir()
+  });
+  const ctxAi = options.ctxAi ?? devAiFromEnv(() => build.result.manifest?.ai ?? null);
+  const ctxData = new LocalData({ root: options.root, environment: options.environment, declarations: () => build.result.manifest?.data ?? null });
+  const record = options.record ?? null;
+  const locale = options.locale ?? devLocale();
+  const content = options.contentOrigin === void 0 ? null : await contentEdge(options.contentOrigin, packagesRoot, () => chunks, record?.prelude ?? "");
+  const handle = async (req, res) => {
+    if (content !== null && await content.serve(req, res)) return;
+    const url = new URL(req.url ?? "/", "http://localhost");
+    const route = url.pathname;
+    if (options.next !== void 0 && route.startsWith(NEXT_ROUTE)) {
+      const upstream = await fetch(`${options.next}${route.slice(NEXT_ROUTE.length - 1)}${url.search}`).catch(() => null);
+      if (upstream === null) send(res, 502, "text/plain", "the next Interactive's dev server did not answer");
+      else send(res, upstream.status, upstream.headers.get("content-type") ?? "application/octet-stream", Buffer.from(await upstream.arrayBuffer()));
+      return;
+    }
+    if (await studio.serve(req, res, route)) return;
+    if (route === DEV_DATA_ROUTE && req.method === "POST") {
+      const call = await readCall(req);
+      if (call === null) send(res, 400, "text/plain", "expected a ctx call");
+      else send(res, 200, CONTENT_TYPES[".json"], JSON.stringify(await ctxData.answer(call)));
+      return;
+    }
+    if (route === DEV_AI_ROUTE && req.method === "POST") {
+      const call = await readCall(req);
+      if (call === null) send(res, 400, "text/plain", "expected a ctx call");
+      else send(res, 200, CONTENT_TYPES[".json"], JSON.stringify(await ctxAi.answer(call)));
+      return;
+    }
+    if (route === "/" || route === "/index.html") {
+      const engineSession = options.engineSessions ? await options.engineSessions.session() : null;
+      send(res, 200, "text/html; charset=utf-8", simulatorPage(build.result.manifest?.identity.name ?? "Interactive", npm.importMap, options.contentOrigin ?? null, engineSession, record?.prelude ?? null, locale));
+      return;
+    }
+    if (route === RECORD_ROUTE && req.method === "POST") {
+      const inputs = record === null ? null : await readJson(req, MAX_RECORD_BYTES);
+      if (record === null) send(res, 404, "text/plain", "not recording; run cimplify dev --record <file>");
+      else if (!Array.isArray(inputs)) send(res, 400, "text/plain", "expected an array of recorded inputs");
+      else {
+        if (record.recorder.add(inputs) > 0) {
+          await record.recorder.flush();
+          record.onInput?.(record.recorder);
+        }
+        send(res, 204, "text/plain", "");
+      }
+      return;
+    }
+    if (route === BUILD_ROUTE) {
+      send(res, 200, CONTENT_TYPES[".json"], JSON.stringify(payloadOf(build, host)));
+      return;
+    }
+    if (route === FEED_PACKAGES_ROUTE && req.method === "GET") {
+      const ids = (url.searchParams.get(FEED_IDS_PARAM) ?? "").split(FEED_ID_SEPARATOR).filter((id) => id.length > 0);
+      send(res, 200, CONTENT_TYPES[".json"], JSON.stringify({ data: feedPackages(build, ids) }));
+      return;
+    }
+    if (route.startsWith(CHUNK_ROUTE)) {
+      const digest2 = route.slice(CHUNK_ROUTE.length);
+      const stored = partStore === null ? null : await partStore.fetch(digest2).catch(() => null);
+      const face = stored === null && faceParts.pinned(digest2) ? await faceParts.fetch(digest2).catch(() => null) : null;
+      const body = stored !== null ? Buffer.from(stored.buffer, stored.byteOffset, stored.byteLength) : face ?? chunks.get(digest2);
+      if (body === void 0) send(res, 404, "text/plain", "not found");
+      else send(res, 200, "application/octet-stream", body);
+      return;
+    }
+    if (route === PARTS_ROUTE) {
+      if (partStore === null) send(res, 404, "text/plain", `no shared part store; set ${PART_STORE_ENV} to a directory`);
+      else send(res, 200, CONTENT_TYPES[".json"], JSON.stringify(partStore.report()));
+      return;
+    }
+    if (route === TICK_ROUTE && req.method === "POST") {
+      const input = parseRunnerInput(await readJson(req, MAX_TICK_INPUT_BYTES));
+      if (input === null) send(res, 400, "text/plain", "expected a tick runner input");
+      else if (tick === null || !tick.send(input)) send(res, 409, "text/plain", "the tick room runner is not running");
+      else send(res, 204, "text/plain", "");
+      return;
+    }
+    if (route === EVENTS_ROUTE) {
+      res.writeHead(200, { "content-type": "text/event-stream", "cache-control": "no-store", connection: "keep-alive", ...HOST_PAGE_ISOLATION_HEADERS });
+      res.write(": connected\n\n");
+      clients.add(res);
+      req.on("close", () => clients.delete(res));
+      return;
+    }
+    if (route.startsWith(APP_ROUTE)) {
+      const code = modules.get(decodeURIComponent(route.slice(APP_ROUTE.length)));
+      if (code === void 0) send(res, 404, "text/plain", "not found");
+      else send(res, 200, CONTENT_TYPES[".js"], code);
+      return;
+    }
+    if (route.startsWith(NPM_ROUTE)) {
+      const file = npm.file(route);
+      if (file === null) {
+        send(res, 404, "text/plain", "not found");
+        return;
+      }
+      try {
+        send(res, 200, contentType(file), await promises.readFile(file));
+      } catch {
+        send(res, 404, "text/plain", "not found");
+      }
+      return;
+    }
+    send(res, 404, "text/plain", "not found");
+  };
+  const server = createServer((req, res) => {
+    handle(req, res).catch((err) => {
+      if (!res.headersSent) send(res, 500, "text/plain", err.message);
+      else if (!res.writableEnded) res.end();
+    });
+  });
+  await new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(options.port, options.host, () => resolve());
+  });
+  const port = server.address().port;
+  const keepalive = setInterval(() => {
+    for (const c of clients) c.write(": keepalive\n\n");
+  }, KEEPALIVE_MS);
+  keepalive.unref();
+  let watcher = null;
+  let timer = null;
+  let running = null;
+  let pending = false;
+  const schedule = () => {
+    if (timer !== null) clearTimeout(timer);
+    timer = setTimeout(() => {
+      timer = null;
+      if (running !== null) {
+        pending = true;
+        return;
+      }
+      running = rebuild().finally(() => {
+        running = null;
+        if (pending) {
+          pending = false;
+          schedule();
+        }
+      });
+    }, REBUILD_DEBOUNCE_MS);
+  };
+  if (options.watch) {
+    watcher = watch(options.root, { recursive: true }, (_event, file) => {
+      if (file === null) return;
+      const first = String(file).split(/[\\/]/)[0];
+      if (EXCLUDED_DIRECTORIES.has(first)) return;
+      schedule();
+    });
+  }
+  return {
+    url: `http://${options.host === "0.0.0.0" ? "localhost" : options.host}:${port}`,
+    port,
+    current: () => build,
+    rebuild,
+    async close() {
+      clearInterval(keepalive);
+      if (timer !== null) clearTimeout(timer);
+      watcher?.close();
+      tick?.stop();
+      ctxData.close();
+      await record?.recorder.flush();
+      for (const c of clients) c.end();
+      clients.clear();
+      await new Promise((resolve) => server.close(() => resolve()));
+      await partStore?.store.flush();
+    }
+  };
+}
+var LOG_FILE = /^isolate-0x[0-9a-f]+-\d+-v8\.log$/;
+var CODE_CREATION = "code-creation";
+var BUILTIN = "Builtin";
+var WASM_FUNCTION = "wasm-function";
+var MICROS_PER_MS = 1e3;
+var FIELD_TYPE = 1;
+var FIELD_TIME = 3;
+var FIELD_SIZE = 5;
+var FIELD_NAME = 6;
+var CODE_LOG_FLAGS = "--log-code";
+function codeLogArgs(directory) {
+  return [`--js-flags=${CODE_LOG_FLAGS} --logfile=${path.join(directory, "v8.log")}`];
+}
+function codeCreatedBetween(directory, startMs, endMs) {
+  let isolates = 0;
+  let bytes = 0;
+  for (const name of readdirSync(directory)) {
+    if (!LOG_FILE.test(name)) continue;
+    const file = path.join(directory, name);
+    const epoch = statSync(file).birthtimeMs;
+    isolates++;
+    for (const line of readFileSync(file, "utf8").split("\n")) {
+      if (!line.startsWith(CODE_CREATION)) continue;
+      const fields = line.split(",");
+      if (fields[FIELD_TYPE] === BUILTIN || (fields[FIELD_NAME] ?? "").startsWith(WASM_FUNCTION)) continue;
+      const at = epoch + Number(fields[FIELD_TIME]) / MICROS_PER_MS;
+      if (at >= startMs && at < endMs) bytes += Number(fields[FIELD_SIZE]);
+    }
+  }
+  return { isolates, bytes };
+}
+
+// src/interactives/harness/canvas.ts
+var COLD_FIRST_FRAME_MS = 400;
+var STEP_TIMEOUT_MS = 3e4;
+var SETTLE_FRAMES = Number(process.env.CANVAS_SETTLE_FRAMES ?? 2400);
+var MEASURED_FRAMES = 600;
+var MEASURED_WINDOWS = 2;
+var REPORTED_SITES = 12;
+var SAMPLING_INTERVAL_BYTES = 16;
+var YOUNG_GARBAGE_BUDGET_BYTES = 0;
+var GATE_YOUNG_GARBAGE = "game and runtime code leave zero young-generation garbage across the window, because young garbage is what scavenges collect and a scavenge is a pause on the frame path (tracker garbage confirmed by the unperturbed sampler)";
+var GATE_NO_COLLECTIONS = "no garbage collection of any kind runs during the window, because any collection is a pause on the frame path";
+var GATE_JIT_SETTLES = "JIT code-space allocation, reported apart from young garbage because compiled code is not collected by scavenges, shrinks from one measured window to the next, so code that keeps recompiling still fails";
+var GC_EVENT_BUDGET = 0;
+var GATE_COLD_FIRST_FRAME = "the first launch of an Interactive, with an empty package and chunk cache and a fresh guest context, draws its first frame within 400 ms of the launch starting, measured after the host page has loaded and the browser and GPU have painted, because players always launch from an already running hub";
+var WARM_FIRST_FRAME_MS = 150;
+var GATE_WARM_FIRST_FRAME = "a launch after the first, once the host has staged and compiled the engine runtime in a pooled guest while the player browsed, draws its first frame within 150 ms of the launch starting";
+var BROWSE_MS = Number(process.env.CANVAS_BROWSE_MS ?? 1e3);
+var RELAUNCH_HOOK = "cimplifyRelaunch";
+var LAUNCH_HOOK = "cimplifyLaunch";
+var HOOK_POLL_MS = 20;
+var REDUCER_START_EVENT = "V8.GCIncrementalMarkingStart";
+var REDUCER_REASON = "memory reducer";
+var HUB_REDUCER_COLLECTIONS = 2;
+var HUB_SETTLE_LIMIT_MS = 32e3;
+var HUB_REDUCER_FOLLOW_UP_MS = 1e4;
+var HUB_TRACE_SLICE_MS = 2e3;
+var THREADED_NEEDS_LOGS = "the game runs worker threads, whose isolates block in Atomics.wait and stall memory dumps; launch the browser with codeLogArgs(dir) and pass that dir so code space is read from each isolate's V8 code log";
+var MIN_WINDOW_FRAME_SHARE = 0.9;
+var HOST_START_MARK = "cimplify:host-start";
+var MILESTONE_PREFIX = "cimplify:";
+var SRCDOC_URL = "about:srcdoc";
+var OUT_OF_PROCESS_SRCDOC_URL = "";
+var MODULE_URL_PREFIX = "blob:";
+var RUNTIME_SITE = "canvas runtime";
+var GAME_SITE = "module";
+var JIT_SPACES = ["code_space", "code_large_object_space", "trusted_space", "trusted_large_object_space"];
+var NEW_SPACES = ["new_space", "new_large_object_space"];
+var HEAP_ALLOCATOR = /^v8\/main\/heap\/([a-z_]+)$/;
+var GC_EVENTS = /* @__PURE__ */ new Set(["MinorGC", "MajorGC", "V8.GCScavenger", "V8.GCFinalizeMC", "V8.GCCompactor", "V8.GCIncrementalMarking"]);
+var TRACE_CATEGORIES = ["v8", "devtools.timeline", "disabled-by-default-v8.gc", "disabled-by-default-memory-infra"];
+var JS_FLAG_ARGS = process.env.CANVAS_JS_FLAGS ? [`--js-flags=${process.env.CANVAS_JS_FLAGS}`, "--single-process"] : [];
+var BROWSER_ARGS = ["--enable-unsafe-swiftshader", "--use-angle=swiftshader", "--ignore-gpu-blocklist", "--enable-unsafe-webgpu", ...JS_FLAG_ARGS];
+var HARDWARE_GPU_ARGS = [
+  ...process.platform === "darwin" ? ["--use-angle=metal"] : [],
+  "--enable-gpu",
+  "--ignore-gpu-blocklist",
+  "--enable-unsafe-webgpu",
+  ...JS_FLAG_ARGS
+];
+var SOFTWARE_RENDERERS = /SwiftShader|llvmpipe|softpipe|Software/i;
+var RENDERER_DOCUMENT = "<!doctype html><canvas></canvas>";
+async function softwareRenderer(page) {
+  await page.setContent(RENDERER_DOCUMENT);
+  const renderer = await page.evaluate(() => {
+    const gl = document.querySelector("canvas")?.getContext("webgl2");
+    if (gl === null || gl === void 0) return "";
+    const info = gl.getExtension("WEBGL_debug_renderer_info");
+    return String(gl.getParameter(info === null ? gl.RENDERER : info.UNMASKED_RENDERER_WEBGL));
+  }, null);
+  return renderer === "" || SOFTWARE_RENDERERS.test(renderer);
+}
+var DISPLAY_HZ = 120;
+var FRAME_INTERVAL_MS = 1e3 / DISPLAY_HZ;
+var WINDOW_MS = Math.round(MEASURED_FRAMES * FRAME_INTERVAL_MS);
+var SETTLE_MS = Math.round(SETTLE_FRAMES * FRAME_INTERVAL_MS);
+var ANIMATION_FRAME_EVENT = "FireAnimationFrame";
+var MICROS_PER_MS2 = 1e3;
+var MS_PER_MINUTE = 6e4;
+var P50 = 0.5;
+var P99 = 0.99;
+var PERCENT = 100;
+var WARM_DOCUMENT = `<!doctype html><canvas width="64" height="64"></canvas><iframe sandbox="allow-scripts" srcdoc="<script>requestAnimationFrame(()=>0)</script>"></iframe>`;
+var WARM_FRAMES = 2;
+function percentile(sorted, at) {
+  return sorted.length === 0 ? 0 : sorted[Math.min(sorted.length - 1, Math.floor(sorted.length * at))];
+}
+function busiestThread(events) {
+  const byThread = /* @__PURE__ */ new Map();
+  for (const event of events) {
+    if (event.name !== ANIMATION_FRAME_EVENT || event.ph !== "X") continue;
+    const key = `${event.pid}:${event.tid}`;
+    const list = byThread.get(key) ?? [];
+    list.push(event);
+    byThread.set(key, list);
+  }
+  let busiest = [];
+  for (const list of byThread.values()) if (list.length > busiest.length) busiest = list;
+  return busiest.sort((a, b) => a.ts - b.ts);
+}
+function frameIntervals(frames) {
+  const out = [];
+  for (let i = 1; i < frames.length; i++) out.push((frames[i].ts - frames[i - 1].ts) / MICROS_PER_MS2);
+  return out;
+}
+function siteOf(frame) {
+  const owner = frame.url.startsWith(MODULE_URL_PREFIX) ? GAME_SITE : frame.url === SRCDOC_URL ? RUNTIME_SITE : null;
+  if (owner === null) return null;
+  return `${frame.functionName || "(anonymous)"} ${owner}:${frame.lineNumber}:${frame.columnNumber}`;
+}
+function ranked(sites) {
+  return [...sites.entries()].filter(([, bytes]) => bytes > 0).map(([site, bytes]) => ({ site, bytes })).sort((a, b) => b.bytes - a.bytes);
+}
+function spaceTotals(events) {
+  const dumps = [];
+  const seen = /* @__PURE__ */ new Map();
+  for (const event of events) {
+    const allocators = event.args?.dumps?.allocators;
+    if (event.ph !== "v" || allocators === void 0) continue;
+    const spaces = /* @__PURE__ */ new Map();
+    for (const [name, allocator] of Object.entries(allocators)) {
+      const match = HEAP_ALLOCATOR.exec(name);
+      const value = allocator.attrs?.allocated_objects_size?.value;
+      if (match !== null && value !== void 0) spaces.set(match[1], Number.parseInt(value, 16));
+    }
+    if (spaces.size === 0) continue;
+    const ordinal = seen.get(event.pid) ?? 0;
+    seen.set(event.pid, ordinal + 1);
+    dumps[ordinal] ??= /* @__PURE__ */ new Map();
+    dumps[ordinal].set(event.pid, spaces);
+  }
+  return dumps;
+}
+function spaceDelta(dumps, names) {
+  const [before, after] = dumps;
+  if (before === void 0 || after === void 0) throw new Error("the memory dumps around the window are missing");
+  let total = 0;
+  for (const [pid, spaces] of after) {
+    const start = before.get(pid);
+    if (start === void 0) continue;
+    for (const [name, size] of spaces) if (names === null || names.indexOf(name) >= 0) total += size - (start.get(name) ?? 0);
+  }
+  return total;
+}
+async function traced(cdp, body, dumps) {
+  const events = [];
+  const collect = (event) => {
+    events.push(...event.value);
+  };
+  cdp.on("Tracing.dataCollected", collect);
+  const complete = new Promise((resolve) => cdp.once("Tracing.tracingComplete", () => resolve()));
+  await cdp.send("Tracing.start", {
+    traceConfig: { includedCategories: TRACE_CATEGORIES, memoryDumpConfig: { triggers: [] } },
+    transferMode: "ReportEvents"
+  });
+  if (dumps) await cdp.send("Tracing.requestMemoryDump", { deterministic: false, levelOfDetail: "background" });
+  const result = await body();
+  if (dumps) await cdp.send("Tracing.requestMemoryDump", { deterministic: false, levelOfDetail: "background" });
+  await cdp.send("Tracing.end");
+  await complete;
+  cdp.off("Tracing.dataCollected", collect);
+  return { result, events };
+}
+var TRACE_NODE_FIELDS = 5;
+function traceAllocations(snap) {
+  const meta = snap.snapshot.meta;
+  const nodeFields = meta.node_fields.length;
+  const sizeAt = meta.node_fields.indexOf("self_size");
+  const traceAt = meta.node_fields.indexOf("trace_node_id");
+  const fnFields = meta.trace_function_info_fields.length;
+  const fnName = meta.trace_function_info_fields.indexOf("name");
+  const fnScript = meta.trace_function_info_fields.indexOf("script_name");
+  const fnLine = meta.trace_function_info_fields.indexOf("line");
+  const fnColumn = meta.trace_function_info_fields.indexOf("column");
+  const liveByTrace = /* @__PURE__ */ new Map();
+  for (let i = 0; i < snap.nodes.length; i += nodeFields) {
+    const trace = snap.nodes[i + traceAt];
+    if (trace !== 0) liveByTrace.set(trace, (liveByTrace.get(trace) ?? 0) + snap.nodes[i + sizeAt]);
+  }
+  const garbage = /* @__PURE__ */ new Map();
+  const live = /* @__PURE__ */ new Map();
+  const visit = (tree) => {
+    for (let i = 0; i < tree.length; i += TRACE_NODE_FIELDS) {
+      const id = tree[i];
+      const fn = tree[i + 1];
+      const bytes = tree[i + 3];
+      const site = siteOf({
+        functionName: snap.strings[snap.trace_function_infos[fn * fnFields + fnName]] ?? "",
+        url: snap.strings[snap.trace_function_infos[fn * fnFields + fnScript]] ?? "",
+        lineNumber: snap.trace_function_infos[fn * fnFields + fnLine],
+        columnNumber: snap.trace_function_infos[fn * fnFields + fnColumn]
+      });
+      if (site !== null && bytes !== 0) {
+        const kept = liveByTrace.get(id) ?? 0;
+        garbage.set(site, (garbage.get(site) ?? 0) + bytes - kept);
+        live.set(site, (live.get(site) ?? 0) + kept);
+      }
+      visit(tree[i + 4]);
+    }
+  };
+  visit(snap.trace_tree);
+  return { garbage, live };
+}
+async function trackedSnapshot(cdp) {
+  const chunks = [];
+  const collect = (event) => {
+    chunks.push(event.chunk);
+  };
+  cdp.on("HeapProfiler.addHeapSnapshotChunk", collect);
+  await cdp.send("HeapProfiler.stopTrackingHeapObjects", { reportProgress: false, treatGlobalObjectsAsRoots: true });
+  cdp.off("HeapProfiler.addHeapSnapshotChunk", collect);
+  return JSON.parse(chunks.join(""));
+}
+function sampledSites(head) {
+  const out = /* @__PURE__ */ new Map();
+  const walk = (node) => {
+    const site = node.selfSize > 0 ? siteOf(node.callFrame) : null;
+    if (site !== null) out.set(site, (out.get(site) ?? 0) + node.selfSize);
+    for (const child of node.children) walk(child);
+  };
+  walk(head);
+  return out;
+}
+async function isolateWindow(cdp, codeLogs, body) {
+  const before = await cdp.send("Runtime.getHeapUsage");
+  const started = Date.now();
+  const { events } = await traced(cdp, body, false);
+  const ended = Date.now();
+  const after = await cdp.send("Runtime.getHeapUsage");
+  return { events, heap: after.usedSize - before.usedSize, jit: codeCreatedBetween(codeLogs, started, ended).bytes };
+}
+async function pacedWindow(cdp, frame, codeLogs) {
+  await cdp.send("HeapProfiler.startSampling", {
+    samplingInterval: SAMPLING_INTERVAL_BYTES,
+    includeObjectsCollectedByMajorGC: true,
+    includeObjectsCollectedByMinorGC: true
+  });
+  const wait = () => frame.page().waitForTimeout(WINDOW_MS);
+  const isolates = codeLogs === null ? null : await isolateWindow(cdp, codeLogs, wait);
+  const events = isolates?.events ?? (await traced(cdp, wait, true)).events;
+  const frames = busiestThread(events);
+  const intervals = frameIntervals(frames).sort((a, b) => a - b);
+  const work = frames.map((event) => (event.dur ?? 0) / MICROS_PER_MS2).sort((a, b) => a - b);
+  const collections = events.filter((event) => GC_EVENTS.has(event.name) && (event.ph === "X" || event.ph === "B"));
+  const profile = await cdp.send("HeapProfiler.stopSampling");
+  if (isolates !== null) {
+    return {
+      frames: intervals.length,
+      frame_ms_p50: Number(percentile(intervals, P50).toFixed(2)),
+      frame_ms_p99: Number(percentile(intervals, P99).toFixed(2)),
+      work_ms_p99: Number(percentile(work, P99).toFixed(3)),
+      gc_events: collections.length,
+      gc_pause_ms_max: collections.reduce((longest, event) => Math.max(longest, (event.dur ?? 0) / MICROS_PER_MS2), 0),
+      heap_growth_bytes: isolates.heap,
+      jit_code_bytes: isolates.jit,
+      new_space_bytes_all_sources: 0,
+      sampled: sampledSites(profile.profile.head),
+      measured_by: "isolate_logs"
+    };
+  }
+  const dumps = spaceTotals(events);
+  return {
+    frames: intervals.length,
+    frame_ms_p50: Number(percentile(intervals, P50).toFixed(2)),
+    frame_ms_p99: Number(percentile(intervals, P99).toFixed(2)),
+    work_ms_p99: Number(percentile(work, P99).toFixed(3)),
+    gc_events: collections.length,
+    gc_pause_ms_max: collections.reduce((longest, event) => Math.max(longest, (event.dur ?? 0) / MICROS_PER_MS2), 0),
+    heap_growth_bytes: spaceDelta(dumps, null),
+    jit_code_bytes: spaceDelta(dumps, JIT_SPACES),
+    new_space_bytes_all_sources: spaceDelta(dumps, NEW_SPACES),
+    sampled: sampledSites(profile.profile.head),
+    measured_by: "memory_dumps"
+  };
+}
+async function garbageWindow(cdp, frame) {
+  await cdp.send("HeapProfiler.startTrackingHeapObjects", { trackAllocations: true });
+  await frame.page().waitForTimeout(WINDOW_MS);
+  const { garbage, live } = traceAllocations(await trackedSnapshot(cdp));
+  return { young_garbage_sites: ranked(garbage).slice(0, REPORTED_SITES), retained_sites: ranked(live).slice(0, REPORTED_SITES) };
+}
+function bytesAt(sites, marker) {
+  return sites.filter((a) => a.site.includes(marker)).reduce((sum, a) => sum + a.bytes, 0);
+}
+function combine(measured, tracked) {
+  const { sampled, ...paced } = measured;
+  const confirmed = tracked.young_garbage_sites.filter((a) => (sampled.get(a.site) ?? 0) > 0);
+  return {
+    ...paced,
+    game_young_garbage_bytes: bytesAt(confirmed, ` ${GAME_SITE}:`),
+    runtime_young_garbage_bytes: bytesAt(confirmed, RUNTIME_SITE),
+    young_garbage_sites: confirmed,
+    tracker_only_sites: tracked.young_garbage_sites.filter((a) => (sampled.get(a.site) ?? 0) === 0),
+    retained_sites: tracked.retained_sites
+  };
+}
+async function canvasFrame(page) {
+  const deadline = Date.now() + STEP_TIMEOUT_MS;
+  for (; ; ) {
+    const frame = page.frames().find((f) => f.url() === SRCDOC_URL || f !== page.mainFrame() && f.url() === OUT_OF_PROCESS_SRCDOC_URL);
+    if (frame !== void 0) return frame;
+    if (Date.now() > deadline) throw new Error(`no canvas frame appeared; errors: ${await page.locator("#errors").textContent()}`);
+    await page.waitForTimeout(5);
+  }
+}
+async function firstFrame(page, url) {
+  await page.goto(`${url}?${HOLD_PARAM}`);
+  await page.waitForFunction(
+    (hook) => typeof globalThis[hook] === "function",
+    LAUNCH_HOOK,
+    { polling: HOOK_POLL_MS, timeout: STEP_TIMEOUT_MS }
+  );
+  await hubSettled(page);
+  await page.evaluate((hook) => {
+    void globalThis[hook]();
+  }, LAUNCH_HOOK);
+  return drawnSinceHostStart(page);
+}
+function reducerCollections(events) {
+  return events.filter((event) => event.name === REDUCER_START_EVENT && event.args?.value?.gc_reason === REDUCER_REASON).length;
+}
+async function hubSettled(page) {
+  const cdp = await page.context().newCDPSession(page);
+  let deadline = Date.now() + HUB_SETTLE_LIMIT_MS;
+  let seen = 0;
+  try {
+    while (seen < HUB_REDUCER_COLLECTIONS && Date.now() < deadline) {
+      const { events } = await traced(cdp, () => page.waitForTimeout(HUB_TRACE_SLICE_MS), false);
+      const before = seen;
+      seen += reducerCollections(events);
+      if (before === 0 && seen > 0) deadline = Math.min(deadline, Date.now() + HUB_REDUCER_FOLLOW_UP_MS);
+    }
+  } finally {
+    await cdp.detach();
+  }
+}
+async function warmFirstFrame(page) {
+  const staged = await page.evaluate(async (relaunch) => {
+    const run = globalThis[relaunch];
+    return run === void 0 ? null : run();
+  }, RELAUNCH_HOOK);
+  if (staged === null) throw new Error("the host page cannot relaunch the Interactive");
+  return { first_frame_ms: await drawnSinceHostStart(page), runtime_staged: staged };
+}
+async function drawnSinceHostStart(page) {
+  const frame = await canvasFrame(page);
+  await frame.waitForFunction(
+    () => {
+      const canvas = document.querySelector("canvas");
+      return canvas !== null && (!canvas.hasAttribute("data-cimplify-engine") || canvas.hasAttribute("data-cimplify-frame"));
+    },
+    void 0,
+    { polling: "raf", timeout: STEP_TIMEOUT_MS }
+  );
+  const drawnAt = await frame.evaluate(() => performance.timeOrigin + performance.now());
+  const startedAt = await page.evaluate((mark) => {
+    const entry = performance.getEntriesByName(mark)[0];
+    return entry === void 0 ? Number.NaN : performance.timeOrigin + entry.startTime;
+  }, HOST_START_MARK);
+  return Math.round(drawnAt - startedAt);
+}
+function drawnFrames(frame, count) {
+  return frame.evaluate(
+    (frames) => new Promise((resolve) => {
+      let left = frames;
+      const tick = () => {
+        if (--left <= 0) resolve();
+        else requestAnimationFrame(tick);
+      };
+      requestAnimationFrame(tick);
+    }),
+    count
+  );
+}
+async function measureLaunches(page, url) {
+  const first_frame_ms = await firstFrame(page, url);
+  await page.waitForTimeout(BROWSE_MS);
+  return { first_frame_ms, warm: await warmFirstFrame(page) };
+}
+async function measureCanvas(page, url, template, codeLogs = null, measured = null) {
+  const launched = await measureLaunches(page, url);
+  const { first_frame_ms, warm } = measured ?? launched;
+  const software_launches = codeLogs === null ? launched : null;
+  const frame = await canvasFrame(page);
+  const isolated = await frame.evaluate(() => globalThis.crossOriginIsolated === true);
+  const milestones = await page.evaluate(
+    ([start, prefix]) => {
+      const origin = performance.getEntriesByName(start)[0]?.startTime ?? 0;
+      const out = {};
+      for (const entry of performance.getEntriesByType("mark")) {
+        if (entry.name.startsWith(prefix)) out[entry.name.slice(prefix.length)] = Math.round(entry.startTime - origin);
+      }
+      return out;
+    },
+    [HOST_START_MARK, MILESTONE_PREFIX]
+  );
+  await Promise.all([page.waitForTimeout(SETTLE_MS), drawnFrames(frame, SETTLE_FRAMES)]);
+  const cdp = await page.context().newCDPSession(page);
+  await cdp.send("HeapProfiler.enable");
+  const windows = [];
+  const paced = [];
+  const threaded = page.workers().length > 0;
+  if (threaded && codeLogs === null) throw new Error(THREADED_NEEDS_LOGS);
+  for (let i = 0; i < MEASURED_WINDOWS; i++) paced.push(await pacedWindow(cdp, frame, threaded ? codeLogs : null));
+  for (let i = 0; i < MEASURED_WINDOWS; i++) windows.push(combine(paced[i], await garbageWindow(cdp, frame)));
+  await cdp.detach();
+  return { template, first_frame_ms, warm, milestones_ms: milestones, cross_origin_isolated: isolated, windows, software_launches };
+}
+function jitComparable(first, second) {
+  const minimum = Math.floor(MEASURED_FRAMES * MIN_WINDOW_FRAME_SHARE);
+  return first.frames >= minimum && second.frames >= minimum;
+}
+function gateMisses(report) {
+  const misses = [];
+  if (report.first_frame_ms > COLD_FIRST_FRAME_MS) misses.push(`${GATE_COLD_FIRST_FRAME} failed: ${report.first_frame_ms} ms`);
+  if (!report.warm.runtime_staged) misses.push(`${GATE_WARM_FIRST_FRAME} failed: the host had no warm guest for the runtime when the player launched again`);
+  else if (report.warm.first_frame_ms > WARM_FIRST_FRAME_MS) misses.push(`${GATE_WARM_FIRST_FRAME} failed: ${report.warm.first_frame_ms} ms`);
+  if (!report.cross_origin_isolated) misses.push("the canvas is not cross-origin isolated");
+  report.windows.forEach((w, i) => {
+    const young = w.game_young_garbage_bytes + w.runtime_young_garbage_bytes;
+    if (young > YOUNG_GARBAGE_BUDGET_BYTES) {
+      misses.push(`${GATE_YOUNG_GARBAGE} failed in window ${i + 1}: ${young} bytes from ${JSON.stringify(w.young_garbage_sites)}`);
+    }
+    if (w.gc_events > GC_EVENT_BUDGET) misses.push(`${GATE_NO_COLLECTIONS} failed in window ${i + 1}: ${w.gc_events} collection events`);
+  });
+  const [first, second] = report.windows;
+  if (first !== void 0 && second !== void 0 && jitComparable(first, second) && second.jit_code_bytes > 0 && second.jit_code_bytes >= first.jit_code_bytes) {
+    misses.push(`${GATE_JIT_SETTLES} failed: ${first.jit_code_bytes} then ${second.jit_code_bytes} bytes of code-space allocation`);
+  }
+  return misses;
+}
+function gateNotices(report) {
+  const [first, second] = report.windows;
+  if (first === void 0 || second === void 0 || jitComparable(first, second)) return [];
+  return [
+    `the JIT gate was skipped: the windows drew ${first.frames} and ${second.frames} of ${MEASURED_FRAMES} frames, under ${Math.round(MIN_WINDOW_FRAME_SHARE * PERCENT)}%, so the machine was too loaded to compare them`
+  ];
+}
+function canvasMeasurements(report) {
+  let work = 0;
+  let pause = 0;
+  let growth = 0;
+  for (const w of report.windows) {
+    work = Math.max(work, w.work_ms_p99);
+    pause = Math.max(pause, w.gc_pause_ms_max);
+    growth = Math.max(growth, w.heap_growth_bytes);
+  }
+  return {
+    frame_micros_p99: Math.round(work * MICROS_PER_MS2),
+    gc_pause_micros_p99: Math.round(pause * MICROS_PER_MS2),
+    heap_growth_bytes_per_minute: Math.round(growth * MS_PER_MINUTE / WINDOW_MS)
+  };
+}
+async function warmBrowser(browser) {
+  const page = await browser.newPage();
+  await page.setContent(WARM_DOCUMENT);
+  await page.evaluate(
+    (frames) => new Promise((resolve) => {
+      const gl = document.querySelector("canvas")?.getContext("webgl2") ?? null;
+      let left = frames;
+      const paint = () => {
+        gl?.clearColor(0, 0, 0, 1);
+        gl?.clear(gl.COLOR_BUFFER_BIT);
+        if (--left <= 0) resolve();
+        else requestAnimationFrame(paint);
+      };
+      requestAnimationFrame(paint);
+    }),
+    WARM_FRAMES
+  );
+  await page.close();
+}
+var PLAYWRIGHT_PACKAGE = "playwright";
+var PINNED_PLAYWRIGHT = "1.62.1";
+var load = createRequire(import.meta.url);
+function locateChromium(bases) {
+  for (const base of bases) {
+    const dir = findPackageDir(base, PLAYWRIGHT_PACKAGE);
+    if (dir === null) continue;
+    const version = readPackageJson(dir).version;
+    if (version !== PINNED_PLAYWRIGHT) return `the build service runs Playwright ${version ?? "unknown"}; the pinned Playwright is ${PINNED_PLAYWRIGHT}`;
+    const loaded = load(dir);
+    if (loaded.chromium === void 0) return `${dir} does not export chromium`;
+    return loaded.chromium;
+  }
+  return `Playwright ${PINNED_PLAYWRIGHT} with Chromium is not installed with the build service, so engine games cannot be measured`;
+}
+
+export { BROWSER_ARGS, EMPTY_READINESS, HARDWARE_GPU_ARGS, HOLD_PARAM, SILENT_PARAM, buildReport, canvasMeasurements, codeLogArgs, devLocale, gateMisses, gateNotices, locateChromium, measureCanvas, measureLaunches, probeScript, softwareRenderer, startDevServer, warmBrowser, writeBuildOutput, writeModuleTree };