@field/cascade 0.11.0 → 0.13.0

package/dist/cli/chunk-5ORUQ6ES.js

@@ -0,0 +1,267 @@
+// server/src/stageCache.ts
+import { createHash as createHash2 } from "node:crypto";
+import fs3 from "node:fs";
+import path2 from "node:path";
+import { fileURLToPath } from "node:url";
+
+// server/src/atomicWrite.ts
+import fs from "node:fs";
+import fsp from "node:fs/promises";
+var temporaryFor = (file) => `${file}.${process.pid}.tmp`;
+async function writeFileAtomic(file, data, options = {}) {
+  const temporary = temporaryFor(file);
+  await fsp.writeFile(temporary, data, options.mode === void 0 ? void 0 : { mode: options.mode });
+  await fsp.rename(temporary, file);
+}
+function writeFileAtomicSync(file, data) {
+  const temporary = temporaryFor(file);
+  fs.writeFileSync(temporary, data);
+  fs.renameSync(temporary, file);
+}
+
+// server/src/stageSources.ts
+import { createHash } from "node:crypto";
+import fs2 from "node:fs";
+import path from "node:path";
+var SKIPPED_DIRECTORIES = /* @__PURE__ */ new Set(["__pycache__", "node_modules", "venv", ".venv", ".git", ".cascade", ".cascade-cache"]);
+var digests = /* @__PURE__ */ new Map();
+function contentDigest(fullPath) {
+  let stat;
+  try {
+    stat = fs2.statSync(fullPath, { bigint: true });
+  } catch {
+    return null;
+  }
+  if (!stat.isFile()) return null;
+  const stamp = `${stat.size}:${stat.mtimeNs}:${stat.ctimeNs}`;
+  const known = digests.get(fullPath);
+  if (known?.stamp === stamp) return known.digest;
+  const hash = createHash("sha256");
+  const handle = fs2.openSync(fullPath, "r");
+  try {
+    const buffer = Buffer.allocUnsafe(1 << 20);
+    let read;
+    while ((read = fs2.readSync(handle, buffer, 0, buffer.length, null)) > 0) hash.update(buffer.subarray(0, read));
+  } finally {
+    fs2.closeSync(handle);
+  }
+  const digest = hash.digest("hex");
+  digests.set(fullPath, { stamp, digest });
+  return digest;
+}
+var StageSources = class {
+  constructor(project, roots) {
+    this.project = project;
+    this.roots = [...new Set(roots)].sort();
+  }
+  /** The default roots for a stage configuration without `sources`. */
+  static defaultRoots(project, entrypoint, worker) {
+    const roots = [path.posix.dirname(entrypoint)];
+    if (worker) roots.push(path.posix.dirname(worker));
+    if (fs2.existsSync(project.resolve("src"))) roots.push("src");
+    return roots.map((root) => root === "" ? "." : root);
+  }
+  /** Every source file, project-relative and sorted. */
+  files() {
+    const found = /* @__PURE__ */ new Set();
+    for (const root of this.roots) {
+      let full;
+      try {
+        full = this.project.resolveMedia(root);
+      } catch {
+        continue;
+      }
+      let stat;
+      try {
+        stat = fs2.statSync(full);
+      } catch {
+        continue;
+      }
+      if (stat.isFile()) found.add(root);
+      else if (stat.isDirectory()) this.walk(full, root, found);
+    }
+    return [...found].sort();
+  }
+  walk(directory, relative, found) {
+    let entries;
+    try {
+      entries = fs2.readdirSync(directory, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const child = relative === "." ? entry.name : path.posix.join(relative, entry.name);
+      if (entry.isDirectory()) {
+        if (SKIPPED_DIRECTORIES.has(entry.name) || entry.name.startsWith(".")) continue;
+        this.walk(path.join(directory, entry.name), child, found);
+      } else if (entry.isFile() && entry.name.endsWith(".py")) {
+        found.add(child);
+      }
+    }
+  }
+  digest(relative) {
+    return contentDigest(this.project.resolveMedia(relative)) ?? "missing";
+  }
+  /**
+   * The code hash, 16 hex characters. A file added, removed or edited changes
+   * it. Cheap to call per request: one directory walk and one stat per file,
+   * with a file read only when its stat changed.
+   */
+  codeHash() {
+    const hash = createHash("sha256");
+    for (const file of this.files()) hash.update(`${file}\0${this.digest(file)}
+`);
+    return hash.digest("hex").slice(0, 16);
+  }
+};
+
+// server/src/stageCache.ts
+var CACHE_FORMAT = 1;
+var CACHE_DIRECTORY = ".cascade/cache/stages";
+var version;
+function cascadeVersion() {
+  if (version) return version;
+  let directory = path2.dirname(fileURLToPath(import.meta.url));
+  for (let depth = 0; depth < 6; depth++) {
+    try {
+      const manifest = JSON.parse(fs3.readFileSync(path2.join(directory, "package.json"), "utf8"));
+      if (manifest.name === "@field/cascade" && manifest.version) return version = manifest.version;
+    } catch {
+    }
+    directory = path2.dirname(directory);
+  }
+  return version = "unknown";
+}
+function projectFile(project, value) {
+  if (!value || value.length > 1024 || value.includes("\0") || /^[a-z][a-z0-9+.-]*:/i.test(value)) return null;
+  if (path2.isAbsolute(value) || !/[./]/.test(value)) return null;
+  try {
+    return project.resolveMedia(value.replace(/^\.\//, ""));
+  } catch {
+    return null;
+  }
+}
+function replaceFiles(project, value, at, skip, onFile) {
+  if (typeof value === "string") {
+    const full = projectFile(project, value);
+    const digest = full ? contentDigest(full) : null;
+    if (!digest) return value;
+    onFile(at, value, digest);
+    return `file:${digest}`;
+  }
+  if (Array.isArray(value)) return value.map((item, index) => replaceFiles(project, item, `${at}[${index}]`, skip, onFile));
+  if (value && typeof value === "object") {
+    const out = {};
+    for (const name of Object.keys(value).sort()) {
+      const child = value[name];
+      const where = at ? `${at}.${name}` : name;
+      out[name] = !at && skip.has(name) ? child : replaceFiles(project, child, where, skip, onFile);
+    }
+    return out;
+  }
+  return value;
+}
+function stageCacheKey(project, stage, args, code, outputs = []) {
+  const inputs = {};
+  const params = replaceFiles(project, args, "", new Set(outputs), (where, _relative, digest) => {
+    inputs[where] = digest.slice(0, 16);
+  });
+  const cascade = cascadeVersion();
+  const blob = JSON.stringify({ format: CACHE_FORMAT, stage, code, cascade, params });
+  return { key: createHash2("sha256").update(blob).digest("hex").slice(0, 32), code, cascade, inputs };
+}
+function entryPath(project, stage, key) {
+  return project.resolve(path2.posix.join(CACHE_DIRECTORY, stage, `${key}.json`));
+}
+function resultFiles(project, result) {
+  const files = {};
+  replaceFiles(project, result, "", /* @__PURE__ */ new Set(), (_where, relative, digest) => {
+    files[relative] = digest;
+  });
+  return files;
+}
+function readEntry(project, stage, key) {
+  let entry;
+  try {
+    entry = JSON.parse(fs3.readFileSync(entryPath(project, stage, key), "utf8"));
+  } catch {
+    return { why: "no entry" };
+  }
+  if (entry.format !== CACHE_FORMAT || entry.key !== key) return { why: "no entry" };
+  for (const [relative, digest] of Object.entries(entry.outputs ?? {})) {
+    const full = projectFile(project, relative);
+    if (!full || contentDigest(full) !== digest) return { why: `output changed: ${relative}` };
+  }
+  return { result: entry.result };
+}
+function writeEntry(project, stage, key, result) {
+  const file = entryPath(project, stage, key);
+  const entry = { format: CACHE_FORMAT, stage, key, result, outputs: resultFiles(project, result) };
+  fs3.mkdirSync(path2.dirname(file), { recursive: true });
+  writeFileAtomicSync(file, JSON.stringify(entry));
+}
+function cacheMode(policy, stage, caller, env) {
+  if (env.CASCADE_STAGE_CACHE === "off") return { use: false, bypass: true, why: "CASCADE_STAGE_CACHE=off" };
+  if (!policy.enabled) return { use: false, bypass: false, why: "not enabled" };
+  if (policy.exclude.includes(stage)) return { use: false, bypass: false, why: "excluded" };
+  if (policy.scope === "cook" && caller !== "cook") return { use: false, bypass: false, why: "not a cook call" };
+  return { use: true, bypass: false };
+}
+function stageSources(project, config) {
+  return new StageSources(project, config.sources ?? StageSources.defaultRoots(project, config.entrypoint, config.worker));
+}
+async function callStage(project, config, stage, args, invoke, options = {}) {
+  const started = performance.now();
+  const code = stageSources(project, config).codeHash();
+  const identity = stageCacheKey(project, stage, args, code, config.cache.outputs);
+  const mode = cacheMode(config.cache, stage, options.caller ?? "cook", options.env ?? process.env);
+  const finish = (result, trace) => {
+    const full = {
+      stage,
+      key: identity.key,
+      ...trace,
+      code: identity.code,
+      cascade: identity.cascade,
+      inputs: identity.inputs,
+      ms: Math.round(performance.now() - started)
+    };
+    options.onTrace?.(full);
+    return { result, trace: full };
+  };
+  let why = mode.why;
+  if (mode.use) {
+    const stored = readEntry(project, stage, identity.key);
+    if ("result" in stored) return finish(stored.result, { cache: "hit" });
+    why = stored.why;
+  }
+  const answer = await invoke({ key: identity.key, code, cache: mode.bypass ? "off" : "use" });
+  if (mode.use) {
+    try {
+      writeEntry(project, stage, identity.key, answer.result);
+    } catch {
+    }
+  }
+  return finish(answer.result, {
+    cache: mode.use ? "miss" : "off",
+    ...why ? { why } : {},
+    ...answer.projectCache ? { project: answer.projectCache } : {},
+    ...answer.restarted ? { restarted: true } : {}
+  });
+}
+function formatStageTrace(trace) {
+  const reason = trace.why ? ` (${trace.why})` : "";
+  const project = trace.project ? ` project:${trace.project}` : "";
+  const restarted = trace.restarted ? " worker restarted for new code" : "";
+  return `${trace.stage}: ${trace.cache}${reason}${project} key ${trace.key.slice(0, 12)} code ${trace.code} ${trace.ms} ms${restarted}`;
+}
+
+export {
+  writeFileAtomic,
+  writeFileAtomicSync,
+  cascadeVersion,
+  stageCacheKey,
+  stageSources,
+  callStage,
+  formatStageTrace
+};
+//# sourceMappingURL=chunk-5ORUQ6ES.js.map

package/dist/cli/{chunk-YAT5Y25U.js → chunk-7QE2ZNSN.js}

@@ -52,7 +52,7 @@ async function encodeSequence(options) {
     if (frames[index] !== frames[index - 1] + 1) throw new Error("--mp4 needs a contiguous range of whole frames (no step)");
   }
   const { prefix, width, extension } = options.sequence;
-  const pattern = path.join(options.root, `${prefix}.%0${width}d${extension}`);
+  const pattern = path.resolve(options.root, `${prefix}.%0${width}d${extension}`);
   const output = path.resolve(options.root, options.file);
   await fs.mkdir(path.dirname(output), { recursive: true });
   const size = scale === 1 ? "pad=ceil(iw/2)*2:ceil(ih/2)*2" : `scale=trunc(iw*${scale}/2)*2:trunc(ih*${scale}/2)*2:flags=lanczos`;
@@ -60,7 +60,7 @@ async function encodeSequence(options) {
   let pixelFormat;
   let codecArgs;
   if (options.codec === "prores") {
-    const first = path.join(options.root, `${prefix}.${String(frames[0]).padStart(width, "0")}${extension}`);
+    const first = path.resolve(options.root, `${prefix}.${String(frames[0]).padStart(width, "0")}${extension}`);
     const alpha = await hasTransparency(first);
     pixelFormat = alpha ? "yuva444p10le" : "yuv422p10le";
     codecArgs = ["-c:v", "prores_ks", "-profile:v", alpha ? "4" : "3", "-vendor", "apl0", "-pix_fmt", pixelFormat];
@@ -118,4 +118,4 @@ export {
   hasFfmpeg,
   encodeSequence
 };
-//# sourceMappingURL=chunk-YAT5Y25U.js.map
+//# sourceMappingURL=chunk-7QE2ZNSN.js.map

package/dist/cli/{chunk-SGJAET2L.js → chunk-BPODRH52.js}

@@ -3,15 +3,16 @@ import {
   packagePathToType,
   registerNodeClasses,
   registerNodeMetadata
-} from "./chunk-FCDXJ6EK.js";
+} from "./chunk-CTPLRSWF.js";
 import {
   bundleValueProblem,
+  gpuLimitShortfall,
   graphSeed,
   isGpuHost,
   nodeSeed,
   seededRandom,
   selectBundleFields
-} from "./chunk-GFS6W3C5.js";
+} from "./chunk-L6B6FUQP.js";
 
 // src/nodes/definition/DefinitionNode.ts
 var silentProgress = { report: () => {
@@ -136,7 +137,10 @@ function attachDefinition(node, registration, capabilities) {
     const gpuHost = (definition.capabilities ?? []).includes("gpu") && isGpuHost(capabilities.gpu) ? capabilities.gpu : null;
     if (gpuHost) {
       await gpuHost.ensure();
-      nodeCapabilities = { ...capabilities, gpu: gpuHost.forNode(node.id) };
+      const gpu = gpuHost.forNode(node.id);
+      const shortfall = gpuLimitShortfall(node.id, definition.gpuLimits, gpu);
+      if (shortfall) throw new Error(shortfall);
+      nodeCapabilities = { ...capabilities, gpu };
     }
     const seed = nodeSeed(graphSeed({ seed: node.documentSeed }), node.id);
     const context = {
@@ -194,4 +198,4 @@ export {
   attachDefinition,
   registerDefinitionNodes
 };
-//# sourceMappingURL=chunk-SGJAET2L.js.map
+//# sourceMappingURL=chunk-BPODRH52.js.map

package/dist/cli/{chunk-XWDSKG7N.js → chunk-BZ63XQ3I.js}

@@ -1,6 +1,6 @@
 import {
   canConnectTypes
-} from "./chunk-BIJO5OFS.js";
+} from "./chunk-FWMSGKEH.js";
 
 // packages/runtime/src/edit/document.ts
 var SUBNET = "cascade.core.Subnet";
@@ -1298,4 +1298,4 @@ export {
   applyOperation,
   readGraph
 };
-//# sourceMappingURL=chunk-XWDSKG7N.js.map
+//# sourceMappingURL=chunk-BZ63XQ3I.js.map

package/dist/cli/{chunk-FCDXJ6EK.js → chunk-CTPLRSWF.js}

@@ -16,7 +16,7 @@ import {
   CORE_TYPES,
   canConnectTypes,
   normalizeCascadeType
-} from "./chunk-BIJO5OFS.js";
+} from "./chunk-FWMSGKEH.js";
 
 // src/utils/nodeTypeUtils.ts
 var nodeClassRegistries = /* @__PURE__ */ new Map();
@@ -136,16 +136,6 @@ function normalizeColor(input) {
   }
   return { r: 0, g: 0, b: 0, a: 1 };
 }
-function colorToCss(color) {
-  const r = Math.round(color.r * 255);
-  const g = Math.round(color.g * 255);
-  const b = Math.round(color.b * 255);
-  const a = color.a !== void 0 ? color.a : 1;
-  if (a < 1) {
-    return `rgba(${r},${g},${b},${a})`;
-  }
-  return `rgb(${r},${g},${b})`;
-}
 function isColorValue(value) {
   if (typeof value === "string") {
     return value.startsWith("#") || value.startsWith("rgb(");
@@ -2197,7 +2187,6 @@ export {
   isStandardLibraryNode,
   getNodeClass,
   normalizeColor,
-  colorToCss,
   isColorValue,
   CORE_TYPES2 as CORE_TYPES,
   isCoreType,
@@ -2205,4 +2194,4 @@ export {
   canConnect,
   Node
 };
-//# sourceMappingURL=chunk-FCDXJ6EK.js.map
+//# sourceMappingURL=chunk-CTPLRSWF.js.map

package/dist/cli/{chunk-WIH4TEIS.js → chunk-EZRWJ4G2.js}

@@ -101,4 +101,4 @@ export {
   canvasAvailable,
   installHeadlessCanvas
 };
-//# sourceMappingURL=chunk-WIH4TEIS.js.map
+//# sourceMappingURL=chunk-EZRWJ4G2.js.map

package/dist/cli/{chunk-BIJO5OFS.js → chunk-FWMSGKEH.js}

@@ -68,4 +68,4 @@ export {
   normalizeCascadeType,
   canConnectTypes
 };
-//# sourceMappingURL=chunk-BIJO5OFS.js.map
+//# sourceMappingURL=chunk-FWMSGKEH.js.map

package/dist/cli/{chunk-POMMNKZZ.js → chunk-G23A2BZZ.js}

@@ -118,6 +118,34 @@ var VERBS = [
       call: { kind: "cli", argv: (args, resolve) => ["export", resolve(args.graph), ...args.out ? ["--out", resolve(args.out)] : ["--plan"]] }
     }]
   },
+  {
+    ...editorVerb,
+    name: "share",
+    json: "keep",
+    usage: "<graph-file | site-directory> [--name <slug>] [--scope <team>] [--protected]",
+    summary: "Export and deploy to Vercel as cascade-<slug>; print the link and record it in shares.json",
+    mcp: [{
+      name: "share",
+      description: "Share a graph's editor, or a static directory with an index.html, as one link (cascade share): export, deploy to the Vercel project cascade-<name> and return `url`, recorded in the project's shares.json. Public unless `protected`.",
+      inputSchema: object({
+        graph: { type: "string", description: "The .cascade file or site directory, relative to the project directory" },
+        name: { type: "string", description: "Slug; the Vercel project is cascade-<name> (default: the editor id or directory name)" },
+        scope: { type: "string", description: "Vercel team (default field-io)" },
+        protected: { type: "boolean", description: "Require Vercel Authentication instead of a public link" }
+      }, ["graph"]),
+      call: {
+        kind: "cli",
+        argv: (args, resolve) => [
+          "share",
+          resolve(args.graph),
+          ...args.name ? ["--name", String(args.name)] : [],
+          ...args.scope ? ["--scope", String(args.scope)] : [],
+          ...args.protected ? ["--protected"] : []
+        ],
+        timeoutMs: () => 10 * 6e4
+      }
+    }]
+  },
   { ...editorVerb, name: "publish", usage: "<graph-file> <node>.<prop> [--label ...]", summary: "Publish a node prop as an editor parameter" },
   { ...editorVerb, name: "freeze", usage: "<graph-file> <node> --fields <a,b>", summary: "Snapshot chosen fields of a live data source for export" },
   { ...editorVerb, name: "scene", usage: "<graph-file> <scene.json> --out <new-graph-file>", summary: "Apply a scene file to a copy of the graph" },
@@ -434,11 +462,11 @@ var VERBS = [
   {
     ...lockVerb,
     name: "ladder",
-    usage: "<graph-file> <node> --name <name> --vary <node.prop>=<a,b,c> | --seeds <a,b,c>",
-    summary: "Cook 3-5 variants, write a labelled contact sheet and ladders/<id>.json",
+    usage: "<graph-file> <node> --name <name> --vary <node.prop>=<a,b,c> | --seeds <a,b,c> [--cairn <vault dir>]",
+    summary: "Cook 3-5 variants, write a labelled contact sheet and ladders/<id>.json; --cairn makes a tap-to-pick card",
     mcp: [{
       name: "ladder",
-      description: "Cook `node` once per variant (cascade ladder) and return the contact sheet, each variant image and the record ladders/<id>.json. `vary` maps node.prop to a list of values (zipped; one value applies to all); `seeds` varies the graph seed. Three to five variants is the usual.",
+      description: 'Cook `node` once per variant (cascade ladder) and return the contact sheet, each variant image and the record ladders/<id>.json. `vary` maps node.prop to a list of values (zipped; one value applies to all); `seeds` varies the graph seed. Three to five variants is the usual. `cairn` is a directory in the Substrate vault (the space\'s _attachments/ladders/<id>): each variant is copied there and `data.cairnChoice` is a cairn:choice fence to post as is (at most 8 variants); a tap comes back as "Picked: <label> (pick:<id>:<n>)", then call `pick` with ladder <id> and variant <n>.',
       inputSchema: object({
         graph,
         node: { type: "string" },
@@ -447,7 +475,9 @@ var VERBS = [
         seeds: { type: "array", items: { type: "integer" } },
         columns: { type: "integer" },
         note: { type: "string" },
-        live: { type: "boolean" }
+        live: { type: "boolean" },
+        cairn: { type: "string", description: "Absolute vault directory for the variant images; returns data.cairnChoice" },
+        vault: { type: "string", description: "Absolute vault root the cairnChoice image paths are relative to (default: nearest .obsidian or .git above `cairn`)" }
       }, ["graph", "node", "name"]),
       call: {
         kind: "cli",
@@ -457,6 +487,9 @@ var VERBS = [
           args.node,
           "--name",
           args.name,
+          // Outside the project by design (the vault), so passed as given: absolute.
+          ...args.cairn ? ["--cairn", String(args.cairn)] : [],
+          ...args.vault ? ["--vault", String(args.vault)] : [],
           ...Object.entries(args.vary ?? {}).flatMap(([key, values]) => [
             "--vary",
             `${key}=${(Array.isArray(values) ? values : [values]).map((value) => JSON.stringify(value)).join(",")}`
@@ -669,4 +702,4 @@ export {
   graphCommandsHelp,
   mainHelp
 };
-//# sourceMappingURL=chunk-POMMNKZZ.js.map
+//# sourceMappingURL=chunk-G23A2BZZ.js.map

package/dist/cli/{chunk-35D343DC.js → chunk-GRIN2DDP.js}

@@ -100,6 +100,23 @@ var Color = Object.freeze({
   opaque(color) {
     return [clamp(color[0]), clamp(color[1]), clamp(color[2]), 1];
   },
+  /**
+   * A colour saved in an older shape, as the one colour: `{ r, g, b, a? }`
+   * (the class-based image nodes stored that until 2026-11-07) or three
+   * components, with alpha 1. Components above 1 are read as 0–255, the way
+   * those nodes read them. Anything else comes back unchanged, so a reader can
+   * apply this to every stored `color` value and validate the result.
+   */
+  upgrade(value) {
+    const legacy = value !== null && typeof value === "object" && !Array.isArray(value) && "r" in value && "g" in value && "b" in value ? value : Array.isArray(value) && value.length === 3 ? { r: value[0], g: value[1], b: value[2] } : null;
+    if (!legacy) return value;
+    const parts = [legacy.r, legacy.g, legacy.b, legacy.a ?? 1];
+    if (!parts.every((part) => typeof part === "number" && Number.isFinite(part))) return value;
+    const numbers = parts;
+    const unit2 = numbers.slice(0, 3).every((part) => part <= 1);
+    const read = (part) => unit2 ? part : part / 255;
+    return [read(numbers[0]), read(numbers[1]), read(numbers[2]), legacy.a === void 0 ? 1 : read(numbers[3])];
+  },
   /**
    * Four unit components from anything indexable, clamping and defaulting a
    * missing alpha to 1. The reader for a `Cd` attribute's flat array, and the
@@ -1438,10 +1455,11 @@ var registrationsById = new Map(
 );
 
 export {
+  Color,
   LIGHT_DEFAULTS,
   isLight,
   isScene,
   geoNodeDefinitions,
   geoNodeRegistrations
 };
-//# sourceMappingURL=chunk-35D343DC.js.map
+//# sourceMappingURL=chunk-GRIN2DDP.js.map