@cimplify/cli 0.15.3 → 0.17.0

package/dist/chunk-PVW5D5AW.mjs

@@ -0,0 +1,42 @@
+#!/usr/bin/env node
+import { framesFor } from './chunk-JTYVGORV.mjs';
+import { loadScript, DEFAULT_DEVICE, BACKENDS, DEFAULT_SEED, DEFAULT_FRAMES, parseDevice, parseInsets, withInsets } from './chunk-SZXO6YSX.mjs';
+import { flagString } from './chunk-XQAHREKO.mjs';
+import { CliError, CLI_ERROR_CODE } from './chunk-I7GEHLDD.mjs';
+import path from 'path';
+
+function invalid(message, remediation) {
+  return new CliError(CLI_ERROR_CODE.INVALID_INPUT, message, remediation === void 0 ? void 0 : { remediation });
+}
+function deviceFrom(spec, safe) {
+  const parsed = parseDevice(spec);
+  if (typeof parsed === "string") throw invalid(parsed);
+  if (safe === void 0) return parsed;
+  const insets = parseInsets(safe);
+  if (typeof insets === "string") throw invalid(insets);
+  return withInsets(parsed, insets);
+}
+async function commonOptions(args, root) {
+  const scriptFlag = flagString(args, "script");
+  let script = null;
+  let scriptPath = null;
+  if (scriptFlag !== void 0) {
+    scriptPath = path.relative(root, path.resolve(root, scriptFlag)) || scriptFlag;
+    try {
+      script = await loadScript(path.resolve(root, scriptFlag));
+    } catch (error) {
+      throw invalid(error.message, 'An input script is JSON or TS: { steps: [{ wait: 30 }, { tap: [195, 600] }, { capture: "menu" }] }');
+    }
+  }
+  const device = deviceFrom(flagString(args, "device") ?? script?.devices?.[0] ?? DEFAULT_DEVICE, flagString(args, "safe"));
+  const backendFlag = flagString(args, "backend") ?? "swiftshader";
+  if (!BACKENDS.includes(backendFlag)) throw invalid(`--backend is one of ${BACKENDS.join(", ")}; got "${backendFlag}"`);
+  const seedFlag = flagString(args, "seed");
+  const seed = seedFlag === void 0 ? script?.seed ?? DEFAULT_SEED : Number(seedFlag);
+  if (!Number.isInteger(seed)) throw invalid(`--seed takes an integer; got "${seedFlag}"`);
+  const frame = framesFor(flagString(args, "time"), flagString(args, "frame"), DEFAULT_FRAMES);
+  if (typeof frame === "string") throw invalid(frame);
+  return { device, backend: backendFlag, seed, scene: flagString(args, "scene") ?? script?.scene ?? null, frame, script, scriptPath };
+}
+
+export { commonOptions };

package/dist/{chunk-LZEG3FEY.mjs → chunk-QQWYQ2HS.mjs}

@@ -1,11 +1,11 @@
 #!/usr/bin/env node
-import { promptYesNo } from './chunk-TH4XENKH.mjs';
-import { gitRemoteHead, managedProviderForHost } from './chunk-UTD34C2H.mjs';
-import { TOKEN_PURPOSE, REPO_PROVIDER, isManagedRepoProvider, REPO_PROVIDER_VALUES } from './chunk-2MKZKUVH.mjs';
-import { parseArgs, flagString, flagBool } from './chunk-5KYR6WJB.mjs';
-import { ApiClient } from './chunk-NYXA6X56.mjs';
-import { readAuth, readProjectLink } from './chunk-MLE4MVYC.mjs';
-import { CliError, CLI_ERROR_CODE, isJsonMode, result, dim, success, info, bold } from './chunk-3QUK5BPY.mjs';
+import { promptYesNo } from './chunk-XASDB7YS.mjs';
+import { gitRemoteHead, managedProviderForHost } from './chunk-EOOOXVHR.mjs';
+import { TOKEN_PURPOSE, REPO_PROVIDER, isManagedRepoProvider, REPO_PROVIDER_VALUES } from './chunk-LLRUOIMU.mjs';
+import { parseArgs, flagString, flagBool } from './chunk-XQAHREKO.mjs';
+import { ApiClient } from './chunk-XBQ4LO2N.mjs';
+import { readAuth, readProjectLink } from './chunk-GGPN4QYQ.mjs';
+import { CliError, CLI_ERROR_CODE, isJsonMode, result, dim, success, info, bold } from './chunk-I7GEHLDD.mjs';
 
 // src/commands/repo.ts
 var SUB_PROVISION = "provision";

package/dist/chunk-QVR6V6QP.mjs

@@ -0,0 +1,46 @@
+#!/usr/bin/env node
+import { locateToolchain, localEngineRuntimeDir, validManifest, engineCacheRoot, cachedVersion, storeRuntime, cachedEngineRuntimeDir } from './chunk-N2WZJX5P.mjs';
+import { ApiClient } from './chunk-XBQ4LO2N.mjs';
+import { readAuthOrNull } from './chunk-GGPN4QYQ.mjs';
+import { isCliError, CLI_ERROR_CODE, info, dim, warn } from './chunk-I7GEHLDD.mjs';
+
+// src/interactives/build/engine-runtime-fetch.ts
+var ENGINE_RUNTIME_ROUTE = "/v1/interactives/engine/runtime";
+var ENGINE_RUNTIME_FILES_ROUTE = `${ENGINE_RUNTIME_ROUTE}/files`;
+var DOWNLOAD_TIMEOUT_MS = 5 * 60 * 1e3;
+async function signedInClient() {
+  const auth = await readAuthOrNull();
+  return auth === null ? null : ApiClient.fromAuth(auth);
+}
+async function ensureEngineRuntime(options) {
+  const sdkDir = locateToolchain(options.projectRoot)?.sdkDir ?? null;
+  const local = sdkDir === null ? null : localEngineRuntimeDir(sdkDir);
+  if (local !== null) return { source: "local", dir: local, version: null };
+  const client = options.client === void 0 ? await signedInClient() : options.client;
+  if (client === null) return { source: "signed_out", dir: null, version: null };
+  let manifest;
+  try {
+    manifest = await client.get(ENGINE_RUNTIME_ROUTE);
+  } catch (error) {
+    if (isCliError(error) && error.code === CLI_ERROR_CODE.NOT_FOUND) return { source: "unpublished", dir: null, version: null };
+    throw error;
+  }
+  if (!validManifest(manifest)) throw new Error("the registry returned an engine runtime manifest this CLI cannot use");
+  const root = options.root ?? engineCacheRoot();
+  const cached = cachedVersion(root, manifest.version);
+  if (cached !== null) return { source: "cached", dir: cached, version: manifest.version };
+  const download = (file) => client.getBytes(`${ENGINE_RUNTIME_FILES_ROUTE}/${file.sha256}`, { timeoutMs: DOWNLOAD_TIMEOUT_MS });
+  const dir = await storeRuntime(root, manifest, download);
+  return { source: "fetched", dir, version: manifest.version };
+}
+async function refreshEngineRuntime(projectRoot) {
+  try {
+    const fetched = await ensureEngineRuntime({ projectRoot });
+    if (fetched.source === "fetched") info(dim(`Downloaded the Cimplify Engine runtime ${fetched.version ?? ""}`));
+  } catch (error) {
+    if (cachedEngineRuntimeDir() !== null) return;
+    warn(`Could not update the Cimplify Engine runtime: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+
+export { ENGINE_RUNTIME_FILES_ROUTE, ENGINE_RUNTIME_ROUTE, ensureEngineRuntime, refreshEngineRuntime };

package/dist/chunk-SGT5IJVW.mjs

@@ -0,0 +1,28 @@
+#!/usr/bin/env node
+// src/interactives/diagnostics.ts
+function diagnostic(code, message, file, at, severity = "error") {
+  return { code, severity, message, file, line: at ? at.line : null, column: at ? at.column : null };
+}
+function hasErrors(diagnostics) {
+  for (let i = 0; i < diagnostics.length; i++) if (diagnostics[i].severity === "error") return true;
+  return false;
+}
+function formatDiagnostic(d) {
+  const where = d.file === null ? "" : d.line === null ? `${d.file}: ` : `${d.file}:${d.line}:${d.column}: `;
+  return `${where}${d.severity} ${d.code}: ${d.message}`;
+}
+function compareDiagnostics(a, b) {
+  const fa = a.file ?? "";
+  const fb = b.file ?? "";
+  if (fa !== fb) return fa < fb ? -1 : 1;
+  const la = a.line ?? 0;
+  const lb = b.line ?? 0;
+  if (la !== lb) return la - lb;
+  const ca = a.column ?? 0;
+  const cb = b.column ?? 0;
+  if (ca !== cb) return ca - cb;
+  if (a.code !== b.code) return a.code < b.code ? -1 : 1;
+  return a.message < b.message ? -1 : a.message > b.message ? 1 : 0;
+}
+
+export { compareDiagnostics, diagnostic, formatDiagnostic, hasErrors };

package/dist/chunk-SZXO6YSX.mjs

@@ -0,0 +1,502 @@
+#!/usr/bin/env node
+import { locateChromium, startDevServer, HARDWARE_GPU_ARGS, BROWSER_ARGS, probeScript, SILENT_PARAM, EMPTY_READINESS } from './chunk-XF3MGADK.mjs';
+import { inspectSnapshot } from './chunk-THATLMEX.mjs';
+import { inflateSync, deflateSync } from 'zlib';
+import { promises } from 'fs';
+import path from 'path';
+import vm from 'vm';
+import ts from 'typescript';
+
+var GOLDEN = { mean: 1.5, outliers: 5e-3 };
+var OUTLIER_DELTA = 24;
+var SIGNATURE = Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]);
+var CHANNELS = { 0: 1, 2: 3, 4: 2, 6: 4 };
+var CRC_TABLE = (() => {
+  const table = new Uint32Array(256);
+  for (let n = 0; n < 256; n++) {
+    let c = n;
+    for (let k = 0; k < 8; k++) c = c & 1 ? 3988292384 ^ c >>> 1 : c >>> 1;
+    table[n] = c >>> 0;
+  }
+  return table;
+})();
+function crc32(bytes) {
+  let c = 4294967295;
+  for (let i = 0; i < bytes.length; i++) c = CRC_TABLE[(c ^ bytes[i]) & 255] ^ c >>> 8;
+  return (c ^ 4294967295) >>> 0;
+}
+function paeth(a, b, c) {
+  const p = a + b - c;
+  const pa = Math.abs(p - a);
+  const pb = Math.abs(p - b);
+  const pc = Math.abs(p - c);
+  return pa <= pb && pa <= pc ? a : pb <= pc ? b : c;
+}
+function decodePng(data) {
+  const bytes = Buffer.from(data.buffer, data.byteOffset, data.byteLength);
+  if (bytes.length < SIGNATURE.length || !bytes.subarray(0, SIGNATURE.length).equals(SIGNATURE)) throw new Error("not a PNG file");
+  let at = SIGNATURE.length;
+  let width = 0;
+  let height = 0;
+  let depth = 0;
+  let type = 0;
+  let interlace = 0;
+  const idat = [];
+  while (at + 8 <= bytes.length) {
+    const length = bytes.readUInt32BE(at);
+    const kind = bytes.toString("latin1", at + 4, at + 8);
+    const body = bytes.subarray(at + 8, at + 8 + length);
+    if (kind === "IHDR") {
+      width = body.readUInt32BE(0);
+      height = body.readUInt32BE(4);
+      depth = body[8];
+      type = body[9];
+      interlace = body[12];
+    } else if (kind === "IDAT") idat.push(body);
+    else if (kind === "IEND") break;
+    at += 12 + length;
+  }
+  const channels = CHANNELS[type];
+  if (depth !== 8 || channels === void 0 || interlace !== 0) throw new Error(`unsupported PNG (bit depth ${depth}, colour type ${type}, interlace ${interlace})`);
+  const raw = inflateSync(Buffer.concat(idat));
+  const stride = width * channels;
+  const rows = new Uint8Array(height * stride);
+  for (let y = 0; y < height; y++) {
+    const filter = raw[y * (stride + 1)];
+    const line = raw.subarray(y * (stride + 1) + 1, (y + 1) * (stride + 1));
+    for (let x = 0; x < stride; x++) {
+      const left = x >= channels ? rows[y * stride + x - channels] : 0;
+      const up = y > 0 ? rows[(y - 1) * stride + x] : 0;
+      const corner = x >= channels && y > 0 ? rows[(y - 1) * stride + x - channels] : 0;
+      const value = line[x];
+      const predicted = filter === 1 ? left : filter === 2 ? up : filter === 3 ? left + up >> 1 : filter === 4 ? paeth(left, up, corner) : 0;
+      rows[y * stride + x] = value + predicted & 255;
+    }
+  }
+  const pixels = new Uint8Array(width * height * 4);
+  for (let i = 0; i < width * height; i++) {
+    const s = i * channels;
+    const d = i * 4;
+    if (channels >= 3) {
+      pixels[d] = rows[s];
+      pixels[d + 1] = rows[s + 1];
+      pixels[d + 2] = rows[s + 2];
+      pixels[d + 3] = channels === 4 ? rows[s + 3] : 255;
+    } else {
+      pixels[d] = pixels[d + 1] = pixels[d + 2] = rows[s];
+      pixels[d + 3] = channels === 2 ? rows[s + 1] : 255;
+    }
+  }
+  return { width, height, pixels };
+}
+function chunk(kind, body) {
+  const head = Buffer.alloc(8);
+  head.writeUInt32BE(body.length, 0);
+  head.write(kind, 4, "latin1");
+  const tail = Buffer.alloc(4);
+  tail.writeUInt32BE(crc32(Buffer.concat([head.subarray(4), body])), 0);
+  return Buffer.concat([head, body, tail]);
+}
+function encodePng(image) {
+  const header = Buffer.alloc(13);
+  header.writeUInt32BE(image.width, 0);
+  header.writeUInt32BE(image.height, 4);
+  header[8] = 8;
+  header[9] = 6;
+  const stride = image.width * 4;
+  const raw = Buffer.alloc((stride + 1) * image.height);
+  for (let y = 0; y < image.height; y++) Buffer.from(image.pixels.buffer, image.pixels.byteOffset + y * stride, stride).copy(raw, y * (stride + 1) + 1);
+  return Buffer.concat([SIGNATURE, chunk("IHDR", header), chunk("IDAT", deflateSync(raw)), chunk("IEND", new Uint8Array(0))]);
+}
+var DIM = 0.25;
+function compareImages(actual, expected, tolerance = GOLDEN) {
+  if (actual.width !== expected.width || actual.height !== expected.height) return { mean: Number.POSITIVE_INFINITY, outliers: 1, passed: false, size_matches: false, diff: null };
+  const texels = actual.width * actual.height;
+  const diff = new Uint8Array(texels * 4);
+  let total = 0;
+  let outliers = 0;
+  for (let i = 0; i < texels; i++) {
+    const at = i * 4;
+    let worst = 0;
+    for (let c = 0; c < 3; c++) {
+      const delta = Math.abs(actual.pixels[at + c] - expected.pixels[at + c]);
+      total += delta;
+      if (delta > worst) worst = delta;
+    }
+    const outlier = worst > OUTLIER_DELTA;
+    if (outlier) outliers++;
+    const grey = Math.round((expected.pixels[at] + expected.pixels[at + 1] + expected.pixels[at + 2]) / 3 * DIM);
+    diff[at] = outlier ? 255 : grey;
+    diff[at + 1] = outlier ? 0 : grey;
+    diff[at + 2] = outlier ? 255 : grey;
+    diff[at + 3] = 255;
+  }
+  const mean = total / (texels * 3);
+  const fraction = outliers / texels;
+  return { mean, outliers: fraction, passed: mean <= tolerance.mean && fraction <= tolerance.outliers, size_matches: true, diff: { width: actual.width, height: actual.height, pixels: diff } };
+}
+var SCRIPT_SCHEMA = "cimplify.input/1";
+var DEFAULT_DRAG_FRAMES = 12;
+var DEFAULT_HOLD_FRAMES = 1;
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function frames(value, where) {
+  if (typeof value !== "number" || !Number.isInteger(value) || value < 0) throw new Error(`${where} must be a whole number of frames, 0 or more`);
+  return value;
+}
+function isPoint(value) {
+  return Array.isArray(value) && value.length === 2 && value.every((v) => typeof v === "number" && Number.isFinite(v));
+}
+function point(value, where) {
+  if (isPoint(value)) return [value[0], value[1]];
+  throw new Error(`${where} must be [x, y] in points`);
+}
+function target(value, where) {
+  if (isPoint(value)) return [value[0], value[1]];
+  if (isRecord(value)) {
+    if (typeof value.node === "number" && Number.isInteger(value.node)) return { node: value.node };
+    if (typeof value.name === "string" && value.name.length > 0) return { name: value.name };
+    if (typeof value.text === "string" && value.text.length > 0) return { text: value.text };
+  }
+  throw new Error(`${where} must be [x, y] in points, { node: id }, { name: "variable" } or { text: "shown text" }`);
+}
+function step(value, index) {
+  const where = `steps[${index}]`;
+  if (!isRecord(value)) throw new Error(`${where} must be an object`);
+  const keys = Object.keys(value);
+  if ("wait" in value) return { wait: frames(value.wait, `${where}.wait`) };
+  if ("wait_ms" in value) {
+    if (typeof value.wait_ms !== "number" || value.wait_ms < 0) throw new Error(`${where}.wait_ms must be 0 or more milliseconds`);
+    return { wait_ms: value.wait_ms };
+  }
+  if ("tap" in value) return { tap: target(value.tap, `${where}.tap`), hold: value.hold === void 0 ? DEFAULT_HOLD_FRAMES : frames(value.hold, `${where}.hold`) };
+  if ("drag" in value) {
+    const drag = value.drag;
+    if (!isRecord(drag)) throw new Error(`${where}.drag must be { from, to, frames?, path? }`);
+    const from = target(drag.from, `${where}.drag.from`);
+    const to = target(drag.to, `${where}.drag.to`);
+    if (drag.path !== void 0) {
+      if (!Array.isArray(drag.path) || drag.path.length === 0) throw new Error(`${where}.drag.path must be a non-empty array of [x, y] points, one per frame`);
+      const path2 = drag.path.map((p, i) => point(p, `${where}.drag.path[${i}]`));
+      if (drag.frames !== void 0 && drag.frames !== path2.length) throw new Error(`${where}.drag.frames must equal the path length (${path2.length})`);
+      return { drag: { from, to, frames: path2.length, path: path2 } };
+    }
+    return { drag: { from, to, frames: drag.frames === void 0 ? DEFAULT_DRAG_FRAMES : Math.max(1, frames(drag.frames, `${where}.drag.frames`)) } };
+  }
+  if ("key" in value) {
+    if (typeof value.key !== "string" || value.key.length === 0) throw new Error(`${where}.key must be a key name such as "Space" or "ArrowLeft"`);
+    return { key: value.key, hold: value.hold === void 0 ? DEFAULT_HOLD_FRAMES : frames(value.hold, `${where}.hold`) };
+  }
+  if ("down" in value) return { down: point(value.down, `${where}.down`) };
+  if ("move" in value) return { move: point(value.move, `${where}.move`) };
+  if ("up" in value) {
+    if (value.up !== true) throw new Error(`${where}.up must be true`);
+    return { up: true };
+  }
+  if ("key_down" in value || "key_up" in value) {
+    const down = "key_down" in value;
+    const key = down ? value.key_down : value.key_up;
+    if (typeof key !== "string" || key.length === 0) throw new Error(`${where}.${down ? "key_down" : "key_up"} must be a key name such as "Space" or "KeyW"`);
+    return down ? { key_down: key } : { key_up: key };
+  }
+  if ("text" in value) {
+    if (typeof value.text !== "string") throw new Error(`${where}.text must be the text to type`);
+    return { text: value.text };
+  }
+  if ("type" in value) {
+    if (typeof value.type !== "string") throw new Error(`${where}.type must be the text to type`);
+    return { type: value.type };
+  }
+  if ("capture" in value) {
+    if (typeof value.capture !== "string" || !/^[a-z0-9][a-z0-9_-]*$/.test(value.capture)) throw new Error(`${where}.capture must be a name of lowercase letters, digits, - and _`);
+    return { capture: value.capture };
+  }
+  throw new Error(`${where} has no known action (${keys.join(", ")}); use wait, wait_ms, tap, drag, key, type, capture, down, move, up, key_down, key_up or text`);
+}
+function parseScript(value) {
+  const body = Array.isArray(value) ? { steps: value } : value;
+  if (!isRecord(body)) throw new Error("an input script is an array of steps or { steps: [...] }");
+  if (!Array.isArray(body.steps)) throw new Error("an input script needs a steps array");
+  const devices = body.devices ?? body.device;
+  const list = devices === void 0 ? null : Array.isArray(devices) ? devices : [devices];
+  if (list !== null && !list.every((d) => typeof d === "string")) throw new Error("devices must be device names");
+  if (body.seed !== void 0 && (typeof body.seed !== "number" || !Number.isInteger(body.seed))) throw new Error("seed must be an integer");
+  if (body.scene !== void 0 && typeof body.scene !== "string") throw new Error("scene must be a scene name");
+  if (body.max_stalls !== void 0 && (typeof body.max_stalls !== "number" || !Number.isInteger(body.max_stalls) || body.max_stalls < 0)) {
+    throw new Error("max_stalls must be a whole number of frames, 0 or more");
+  }
+  return {
+    devices: list,
+    seed: body.seed ?? null,
+    scene: body.scene ?? null,
+    steps: body.steps.map(step),
+    max_stalls: body.max_stalls ?? null
+  };
+}
+function evaluateModule(source, file) {
+  const js = ts.transpileModule(source, { compilerOptions: { module: ts.ModuleKind.CommonJS, target: ts.ScriptTarget.ES2022 }, fileName: file }).outputText;
+  const module = { exports: {} };
+  const context = vm.createContext({ module, exports: module.exports });
+  vm.runInContext(js, context, { filename: file, timeout: 1e3 });
+  const exported = module.exports;
+  return "default" in exported ? exported.default : exported;
+}
+async function loadScript(file) {
+  const text = await promises.readFile(file, "utf8");
+  const ext = path.extname(file);
+  try {
+    const value = ext === ".json" ? JSON.parse(text) : evaluateModule(text, file);
+    return parseScript(value);
+  } catch (error) {
+    throw new Error(`${file}: ${error.message}`);
+  }
+}
+
+// src/interactives/inspect/session.ts
+var FRAME_MS = 1e3 / 60;
+var DEFAULT_SEED = 1;
+var DEFAULT_EPOCH_MS = Date.UTC(2026, 0, 1);
+var DEFAULT_FRAMES = 60;
+var BACKENDS = ["swiftshader", "hardware"];
+var READY_TIMEOUT_MS = 6e4;
+var POLL_MS = 100;
+var LOCAL_HOST = "127.0.0.1";
+var ANY_PORT = 0;
+var MAX_NODES = 4096;
+var ERRORS_SELECTOR = "#errors";
+async function playStep(step2, driver) {
+  const mouse = driver.mouse;
+  const keyboard = driver.keyboard;
+  if ("wait" in step2) await driver.step(step2.wait);
+  else if ("wait_ms" in step2) await driver.step(Math.round(step2.wait_ms / FRAME_MS));
+  else if ("tap" in step2) {
+    const [x, y] = await driver.resolve(step2.tap);
+    await mouse.move(x, y);
+    await mouse.down();
+    await driver.step(step2.hold ?? DEFAULT_HOLD_FRAMES);
+    await mouse.up();
+    await driver.step(1);
+  } else if ("drag" in step2) {
+    const from = await driver.resolve(step2.drag.from);
+    const to = await driver.resolve(step2.drag.to);
+    const path2 = step2.drag.path;
+    const frames2 = path2?.length ?? step2.drag.frames ?? DEFAULT_DRAG_FRAMES;
+    await mouse.move(from[0], from[1]);
+    await mouse.down();
+    await driver.step(1);
+    for (let i = 1; i <= frames2; i++) {
+      if (path2 !== void 0) await mouse.move(path2[i - 1][0], path2[i - 1][1]);
+      else await mouse.move(from[0] + (to[0] - from[0]) * i / frames2, from[1] + (to[1] - from[1]) * i / frames2);
+      await driver.step(1);
+    }
+    await mouse.up();
+    await driver.step(1);
+  } else if ("key" in step2) {
+    await keyboard.down(step2.key);
+    await driver.step(step2.hold ?? DEFAULT_HOLD_FRAMES);
+    await keyboard.up(step2.key);
+    await driver.step(1);
+  } else if ("type" in step2) {
+    await keyboard.type(step2.type);
+    await driver.step(1);
+  } else if ("down" in step2) {
+    await mouse.move(step2.down[0], step2.down[1]);
+    await mouse.down();
+  } else if ("move" in step2) await mouse.move(step2.move[0], step2.move[1]);
+  else if ("up" in step2) await mouse.up();
+  else if ("key_down" in step2) await keyboard.down(step2.key_down);
+  else if ("key_up" in step2) await keyboard.up(step2.key_up);
+  else if ("text" in step2) await keyboard.type(step2.text);
+  else await driver.capture(step2.capture);
+}
+var SessionError = class extends Error {
+};
+var CaptureSession = class _CaptureSession {
+  constructor(options, server, browser, context, page) {
+    this.options = options;
+    this.server = server;
+    this.browser = browser;
+    this.context = context;
+    this.page = page;
+  }
+  options;
+  server;
+  browser;
+  context;
+  page;
+  guest = null;
+  frame = 0;
+  cssSafeArea = false;
+  static async open(setup, options) {
+    const chromium = locateChromium([setup.toolchain.base, setup.toolchain.sdkDir]);
+    if (typeof chromium === "string") throw new SessionError(chromium);
+    const server = await startDevServer({ root: setup.root, host: LOCAL_HOST, port: ANY_PORT, watch: false, build: setup.build, packagesRoot: setup.toolchain.base });
+    let browser = null;
+    try {
+      browser = await chromium.launch({ headless: true, args: options.backend === "hardware" ? HARDWARE_GPU_ARGS : BROWSER_ARGS });
+      const device = options.device;
+      const context = await browser.newContext({ viewport: { width: device.width, height: device.height }, deviceScaleFactor: device.scale, hasTouch: device.touch });
+      await context.addInitScript({
+        content: probeScript({ seed: options.seed, epoch: DEFAULT_EPOCH_MS, frame_ms: FRAME_MS, insets: device.insets, bare: true, scene: options.scene, max_nodes: MAX_NODES })
+      });
+      const page = await context.newPage();
+      const session = new _CaptureSession(options, server, browser, context, page);
+      await session.overrideSafeArea();
+      await page.goto(`${server.url}/?${SILENT_PARAM}`);
+      await session.waitReady();
+      return session;
+    } catch (error) {
+      await browser?.close();
+      await server.close();
+      throw error;
+    }
+  }
+  async overrideSafeArea() {
+    const insets = this.options.device.insets;
+    try {
+      const cdp = await this.context.newCDPSession(this.page);
+      await cdp.send("Emulation.setSafeAreaInsetsOverride", {
+        insets: { top: insets.top, topMax: insets.top, right: insets.right, rightMax: insets.right, bottom: insets.bottom, bottomMax: insets.bottom, left: insets.left, leftMax: insets.left }
+      });
+      this.cssSafeArea = true;
+    } catch {
+      this.cssSafeArea = false;
+    }
+  }
+  async pageErrors() {
+    return (await this.page.locator(ERRORS_SELECTOR).textContent() ?? "").trim();
+  }
+  async waitReady() {
+    const deadline = Date.now() + READY_TIMEOUT_MS;
+    while (Date.now() < deadline) {
+      for (const frame of this.page.frames()) {
+        const state = await frame.evaluate(() => {
+          const probe = globalThis.__cimplify_probe;
+          if (probe === void 0 || !probe.guest) return { ready: false, refused: null };
+          return { ready: probe.ready(), refused: probe.refused() };
+        }, void 0).catch(() => ({ ready: false, refused: null }));
+        if (state.refused !== null) throw new SessionError(state.refused);
+        if (state.ready) {
+          this.guest = frame;
+          return;
+        }
+      }
+      const errors = await this.pageErrors();
+      if (errors.length > 0) throw new SessionError(`the game failed to start: ${errors}`);
+      await new Promise((resolve) => setTimeout(resolve, POLL_MS));
+    }
+    throw new SessionError(`the game did not start its engine within ${READY_TIMEOUT_MS / 1e3} s`);
+  }
+  get frameHandle() {
+    if (this.guest === null) throw new SessionError("the game frame is not ready");
+    return this.guest;
+  }
+  async step(frames2) {
+    if (frames2 <= 0) return;
+    const frame = this.frameHandle;
+    try {
+      this.frame = await frame.evaluate((n) => globalThis.__cimplify_probe.step(n), frames2);
+    } catch (error) {
+      const refused = await frame.evaluate(() => globalThis.__cimplify_probe.refused(), void 0).catch(() => null);
+      if (refused !== null) throw new SessionError(refused);
+      throw error;
+    }
+  }
+  async advanceTo(frame) {
+    await this.step(frame - this.frame);
+  }
+  async loopSamples() {
+    return this.frameHandle.evaluate(() => {
+      const probe = globalThis.__cimplify_loop_probe;
+      return probe?.samples?.() ?? {};
+    }, void 0).catch(() => ({}));
+  }
+  async readiness() {
+    return this.frameHandle.evaluate(() => {
+      const probe = globalThis.__cimplify_readiness_probe;
+      return probe?.report?.() ?? null;
+    }, void 0).then((report) => report ?? EMPTY_READINESS).catch(() => EMPTY_READINESS);
+  }
+  async snapshot() {
+    return this.frameHandle.evaluate(() => globalThis.__cimplify_probe.snapshot(), void 0);
+  }
+  driver() {
+    const frame = this.frameHandle;
+    return {
+      open: () => frame.evaluate(() => globalThis.__cimplify_probe.shadowOpen(), void 0),
+      apply: (patch) => frame.evaluate((p) => globalThis.__cimplify_probe.shadowApply(p), patch),
+      frame: (dt, full) => frame.evaluate(([d, f]) => globalThis.__cimplify_probe.shadowFrame(d, f), [dt, full]),
+      close: () => frame.evaluate(() => globalThis.__cimplify_probe.shadowClose(), void 0)
+    };
+  }
+  async screenshot() {
+    await this.page.mainFrame().evaluate(
+      () => new Promise((resolve) => {
+        const scope = globalThis;
+        scope.requestAnimationFrame(() => scope.requestAnimationFrame(() => resolve()));
+      }),
+      void 0
+    );
+    return this.page.screenshot({ type: "png" });
+  }
+  async inspect(png) {
+    const screenshot = png === null ? null : decodePng(png);
+    return inspectSnapshot(await this.snapshot(), this.driver(), this.options.device, screenshot);
+  }
+  async resolve(target2) {
+    if (Array.isArray(target2)) return target2;
+    const { report } = await this.inspect(null);
+    const visible = report.nodes.filter((n) => n.visible && n.rect !== null);
+    const t = target2;
+    const match = t.node !== void 0 ? visible.find((n) => n.id === t.node) : t.name !== void 0 ? visible.find((n) => n.name === t.name) : visible.find((n) => n.text === t.text) ?? visible.find((n) => n.text !== null && t.text !== void 0 && n.text.includes(t.text));
+    if (match === void 0 || match.rect === null) throw new SessionError(`no visible node matches ${JSON.stringify(target2)} at frame ${this.frame}`);
+    return [match.rect.x + match.rect.width / 2, match.rect.y + match.rect.height / 2];
+  }
+  async perform(step2, onCapture) {
+    await playStep(step2, { mouse: this.page.mouse, keyboard: this.page.keyboard, step: (frames2) => this.step(frames2), resolve: (target2) => this.resolve(target2), capture: onCapture });
+  }
+  async run(script, onCapture) {
+    for (const step2 of script.steps) await this.perform(step2, onCapture);
+  }
+  async close() {
+    await this.page.close().catch(() => {
+    });
+    await this.context.close().catch(() => {
+    });
+    await this.browser.close().catch(() => {
+    });
+    await this.server.close();
+  }
+};
+
+// src/interactives/inspect/devices.ts
+var NO_INSETS = { top: 0, right: 0, bottom: 0, left: 0 };
+var DEVICES = {
+  "phone-portrait": { name: "phone-portrait", width: 390, height: 844, scale: 3, insets: { top: 47, right: 0, bottom: 34, left: 0 }, touch: true },
+  "phone-landscape": { name: "phone-landscape", width: 844, height: 390, scale: 3, insets: { top: 0, right: 47, bottom: 21, left: 47 }, touch: true },
+  "phone-small": { name: "phone-small", width: 375, height: 667, scale: 2, insets: { top: 20, right: 0, bottom: 0, left: 0 }, touch: true },
+  tablet: { name: "tablet", width: 820, height: 1180, scale: 2, insets: { top: 24, right: 0, bottom: 20, left: 0 }, touch: true },
+  "tablet-landscape": { name: "tablet-landscape", width: 1180, height: 820, scale: 2, insets: { top: 24, right: 0, bottom: 20, left: 0 }, touch: true }
+};
+var DEFAULT_DEVICE = "phone-portrait";
+var CHECK_DEVICES = ["phone-portrait", "phone-landscape", "tablet"];
+var CUSTOM = /^(\d{2,5})x(\d{2,5})(?:@(\d(?:\.\d+)?))?$/;
+function parseDevice(spec) {
+  const known = DEVICES[spec];
+  if (known !== void 0) return known;
+  const match = CUSTOM.exec(spec);
+  if (match === null) return `unknown device "${spec}"; use one of ${Object.keys(DEVICES).join(", ")} or WIDTHxHEIGHT[@SCALE]`;
+  const scale = match[3] === void 0 ? 1 : Number(match[3]);
+  return { name: spec, width: Number(match[1]), height: Number(match[2]), scale, insets: NO_INSETS, touch: false };
+}
+function withInsets(device, insets) {
+  return { ...device, insets };
+}
+function parseInsets(spec) {
+  const parts = spec.split(",").map((p) => Number(p.trim()));
+  if (parts.length !== 4 || parts.some((p) => !Number.isFinite(p) || p < 0)) return `--safe takes four non-negative numbers, top,right,bottom,left; got "${spec}"`;
+  return { top: parts[0], right: parts[1], bottom: parts[2], left: parts[3] };
+}
+
+export { BACKENDS, CHECK_DEVICES, CaptureSession, DEFAULT_DEVICE, DEFAULT_DRAG_FRAMES, DEFAULT_EPOCH_MS, DEFAULT_FRAMES, DEFAULT_HOLD_FRAMES, DEFAULT_SEED, DEVICES, FRAME_MS, GOLDEN, SCRIPT_SCHEMA, SessionError, compareImages, decodePng, encodePng, loadScript, parseDevice, parseInsets, withInsets };