@field/cascade 0.8.0 → 0.11.0

package/dist/cli/definitions-HF2FTHYU.js

@@ -0,0 +1,32 @@
+import {
+  registerDefinitionNodes
+} from "./chunk-SGJAET2L.js";
+import "./chunk-FCDXJ6EK.js";
+import "./chunk-RUU3YWXU.js";
+import {
+  cameraRegistration,
+  feedbackRegistration,
+  frozenRegistration,
+  packRegistration,
+  pickRegistration,
+  previousRegistration,
+  timeRegistration
+} from "./chunk-D6BUOHUG.js";
+import "./chunk-RXDIMXN5.js";
+import "./chunk-DEQSEFFH.js";
+import "./chunk-GFS6W3C5.js";
+import "./chunk-HFHWYL55.js";
+import "./chunk-CO22XHNG.js";
+import "./chunk-BIJO5OFS.js";
+
+// src/nodes/core/definitions.ts
+registerDefinitionNodes([
+  cameraRegistration,
+  timeRegistration,
+  feedbackRegistration,
+  previousRegistration,
+  pickRegistration,
+  packRegistration,
+  frozenRegistration
+]);
+//# sourceMappingURL=definitions-HF2FTHYU.js.map

package/dist/cli/doctorCommand-B7BPQMN6.js

@@ -0,0 +1,76 @@
+import {
+  provisionPythonEnv,
+  pythonEnvStatus
+} from "./chunk-WD62JIP6.js";
+
+// src/cli/doctorCommand.ts
+import { execFile } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+var DOCTOR_USAGE = "cascade doctor [project-directory] [--fix] [--json]";
+async function runDoctorCommand(args) {
+  const fix = args.includes("--fix");
+  const json = args.includes("--json");
+  const root = path.resolve(args.slice(1).find((arg) => !arg.startsWith("-")) ?? ".");
+  if (!fs.existsSync(root) || !fs.statSync(root).isDirectory()) throw new Error(`${root} is not a directory`);
+  const checks = await doctor(root, { fix, log: (line) => {
+    if (!json) console.log(line);
+  } });
+  const ok = checks.every((check) => check.ok || check.optional);
+  if (json) process.stdout.write(`${JSON.stringify({ project: root, ok, checks })}
+`);
+  else for (const check of checks) console.log(`${check.ok ? "ok  " : check.optional ? "warn" : "FAIL"}  ${check.name}: ${check.detail}`);
+  if (!ok) {
+    if (json) console.error(checks.filter((check) => !check.ok && !check.optional).map((check) => `${check.name}: ${check.detail}`).join("\n"));
+    process.exitCode = 1;
+  }
+}
+async function doctor(root, options = {}) {
+  const checks = [];
+  let env;
+  try {
+    env = pythonEnvStatus(root);
+    if (env.declared && env.state !== "current" && options.fix) env = await provisionPythonEnv(root, options.log);
+    checks.push(env.state === "none" ? { name: "python environment", ok: true, detail: 'none declared (cascade.json "python": { "requirements": [...] } provisions one)' } : env.state === "current" ? { name: "python environment", ok: true, detail: `current, ${path.relative(root, env.directory)}` } : { name: "python environment", ok: false, detail: `${env.state}: ${env.reason}. Run cascade doctor --fix` });
+  } catch (error) {
+    checks.push({ name: "python environment", ok: false, detail: error instanceof Error ? error.message : String(error) });
+  }
+  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 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}` });
+    } catch (error) {
+      checks.push({ name: "stage interpreter", ok: false, detail: error instanceof Error ? error.message : String(error) });
+    }
+  }
+  const { hasFfmpeg } = await import("./encode-HAUZTYPT.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");
+  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;
+}
+function hasStages(root) {
+  try {
+    const manifest = JSON.parse(fs.readFileSync(path.join(root, "cascade.json"), "utf8"));
+    return Boolean(manifest?.exec?.stages);
+  } catch {
+    return false;
+  }
+}
+function output(command, args, cwd) {
+  return new Promise((resolve, reject) => {
+    execFile(command, args, { cwd, timeout: 3e4 }, (error, stdout, stderr) => {
+      if (error) reject(new Error(`${command} does not start: ${(stderr || error.message).trim().slice(-500)}`));
+      else resolve(stdout.trim());
+    });
+  });
+}
+export {
+  DOCTOR_USAGE,
+  doctor,
+  runDoctorCommand
+};
+//# sourceMappingURL=doctorCommand-B7BPQMN6.js.map

package/dist/cli/edit-JHCPTQFT.js

@@ -0,0 +1,28 @@
+import {
+  GRAPH_EDIT_OPERATIONS,
+  GraphEditError,
+  GraphEditor,
+  applyOperation,
+  defaultIdFor,
+  flowStep,
+  placeNode,
+  readGraph,
+  readWire,
+  splitEndpoint,
+  wireLabel
+} from "./chunk-XWDSKG7N.js";
+import "./chunk-BIJO5OFS.js";
+export {
+  GRAPH_EDIT_OPERATIONS,
+  GraphEditError,
+  GraphEditor,
+  applyOperation,
+  defaultIdFor,
+  flowStep,
+  placeNode,
+  readGraph,
+  readWire,
+  splitEndpoint,
+  wireLabel
+};
+//# sourceMappingURL=edit-JHCPTQFT.js.map

package/dist/cli/editorCommands-UIF5YLUZ.js

@@ -0,0 +1,33 @@
+import {
+  EDITOR_COMMANDS,
+  EDITOR_HELP,
+  runEditorCommand,
+  sceneDocument
+} from "./chunk-WKURDVYP.js";
+import "./chunk-3JTJHF7V.js";
+import "./chunk-EUIAC3U3.js";
+import "./chunk-36P5K3SD.js";
+import "./chunk-D6BUOHUG.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 "./chunk-ICH7N5PN.js";
+import "./chunk-GFS6W3C5.js";
+import "./chunk-HFHWYL55.js";
+import "./chunk-CO22XHNG.js";
+import "./chunk-RQZ4SX5R.js";
+import "./chunk-A4OAMOZH.js";
+import "./chunk-J7VK7MNF.js";
+import "./chunk-XWDSKG7N.js";
+import "./chunk-BIJO5OFS.js";
+import "./chunk-WIH4TEIS.js";
+export {
+  EDITOR_COMMANDS,
+  EDITOR_HELP,
+  runEditorCommand,
+  sceneDocument
+};
+//# sourceMappingURL=editorCommands-UIF5YLUZ.js.map

package/dist/cli/encode-HAUZTYPT.js

@@ -0,0 +1,17 @@
+import {
+  DEFAULT_CRF,
+  encodeMp4,
+  encodeSequence,
+  frameSequences,
+  hasFfmpeg,
+  timelineFrameSpec
+} from "./chunk-YAT5Y25U.js";
+export {
+  DEFAULT_CRF,
+  encodeMp4,
+  encodeSequence,
+  frameSequences,
+  hasFfmpeg,
+  timelineFrameSpec
+};
+//# sourceMappingURL=encode-HAUZTYPT.js.map

package/dist/cli/frames-LSAUBZ7P.js

@@ -0,0 +1,16 @@
+import {
+  cookUntilSettled,
+  outputPorts,
+  parseFrameSpec,
+  renderFrameRange
+} from "./chunk-BP7UKF36.js";
+import "./chunk-RUU3YWXU.js";
+import "./chunk-ICH7N5PN.js";
+import "./chunk-CO22XHNG.js";
+export {
+  cookUntilSettled,
+  outputPorts,
+  parseFrameSpec,
+  renderFrameRange
+};
+//# sourceMappingURL=frames-LSAUBZ7P.js.map

package/dist/cli/geo-4RNK3QVN.js

@@ -0,0 +1,43 @@
+import {
+  browserAssetCapability
+} from "./chunk-53NMBJAO.js";
+import {
+  registerDefinitionNodes
+} from "./chunk-SGJAET2L.js";
+import "./chunk-FCDXJ6EK.js";
+import "./chunk-RUU3YWXU.js";
+import {
+  geoNodeDefinitions,
+  geoNodeRegistrations
+} from "./chunk-35D343DC.js";
+import "./chunk-DEQSEFFH.js";
+import "./chunk-HSNOBIVT.js";
+import "./chunk-GFS6W3C5.js";
+import "./chunk-HFHWYL55.js";
+import "./chunk-CO22XHNG.js";
+import "./chunk-J7VK7MNF.js";
+import "./chunk-BIJO5OFS.js";
+
+// src/nodes/geo/library.ts
+var geoLibrary = {
+  id: "geo",
+  label: "Geometry",
+  icon: "Shapes",
+  categories: [{
+    id: "geometry",
+    label: "Geometry",
+    nodes: geoNodeDefinitions.map(([moduleId, definition]) => ({
+      name: definition.label ?? moduleId.split(".").pop(),
+      icon: definition.icon ?? "Shapes",
+      description: definition.description ?? "",
+      type: moduleId
+    }))
+  }]
+};
+
+// src/nodes/geo/index.ts
+registerDefinitionNodes(geoNodeRegistrations, { assets: browserAssetCapability });
+export {
+  geoLibrary
+};
+//# sourceMappingURL=geo-4RNK3QVN.js.map

package/dist/cli/graphCommands-6BMAKGQE.js

@@ -0,0 +1,184 @@
+import {
+  VERBS,
+  graphOptions
+} from "./chunk-POMMNKZZ.js";
+
+// src/cli/graphCommands.ts
+import fs from "node:fs/promises";
+import path from "node:path";
+var loadGraphFile = async () => (await import("./graphFile-VPSQ6OF7.js")).GraphFile;
+async function runGraphCommand(args, options) {
+  const parsed = parseArguments(args);
+  const [command, ...rest] = parsed.positional;
+  const say = options.json ? () => {
+  } : (line) => console.log(line);
+  if (command === "graph") {
+    const [sub, file2] = rest;
+    if (sub === "create") {
+      const created = await (await loadGraphFile()).create(required(file2, "cascade graph create <graph>"), optional(parsed.values.name));
+      say(`created ${created}`);
+      return { file: created };
+    }
+    if (sub === "read") {
+      const graph = await (await loadGraphFile()).open(required(file2, "cascade graph read <graph>"));
+      const { readGraph } = await import("./edit-JHCPTQFT.js");
+      const read = readGraph(graph.document, optional(parsed.values.in, "in"));
+      if (!options.json) printGraph(read);
+      return { file: graph.file, ...read };
+    }
+    if (sub === "list") {
+      const listed = await listGraphs(file2 ?? ".");
+      for (const entry of listed) say(`${entry.file}  ${entry.name ?? ""}  (${entry.nodes} nodes, ${entry.wires} wires)`);
+      return { graphs: listed };
+    }
+    throw new Error("usage: cascade graph create|read|list ...");
+  }
+  const twoWords = command === "node" || command === "subnet";
+  const [file, ...operands] = twoWords ? rest.slice(1) : rest;
+  const graphFile = required(file, `cascade ${command} <graph> ...`);
+  const operations = command === "edit" ? await readOperations(required(operands[0], "cascade edit <graph> <operations.json | ->")) : [operationFor(twoWords ? `${command} ${rest[0]}` : command, operands, parsed)];
+  return applyEdits(graphFile, operations, { dryRun: parsed.flags.has("dry-run"), json: options.json });
+}
+function operationFor(name, operands, parsed) {
+  const verb = VERBS.find((candidate) => candidate.handler === "graph" && (candidate.name === name || candidate.aliases?.includes(name)));
+  if (!verb?.operation) throw new Error(`Unknown graph command: cascade ${name}. Run "cascade --help".`);
+  return verb.operation(operands, parsed);
+}
+async function applyEdits(file, operations, options = {}) {
+  const graph = await (await loadGraphFile()).open(file);
+  const outcome = await graph.applyAll(operations, { dryRun: options.dryRun === true });
+  if (!options.json) for (const result of outcome.results) console.log(describe(result));
+  for (const warning of outcome.warnings) console.warn(options.json ? warning : `warning: ${warning}`);
+  if (options.dryRun && !options.json) console.log("dry run: nothing written");
+  return { file: graph.file, changed: outcome.changed, dryRun: options.dryRun === true, results: outcome.results };
+}
+function describe(result) {
+  const node = result.node;
+  const at = (summary) => `${summary.position.x},${summary.position.y}`;
+  switch (result.op) {
+    case "node.add":
+      return `added ${node.id} (${node.module})${node.parent ? ` in ${node.parent}` : ""} at ${at(node)}`;
+    case "node.remove": {
+      const wires = result.wires;
+      return `removed ${result.removed.join(", ")}${wires.length ? `; unwired ${wires.join(", ")}` : ""}`;
+    }
+    case "connect": {
+      const moved = result.moved;
+      return `connected ${result.wire}${result.replaced ? ` (replaced ${result.replaced})` : ""}${moved ? `; placed ${moved.id} at ${at(moved)}` : ""}`;
+    }
+    case "disconnect":
+      return `disconnected ${result.removed.join(", ")}`;
+    case "set":
+      return `set ${result.node}.${result.param}: ${show(result.before)} -> ${show(result.after)}`;
+    case "subnet.create": {
+      const subnet = result.subnet;
+      const inputs = result.inputs;
+      const outputs = result.outputs;
+      return `created subnet ${subnet.id}${inputs.length ? `; inputs ${inputs.join(", ")}` : ""}${outputs.length ? `; outputs ${outputs.join(", ")}` : ""}`;
+    }
+    case "subnet.move":
+      return `moved ${result.moved.join(", ")} to ${result.to ?? "the top level"}`;
+    case "subnet.dissolve":
+      return `dissolved; lifted ${result.lifted.join(", ") || "nothing"}`;
+    default:
+      return JSON.stringify(result);
+  }
+}
+function show(value) {
+  return value === void 0 || value === null ? "(default)" : JSON.stringify(value);
+}
+function printGraph(read) {
+  console.log(`${read.name ?? "(untitled)"}: ${read.nodes.length} nodes, ${read.wires.length} wires`);
+  const byParent = /* @__PURE__ */ new Map();
+  for (const node of read.nodes) byParent.set(node.parent, [...byParent.get(node.parent) ?? [], node]);
+  const print = (parent, depth) => {
+    for (const node of byParent.get(parent) ?? []) {
+      const ports = node.ports ? `  in: ${node.ports.inputs.join(", ") || "-"}  out: ${node.ports.outputs.join(", ") || "-"}` : "";
+      const props = node.props ? `  ${JSON.stringify(node.props)}` : "";
+      console.log(`${"  ".repeat(depth)}${node.id}  ${node.module}${ports}${props}`);
+      print(node.id, depth + 1);
+    }
+  };
+  print(read.nodes.some((node) => node.parent === null) ? null : read.nodes[0]?.parent ?? null, 1);
+  if (read.wires.length) console.log("wires:");
+  for (const wire of read.wires) console.log(`  ${wire}`);
+}
+async function listGraphs(directory) {
+  const skip = /* @__PURE__ */ new Set(["node_modules", ".git", "dist", ".cascade-cache", ".cascade", "renders", "out"]);
+  const found = [];
+  const walk = async (dir, depth) => {
+    let entries;
+    try {
+      entries = await fs.readdir(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
+      if (entry.isDirectory() && depth < 3 && !skip.has(entry.name) && !entry.name.startsWith(".")) await walk(path.join(dir, entry.name), depth + 1);
+      else if (entry.isFile() && entry.name.endsWith(".cascade")) found.push(path.join(dir, entry.name));
+    }
+  };
+  await walk(path.resolve(directory), 0);
+  return Promise.all(found.map(async (file) => {
+    try {
+      const document = JSON.parse(await fs.readFile(file, "utf8"));
+      return {
+        file: path.relative(process.cwd(), file) || file,
+        name: typeof document.metadata?.name === "string" ? document.metadata.name : null,
+        nodes: Array.isArray(document.nodes) ? document.nodes.length : 0,
+        wires: Array.isArray(document.connections) ? document.connections.length : 0
+      };
+    } catch {
+      return { file: path.relative(process.cwd(), file) || file, name: null, nodes: 0, wires: 0 };
+    }
+  }));
+}
+async function readOperations(source) {
+  const text = source === "-" ? await readStdin() : await fs.readFile(source, "utf8");
+  const parsed = JSON.parse(text);
+  const operations = Array.isArray(parsed) ? parsed : parsed?.operations;
+  if (!Array.isArray(operations)) throw new Error('cascade edit expects a JSON array of operations, or { "operations": [...] }');
+  return operations;
+}
+async function readStdin() {
+  const chunks = [];
+  for await (const chunk of process.stdin) chunks.push(chunk);
+  return Buffer.concat(chunks).toString("utf8");
+}
+var OPTIONS = graphOptions();
+function parseArguments(args) {
+  const positional = [];
+  const values = {};
+  const lists = {};
+  const flags = /* @__PURE__ */ new Set();
+  for (let index = 0; index < args.length; index += 1) {
+    const argument = args[index];
+    if (!argument.startsWith("--")) {
+      positional.push(argument);
+      continue;
+    }
+    const [name, inline] = argument.slice(2).split(/=(.*)/s, 2);
+    if (OPTIONS.flag.has(name)) {
+      flags.add(name);
+      continue;
+    }
+    if (!OPTIONS.value.has(name) && !OPTIONS.list.has(name)) throw new Error(`Unknown option --${name}`);
+    const value = inline ?? args[++index];
+    if (value === void 0) throw new Error(`--${name} needs a value`);
+    if (OPTIONS.list.has(name)) (lists[name] ??= []).push(value);
+    else values[name] = value;
+  }
+  return { positional, values, lists, flags };
+}
+function required(value, usage) {
+  if (!value) throw new Error(`usage: ${usage}`);
+  return value;
+}
+function optional(value, key = "name") {
+  return value === void 0 ? {} : { [key]: value };
+}
+export {
+  applyEdits,
+  runGraphCommand
+};
+//# sourceMappingURL=graphCommands-6BMAKGQE.js.map