@field/cascade 0.11.0 → 0.12.0

package/dist/cli/{commands-Q23M26QM.js → commands-PHYFYA3F.js}

@@ -1,62 +1,65 @@
 import {
-  RunTrace
-} from "./chunk-4UDFYF5G.js";
-import {
-  installProjectStages
-} from "./chunk-QBBKRNGY.js";
+  sceneDocument
+} from "./chunk-73S4JZXK.js";
 import {
   setEmbeddedCompiler,
   setProjectModuleCompiler
 } from "./chunk-2KXB47FP.js";
 import {
-  sceneDocument
-} from "./chunk-WKURDVYP.js";
-import "./chunk-3JTJHF7V.js";
+  installHeadlessCanvas
+} from "./chunk-EZRWJ4G2.js";
+import "./chunk-3RXL5GHB.js";
+import "./chunk-OM6BEME6.js";
 import {
-  cascadeVersion,
-  compileEmbedded,
-  compileProjectModule
-} from "./chunk-MIIEFUGG.js";
-import "./chunk-WPUDGEFY.js";
-import "./chunk-VVGSLVSF.js";
-import "./chunk-WD62JIP6.js";
+  composeContactSheet
+} from "./chunk-53LGFPWX.js";
 import {
+  RunTrace,
   cookProjectGraph,
   installProjectIo,
+  installProjectStages,
   moduleId,
   projectModuleFile
-} from "./chunk-EUIAC3U3.js";
-import {
-  composeContactSheet
-} from "./chunk-36P5K3SD.js";
-import "./chunk-D6BUOHUG.js";
+} from "./chunk-MP653A5O.js";
+import "./chunk-MI5JLQYA.js";
+import "./chunk-GRIN2DDP.js";
+import "./chunk-X4WKAOQP.js";
+import "./chunk-DEQSEFFH.js";
 import "./chunk-RXDIMXN5.js";
 import "./chunk-QQPA2ZHH.js";
 import "./chunk-KH4MUBKF.js";
-import "./chunk-35D343DC.js";
-import "./chunk-DEQSEFFH.js";
 import "./chunk-HSNOBIVT.js";
-import {
-  imagePath
-} from "./chunk-ICH7N5PN.js";
 import {
   graphSeed
-} from "./chunk-GFS6W3C5.js";
+} from "./chunk-L6B6FUQP.js";
 import "./chunk-HFHWYL55.js";
+import "./chunk-KBGUO27Q.js";
+import {
+  imagePath
+} from "./chunk-ICH7N5PN.js";
 import "./chunk-CO22XHNG.js";
+import "./chunk-LTXWBXOM.js";
+import "./chunk-BZ63XQ3I.js";
+import {
+  compileEmbedded,
+  compileProjectModule
+} from "./chunk-EU4ZFZ7Y.js";
+import "./chunk-YH637PDL.js";
+import "./chunk-X566FWBV.js";
+import "./chunk-WD62JIP6.js";
+import {
+  cascadeVersion
+} from "./chunk-5ORUQ6ES.js";
 import {
   ProjectRoot
-} from "./chunk-RQZ4SX5R.js";
-import "./chunk-A4OAMOZH.js";
+} from "./chunk-2JEU3MGB.js";
+import "./chunk-NJFMDXHR.js";
 import "./chunk-J7VK7MNF.js";
-import "./chunk-XWDSKG7N.js";
-import "./chunk-BIJO5OFS.js";
-import {
-  installHeadlessCanvas
-} from "./chunk-WIH4TEIS.js";
+import "./chunk-FWMSGKEH.js";
+import "./chunk-JVOCK5W4.js";
 
 // src/cli/locks/commands.ts
-import path7 from "node:path";
+import path8 from "node:path";
 
 // src/cli/locks/lock.ts
 import { execFile as execFile2 } from "node:child_process";
@@ -1001,6 +1004,69 @@ async function exists2(file) {
   }
 }
 
+// src/cli/locks/ladderCard.ts
+import fs6 from "node:fs/promises";
+import path7 from "node:path";
+var MAX_CHOICE_OPTIONS = 8;
+function checkCardSize(count) {
+  if (count > MAX_CHOICE_OPTIONS) {
+    throw new Error(`--cairn shows at most ${MAX_CHOICE_OPTIONS} options on a choice card (this ladder has ${count}); ladder fewer variants`);
+  }
+}
+function pickValue(ladderId, index) {
+  return `pick:${ladderId}:${index}`;
+}
+function choiceLabel(variant, seedVaried) {
+  const parts = Object.entries(variant.set).map(([key, value]) => `${key}=${typeof value === "string" ? value : JSON.stringify(value)}`);
+  if (seedVaried) parts.push(`seed ${variant.seed}`);
+  return parts.join(", ");
+}
+async function writeLadderCard(root, ladder, directory, vault) {
+  checkCardSize(ladder.variants.length);
+  const target = path7.resolve(directory);
+  const vaultRoot = vault ? path7.resolve(vault) : await findVault(target);
+  const relative = path7.relative(vaultRoot, target);
+  if (relative.startsWith("..") || path7.isAbsolute(relative)) throw new Error(`--cairn ${target} is not inside the vault ${vaultRoot}`);
+  await fs6.mkdir(target, { recursive: true });
+  const seedVaried = Boolean(ladder.seeds);
+  const files = [];
+  const options = [];
+  for (const variant of ladder.variants) {
+    const file = path7.join(target, `${ladder.id}-${String(variant.index).padStart(2, "0")}${path7.extname(variant.image).toLowerCase()}`);
+    await fs6.copyFile(path7.join(root, variant.image), file);
+    files.push(file);
+    options.push({
+      label: choiceLabel(variant, seedVaried) || `variant ${variant.index}`,
+      value: pickValue(ladder.id, variant.index),
+      image: path7.relative(vaultRoot, file).split(path7.sep).join("/")
+    });
+  }
+  const choice = { prompt: `${ladder.name}: which one? (ladder ${ladder.id}, ${ladder.graph.file} ${ladder.graph.node})`, options };
+  return { choice, fence: choiceFence(choice), vault: vaultRoot, files };
+}
+function choiceFence(choice) {
+  return `\`\`\`cairn:choice
+${JSON.stringify(choice)}
+\`\`\``;
+}
+async function findVault(start) {
+  for (const marker of [".obsidian", ".git"]) {
+    for (let directory = start; ; directory = path7.dirname(directory)) {
+      if (await exists3(path7.join(directory, marker))) return directory;
+      if (path7.dirname(directory) === directory) break;
+    }
+  }
+  throw new Error(`--cairn ${start}: no vault above it (no .obsidian or .git); name it with --vault <dir>`);
+}
+async function exists3(file) {
+  try {
+    await fs6.access(file);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 // src/cli/locks/commands.ts
 var LOCK_COMMANDS = ["lock", "locks", "replay", "ladder", "pick"];
 var LOCK_HELP = `
@@ -1031,13 +1097,18 @@ Ladders: three to five options side by side, and a lock at approval.
 
   cascade ladder <graph> <node> --name <name> [--vary <node.prop>=<a,b,c>]...
                  [--seeds <a,b,c>] [--columns N] [--port <output>]... [--input <file>]...
-                 [--note <text>] [--live] [--json]
+                 [--note <text>] [--live] [--cairn <vault dir> [--vault <dir>]] [--json]
       Cook <node> once per variant and write ladders/<id>/<n>.png, a labelled
       contact sheet ladders/<id>/sheet.png, and the record ladders/<id>.json
       (per variant: graph, params, seed, inputs, output fingerprint; the
       stored code and git commit once). Values are a JSON list without its
       brackets (0.5,1,2 or [1,2],[3,4]); lists are zipped, one value applies
       to every variant. Cooks from the stored code in a fresh copy unless --live.
+      --cairn copies each variant to <dir>/<id>-<nn>.png (a space's
+      _attachments/ladders/<id>/) and prints a cairn:choice card (--json:
+      data.cairnChoice) whose images are relative to the vault (the nearest
+      .obsidian or .git above, or --vault); at most 8 variants. A tap answers
+      "Picked: <label> (pick:<id>:<n>)": run cascade pick <id> <n>.
 
   cascade pick <ladder-id | ladders/<id>.json> <n> [--name <lock name>] [--note <text>]
                [--status approved] [--supersedes <id>] [--project <dir>] [--json]
@@ -1130,9 +1201,9 @@ async function replayCommand(parsed, json, print) {
   if (result.status !== "match") process.exitCode = 1;
 }
 async function verifyCommand(parsed, json, print) {
-  const root = path7.resolve(one(parsed, "--project") ?? process.cwd());
+  const root = path8.resolve(one(parsed, "--project") ?? process.cwd());
   const locks = parsed.positional.length ? await Promise.all(parsed.positional.map(async (id) => (await readLock(root, id)).lock)) : await listLocks(root);
-  if (!locks.length) throw new Error(`No locks in ${path7.join(root, "locks")}`);
+  if (!locks.length) throw new Error(`No locks in ${path8.join(root, "locks")}`);
   const results = [];
   for (const lock of locks) {
     try {
@@ -1157,7 +1228,7 @@ ${results.length - failed} of ${results.length} locks reproduce${failed ? `; ${f
   if (failed) process.exitCode = 1;
 }
 async function locksCommand(parsed, json, print) {
-  const root = path7.resolve(parsed.positional[0] ?? one(parsed, "--project") ?? process.cwd());
+  const root = path8.resolve(parsed.positional[0] ?? one(parsed, "--project") ?? process.cwd());
   const locks = await listLocks(root);
   if (json) {
     return print({
@@ -1176,7 +1247,7 @@ async function locksCommand(parsed, json, print) {
       }))
     });
   }
-  if (!locks.length) return console.log(`No locks in ${path7.join(root, "locks")}`);
+  if (!locks.length) return console.log(`No locks in ${path8.join(root, "locks")}`);
   const width = Math.max(...locks.map((lock) => lock.id.length));
   for (const lock of locks) {
     const commit = lock.versions.project.commit ? ` @${lock.versions.project.commit.slice(0, 7)}${lock.versions.project.dirty ? "+" : ""}` : "";
@@ -1195,6 +1266,9 @@ async function ladderCommand(parsed, json, print) {
     vary[pair.slice(0, at)] = parseValues(pair.slice(at + 1));
   }
   const seedsText = one(parsed, "--seeds");
+  const seeds = seedsText === void 0 ? void 0 : seedsText.split(",").map((text) => seedValue(text.trim()));
+  const cairn = one(parsed, "--cairn");
+  if (cairn) checkCardSize(Math.max(0, ...Object.values(vary).map((values) => values.length), seeds?.length ?? 0));
   const columns = one(parsed, "--columns");
   const { ladder, file } = await createLadder({
     graph,
@@ -1202,27 +1276,35 @@ async function ladderCommand(parsed, json, print) {
     name,
     note: one(parsed, "--note"),
     vary,
-    seeds: seedsText === void 0 ? void 0 : seedsText.split(",").map((text) => seedValue(text.trim())),
+    seeds,
     columns: columns === void 0 ? void 0 : Number(columns),
     ports: parsed.values.get("--port"),
     inputs: parsed.values.get("--input"),
     live: parsed.switches.has("--live"),
     verbose: parsed.switches.has("--verbose")
   });
-  const root = path7.dirname(path7.dirname(file));
+  const root = path8.dirname(path8.dirname(file));
+  const card = cairn ? await writeLadderCard(root, ladder, cairn, one(parsed, "--vault")) : void 0;
   if (json) {
     return print({
       status: "laddered",
       file,
-      sheet: path7.join(root, ladder.sheet.file),
-      variants: ladder.variants.map((variant) => ({ index: variant.index, label: variant.label, image: path7.join(root, variant.image), set: variant.set, seed: variant.seed })),
+      sheet: path8.join(root, ladder.sheet.file),
+      variants: ladder.variants.map((variant) => ({ index: variant.index, label: variant.label, image: path8.join(root, variant.image), set: variant.set, seed: variant.seed })),
+      ...card ? { cairnChoice: card.fence, cairn: { vault: card.vault, files: card.files, choice: card.choice } } : {},
       ladder
     });
   }
   console.log(`Ladder ${ladder.id} -> ${shown(file)}, cooked from the ${ladder.host.cooked}`);
-  console.log(`  sheet ${shown(path7.join(root, ladder.sheet.file))}`);
+  console.log(`  sheet ${shown(path8.join(root, ladder.sheet.file))}`);
   for (const variant of ladder.variants) console.log(`  ${variant.label}  ${variant.image}  (${seconds(variant.output.durationMs)})`);
-  console.log(`Pick one with: cascade pick ${ladder.id} <n>`);
+  console.log(`Pick one with: cascade pick ${ladder.id} <n> --project ${root}`);
+  if (card) {
+    console.log(`
+Cairn choice card (images in ${shown(path8.dirname(card.files[0]))}); post it as is, and on "Picked: \u2026 (pick:${ladder.id}:<n>)" run cascade pick ${ladder.id} <n> --project ${root}:
+`);
+    console.log(card.fence);
+  }
 }
 async function pickCommand(parsed, json, print) {
   const [ladder, variant] = parsed.positional;
@@ -1272,7 +1354,7 @@ function describePort(fingerprint) {
   return `${fingerprint.path}${size} ${short(fingerprint.pixels ?? fingerprint.sha256)}`;
 }
 function shown(file) {
-  const relative = path7.relative(process.cwd(), file);
+  const relative = path8.relative(process.cwd(), file);
   return relative.startsWith("..") ? file : relative;
 }
 function seedValue(text) {
@@ -1289,4 +1371,4 @@ export {
   LOCK_HELP,
   runLockCommand
 };
-//# sourceMappingURL=commands-Q23M26QM.js.map
+//# sourceMappingURL=commands-PHYFYA3F.js.map

package/dist/cli/contactSheet-2PQVRUFW.js

@@ -0,0 +1,11 @@
+import {
+  composeContactSheet,
+  contactSheetLayout,
+  executeContactSheet
+} from "./chunk-53LGFPWX.js";
+export {
+  composeContactSheet,
+  contactSheetLayout,
+  executeContactSheet
+};
+//# sourceMappingURL=contactSheet-2PQVRUFW.js.map

package/dist/cli/{definitions-HF2FTHYU.js → definitions-BPOPW52L.js}

@@ -1,7 +1,7 @@
 import {
   registerDefinitionNodes
-} from "./chunk-SGJAET2L.js";
-import "./chunk-FCDXJ6EK.js";
+} from "./chunk-BPODRH52.js";
+import "./chunk-CTPLRSWF.js";
 import "./chunk-RUU3YWXU.js";
 import {
   cameraRegistration,
@@ -11,13 +11,13 @@ import {
   pickRegistration,
   previousRegistration,
   timeRegistration
-} from "./chunk-D6BUOHUG.js";
-import "./chunk-RXDIMXN5.js";
+} from "./chunk-X4WKAOQP.js";
 import "./chunk-DEQSEFFH.js";
-import "./chunk-GFS6W3C5.js";
+import "./chunk-RXDIMXN5.js";
+import "./chunk-L6B6FUQP.js";
 import "./chunk-HFHWYL55.js";
 import "./chunk-CO22XHNG.js";
-import "./chunk-BIJO5OFS.js";
+import "./chunk-FWMSGKEH.js";
 
 // src/nodes/core/definitions.ts
 registerDefinitionNodes([
@@ -29,4 +29,4 @@ registerDefinitionNodes([
   packRegistration,
   frozenRegistration
 ]);
-//# sourceMappingURL=definitions-HF2FTHYU.js.map
+//# sourceMappingURL=definitions-BPOPW52L.js.map

package/dist/cli/{doctorCommand-B7BPQMN6.js → doctorCommand-ORWQRNYP.js}

@@ -37,18 +37,37 @@ async function doctor(root, options = {}) {
   }
   if (hasStages(root)) {
     try {
-      const { ProjectRoot } = await import("./project-K3QIPGBB.js");
-      const { readStageConfig } = await import("./stageRunner-KUNIMQKJ.js");
-      const { python } = readStageConfig(new ProjectRoot(root));
+      const { ProjectRoot } = await import("./project-VYGIA7JX.js");
+      const { readStageConfig } = await import("./stageRunner-KY2EJP7X.js");
+      const { stageSources } = await import("./stageCache-TY2BFZJR.js");
+      const project = new ProjectRoot(root);
+      const config = readStageConfig(project);
+      const { python } = config;
       const version = await output(python, ["-c", "import sys; print(sys.version.split()[0], sys.executable)"], root);
       checks.push({ name: "stage interpreter", ok: true, detail: `Python ${version}` });
+      if (env?.state === "none") {
+        const sources = stageSources(project, config);
+        const importer = sources.files().find((file) => importsModule(project.resolveMedia(file), "numpy"));
+        if (importer) {
+          try {
+            await output(python, ["-c", "import numpy"], root);
+            checks.push({ name: "stage imports", ok: true, detail: `numpy (imported by ${importer}) loads in ${python}` });
+          } catch {
+            checks.push({
+              name: "stage imports",
+              ok: false,
+              detail: `${importer} imports numpy, which ${python} (Python ${version.split(" ")[0]}) does not have, and no environment is declared. Declare one in cascade.json ("python": { "requirements": ["numpy"] }) and run cascade doctor --fix, or point exec.stages.python at an interpreter that has it`
+            });
+          }
+        }
+      }
     } catch (error) {
       checks.push({ name: "stage interpreter", ok: false, detail: error instanceof Error ? error.message : String(error) });
     }
   }
-  const { hasFfmpeg } = await import("./encode-HAUZTYPT.js");
+  const { hasFfmpeg } = await import("./encode-ICPEPMH5.js");
   checks.push(await hasFfmpeg() ? { name: "ffmpeg", ok: true, detail: "on the PATH" } : { name: "ffmpeg", ok: false, optional: true, detail: "not on the PATH: --mp4 and cascade render videos need it (brew install ffmpeg)" });
-  const { canvasAvailable, CANVAS_PACKAGE } = await import("./headlessCanvas-5XLDZT7M.js");
+  const { canvasAvailable, CANVAS_PACKAGE } = await import("./headlessCanvas-ENRHC7GS.js");
   checks.push(await canvasAvailable() ? { name: "headless canvas", ok: true, detail: CANVAS_PACKAGE } : { name: "headless canvas", ok: false, optional: true, detail: `${CANVAS_PACKAGE} is not installed: drawing nodes cannot run headlessly (npm install ${CANVAS_PACKAGE})` });
   return checks;
 }
@@ -60,6 +79,16 @@ function hasStages(root) {
     return false;
   }
 }
+function importsModule(file, module) {
+  let source;
+  try {
+    source = fs.readFileSync(file, "utf8");
+  } catch {
+    return false;
+  }
+  const name = module.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  return new RegExp(`^\\s*(?:import\\s+(?:[\\w.]+\\s*(?:as\\s+\\w+)?\\s*,\\s*)*${name}\\b|from\\s+${name}(?:\\.|\\s))`, "m").test(source);
+}
 function output(command, args, cwd) {
   return new Promise((resolve, reject) => {
     execFile(command, args, { cwd, timeout: 3e4 }, (error, stdout, stderr) => {
@@ -71,6 +100,7 @@ function output(command, args, cwd) {
 export {
   DOCTOR_USAGE,
   doctor,
+  importsModule,
   runDoctorCommand
 };
-//# sourceMappingURL=doctorCommand-B7BPQMN6.js.map
+//# sourceMappingURL=doctorCommand-ORWQRNYP.js.map

package/dist/cli/{edit-JHCPTQFT.js → edit-S5KEQ5RA.js}

@@ -10,8 +10,8 @@ import {
   readWire,
   splitEndpoint,
   wireLabel
-} from "./chunk-XWDSKG7N.js";
-import "./chunk-BIJO5OFS.js";
+} from "./chunk-BZ63XQ3I.js";
+import "./chunk-FWMSGKEH.js";
 export {
   GRAPH_EDIT_OPERATIONS,
   GraphEditError,
@@ -25,4 +25,4 @@ export {
   splitEndpoint,
   wireLabel
 };
-//# sourceMappingURL=edit-JHCPTQFT.js.map
+//# sourceMappingURL=edit-S5KEQ5RA.js.map

package/dist/cli/editorCommands-NFR32JOY.js

@@ -0,0 +1,41 @@
+import {
+  EDITOR_COMMANDS,
+  EDITOR_HELP,
+  runEditorCommand,
+  sceneDocument
+} from "./chunk-73S4JZXK.js";
+import "./chunk-EZRWJ4G2.js";
+import "./chunk-3RXL5GHB.js";
+import "./chunk-OM6BEME6.js";
+import "./chunk-MP653A5O.js";
+import "./chunk-MI5JLQYA.js";
+import "./chunk-GRIN2DDP.js";
+import "./chunk-X4WKAOQP.js";
+import "./chunk-DEQSEFFH.js";
+import "./chunk-RXDIMXN5.js";
+import "./chunk-QQPA2ZHH.js";
+import "./chunk-KH4MUBKF.js";
+import "./chunk-HSNOBIVT.js";
+import "./chunk-L6B6FUQP.js";
+import "./chunk-HFHWYL55.js";
+import "./chunk-KBGUO27Q.js";
+import "./chunk-ICH7N5PN.js";
+import "./chunk-CO22XHNG.js";
+import "./chunk-LTXWBXOM.js";
+import "./chunk-BZ63XQ3I.js";
+import "./chunk-YH637PDL.js";
+import "./chunk-X566FWBV.js";
+import "./chunk-WD62JIP6.js";
+import "./chunk-5ORUQ6ES.js";
+import "./chunk-2JEU3MGB.js";
+import "./chunk-NJFMDXHR.js";
+import "./chunk-J7VK7MNF.js";
+import "./chunk-FWMSGKEH.js";
+import "./chunk-JVOCK5W4.js";
+export {
+  EDITOR_COMMANDS,
+  EDITOR_HELP,
+  runEditorCommand,
+  sceneDocument
+};
+//# sourceMappingURL=editorCommands-NFR32JOY.js.map

package/dist/cli/{encode-HAUZTYPT.js → encode-ICPEPMH5.js}

@@ -5,7 +5,7 @@ import {
   frameSequences,
   hasFfmpeg,
   timelineFrameSpec
-} from "./chunk-YAT5Y25U.js";
+} from "./chunk-7QE2ZNSN.js";
 export {
   DEFAULT_CRF,
   encodeMp4,
@@ -14,4 +14,4 @@ export {
   hasFfmpeg,
   timelineFrameSpec
 };
-//# sourceMappingURL=encode-HAUZTYPT.js.map
+//# sourceMappingURL=encode-ICPEPMH5.js.map

package/dist/cli/file-3HTQHPYQ.js

@@ -0,0 +1,41 @@
+import {
+  imageReference,
+  output,
+  readPlanar,
+  resample
+} from "./chunk-WGKPJZDY.js";
+
+// packages/runtime/src/builtins/image/file.ts
+async function executeImage(context) {
+  const { props } = context;
+  const source = await readPlanar(context, imageReference(context.inputs.image) ?? imageReference(props.file));
+  if (!source) return;
+  if (props.resolutionMode === "original") {
+    await output(context, source);
+    return;
+  }
+  if (props.resolutionMode === "max") {
+    const [maxWidth, maxHeight] = props.maxResolution;
+    const aspect = source.width / source.height;
+    let width2 = source.width;
+    let height2 = source.height;
+    if (width2 > maxWidth) {
+      width2 = maxWidth;
+      height2 = maxWidth / aspect;
+    }
+    if (height2 > maxHeight) {
+      height2 = maxHeight;
+      width2 = maxHeight * aspect;
+    }
+    width2 = Math.round(width2);
+    height2 = Math.round(height2);
+    await output(context, width2 !== source.width || height2 !== source.height ? resample(source, width2, height2) : source);
+    return;
+  }
+  const [width, height] = props.fixedResolution;
+  await output(context, resample(source, width, height));
+}
+export {
+  executeImage
+};
+//# sourceMappingURL=file-3HTQHPYQ.js.map