@field/cascade 0.10.0 → 0.11.0

package/dist/cli/chunk-BP7UKF36.js

@@ -0,0 +1,376 @@
+import {
+  expressionEngine
+} from "./chunk-RUU3YWXU.js";
+import {
+  imagePath,
+  sequenceFileName,
+  sequenceWidth
+} from "./chunk-ICH7N5PN.js";
+import {
+  TimeState,
+  runFrameRange
+} from "./chunk-CO22XHNG.js";
+
+// src/cli/frames.ts
+import fs from "node:fs/promises";
+import path from "node:path";
+
+// src/engine/cascade.ts
+var CascadeContext = class {
+  constructor() {
+    this._graph = null;
+    this._pwd = null;
+    /**
+     * Time state. Frames are stored as real numbers: `frame()` reports the
+     * integer frame ($F) and `fframe()` the fractional one ($FF), so sub-frame
+     * time exists rather than being floored away at the door.
+     */
+    this._time = new TimeState();
+    this._selectedNodes = /* @__PURE__ */ new Set();
+  }
+  /**
+   * Initialize with a graph reference
+   */
+  setGraph(graph) {
+    this._graph = graph;
+    expressionEngine.setGraph(graph);
+  }
+  /**
+   * Get the current graph
+   */
+  getGraph() {
+    return this._graph;
+  }
+  // ============ Node Access ============
+  /**
+   * Find a node by path (absolute or relative to pwd)
+   */
+  node(path2) {
+    if (!this._graph) return null;
+    if (path2.startsWith("/")) {
+      return this.resolveAbsolutePath(path2);
+    }
+    if (this._pwd) {
+      return this._pwd.node(path2);
+    }
+    return this.resolveAbsolutePath("/" + path2);
+  }
+  /**
+   * Find a parameter by path (e.g., "/node1/radius")
+   */
+  parm(path2) {
+    const lastSlash = path2.lastIndexOf("/");
+    if (lastSlash === -1) return null;
+    const nodePath = path2.substring(0, lastSlash) || "/";
+    const parmName = path2.substring(lastSlash + 1);
+    const node = this.node(nodePath);
+    return node?.parm(parmName) ?? null;
+  }
+  /**
+   * Get the root node (virtual - returns null, represents "/")
+   * In Cascade, root is not a real node but the graph itself
+   */
+  root() {
+    return null;
+  }
+  /**
+   * Get current working directory/network
+   */
+  pwd() {
+    return this._pwd;
+  }
+  /**
+   * Set current working directory/network
+   */
+  setPwd(node) {
+    this._pwd = node;
+  }
+  /**
+   * Navigate to a path (like cd command)
+   */
+  cd(path2) {
+    if (path2 === "/") {
+      this._pwd = null;
+      return;
+    }
+    const target = this.node(path2);
+    if (target && target.isNetwork()) {
+      this._pwd = target;
+    }
+  }
+  // ============ Selection ============
+  /**
+   * Get all selected nodes
+   */
+  selectedNodes() {
+    if (!this._graph) return [];
+    return Array.from(this._selectedNodes).map((id) => this._graph.getNode(id)).filter((n) => n !== null);
+  }
+  /**
+   * Get selected node IDs
+   */
+  selectedNodeIds() {
+    return Array.from(this._selectedNodes);
+  }
+  /**
+   * Set selection (internal use by editor)
+   */
+  setSelection(nodeIds) {
+    this._selectedNodes = new Set(nodeIds);
+    this.onSelectionChange?.(nodeIds);
+  }
+  /**
+   * Clear all selection
+   */
+  clearAllSelected() {
+    this._selectedNodes.clear();
+    this.onSelectionChange?.([]);
+  }
+  // ============ Time/Playback ============
+  /**
+   * Get current frame number (integer) — $F
+   */
+  frame() {
+    return this._time.frame;
+  }
+  /**
+   * Get current frame as a fractional value — $FF
+   */
+  fframe() {
+    return this._time.frameFraction;
+  }
+  /**
+   * Get current time in seconds — $T
+   */
+  time() {
+    return this._time.time;
+  }
+  /**
+   * Get frames per second — $FPS
+   */
+  fps() {
+    return this._time.fps;
+  }
+  /**
+   * Set current frame. Fractional frames are preserved; `frame()` still
+   * reports the floored integer frame.
+   */
+  setFrame(frame) {
+    this._time.setFrame(frame);
+    expressionEngine.setFrame(this._time.frameFraction);
+  }
+  /**
+   * Set current time in seconds, keeping the sub-frame remainder
+   */
+  setTime(time) {
+    this._time.setTime(time);
+    expressionEngine.setFrame(this._time.frameFraction);
+  }
+  /**
+   * Set FPS
+   */
+  setFps(fps) {
+    this._time.setFps(fps);
+    expressionEngine.setFps(this._time.fps);
+  }
+  /**
+   * The clock a frame-range loop drives. Nothing here reads a wall clock —
+   * the caller owns time, which is what keeps a cook deterministic.
+   */
+  clock() {
+    return {
+      setFrame: (frame) => this.setFrame(frame),
+      markTimeDependentDirty: () => this.markTimeDependentDirty(),
+      getFrame: () => this.frame(),
+      getFrameFraction: () => this.fframe(),
+      getTime: () => this.time(),
+      getFps: () => this.fps()
+    };
+  }
+  // ============ Channel Shortcuts ============
+  /**
+   * Get parameter value as number (shorthand)
+   */
+  ch(path2) {
+    const p = this.parm(path2);
+    return p?.evalAsFloat() ?? 0;
+  }
+  /**
+   * Get parameter value as string (shorthand)
+   */
+  chs(path2) {
+    const p = this.parm(path2);
+    return p?.evalAsString() ?? "";
+  }
+  /**
+   * Get parameter value as vector (shorthand)
+   */
+  chv(path2) {
+    const p = this.parm(path2);
+    const val = p?.eval();
+    if (Array.isArray(val)) return val;
+    if (typeof val === "number") return [val];
+    return [];
+  }
+  // ============ Time-Dependent Updates ============
+  /**
+   * Mark all time-dependent nodes as dirty
+   * Call this at the start of each frame in the animation loop
+   */
+  markTimeDependentDirty() {
+    if (!this._graph) return;
+    for (const node of this._graph.nodes) {
+      if (node.isTimeDependent) {
+        node.markDirty();
+      }
+    }
+  }
+  /**
+   * Get all time-dependent nodes in the graph
+   */
+  getTimeDependentNodes() {
+    if (!this._graph) return [];
+    return this._graph.nodes.filter((n) => n.isTimeDependent);
+  }
+  /**
+   * Advance the frame and mark time-dependent nodes dirty.
+   * Convenience method for animation loops; `step` may be fractional.
+   * Returns the new fractional frame.
+   */
+  nextFrame(step = 1) {
+    this.setFrame(this.fframe() + step);
+    this.markTimeDependentDirty();
+    return this.fframe();
+  }
+  // ============ Internal Helpers ============
+  resolveAbsolutePath(path2) {
+    if (!this._graph) return null;
+    const segments = path2.replace(/^\//, "").split("/").filter((s) => s.length > 0);
+    if (segments.length === 0) {
+      return null;
+    }
+    let current = null;
+    const rootNodes = this._graph.nodes.filter((n) => !n.parent);
+    for (let i = 0; i < segments.length; i++) {
+      const segment = segments[i];
+      const searchIn = current ? current.children() : rootNodes;
+      const found = searchIn.find((n) => n.id === segment);
+      if (!found) return null;
+      current = found;
+    }
+    return current;
+  }
+};
+var cascade = new CascadeContext();
+
+// src/engine/animation/frameRange.ts
+async function evaluateFrameRange(options) {
+  const { fps, context = cascade, ...rest } = options;
+  const previousFps = context.fps();
+  if (fps !== void 0) context.setFps(fps);
+  try {
+    return await runFrameRange(context.clock(), rest);
+  } finally {
+    if (fps !== void 0) context.setFps(previousFps);
+  }
+}
+
+// src/cli/frames.ts
+function parseFrameSpec(spec) {
+  const text = String(spec ?? "").trim();
+  const match = /^(-?\d+(?:\.\d+)?)(?:\s*[-:]\s*(-?\d+(?:\.\d+)?))?(?:\s*x\s*(\d+(?:\.\d+)?))?$/i.exec(text);
+  if (!match) {
+    throw new Error(`--frames expects a range like 1-100, 1-100x2, or a single frame like 42 (got "${spec}")`);
+  }
+  const start = Number(match[1]);
+  const end = match[2] === void 0 ? start : Number(match[2]);
+  const step = match[3] === void 0 ? void 0 : Number(match[3]);
+  if (end < start) throw new Error(`--frames: end (${end}) must not be before start (${start})`);
+  if (step !== void 0 && !(step > 0)) throw new Error(`--frames: step must be greater than 0 (got ${step})`);
+  return step === void 0 ? { start, end } : { start, end, step };
+}
+function outputPorts(graph, entryNode) {
+  const nodes = entryNode ? [entryNode] : graph.nodes;
+  const found = [];
+  for (const node of nodes) {
+    for (const port of node.outputs) {
+      if (port.dataType !== "image") continue;
+      if (!entryNode && port.connections.length > 0) continue;
+      found.push({ node, port });
+    }
+  }
+  return found;
+}
+function outputSnapshot(graph) {
+  return JSON.stringify(graph.nodes.map((node) => [node.id, node.outputs.map((port) => port.value ?? null)]));
+}
+async function cookUntilSettled(graph, entryNode, options = {}) {
+  const { fixpoint = false, passes = 8 } = options;
+  const dirtyAll = () => {
+    for (const node of graph.nodes) node.markDirty?.();
+  };
+  let previous = fixpoint ? outputSnapshot(graph) : null;
+  for (let pass = 0; pass < passes; pass++) {
+    await graph.execute(entryNode);
+    await graph.scheduler?.whenIdle?.();
+    if (graph.nodes.some((node) => node.error !== null)) return;
+    const stale = graph.nodes.some((node) => node.cookState === "stale" || node.cookState === "queued");
+    if (!fixpoint) {
+      if (!stale) return;
+      continue;
+    }
+    const snapshot = outputSnapshot(graph);
+    const settled = !stale && snapshot === previous;
+    previous = snapshot;
+    if (settled) return;
+    dirtyAll();
+  }
+  throw new Error(`graph did not settle after ${passes} cook passes`);
+}
+async function renderFrameRange(options) {
+  const { graph, project, out, start, end, step, fps, entryNode, verbose, signal } = options;
+  cascade.setGraph(graph);
+  const outDirectory = project.resolve(out);
+  await fs.mkdir(outDirectory, { recursive: true });
+  const files = [];
+  const width = sequenceWidth(end);
+  const result = await evaluateFrameRange({
+    start,
+    end,
+    step,
+    fps,
+    signal,
+    onFrame: async ({ frame, index, total }) => {
+      if (index === 0) for (const node of graph.nodes) node.markDirty();
+      await cookUntilSettled(graph, entryNode, { fixpoint: index === 0 });
+      const failed = graph.nodes.filter((node) => node.error !== null);
+      if (failed.length) {
+        const detail = failed.map((node) => `${node.id}: ${node.error?.message ?? "unknown cook error"}`).join("; ");
+        throw new Error(`frame ${frame} failed \u2014 ${detail}`);
+      }
+      const ports = outputPorts(graph, entryNode);
+      if (!ports.length) {
+        throw new Error(
+          "No image output to save: the graph has no unconsumed image port. Name the node to render with --entry-node."
+        );
+      }
+      for (const { node, port } of ports) {
+        const source = imagePath(port.value);
+        if (!source) continue;
+        const name = sequenceFileName(node.id, frame, source, width);
+        await fs.copyFile(project.resolveMedia(source), path.join(outDirectory, name));
+        files.push(path.posix.join(out, name));
+      }
+      if (verbose) console.log(`  frame ${frame} (${index + 1}/${total})`);
+    }
+  });
+  return { frames: result.frames, files, aborted: result.aborted };
+}
+
+export {
+  parseFrameSpec,
+  outputPorts,
+  cookUntilSettled,
+  renderFrameRange
+};
+//# sourceMappingURL=chunk-BP7UKF36.js.map

package/dist/cli/chunk-CKS2FQWR.js

@@ -0,0 +1,89 @@
+// src/cli/jsonEnvelope.ts
+var ExitRequested = class extends Error {
+  constructor(code) {
+    super("");
+    this.code = code;
+  }
+};
+async function captureEnvelope(command) {
+  const logged = [];
+  const warnings = [];
+  const errors = [];
+  const original = {
+    log: console.log,
+    info: console.info,
+    warn: console.warn,
+    error: console.error,
+    write: process.stdout.write,
+    exit: process.exit
+  };
+  const text = (args) => args.map((arg) => typeof arg === "string" ? arg : arg instanceof Error ? arg.message : JSON.stringify(arg)).join(" ");
+  console.log = (...args) => {
+    logged.push(text(args));
+  };
+  console.info = console.log;
+  console.warn = (...args) => {
+    warnings.push(text(args));
+  };
+  console.error = (...args) => {
+    errors.push(text(args));
+  };
+  process.stdout.write = ((chunk) => {
+    logged.push(String(chunk));
+    return true;
+  });
+  process.exit = ((code) => {
+    throw new ExitRequested(typeof code === "number" ? code : 0);
+  });
+  let result;
+  let failure = null;
+  try {
+    result = await command();
+    if (process.exitCode && process.exitCode !== 0) failure = errors.join("\n") || `exited with code ${process.exitCode}`;
+  } catch (error) {
+    if (error instanceof ExitRequested) {
+      if (error.code !== 0) failure = errors.join("\n") || `exited with code ${error.code}`;
+    } else {
+      failure = error instanceof Error ? error.message : String(error);
+    }
+  } finally {
+    console.log = original.log;
+    console.info = original.info;
+    console.warn = original.warn;
+    console.error = original.error;
+    process.stdout.write = original.write;
+    process.exit = original.exit;
+  }
+  const allWarnings = [...warnings, ...failure ? [] : errors].flatMap(splitLines);
+  if (failure) return { ok: false, error: { message: failure.replace(/^Error: /, "") }, warnings: allWarnings };
+  return { ok: true, data: result !== void 0 ? result : dataFromOutput(logged), warnings: allWarnings };
+}
+async function runWithJsonEnvelope(command) {
+  const envelope = await captureEnvelope(command);
+  process.stdout.write(`${JSON.stringify(envelope)}
+`);
+  process.exitCode = envelope.ok ? 0 : 1;
+}
+function dataFromOutput(chunks) {
+  const output = chunks.join("\n").trim();
+  if (!output) return null;
+  try {
+    return JSON.parse(output);
+  } catch {
+    const lines = output.split("\n").filter(Boolean);
+    try {
+      return JSON.parse(lines[lines.length - 1]);
+    } catch {
+      return { output: lines };
+    }
+  }
+}
+function splitLines(text) {
+  return text.split("\n").map((line) => line.trimEnd()).filter((line) => line.trim());
+}
+
+export {
+  captureEnvelope,
+  runWithJsonEnvelope
+};
+//# sourceMappingURL=chunk-CKS2FQWR.js.map