@field/cascade 0.8.0 → 0.11.0

package/dist/cli/chunk-DEQSEFFH.js

@@ -0,0 +1,153 @@
+// packages/runtime/src/camera/index.ts
+var DEG = Math.PI / 180;
+function cross(a, b) {
+  return [
+    a[1] * b[2] - a[2] * b[1],
+    a[2] * b[0] - a[0] * b[2],
+    a[0] * b[1] - a[1] * b[0]
+  ];
+}
+function normalize(v) {
+  const length = Math.hypot(v[0], v[1], v[2]);
+  if (length === 0) return [0, 0, 0];
+  return [v[0] / length, v[1] / length, v[2] / length];
+}
+function subtract(a, b) {
+  return [a[0] - b[0], a[1] - b[1], a[2] - b[2]];
+}
+function dot(a, b) {
+  return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+}
+function lookAtRotation(from, to, up = [0, 1, 0]) {
+  const forward = normalize(subtract(to, from));
+  if (forward[0] === 0 && forward[1] === 0 && forward[2] === 0) return [0, 0, 0];
+  const horizontal = Math.hypot(forward[0], forward[2]);
+  const pitch = Math.atan2(forward[1], horizontal);
+  const yaw = Math.atan2(-forward[0], -forward[2]);
+  return [pitch / DEG, yaw / DEG, rollTowards(forward, pitch, yaw, up) / DEG];
+}
+function rollTowards(forward, pitch, yaw, up) {
+  const desired = normalize([
+    up[0] - forward[0] * dot(up, forward),
+    up[1] - forward[1] * dot(up, forward),
+    up[2] - forward[2] * dot(up, forward)
+  ]);
+  if (desired[0] === 0 && desired[1] === 0 && desired[2] === 0) return 0;
+  const locked = cameraBasis({
+    ...CAMERA_ROTATION_ONLY,
+    rotate: [pitch / DEG, yaw / DEG, 0]
+  }).up;
+  return Math.atan2(dot(cross(desired, locked), forward), dot(locked, desired));
+}
+var CAMERA_ROTATION_ONLY = {
+  translate: [0, 0, 0],
+  focal: 50,
+  aperture: 41.4214,
+  near: 1e-3,
+  far: 1e4,
+  resolution: [1, 1],
+  aspect: 1,
+  projection: "perspective",
+  orthowidth: 2
+};
+function cameraBasis(camera) {
+  const [rx, ry, rz] = camera.rotate;
+  const sx = Math.sin(rx * DEG);
+  const cx = Math.cos(rx * DEG);
+  const sy = Math.sin(ry * DEG);
+  const cy = Math.cos(ry * DEG);
+  const sz = Math.sin(rz * DEG);
+  const cz = Math.cos(rz * DEG);
+  const m00 = cy * cz + sy * sx * sz;
+  const m01 = -cy * sz + sy * sx * cz;
+  const m02 = sy * cx;
+  const m10 = cx * sz;
+  const m11 = cx * cz;
+  const m12 = -sx;
+  const m20 = -sy * cz + cy * sx * sz;
+  const m21 = sy * sz + cy * sx * cz;
+  const m22 = cy * cx;
+  const right = [m00, m10, m20];
+  const up = [m01, m11, m21];
+  const forward = [-m02, -m12, -m22];
+  return { eye: camera.translate, forward, right, up };
+}
+function frameAspect(camera) {
+  const [width, height] = camera.resolution;
+  if (height === 0) return 1;
+  return width * camera.aspect / height;
+}
+function viewMatrix(camera) {
+  const { eye, forward, right, up } = cameraBasis(camera);
+  const back = [-forward[0], -forward[1], -forward[2]];
+  return [
+    right[0],
+    up[0],
+    back[0],
+    0,
+    right[1],
+    up[1],
+    back[1],
+    0,
+    right[2],
+    up[2],
+    back[2],
+    0,
+    -(right[0] * eye[0] + right[1] * eye[1] + right[2] * eye[2]),
+    -(up[0] * eye[0] + up[1] * eye[1] + up[2] * eye[2]),
+    -(back[0] * eye[0] + back[1] * eye[1] + back[2] * eye[2]),
+    1
+  ];
+}
+function projectionMatrix(camera) {
+  const { near, far } = camera;
+  const aspect = frameAspect(camera);
+  if (camera.projection === "orthographic") {
+    const halfWidth = camera.orthowidth / 2;
+    const halfHeight = aspect === 0 ? halfWidth : halfWidth / aspect;
+    return [
+      1 / halfWidth,
+      0,
+      0,
+      0,
+      0,
+      1 / halfHeight,
+      0,
+      0,
+      0,
+      0,
+      -2 / (far - near),
+      0,
+      0,
+      0,
+      -(far + near) / (far - near),
+      1
+    ];
+  }
+  const focalScale = 2 * camera.focal / camera.aperture;
+  return [
+    focalScale,
+    0,
+    0,
+    0,
+    0,
+    focalScale * aspect,
+    0,
+    0,
+    0,
+    0,
+    -(far + near) / (far - near),
+    -1,
+    0,
+    0,
+    -2 * far * near / (far - near),
+    0
+  ];
+}
+
+export {
+  lookAtRotation,
+  viewMatrix,
+  projectionMatrix
+};
+//# sourceMappingURL=chunk-DEQSEFFH.js.map

package/dist/cli/chunk-DUIUFVU2.js

@@ -0,0 +1,241 @@
+import {
+  RunTrace,
+  captureNodeConsole
+} from "./chunk-4UDFYF5G.js";
+import {
+  installProjectStages
+} from "./chunk-QBBKRNGY.js";
+import {
+  setEmbeddedCompiler,
+  setProjectModuleCompiler
+} from "./chunk-2KXB47FP.js";
+import {
+  parseFrameSpec
+} from "./chunk-BP7UKF36.js";
+import {
+  encodeMp4,
+  timelineFrameSpec
+} from "./chunk-YAT5Y25U.js";
+import {
+  applyEnv
+} from "./chunk-ZL4JTG5Y.js";
+import {
+  cascadeVersion,
+  compileEmbedded,
+  compileProjectModule,
+  formatStageTrace
+} from "./chunk-MIIEFUGG.js";
+import {
+  checkProjectGraph,
+  inspectProjectGraph,
+  installProjectIo,
+  renderDeterministicProjectFrames,
+  runDeterministicProjectGraph,
+  saveStillImages,
+  validateProjectGraph
+} from "./chunk-EUIAC3U3.js";
+import {
+  graphSeed
+} from "./chunk-GFS6W3C5.js";
+import {
+  ProjectRoot
+} from "./chunk-RQZ4SX5R.js";
+import {
+  installHeadlessCanvas
+} from "./chunk-WIH4TEIS.js";
+
+// src/cli/runner.ts
+import * as fs from "fs/promises";
+import * as path from "path";
+import { existsSync } from "node:fs";
+async function runGraph(options) {
+  const { file, entryNode, nodes, validateOnly, checkOnly, inspectOnly, strict, verbose, frames, fps, out } = options;
+  if (verbose) {
+    console.log(`Loading graph from: ${file}`);
+  }
+  let graphData;
+  try {
+    const filePath = path.resolve(file);
+    const content = await fs.readFile(filePath, "utf-8");
+    graphData = JSON.parse(content);
+    if (options.seed !== void 0) graphData.seed = options.seed;
+  } catch (error) {
+    console.error(`Failed to load graph file: ${error.message}`);
+    process.exit(1);
+  }
+  const projectRoot = path.dirname(path.resolve(file));
+  if (validateOnly || checkOnly) {
+    const unresolved = checkOnly ? await checkProjectGraph(file, graphData, strict) : await validateProjectGraph(file, graphData, strict);
+    const headline = checkOnly ? "Static check passed" : "Graph validation passed";
+    console.log(
+      unresolved > 0 ? `${headline} with ${unresolved} unresolved ${unresolved === 1 ? "module" : "modules"} \u2014 run with --strict to fail on these` : `${headline}!`
+    );
+    return;
+  }
+  if (inspectOnly) {
+    console.log(JSON.stringify(await inspectProjectGraph(file, graphData), null, 2));
+    return;
+  }
+  let disposeStageBridge;
+  let disposeIoBridge;
+  let canvasHost;
+  let canvasError = null;
+  let project;
+  const trace = new RunTrace(path.resolve(file), cascadeVersion(), graphSeed(graphData));
+  const observe = (graph) => trace.attach(graph);
+  const writeTrace = () => {
+    if (!project || !existsSync(path.resolve(file))) return void 0;
+    try {
+      return trace.write(project.root);
+    } catch (error) {
+      console.warn(`Could not write the run trace: ${error instanceof Error ? error.message : error}`);
+      return void 0;
+    }
+  };
+  try {
+    project = new ProjectRoot(path.dirname(path.resolve(file)));
+    setProjectModuleCompiler(async (folderName) => (await compileProjectModule(project, folderName)).code);
+    setEmbeddedCompiler(async (code) => (await compileEmbedded(project, code)).code);
+    disposeStageBridge = installProjectStages(project, {
+      verbose,
+      onTrace: (stage) => {
+        trace.recordStage(stage);
+        if (verbose) console.log(`[stage] ${formatStageTrace(stage)}`);
+      },
+      // What a stage prints goes into the trace against the node that called
+      // it, always; on the terminal too with --verbose (the console capture
+      // below records that copy, so it is not recorded twice).
+      onOutput: (stage, stream, line) => {
+        const text = `[${stage ?? "stage-worker"}] ${line}`;
+        if (verbose) (stream === "stderr" ? console.warn : console.log)(text);
+        else trace.recordLog(stream, text);
+      }
+    });
+    disposeIoBridge = installProjectIo(project);
+  } catch (error) {
+    if (verbose) console.warn(`No project context for ${file}: ${error instanceof Error ? error.message : error}`);
+  }
+  try {
+    canvasHost = await installHeadlessCanvas();
+    if (verbose) console.log(`Canvas: ${canvasHost.renderer}`);
+  } catch (error) {
+    canvasError = error instanceof Error ? error : new Error(String(error));
+    if (verbose) console.warn(canvasError.message);
+  }
+  const frameSpec = frames ? frames === "timeline" ? timelineFrameSpec(graphData) : parseFrameSpec(frames) : null;
+  const restoreConsole = captureNodeConsole(trace);
+  const restoreEnv = applyEnv(options.env);
+  if (options.env) trace.setEnvNames(Object.keys(options.env));
+  let hostReleased = false;
+  const releaseHost = () => {
+    if (hostReleased) return;
+    hostReleased = true;
+    const errors = [];
+    for (const dispose of [
+      restoreConsole,
+      disposeStageBridge,
+      restoreEnv,
+      disposeIoBridge,
+      canvasHost ? () => canvasHost.dispose() : void 0,
+      () => setProjectModuleCompiler(null),
+      () => setEmbeddedCompiler(null)
+    ]) {
+      try {
+        dispose?.();
+      } catch (error) {
+        errors.push(error);
+      }
+    }
+    if (errors.length) throw errors[0];
+  };
+  try {
+    if (frameSpec) {
+      const rendered = await renderDeterministicProjectFrames(file, graphData, {
+        ...frameSpec,
+        ...fps === void 0 ? {} : { fps },
+        out: out ?? "renders",
+        ...entryNode ? { entryNode } : {},
+        ...nodes?.length ? { nodes } : {},
+        ...options.outNodes?.length ? { outNodes: options.outNodes } : {},
+        ...verbose ? { verbose } : {},
+        ...options.fresh ? { fresh: true } : {},
+        ...options.worker ? { frameSource: options.worker.frameSource, onFrame: options.worker.onFrame } : {},
+        observe
+      });
+      if (rendered && options.worker) {
+        releaseHost();
+        return;
+      }
+      if (rendered) {
+        releaseHost();
+        const tracePath = writeTrace();
+        const video = options.mp4 && !rendered.aborted ? await encodeMp4({ root: projectRoot, files: rendered.files, frames: rendered.frames, fps: rendered.fps, file: options.mp4, ...options.crf === void 0 ? {} : { crf: options.crf } }) : void 0;
+        if (options.json) {
+          process.stdout.write(JSON.stringify({
+            status: "completed",
+            graph: path.resolve(file),
+            ...rendered,
+            ...video ? { video } : {},
+            seed: graphSeed(graphData),
+            ...tracePath ? { trace: tracePath } : {},
+            stages: trace.stages(),
+            logs: trace.logs()
+          }) + "\n");
+        } else {
+          console.log(`Rendered ${rendered.frames.length} frames, ${rendered.files.length} files -> ${out ?? "renders"}/`);
+          if (video) console.log(`Encoded ${video.file} (H.264 yuv420p, crf ${video.crf}, ${video.fps} fps)`);
+        }
+        return;
+      }
+      if (options.json) throw new Error("--json rendering requires a fully definition-v1 graph");
+    } else {
+      const started = performance.now();
+      let images = [];
+      const target = options.outNodes?.length || (nodes?.length ?? 0) > 1 ? void 0 : nodes?.[0] ?? entryNode;
+      const saveImages = async (graph) => {
+        if (!project) return;
+        images = await saveStillImages(graph, project, {
+          ...out ? { out } : {},
+          ...nodes?.length ? { nodes } : entryNode ? { nodes: [entryNode] } : {},
+          ...options.outNodes?.length ? { extra: options.outNodes } : {}
+        });
+      };
+      if (await runDeterministicProjectGraph(file, graphData, target, observe, saveImages)) {
+        if (verbose) console.log("Graph execution completed");
+        releaseHost();
+        const tracePath = writeTrace();
+        if (options.json) {
+          process.stdout.write(JSON.stringify({
+            status: "completed",
+            graph: path.resolve(file),
+            durationMs: performance.now() - started,
+            seed: graphSeed(graphData),
+            images,
+            ...out ? { files: images.map((image) => image.file) } : {},
+            ...tracePath ? { trace: tracePath } : {},
+            stages: trace.stages(),
+            logs: trace.logs()
+          }) + "\n");
+        } else if (out) {
+          console.log(`Saved ${images.length} ${images.length === 1 ? "image" : "images"} -> ${out}/`);
+        }
+        return;
+      }
+    }
+  } catch (error) {
+    releaseHost();
+    const tracePath = options.worker ? void 0 : writeTrace();
+    if (tracePath && error instanceof Error) error.message += `
+Run trace: ${tracePath}`;
+    throw error;
+  }
+  releaseHost();
+  throw new Error(
+    `${path.resolve(file)} has no definition-v1 nodes, and the dynamic executor was removed in 0.7. Every node needs a static \`export const definition\` \u2014 see doc/NODE_AUTHORING.md.`
+  );
+}
+
+export {
+  runGraph
+};
+//# sourceMappingURL=chunk-DUIUFVU2.js.map