@field/cascade 0.10.0 → 0.12.0

package/dist/cli/chunk-73S4JZXK.js

@@ -0,0 +1,336 @@
+import {
+  installHeadlessCanvas
+} from "./chunk-EZRWJ4G2.js";
+import {
+  applyScene,
+  exportEditor,
+  formatPlan,
+  fromBase64,
+  parseScene
+} from "./chunk-3RXL5GHB.js";
+import {
+  cookProjectGraph,
+  installProjectIo
+} from "./chunk-MP653A5O.js";
+import {
+  ProjectRoot
+} from "./chunk-2JEU3MGB.js";
+
+// src/cli/editorCommands.ts
+import fs from "node:fs/promises";
+import path from "node:path";
+var EDITOR_COMMANDS = ["export", "share", "freeze", "publish", "scene"];
+var EDITOR_HELP = `
+Shareable editors (see doc/EDITOR_EXPORT.md):
+  cascade export <graph> --plan                 Print what would ship, build nothing
+  cascade export <graph> --out <dir> [--deploy vercel [--project <name>] [--scope <team>] [--public]]
+  cascade share <graph | site-dir> [--name <slug>] [--scope <team>] [--protected]   Deploy as cascade-<slug>, print the link
+  cascade publish <graph> <node>.<prop> [--id <id>] [--label <text>] [--group <name>]
+                  [--control <kind>] [--min n] [--max n] [--step n] [--help <text>] [--remove]
+  cascade freeze <graph> <node> --fields <a,b.c> [--output <port>] [--personal <a,..>]
+  cascade scene <graph> <scene.json> --out <new-graph.cascade>
+  cascade run <graph> --scene <scene.json> [--write <node>.<port>=<file>]...
+`;
+async function runEditorCommand(args) {
+  const [command, graph] = args;
+  if (command === "share") {
+    const { runShareCommand } = await import("./share-MHF6TNRK.js");
+    return runShareCommand(args);
+  }
+  if (!graph || graph.startsWith("-")) throw new Error(`cascade ${command} requires a graph file`);
+  const flags = parseFlags(args.slice(2));
+  switch (command) {
+    case "export":
+      return exportCommand(graph, flags);
+    case "publish":
+      return publishCommand(graph, flags);
+    case "freeze":
+      return freezeCommand(graph, flags);
+    case "scene":
+      return sceneCommand(graph, flags);
+    case "run":
+      return runWithScene(graph, flags);
+    default:
+      throw new Error(`Unknown command ${command}`);
+  }
+}
+var SWITCHES = /* @__PURE__ */ new Set(["--plan", "--remove", "--json", "--public"]);
+function parseFlags(args) {
+  const positional = [];
+  const values = /* @__PURE__ */ new Map();
+  const switches = /* @__PURE__ */ new Set();
+  for (let index = 0; index < args.length; index++) {
+    const arg = args[index];
+    if (!arg.startsWith("--")) {
+      positional.push(arg);
+      continue;
+    }
+    if (SWITCHES.has(arg)) {
+      switches.add(arg);
+      continue;
+    }
+    const value = args[index + 1];
+    if (value === void 0 || value.startsWith("--") && !/^--?\d/.test(value)) throw new Error(`${arg} needs a value`);
+    values.set(arg, [...values.get(arg) ?? [], value]);
+    index++;
+  }
+  return { positional, values, switches };
+}
+var one = (flags, name) => {
+  const list = flags.values.get(name);
+  return list?.[list.length - 1];
+};
+async function exportCommand(graph, flags) {
+  const deploy = one(flags, "--deploy");
+  if (deploy && deploy !== "vercel") throw new Error("--deploy supports vercel only");
+  const result = await exportEditor(graph, {
+    plan: flags.switches.has("--plan"),
+    out: one(flags, "--out"),
+    ...deploy ? { deploy: "vercel" } : {},
+    project: one(flags, "--project"),
+    scope: one(flags, "--scope"),
+    ...flags.switches.has("--public") ? { public: true } : {}
+  });
+  if (flags.switches.has("--json")) console.log(JSON.stringify(result.plan, null, 2));
+  else console.log(formatPlan(result.plan));
+  if (result.directory) console.log(`
+Editor exported: ${result.directory}
+Manifest: ${path.join(result.directory, "export-manifest.json")}`);
+  if (result.url) console.log(`Deployed: ${result.url}`);
+}
+async function readGraph(file) {
+  return JSON.parse(await fs.readFile(file, "utf8"));
+}
+async function writeEditor(file, document, editor) {
+  const next = { ...document, editor };
+  await fs.writeFile(file, `${JSON.stringify(next, null, 2)}
+`);
+}
+async function publishCommand(graph, flags) {
+  const target = flags.positional[0];
+  const match = target ? /^([^.]+)\.(.+)$/.exec(target) : null;
+  if (!match) throw new Error("cascade publish needs <node>.<prop>");
+  const [, node, prop] = match;
+  const document = await readGraph(graph);
+  if (!document.nodes.some((item) => item.id === node)) throw new Error(`No node ${node} in ${graph}`);
+  const editor = document.editor ?? { id: path.basename(graph).replace(/\.cascade$/, "") };
+  const parameters = [...editor.parameters ?? []];
+  const id = one(flags, "--id") ?? prop;
+  const existing = parameters.findIndex((item) => item.node === node && item.prop === prop);
+  if (flags.switches.has("--remove")) {
+    if (existing < 0) throw new Error(`${node}.${prop} is not published`);
+    parameters.splice(existing, 1);
+    await writeEditor(graph, document, { ...editor, parameters });
+    console.log(`Unpublished ${node}.${prop}`);
+    return;
+  }
+  const number = (name) => {
+    const value = one(flags, name);
+    if (value === void 0) return void 0;
+    const parsed = Number(value);
+    if (!Number.isFinite(parsed)) throw new Error(`${name} must be a number`);
+    return parsed;
+  };
+  const previous = existing >= 0 ? parameters[existing] : void 0;
+  const parameter = {
+    ...previous,
+    id: previous?.id ?? id,
+    node,
+    prop,
+    ...one(flags, "--label") ? { label: one(flags, "--label") } : {},
+    ...one(flags, "--group") ? { group: one(flags, "--group") } : {},
+    ...one(flags, "--control") ? { control: one(flags, "--control") } : {},
+    ...number("--min") !== void 0 ? { min: number("--min") } : {},
+    ...number("--max") !== void 0 ? { max: number("--max") } : {},
+    ...number("--step") !== void 0 ? { step: number("--step") } : {},
+    ...number("--order") !== void 0 ? { order: number("--order") } : {},
+    ...one(flags, "--help") ? { help: one(flags, "--help") } : {},
+    ...one(flags, "--unit") ? { unit: one(flags, "--unit") } : {}
+  };
+  if (existing >= 0) parameters[existing] = parameter;
+  else {
+    if (parameters.some((item) => item.id === parameter.id)) throw new Error(`Parameter id ${parameter.id} is taken; pass --id`);
+    parameters.push(parameter);
+  }
+  await writeEditor(graph, document, { ...editor, parameters });
+  console.log(`${existing >= 0 ? "Updated" : "Published"} ${node}.${prop} as "${parameter.id}"`);
+}
+async function freezeCommand(graph, flags) {
+  const node = flags.positional[0];
+  if (!node) throw new Error("cascade freeze needs a node id");
+  const fields = (one(flags, "--fields") ?? "").split(",").map((item) => item.trim()).filter(Boolean);
+  if (!fields.length) throw new Error("cascade freeze needs --fields: name exactly the values to keep");
+  const personal = (one(flags, "--personal") ?? "").split(",").map((item) => item.trim()).filter(Boolean);
+  const document = await readGraph(graph);
+  if (!document.nodes.some((item) => item.id === node)) throw new Error(`No node ${node} in ${graph}`);
+  const graphFile = path.resolve(graph);
+  const project = new ProjectRoot(path.dirname(graphFile));
+  await installHeadlessCanvas().catch(() => void 0);
+  const removeIo = installProjectIo(project);
+  const { outputs } = await cookProjectGraph(graphFile, document, node).finally(removeIo);
+  const produced = outputs.get(node);
+  if (!produced) throw new Error(`${node} produced nothing`);
+  const output = one(flags, "--output") ?? [...produced.keys()][0];
+  if (!produced.has(output)) throw new Error(`${node} has no output ${output}; it has ${[...produced.keys()].join(", ")}`);
+  const full = toJson(produced.get(output));
+  const directory = path.join("frozen", node);
+  await fs.mkdir(project.resolve(directory), { recursive: true });
+  const files = [];
+  const pick = async (value) => {
+    if (value && typeof value === "object" && !Array.isArray(value) && typeof value.path === "string") {
+      const from = value.path;
+      const source = project.resolve(from.replace(/^\.\//, ""));
+      const name = `${directory}/${path.basename(from)}`;
+      await fs.copyFile(source, project.resolve(name));
+      files.push(name);
+      return { ...value, path: name };
+    }
+    if (Array.isArray(value)) return Promise.all(value.map(pick));
+    if (value && typeof value === "object")
+      return Object.fromEntries(await Promise.all(Object.entries(value).map(async ([key, item]) => [key, await pick(item)])));
+    return value;
+  };
+  const chosen = {};
+  for (const field of fields) {
+    const value = getPath(full, field);
+    if (value === void 0) throw new Error(`${node}.${output} has no field ${field}`);
+    setPath(chosen, field, await pick(value));
+  }
+  if (fields.includes("path") && typeof chosen.path === "string" && full && typeof full === "object" && !Array.isArray(full)) {
+    const { path: copied } = await pick({ path: chosen.path });
+    chosen.path = copied;
+  }
+  const snapshot = {
+    format: "cascade.frozen",
+    version: 1,
+    node,
+    output,
+    fields,
+    ...personal.length ? { personal } : {},
+    value: chosen,
+    ...files.length ? { files } : {},
+    frozenAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const snapshotFile = `${directory}.json`;
+  await fs.writeFile(project.resolve(snapshotFile), `${JSON.stringify(snapshot, null, 2)}
+`);
+  const editor = document.editor ?? { id: path.basename(graph).replace(/\.cascade$/, "") };
+  const freeze = (editor.freeze ?? []).filter((item) => item.node !== node);
+  freeze.push({ node, output, snapshot: snapshotFile });
+  await writeEditor(graph, document, { ...editor, freeze });
+  console.log(`Froze ${node}.${output}: ${fields.join(", ")} \u2192 ${snapshotFile}${files.length ? ` (+${files.length} file${files.length > 1 ? "s" : ""})` : ""}`);
+}
+async function sceneCommand(graph, flags) {
+  const sceneFile = flags.positional[0];
+  const out = one(flags, "--out");
+  if (!sceneFile || !out) throw new Error("cascade scene needs <scene.json> --out <new-graph.cascade>");
+  if (path.resolve(out) === path.resolve(graph)) throw new Error("--out must be a new file; the source graph is never overwritten");
+  const { document, warnings } = await sceneDocument(graph, sceneFile);
+  await fs.writeFile(out, `${JSON.stringify(document, null, 2)}
+`);
+  for (const warning of warnings) console.warn(`Warning: ${warning}`);
+  console.log(`Scene applied: ${out}`);
+}
+async function sceneDocument(graph, sceneFile) {
+  const document = await readGraph(graph);
+  const scene = parseScene(await fs.readFile(sceneFile, "utf8"));
+  const project = new ProjectRoot(path.dirname(path.resolve(graph)));
+  const located = /* @__PURE__ */ new Map();
+  for (const [id, file] of Object.entries(scene.files ?? {})) {
+    const found = await locateSceneFile(project, file);
+    if (found) located.set(id, { path: found, ...file.mediaType ? { mediaType: file.mediaType } : {} });
+  }
+  return applyScene(document, scene, { resolveFile: (parameter) => located.get(parameter.id) });
+}
+async function locateSceneFile(project, file) {
+  const { createHash } = await import("node:crypto");
+  const safe = path.basename(file.name).replace(/[^A-Za-z0-9._-]/g, "_");
+  if (file.data) {
+    const bytes = fromBase64(file.data);
+    const digest = createHash("sha256").update(bytes).digest("hex");
+    if (digest !== file.sha256) throw new Error(`Scene file ${file.name} does not match its hash`);
+    const name = `assets/scenes/${digest.slice(0, 12)}-${safe}`;
+    await fs.mkdir(path.dirname(project.resolve(name)), { recursive: true });
+    await fs.writeFile(project.resolve(name), bytes);
+    return name;
+  }
+  for (const candidate of await filesNamed(project.root, path.basename(file.name))) {
+    const digest = createHash("sha256").update(await fs.readFile(candidate)).digest("hex");
+    if (digest === file.sha256) return path.relative(project.root, candidate).split(path.sep).join("/");
+  }
+  return void 0;
+}
+async function filesNamed(root, name) {
+  const found = [];
+  const walk = async (directory, depth) => {
+    if (depth > 6) return;
+    for (const entry of await fs.readdir(directory, { withFileTypes: true }).catch(() => [])) {
+      if (entry.name === "node_modules" || entry.name === ".git" || entry.name === ".cascade-cache") continue;
+      const file = path.join(directory, entry.name);
+      if (entry.isDirectory()) await walk(file, depth + 1);
+      else if (entry.name === name) found.push(file);
+    }
+  };
+  await walk(path.join(root, "assets"), 0);
+  await walk(path.join(root, "licensed"), 0);
+  return found;
+}
+async function runWithScene(graph, flags) {
+  const graphFile = path.resolve(graph);
+  let document = await readGraph(graph);
+  const scene = one(flags, "--scene");
+  if (scene) {
+    const applied = await sceneDocument(graph, scene);
+    document = applied.document;
+    for (const warning of applied.warnings) console.warn(`Warning: ${warning}`);
+  }
+  await installHeadlessCanvas().catch(() => void 0);
+  const project = new ProjectRoot(path.dirname(graphFile));
+  const removeIo = installProjectIo(project);
+  const { outputs } = await cookProjectGraph(graphFile, document).finally(removeIo);
+  for (const spec of flags.values.get("--write") ?? []) {
+    const match = /^([^.=]+)\.([^=]+)=(.+)$/.exec(spec);
+    if (!match) throw new Error(`--write expects <node>.<port>=<file>, got ${spec}`);
+    const [, node, port, file] = match;
+    const value = outputs.get(node)?.get(port);
+    if (value === void 0) throw new Error(`${node}.${port} produced nothing`);
+    if (typeof value === "string") await fs.writeFile(file, value);
+    else if (value && typeof value === "object" && typeof value.path === "string")
+      await fs.copyFile(project.resolve(value.path.replace(/^\.\//, "")), file);
+    else await fs.writeFile(file, JSON.stringify(toJson(value)));
+    console.log(`Wrote ${node}.${port} \u2192 ${file}`);
+  }
+}
+function toJson(value) {
+  return JSON.parse(JSON.stringify(value, (_key, item) => ArrayBuffer.isView(item) ? Array.from(item) : item) ?? "null");
+}
+function getPath(value, field) {
+  let current = value;
+  for (const part of field.split(".").flatMap((item) => item.split(/\[(\d+)\]/).filter(Boolean))) {
+    if (current === null || typeof current !== "object") return void 0;
+    current = current[part];
+  }
+  return current;
+}
+function setPath(target, field, value) {
+  const parts = field.split(".").flatMap((item) => item.split(/\[(\d+)\]/).filter(Boolean));
+  let current = target;
+  parts.forEach((part, index) => {
+    const last = index === parts.length - 1;
+    const container = current;
+    if (last) {
+      container[part] = value;
+      return;
+    }
+    if (container[part] === void 0) container[part] = /^\d+$/.test(parts[index + 1]) ? [] : {};
+    current = container[part];
+  });
+}
+
+export {
+  EDITOR_COMMANDS,
+  EDITOR_HELP,
+  runEditorCommand,
+  sceneDocument
+};
+//# sourceMappingURL=chunk-73S4JZXK.js.map

package/dist/cli/chunk-7QE2ZNSN.js

@@ -0,0 +1,121 @@
+// src/cli/encode.ts
+import { execFile } from "node:child_process";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { promisify } from "node:util";
+var run = promisify(execFile);
+var DEFAULT_CRF = 18;
+function timelineFrameSpec(document) {
+  const start = document?.timeline?.start;
+  const end = document?.timeline?.end;
+  if (typeof start !== "number" || typeof end !== "number") {
+    throw new Error("--frames timeline: the graph has no saved timeline range (set it in Studio's Timeline and save, or name the range: --frames 1-250)");
+  }
+  if (end < start) throw new Error(`--frames timeline: the saved end (${end}) is before the start (${start})`);
+  return { start, end };
+}
+function frameSequences(files) {
+  const sequences = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    const match = /^(.*)\.(\d+)(\.[^./]+)$/.exec(file);
+    if (!match) throw new Error(`${file} is not a numbered frame`);
+    const key = `${match[1]}|${match[2].length}|${match[3]}`;
+    const entry = sequences.get(key) ?? { prefix: match[1], width: match[2].length, extension: match[3], files: [] };
+    entry.files.push(file);
+    sequences.set(key, entry);
+  }
+  return [...sequences.values()];
+}
+async function encodeMp4(options) {
+  const sequences = frameSequences(options.files);
+  if (sequences.length !== 1) {
+    const names = sequences.map((sequence) => path.basename(sequence.prefix));
+    throw new Error(`--mp4 encodes one sequence, and this run wrote ${sequences.length} (${names.join(", ")}). Name the one to encode with --node.`);
+  }
+  const { scale: _scale, ...video } = await encodeSequence({ ...options, sequence: sequences[0], codec: "h264" });
+  return video;
+}
+async function hasFfmpeg() {
+  try {
+    await run("ffmpeg", ["-version"]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function encodeSequence(options) {
+  const frames = options.frames;
+  const scale = options.scale ?? 1;
+  if (!(scale > 0 && scale <= 1)) throw new Error(`video scale must be greater than 0 and at most 1 (got ${scale})`);
+  if (!frames.length) throw new Error("--mp4: no frames were rendered");
+  for (let index = 1; index < frames.length; index += 1) {
+    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.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`;
+  const crf = options.crf ?? DEFAULT_CRF;
+  let pixelFormat;
+  let codecArgs;
+  if (options.codec === "prores") {
+    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];
+  } else {
+    pixelFormat = "yuv420p";
+    codecArgs = ["-c:v", "libx264", "-pix_fmt", pixelFormat, "-crf", String(crf), "-movflags", "+faststart"];
+  }
+  try {
+    await run("ffmpeg", [
+      "-nostdin",
+      "-y",
+      "-loglevel",
+      "error",
+      "-framerate",
+      String(options.fps),
+      "-start_number",
+      String(frames[0]),
+      "-i",
+      pattern,
+      "-frames:v",
+      String(frames.length),
+      "-vf",
+      size,
+      ...codecArgs,
+      "-r",
+      String(options.fps),
+      output
+    ], { maxBuffer: 16 * 1024 * 1024 });
+  } catch (error) {
+    const err = error;
+    if (err.code === "ENOENT") throw new Error("Encoding needs ffmpeg on the PATH (brew install ffmpeg)");
+    throw new Error(`ffmpeg failed: ${(err.stderr || err.message).trim()}`);
+  }
+  return {
+    file: path.relative(options.root, output).split(path.sep).join("/"),
+    codec: options.codec,
+    pixelFormat,
+    ...options.codec === "h264" ? { crf } : {},
+    fps: options.fps,
+    frames: frames.length,
+    scale
+  };
+}
+async function hasTransparency(file) {
+  const sharp = (await import("sharp")).default;
+  const stats = await sharp(file).stats();
+  return !stats.isOpaque;
+}
+
+export {
+  DEFAULT_CRF,
+  timelineFrameSpec,
+  frameSequences,
+  encodeMp4,
+  hasFfmpeg,
+  encodeSequence
+};
+//# sourceMappingURL=chunk-7QE2ZNSN.js.map