@cimplify/cli 0.15.3 → 0.17.0

package/dist/{projects-YL4T24VV.mjs → projects-HYITVEXS.mjs}

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
-import { managedProviderForHost } from './chunk-UTD34C2H.mjs';
-import { REPO_PROVIDER, isManagedRepoProvider } from './chunk-2MKZKUVH.mjs';
-import { parseArgs, flagString, flagBool } from './chunk-5KYR6WJB.mjs';
-import { ApiClient } from './chunk-NYXA6X56.mjs';
-import { readAuth } from './chunk-MLE4MVYC.mjs';
-import { CliError, CLI_ERROR_CODE, info, dim, result, bold, success } from './chunk-3QUK5BPY.mjs';
+import { managedProviderForHost } from './chunk-EOOOXVHR.mjs';
+import { REPO_PROVIDER, isManagedRepoProvider } from './chunk-LLRUOIMU.mjs';
+import { parseArgs, flagString, flagBool } from './chunk-XQAHREKO.mjs';
+import { ApiClient } from './chunk-XBQ4LO2N.mjs';
+import { readAuth } from './chunk-GGPN4QYQ.mjs';
+import { CliError, CLI_ERROR_CODE, info, dim, result, bold, success } from './chunk-I7GEHLDD.mjs';
 
 // src/commands/projects.ts
 var SUB_LS = "ls";

package/dist/publish-DZRR5A5X.mjs

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+export { checkAllowance, run as default, keyLabel, parseChannel, progressPrinter, publishProject, registeredSigningKey } from './chunk-TYR4Q37L.mjs';
+import './chunk-XZG3DTXV.mjs';
+import './chunk-JNCEKW2Y.mjs';
+import './chunk-BTNVYAC4.mjs';
+import './chunk-VHK7WBO3.mjs';
+import './chunk-454RQ6NR.mjs';
+import './chunk-JKECUAAV.mjs';
+import './chunk-HQPZQIWW.mjs';
+import './chunk-KQNZKV6E.mjs';
+import './chunk-QVR6V6QP.mjs';
+import './chunk-N2WZJX5P.mjs';
+import './chunk-EYEMPIMP.mjs';
+import './chunk-BGM7CH5G.mjs';
+import './chunk-25ZPFHLF.mjs';
+import './chunk-SGT5IJVW.mjs';
+import './chunk-XQAHREKO.mjs';
+import './chunk-XBQ4LO2N.mjs';
+import './chunk-GGPN4QYQ.mjs';
+import './chunk-I7GEHLDD.mjs';

package/dist/remix-4HVXRIEB.mjs

@@ -0,0 +1,125 @@
+#!/usr/bin/env node
+import { CliError, CLI_ERROR_CODE, info, bold, result, success, dim } from './chunk-I7GEHLDD.mjs';
+import { existsSync, statSync, readFileSync, writeFileSync } from 'fs';
+import path from 'path';
+import { SLOT_TEMPLATES, templateFromSchema, decodeRemix, remixDigest, memoryRemixSources, assignSlots, remix, slotChoices, templateSlotsEnabled, TemplateSlotError, describeIssue, TEMPLATE_SLOTS_FLAG } from '@cimplify/sdk/game/kit/slots';
+
+var SCHEMA_FILE = "template.json";
+var SET_FLAG = "--set";
+var PARENT_FLAG = "--parent";
+var OUT_FLAG = "--out";
+var GLOBAL_FLAGS = /* @__PURE__ */ new Set(["--json", "--yes", "-y"]);
+var UTF8 = "utf8";
+var DIGEST_PREVIEW = 19;
+function invalid(message, remediation) {
+  return new CliError(CLI_ERROR_CODE.INVALID_INPUT, message, remediation === void 0 ? {} : { remediation });
+}
+function parseRemixArgs(argv) {
+  const sets = [];
+  let template = null;
+  let parent = null;
+  let out = null;
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    const [flag, inline] = arg.startsWith("--") && arg.includes("=") && !arg.startsWith(`${SET_FLAG}=`) ? [arg.slice(0, arg.indexOf("=")), arg.slice(arg.indexOf("=") + 1)] : [arg, null];
+    const value = () => {
+      if (inline !== null) return inline;
+      const next = argv[++i];
+      if (next === void 0) throw invalid(`${flag} needs a value`);
+      return next;
+    };
+    if (GLOBAL_FLAGS.has(arg)) continue;
+    if (arg.startsWith(`${SET_FLAG}=`)) sets.push(arg.slice(SET_FLAG.length + 1));
+    else if (flag === SET_FLAG) sets.push(value());
+    else if (flag === PARENT_FLAG) parent = value();
+    else if (flag === OUT_FLAG) out = value();
+    else if (arg.startsWith("--")) throw invalid(`unknown flag ${flag}`, "cimplify remix <template> [--set slot=value]... [--parent <remix.json>] [--out <remix.json>]");
+    else if (template === null) template = arg;
+    else throw invalid(`unexpected argument ${arg}`);
+  }
+  return { template, sets, parent, out };
+}
+function readJson(file, what) {
+  try {
+    return JSON.parse(readFileSync(file, UTF8));
+  } catch (error) {
+    throw invalid(`could not read ${what} ${file}: ${error.message}`);
+  }
+}
+function slotError(error) {
+  if (error instanceof TemplateSlotError || error instanceof Error && error.name === "TemplateSlotError") return invalid(error.issues.map(describeIssue).join("\n"), "run cimplify remix <template> without --set to list each slot and what fits it");
+  if (error instanceof Error && error.name === "RemixError") return invalid(error.message);
+  return error;
+}
+function loadTemplate(name, cwd) {
+  if (name !== null && SLOT_TEMPLATES[name] !== void 0) return SLOT_TEMPLATES[name];
+  const target = path.resolve(cwd, name ?? ".");
+  const file = existsSync(target) && statSync(target).isDirectory() ? path.join(target, SCHEMA_FILE) : target;
+  if (!existsSync(file)) {
+    const known = Object.keys(SLOT_TEMPLATES).join(", ");
+    throw new CliError(CLI_ERROR_CODE.NOT_FOUND, `${name ?? "this folder"} is not a slotted template: not one of ${known} and no ${SCHEMA_FILE} at ${file}`, {
+      remediation: `name a built-in template (${known}) or a folder with ${SCHEMA_FILE}`
+    });
+  }
+  try {
+    return templateFromSchema(readJson(file, "template schema"));
+  } catch (error) {
+    throw slotError(error);
+  }
+}
+function loadParent(file) {
+  const raw = readJson(file, "parent remix");
+  if (raw === null || typeof raw !== "object" || raw.manifest === void 0) throw invalid(`${file} is not a remix written by cimplify remix --out`);
+  try {
+    const manifest = decodeRemix(raw.manifest);
+    const lineage = (raw.lineage ?? []).map((m) => decodeRemix(m));
+    return { template: manifest.template, digest: remixDigest(manifest), manifest, lineage, content: raw.content ?? {} };
+  } catch (error) {
+    throw slotError(error);
+  }
+}
+function remixBundle(t, sets, parent, readFile) {
+  const sources = memoryRemixSources();
+  if (parent !== null) for (const manifest of [parent.manifest, ...parent.lineage]) sources.add({ manifest, digest: remixDigest(manifest), content: parent.content });
+  try {
+    const set = assignSlots(t, sets, { readFile });
+    const made = remix(t, set, { parent: parent?.manifest ?? null, sources });
+    return {
+      template: t.ref,
+      digest: made.digest,
+      manifest: made.manifest,
+      lineage: parent === null ? [] : [parent.manifest, ...parent.lineage],
+      content: { ...parent?.content ?? {}, ...made.content }
+    };
+  } catch (error) {
+    throw slotError(error);
+  }
+}
+function describeSlots(t) {
+  return Object.keys(t.slots).map((slot) => `${slot.padEnd(8)} ${slotChoices(t, slot)}`);
+}
+async function run(argv) {
+  if (!templateSlotsEnabled(process.env)) {
+    throw invalid(`cimplify remix is switched off by ${TEMPLATE_SLOTS_FLAG}`, `unset ${TEMPLATE_SLOTS_FLAG} to use template slots`);
+  }
+  const args = parseRemixArgs(argv);
+  const cwd = process.cwd();
+  const t = loadTemplate(args.template, cwd);
+  if (args.sets.length === 0 && args.parent === null) {
+    info(bold(`${t.title} (${t.ref})`));
+    for (const line of describeSlots(t)) info(line);
+    result({ template: t.ref, slots: Object.fromEntries(Object.keys(t.slots).map((slot) => [slot, slotChoices(t, slot)])) });
+    return;
+  }
+  const parent = args.parent === null ? null : loadParent(path.resolve(cwd, args.parent));
+  const bundle = remixBundle(t, args.sets, parent, (file) => readFileSync(path.resolve(cwd, file), UTF8));
+  if (args.out !== null) writeFileSync(path.resolve(cwd, args.out), `${JSON.stringify(bundle, null, 2)}
+`);
+  success(`remix ${bundle.digest.slice(0, DIGEST_PREVIEW)} of ${bundle.template}`);
+  for (const [slot, ref] of Object.entries(bundle.manifest.slots)) info(`${slot.padEnd(8)} ${typeof ref === "string" ? ref : JSON.stringify(ref)}`);
+  if (bundle.lineage.length > 0) info(dim(`remixes ${bundle.lineage.map((m) => remixDigest(m).slice(0, DIGEST_PREVIEW)).join(" <- ")}`));
+  if (args.out !== null) info(dim(`wrote ${args.out}`));
+  result(bundle);
+}
+
+export { run as default, describeSlots, loadParent, loadTemplate, parseRemixArgs, remixBundle };

package/dist/repo-FG3CMZQS.mjs

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+export { run as default, fetchCloneToken, fetchRepoRecord } from './chunk-QQWYQ2HS.mjs';
+import './chunk-XASDB7YS.mjs';
+import './chunk-EOOOXVHR.mjs';
+import './chunk-LLRUOIMU.mjs';
+import './chunk-XQAHREKO.mjs';
+import './chunk-XBQ4LO2N.mjs';
+import './chunk-GGPN4QYQ.mjs';
+import './chunk-I7GEHLDD.mjs';

package/dist/report-M7F4ZYP7.mjs

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export { compactReport, inspectSnapshot, patchesOf } from './chunk-THATLMEX.mjs';

package/dist/rollback-H7Q4XYGX.mjs

@@ -0,0 +1,43 @@
+#!/usr/bin/env node
+import { parseChannel } from './chunk-TYR4Q37L.mjs';
+import { renderStatus } from './chunk-6KKLF5KG.mjs';
+import { remoteFromEnv } from './chunk-XZG3DTXV.mjs';
+import { readInteractiveId, remoteCall } from './chunk-JNCEKW2Y.mjs';
+import { requireInteractiveProject } from './chunk-BTNVYAC4.mjs';
+import './chunk-VHK7WBO3.mjs';
+import './chunk-454RQ6NR.mjs';
+import './chunk-JKECUAAV.mjs';
+import './chunk-HQPZQIWW.mjs';
+import './chunk-KQNZKV6E.mjs';
+import './chunk-QVR6V6QP.mjs';
+import './chunk-N2WZJX5P.mjs';
+import './chunk-EYEMPIMP.mjs';
+import './chunk-BGM7CH5G.mjs';
+import './chunk-25ZPFHLF.mjs';
+import './chunk-SGT5IJVW.mjs';
+import { parseArgs, flagString } from './chunk-XQAHREKO.mjs';
+import './chunk-XBQ4LO2N.mjs';
+import './chunk-GGPN4QYQ.mjs';
+import { CliError, CLI_ERROR_CODE, success, info, result } from './chunk-I7GEHLDD.mjs';
+
+// src/interactives/commands/rollback.ts
+async function rollbackInteractive(root, remote, revision, channel) {
+  const id = await readInteractiveId(root);
+  return remoteCall(() => remote.rollback(id, revision, channel));
+}
+async function run(argv) {
+  const args = parseArgs(argv);
+  const revision = args.positional[0];
+  if (!revision) {
+    throw new CliError(CLI_ERROR_CODE.INVALID_INPUT, "usage: cimplify rollback <revision> [--channel live|test]");
+  }
+  const root = process.cwd();
+  requireInteractiveProject(root, "rollback");
+  const channel = parseChannel(flagString(args, "channel"));
+  const status = await rollbackInteractive(root, await remoteFromEnv(), revision, channel);
+  success(`${channel} now points at ${revision}`);
+  for (const line of renderStatus(status)) info(line);
+  result(status);
+}
+
+export { run as default, rollbackInteractive };

package/dist/{rollback-47VQ4HJK.mjs → rollback-OM64O67F.mjs}

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
-import { pollDeployment } from './chunk-O2TO2J4I.mjs';
-import { DEPLOYMENT_STATUS, DEPLOY_TRIGGER } from './chunk-2MKZKUVH.mjs';
-import { parseArgs, flagBool } from './chunk-5KYR6WJB.mjs';
-import { ApiClient } from './chunk-NYXA6X56.mjs';
-import { readAuth, readProjectLink, writeProjectState } from './chunk-MLE4MVYC.mjs';
-import { CliError, CLI_ERROR_CODE, step, success, info, dim, result, EXIT_CODE } from './chunk-3QUK5BPY.mjs';
+import { pollDeployment } from './chunk-6CQMRZ2W.mjs';
+import { DEPLOYMENT_STATUS, DEPLOY_TRIGGER } from './chunk-LLRUOIMU.mjs';
+import { parseArgs, flagBool } from './chunk-XQAHREKO.mjs';
+import { ApiClient } from './chunk-XBQ4LO2N.mjs';
+import { readAuth, readProjectLink, writeProjectState } from './chunk-GGPN4QYQ.mjs';
+import { CliError, CLI_ERROR_CODE, step, success, info, dim, result, EXIT_CODE } from './chunk-I7GEHLDD.mjs';
 
 // src/commands/rollback.ts
 var FLAG_NO_POLL = "no-poll";

package/dist/scene-QTHT3ZPL.mjs

@@ -0,0 +1,324 @@
+#!/usr/bin/env node
+import { scenesEnabled, SCENES_FLAG, compileSites, formatSceneDiagnostic } from './chunk-VHK7WBO3.mjs';
+import './chunk-SGT5IJVW.mjs';
+import { parseArgs, flagString, flagBool } from './chunk-XQAHREKO.mjs';
+import { ApiClient, isServiceUnavailable } from './chunk-XBQ4LO2N.mjs';
+import { readAuthOrNull } from './chunk-GGPN4QYQ.mjs';
+import { CliError, CLI_ERROR_CODE, result, info, dim, warn, success, failure, bold } from './chunk-I7GEHLDD.mjs';
+import { existsSync, promises } from 'fs';
+import path2 from 'path';
+import { fileURLToPath } from 'url';
+
+var RESOLVE_PATH = "/v1/content/scenes/resolve";
+var RESOLVE_USAGE = "cimplify scene resolve <file> [--json] [--out <assets.json>] [--tier low|mid|high] [--no-generate] [--wait <seconds>] [--export name]";
+var ASSETS_SUFFIX = ".assets.json";
+var DEFAULT_WAIT_MS = 15 * 60 * 1e3;
+var POLL_MS = 5e3;
+var ASSETS_VERSION = 1;
+var BUSY_ATTEMPTS = 5;
+var BUSY_PAUSE_MS = 1e3;
+var MM_PER_METRE = 1e3;
+var MS_PER_SECOND = 1e3;
+var DEFAULT_STYLE = "default";
+var STYLE_SHAPE = /^[a-z0-9_-]+$/;
+var TIERS = ["low", "mid", "high"];
+var SIZE_CEILINGS = [
+  ["tiny", 0.5],
+  ["small", 1.5],
+  ["medium", 4],
+  ["large", 12]
+];
+var UNRESOLVED_EXIT = 1;
+var HttpSceneAssetsRemote = class {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  async resolve(requests, retry) {
+    for (let attempt = 1; ; attempt++) {
+      try {
+        const body = await this.client.post(RESOLVE_PATH, { requests, retry });
+        return body.resolutions;
+      } catch (error) {
+        if (!isServiceUnavailable(error) || attempt >= BUSY_ATTEMPTS) throw error;
+        await new Promise((done) => setTimeout(done, BUSY_PAUSE_MS * attempt));
+      }
+    }
+  }
+};
+function sizeClassOf(footprintMm) {
+  const metres = Math.max(footprintMm[0], footprintMm[1]) / MM_PER_METRE;
+  for (const [size, ceiling] of SIZE_CEILINGS) if (metres < ceiling) return size;
+  return "huge";
+}
+function styleOf(style) {
+  const trimmed = style.trim().toLowerCase();
+  return trimmed.length > 0 && STYLE_SHAPE.test(trimmed) ? trimmed : DEFAULT_STYLE;
+}
+function kindsOfWire(wire) {
+  return {
+    scene: wire.name,
+    style: styleOf(wire.style),
+    kinds: wire.kinds.map((k) => ({ name: k.name, footprint_mm: [k.footprint[0], k.footprint[1]], height_mm: k.height }))
+  };
+}
+function kindsOfReport(report, catalogue) {
+  const names = [...new Set(report.placements.map((p) => p.kind))].sort();
+  const kinds = names.map((name) => {
+    const meta = catalogue[name];
+    if (meta === void 0) throw new CliError(CLI_ERROR_CODE.INVALID_INPUT, `the report names ${name}, which is not in the catalogue`, { remediation: "resolve from the scene source or its wire IR instead" });
+    return {
+      name,
+      footprint_mm: [Math.round(meta.footprint[0] * MM_PER_METRE), Math.round(meta.footprint[1] * MM_PER_METRE)],
+      height_mm: Math.round(meta.height * MM_PER_METRE)
+    };
+  });
+  return { scene: report.scene, style: styleOf(report.style), kinds };
+}
+function requestsOf(kinds, options) {
+  return kinds.kinds.map((k) => ({
+    kind: k.name,
+    style: kinds.style,
+    size_class: sizeClassOf(k.footprint_mm),
+    dimensions: { footprint_mm: k.footprint_mm, height_mm: k.height_mm },
+    constraints: {
+      ...options.tier === void 0 ? {} : { tier: options.tier },
+      allow_generation: options.allowGeneration,
+      human_made_only: false
+    }
+  }));
+}
+async function resolveAll(requests, remote, options) {
+  const resolutions = [...await remote.resolve(requests, true)];
+  const deadline = options.now() + options.waitMs;
+  for (; ; ) {
+    const open = resolutions.map((r, i) => r.status === "pending" ? i : -1).filter((i) => i >= 0);
+    if (open.length === 0 || options.now() >= deadline) return resolutions;
+    options.onPending?.(open.length);
+    await options.sleep(options.pollMs);
+    const again = await remote.resolve(
+      open.map((i) => requests[i]),
+      false
+    );
+    open.forEach((at, i) => {
+      const earlier = resolutions[at];
+      const next = again[i];
+      resolutions[at] = { ...next, units_charged: earlier.units_charged + next.units_charged };
+    });
+  }
+}
+function assetsReport(kinds, resolutions) {
+  const assets = kinds.kinds.map((k, i) => {
+    const r = resolutions[i];
+    return {
+      kind: k.name,
+      status: r.status,
+      cached: r.cached,
+      units_charged: r.units_charged,
+      ...r.asset === void 0 ? {} : { asset: r.asset },
+      ...r.reason === void 0 ? {} : { reason: r.reason }
+    };
+  });
+  const unresolved = assets.filter((a) => a.status !== "resolved").map((a) => a.kind);
+  return {
+    version: ASSETS_VERSION,
+    scene: kinds.scene,
+    style: kinds.style,
+    status: unresolved.length === 0 ? "resolved" : "partial",
+    units_charged: assets.reduce((sum, a) => sum + a.units_charged, 0),
+    assets,
+    models: assets.flatMap((a) => a.asset === void 0 ? [] : [{ name: a.kind, item: `${a.asset.item}@${a.asset.version}`, version_digest: a.asset.version_digest }]),
+    unresolved
+  };
+}
+function isWire(value) {
+  return typeof value === "object" && value !== null && Array.isArray(value.kinds) && typeof value.name === "string";
+}
+function isReport(value) {
+  return typeof value === "object" && value !== null && Array.isArray(value.placements) && typeof value.scene === "string";
+}
+async function sceneKindsOf(file, exportName) {
+  const absolute = path2.resolve(file);
+  const text = await promises.readFile(absolute, "utf8").catch(() => {
+    throw new CliError(CLI_ERROR_CODE.NOT_FOUND, `cannot read ${file}`);
+  });
+  const sdk = await import('@cimplify/sdk/game');
+  if (absolute.endsWith(".json")) {
+    let parsed;
+    try {
+      parsed = JSON.parse(text);
+    } catch {
+      throw new CliError(CLI_ERROR_CODE.INVALID_INPUT, `${file} is not JSON`);
+    }
+    if (isWire(parsed)) return kindsOfWire(parsed);
+    if (isReport(parsed)) return kindsOfReport(parsed, sdk.STARTER_CATALOGUE);
+    throw new CliError(CLI_ERROR_CODE.INVALID_INPUT, `${file} is neither a scene wire IR nor a placement report`);
+  }
+  const relative = path2.relative(process.cwd(), absolute) || file;
+  const compiled = compileSites(relative, text, (def) => sdk.compileScene(def));
+  const { pickSite: pickSite2 } = await import('./scene-QTHT3ZPL.mjs');
+  const site = pickSite2(compiled.sites, exportName);
+  const wire = compiled.compiled[compiled.sites.indexOf(site)]?.wire ?? null;
+  if (wire === null) throw new CliError(CLI_ERROR_CODE.INVALID_INPUT, `${relative}: the scene does not compile; run cimplify scene solve for its diagnostics`);
+  return kindsOfWire(wire);
+}
+function tierOf(raw) {
+  if (raw === void 0) return void 0;
+  if (!TIERS.includes(raw)) throw new CliError(CLI_ERROR_CODE.INVALID_INPUT, `--tier must be one of ${TIERS.join(", ")}`);
+  return raw;
+}
+function waitOf(raw) {
+  if (raw === void 0) return DEFAULT_WAIT_MS;
+  const seconds = Number(raw);
+  if (!Number.isFinite(seconds) || seconds < 0) throw new CliError(CLI_ERROR_CODE.INVALID_INPUT, "--wait must be a number of seconds");
+  return seconds * MS_PER_SECOND;
+}
+function describe(a) {
+  if (a.asset !== void 0) {
+    const origin = a.asset.from === "generated" ? "generated" : "library";
+    return `${a.asset.item}@${a.asset.version} ${dim(`${origin}, fit ${a.asset.fit}${a.cached ? ", cached" : ""}`)}`;
+  }
+  return a.status === "pending" ? "still generating" : `unresolved${a.reason === void 0 ? "" : `: ${a.reason}`}`;
+}
+async function runSceneResolve(argv, remote) {
+  const args = parseArgs(argv);
+  const [file] = args.positional;
+  if (file === void 0) throw new CliError(CLI_ERROR_CODE.INVALID_INPUT, `usage: ${RESOLVE_USAGE}`);
+  const kinds = await sceneKindsOf(file, flagString(args, "export"));
+  const requests = requestsOf(kinds, { tier: tierOf(flagString(args, "tier")), allowGeneration: !flagBool(args, "no-generate") });
+  if (requests.length === 0) throw new CliError(CLI_ERROR_CODE.INVALID_INPUT, `${file} places no objects`);
+  let assets = remote;
+  if (assets === void 0) {
+    const auth = await readAuthOrNull();
+    if (auth === null) throw new CliError(CLI_ERROR_CODE.NOT_LOGGED_IN, "resolving scene assets needs a signed-in account; run cimplify login");
+    assets = new HttpSceneAssetsRemote(ApiClient.fromAuth(auth));
+  }
+  const resolutions = await resolveAll(requests, assets, {
+    waitMs: waitOf(flagString(args, "wait")),
+    pollMs: POLL_MS,
+    sleep: (ms) => new Promise((done) => setTimeout(done, ms)),
+    now: () => Date.now(),
+    onPending: (pending) => info(dim(`${pending} asset${pending === 1 ? "" : "s"} still generating`))
+  });
+  const report = assetsReport(kinds, resolutions);
+  const out = flagString(args, "out") ?? `${file.replace(/\.[^./]+$/, "")}${ASSETS_SUFFIX}`;
+  await promises.writeFile(out, `${JSON.stringify(report, null, 2)}
+`);
+  for (const a of report.assets) (a.asset === void 0 ? warn : info)(`  ${a.kind.padEnd(16)}${describe(a)}`);
+  const head = `${report.scene}: ${report.models.length}/${report.assets.length} kinds resolved, ${report.units_charged} AI units charged, written to ${out}`;
+  if (report.status === "resolved") success(head);
+  else failure(head);
+  result(report);
+  if (report.status !== "resolved") process.exitCode = UNRESOLVED_EXIT;
+  return report;
+}
+
+// src/interactives/commands/scene.ts
+var SOLVER_ENV = "CIMPLIFY_SCENE_SOLVER_WASM";
+var SOLVER_ARTIFACT = path2.join("target", "wasm32-unknown-unknown", "release", "engine_scene.wasm");
+var BUILD_HINT = "cargo build -p engine_scene --features wasm --target wasm32-unknown-unknown --release";
+var USAGE = "cimplify scene solve <file> [--json] [--seed n] [--export name]";
+var SOLVE = "solve";
+var RESOLVE = "resolve";
+var UNSATISFIED_EXIT = 1;
+var MS_DIGITS = 3;
+function upward(start) {
+  let dir = path2.resolve(start);
+  for (; ; ) {
+    const candidate = path2.join(dir, SOLVER_ARTIFACT);
+    if (existsSync(candidate)) return candidate;
+    const parent = path2.dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+function locateSolver(env = process.env, cwd = process.cwd()) {
+  const explicit = env[SOLVER_ENV];
+  if (explicit !== void 0 && explicit.length > 0) {
+    if (!existsSync(explicit)) throw new CliError(CLI_ERROR_CODE.NOT_FOUND, `${SOLVER_ENV} points at ${explicit}, which does not exist`, { remediation: BUILD_HINT });
+    return explicit;
+  }
+  const found = upward(cwd) ?? upward(path2.dirname(fileURLToPath(import.meta.url)));
+  if (found === null) throw new CliError(CLI_ERROR_CODE.NOT_FOUND, "the scene solver module was not found", { remediation: `${BUILD_HINT}, or set ${SOLVER_ENV}` });
+  return found;
+}
+function pickSite(sites, wanted) {
+  const named = sites.filter((s) => s.definition !== null);
+  if (wanted !== void 0) {
+    const hit = sites.find((s) => s.binding === wanted || s.definition?.name === wanted);
+    if (hit === void 0) throw new CliError(CLI_ERROR_CODE.INVALID_INPUT, `no scene named ${wanted}`, { remediation: `scenes here: ${named.map((s) => s.binding ?? s.definition?.name).join(", ") || "none"}` });
+    return hit;
+  }
+  if (sites.length === 1) return sites[0];
+  if (sites.length === 0) throw new CliError(CLI_ERROR_CODE.INVALID_INPUT, "the file declares no scene(...)", { remediation: 'import { scene } from "@cimplify/sdk/game" and export a scene' });
+  throw new CliError(CLI_ERROR_CODE.INVALID_INPUT, `the file declares ${sites.length} scenes`, { remediation: `pick one with --export ${named.map((s) => s.binding ?? s.definition?.name).join(" | ")}` });
+}
+function renderReport(report) {
+  const head = `${report.scene}: ${report.status}, ${report.placements.length} placements, seed ${report.seed}, try ${report.try}, score ${report.score}`;
+  if (report.status === "solved") success(head);
+  else failure(head);
+  const width = Math.max(4, ...report.placements.map((p) => p.name.length)) + 2;
+  for (const p of report.placements) {
+    const at = p.at.map((v) => v.toFixed(2)).join(", ");
+    const flag = p.violations.length > 0 ? `  ${p.violations.join(", ")}` : "";
+    info(`  ${p.name.padEnd(width)}${dim(p.kind)}  [${at}]  ${p.yaw} deg${p.support === null ? "" : ` on ${p.support}`}${flag}`);
+  }
+  for (const v of report.violations) warn(`${v.object}: ${v.code}${v.relation === "" ? "" : ` (${v.relation})`}${v.amount > 0 ? ` by ${v.amount} m` : ""}`);
+  if (report.conflicts !== void 0) {
+    failure(`minimal conflicting set: ${bold(report.conflicts.objects.join(", "))}`);
+    for (const r of report.conflicts.reasons) info(`  ${r}`);
+  }
+  info(dim(`digest ${report.digest}`));
+}
+function reportDiagnostics(diagnostics) {
+  for (const d of diagnostics) (d.severity === "error" ? failure : warn)(formatSceneDiagnostic(d));
+}
+async function run(argv) {
+  if (!scenesEnabled()) {
+    throw new CliError(CLI_ERROR_CODE.INVALID_INPUT, `generative scenes are switched off by ${SCENES_FLAG}`, { remediation: `unset ${SCENES_FLAG}` });
+  }
+  const args = parseArgs(argv);
+  const [action, file] = args.positional;
+  if (action === RESOLVE) {
+    await runSceneResolve(argv.slice(argv.indexOf(RESOLVE) + 1));
+    return;
+  }
+  if (action !== SOLVE || file === void 0) throw new CliError(CLI_ERROR_CODE.INVALID_INPUT, `usage: ${USAGE}
+       ${RESOLVE_USAGE}`);
+  const seedFlag = flagString(args, "seed");
+  const seed = seedFlag === void 0 ? void 0 : Number(seedFlag);
+  if (seed !== void 0 && (!Number.isInteger(seed) || seed < 0 || seed > 4294967295)) {
+    throw new CliError(CLI_ERROR_CODE.INVALID_INPUT, "--seed must be an integer from 0 to 4294967295");
+  }
+  const absolute = path2.resolve(file);
+  const text = await promises.readFile(absolute, "utf8").catch(() => {
+    throw new CliError(CLI_ERROR_CODE.NOT_FOUND, `cannot read ${file}`);
+  });
+  const sdk = await import('@cimplify/sdk/game');
+  const started = performance.now();
+  const relative = path2.relative(process.cwd(), absolute) || file;
+  const compiled = compileSites(relative, text, (def) => sdk.compileScene(def));
+  const site = pickSite(compiled.sites, flagString(args, "export"));
+  const index = compiled.sites.indexOf(site);
+  const mine = compiled.diagnostics.filter((d) => d.scene === (site.definition?.name ?? site.binding ?? "scene"));
+  reportDiagnostics(mine);
+  const wire = compiled.compiled[index]?.wire ?? null;
+  if (wire === null || mine.some((d) => d.severity === "error")) {
+    result({ status: "invalid", diagnostics: mine });
+    throw new CliError(CLI_ERROR_CODE.INVALID_INPUT, `${relative}: the scene does not compile`, { details: mine });
+  }
+  const solver = await sdk.createSceneSolver(await promises.readFile(locateSolver()));
+  const setup = performance.now();
+  const solved = solver.solve(wire, seed);
+  const done = performance.now();
+  const report = {
+    ...solved.report,
+    timings: { setup_ms: Number((setup - started).toFixed(MS_DIGITS)), solve_ms: Number((done - setup).toFixed(MS_DIGITS)) }
+  };
+  renderReport(report);
+  info(dim(`setup ${report.timings.setup_ms} ms, solve ${report.timings.solve_ms} ms`));
+  result(report);
+  if (report.status !== "solved") process.exitCode = UNSATISFIED_EXIT;
+}
+
+export { SOLVER_ENV, run as default, locateSolver, pickSite };

package/dist/{status-TWPOMWNA.mjs → status-5D4RR3MM.mjs}

@@ -1,9 +1,9 @@
 #!/usr/bin/env node
-import { DEPLOYMENT_STATUS } from './chunk-2MKZKUVH.mjs';
-import { parseArgs } from './chunk-5KYR6WJB.mjs';
-import { ApiClient } from './chunk-NYXA6X56.mjs';
-import { readAuth, readProjectLink, readProjectState } from './chunk-MLE4MVYC.mjs';
-import { bold, dim, info, result } from './chunk-3QUK5BPY.mjs';
+import { DEPLOYMENT_STATUS } from './chunk-LLRUOIMU.mjs';
+import { parseArgs } from './chunk-XQAHREKO.mjs';
+import { ApiClient } from './chunk-XBQ4LO2N.mjs';
+import { readAuth, readProjectLink, readProjectState } from './chunk-GGPN4QYQ.mjs';
+import { bold, dim, info, result } from './chunk-I7GEHLDD.mjs';
 
 // src/commands/status.ts
 var QUERY_LIMIT = "limit";

package/dist/status-AKI6E3JK.mjs

@@ -0,0 +1,18 @@
+#!/usr/bin/env node
+export { run as default, interactiveStatus, renderStatus } from './chunk-6KKLF5KG.mjs';
+import './chunk-XZG3DTXV.mjs';
+import './chunk-JNCEKW2Y.mjs';
+import './chunk-BTNVYAC4.mjs';
+import './chunk-VHK7WBO3.mjs';
+import './chunk-454RQ6NR.mjs';
+import './chunk-JKECUAAV.mjs';
+import './chunk-HQPZQIWW.mjs';
+import './chunk-KQNZKV6E.mjs';
+import './chunk-N2WZJX5P.mjs';
+import './chunk-EYEMPIMP.mjs';
+import './chunk-BGM7CH5G.mjs';
+import './chunk-25ZPFHLF.mjs';
+import './chunk-SGT5IJVW.mjs';
+import './chunk-XBQ4LO2N.mjs';
+import './chunk-GGPN4QYQ.mjs';
+import './chunk-I7GEHLDD.mjs';