@field/cascade 0.10.0 → 0.12.0

package/dist/cli/contactSheet-2PQVRUFW.js

@@ -0,0 +1,11 @@
+import {
+  composeContactSheet,
+  contactSheetLayout,
+  executeContactSheet
+} from "./chunk-53LGFPWX.js";
+export {
+  composeContactSheet,
+  contactSheetLayout,
+  executeContactSheet
+};
+//# sourceMappingURL=contactSheet-2PQVRUFW.js.map

package/dist/cli/definitions-BPOPW52L.js

@@ -0,0 +1,32 @@
+import {
+  registerDefinitionNodes
+} from "./chunk-BPODRH52.js";
+import "./chunk-CTPLRSWF.js";
+import "./chunk-RUU3YWXU.js";
+import {
+  cameraRegistration,
+  feedbackRegistration,
+  frozenRegistration,
+  packRegistration,
+  pickRegistration,
+  previousRegistration,
+  timeRegistration
+} from "./chunk-X4WKAOQP.js";
+import "./chunk-DEQSEFFH.js";
+import "./chunk-RXDIMXN5.js";
+import "./chunk-L6B6FUQP.js";
+import "./chunk-HFHWYL55.js";
+import "./chunk-CO22XHNG.js";
+import "./chunk-FWMSGKEH.js";
+
+// src/nodes/core/definitions.ts
+registerDefinitionNodes([
+  cameraRegistration,
+  timeRegistration,
+  feedbackRegistration,
+  previousRegistration,
+  pickRegistration,
+  packRegistration,
+  frozenRegistration
+]);
+//# sourceMappingURL=definitions-BPOPW52L.js.map

package/dist/cli/doctorCommand-ORWQRNYP.js

@@ -0,0 +1,106 @@
+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-VYGIA7JX.js");
+      const { readStageConfig } = await import("./stageRunner-KY2EJP7X.js");
+      const { stageSources } = await import("./stageCache-TY2BFZJR.js");
+      const project = new ProjectRoot(root);
+      const config = readStageConfig(project);
+      const { python } = config;
+      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}` });
+      if (env?.state === "none") {
+        const sources = stageSources(project, config);
+        const importer = sources.files().find((file) => importsModule(project.resolveMedia(file), "numpy"));
+        if (importer) {
+          try {
+            await output(python, ["-c", "import numpy"], root);
+            checks.push({ name: "stage imports", ok: true, detail: `numpy (imported by ${importer}) loads in ${python}` });
+          } catch {
+            checks.push({
+              name: "stage imports",
+              ok: false,
+              detail: `${importer} imports numpy, which ${python} (Python ${version.split(" ")[0]}) does not have, and no environment is declared. Declare one in cascade.json ("python": { "requirements": ["numpy"] }) and run cascade doctor --fix, or point exec.stages.python at an interpreter that has it`
+            });
+          }
+        }
+      }
+    } catch (error) {
+      checks.push({ name: "stage interpreter", ok: false, detail: error instanceof Error ? error.message : String(error) });
+    }
+  }
+  const { hasFfmpeg } = await import("./encode-ICPEPMH5.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-ENRHC7GS.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 importsModule(file, module) {
+  let source;
+  try {
+    source = fs.readFileSync(file, "utf8");
+  } catch {
+    return false;
+  }
+  const name = module.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  return new RegExp(`^\\s*(?:import\\s+(?:[\\w.]+\\s*(?:as\\s+\\w+)?\\s*,\\s*)*${name}\\b|from\\s+${name}(?:\\.|\\s))`, "m").test(source);
+}
+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,
+  importsModule,
+  runDoctorCommand
+};
+//# sourceMappingURL=doctorCommand-ORWQRNYP.js.map

package/dist/cli/edit-S5KEQ5RA.js

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

package/dist/cli/editorCommands-NFR32JOY.js

@@ -0,0 +1,41 @@
+import {
+  EDITOR_COMMANDS,
+  EDITOR_HELP,
+  runEditorCommand,
+  sceneDocument
+} from "./chunk-73S4JZXK.js";
+import "./chunk-EZRWJ4G2.js";
+import "./chunk-3RXL5GHB.js";
+import "./chunk-OM6BEME6.js";
+import "./chunk-MP653A5O.js";
+import "./chunk-MI5JLQYA.js";
+import "./chunk-GRIN2DDP.js";
+import "./chunk-X4WKAOQP.js";
+import "./chunk-DEQSEFFH.js";
+import "./chunk-RXDIMXN5.js";
+import "./chunk-QQPA2ZHH.js";
+import "./chunk-KH4MUBKF.js";
+import "./chunk-HSNOBIVT.js";
+import "./chunk-L6B6FUQP.js";
+import "./chunk-HFHWYL55.js";
+import "./chunk-KBGUO27Q.js";
+import "./chunk-ICH7N5PN.js";
+import "./chunk-CO22XHNG.js";
+import "./chunk-LTXWBXOM.js";
+import "./chunk-BZ63XQ3I.js";
+import "./chunk-YH637PDL.js";
+import "./chunk-X566FWBV.js";
+import "./chunk-WD62JIP6.js";
+import "./chunk-5ORUQ6ES.js";
+import "./chunk-2JEU3MGB.js";
+import "./chunk-NJFMDXHR.js";
+import "./chunk-J7VK7MNF.js";
+import "./chunk-FWMSGKEH.js";
+import "./chunk-JVOCK5W4.js";
+export {
+  EDITOR_COMMANDS,
+  EDITOR_HELP,
+  runEditorCommand,
+  sceneDocument
+};
+//# sourceMappingURL=editorCommands-NFR32JOY.js.map

package/dist/cli/encode-ICPEPMH5.js

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

package/dist/cli/file-3HTQHPYQ.js

@@ -0,0 +1,41 @@
+import {
+  imageReference,
+  output,
+  readPlanar,
+  resample
+} from "./chunk-WGKPJZDY.js";
+
+// packages/runtime/src/builtins/image/file.ts
+async function executeImage(context) {
+  const { props } = context;
+  const source = await readPlanar(context, imageReference(context.inputs.image) ?? imageReference(props.file));
+  if (!source) return;
+  if (props.resolutionMode === "original") {
+    await output(context, source);
+    return;
+  }
+  if (props.resolutionMode === "max") {
+    const [maxWidth, maxHeight] = props.maxResolution;
+    const aspect = source.width / source.height;
+    let width2 = source.width;
+    let height2 = source.height;
+    if (width2 > maxWidth) {
+      width2 = maxWidth;
+      height2 = maxWidth / aspect;
+    }
+    if (height2 > maxHeight) {
+      height2 = maxHeight;
+      width2 = maxHeight * aspect;
+    }
+    width2 = Math.round(width2);
+    height2 = Math.round(height2);
+    await output(context, width2 !== source.width || height2 !== source.height ? resample(source, width2, height2) : source);
+    return;
+  }
+  const [width, height] = props.fixedResolution;
+  await output(context, resample(source, width, height));
+}
+export {
+  executeImage
+};
+//# sourceMappingURL=file-3HTQHPYQ.js.map

package/dist/cli/filters-6ODFWYK4.js

@@ -0,0 +1,379 @@
+import {
+  Planar,
+  output,
+  readPlanar,
+  resample,
+  resizeToFit,
+  resolveOutputSize
+} from "./chunk-WGKPJZDY.js";
+
+// packages/runtime/src/builtins/image/filters.ts
+function boxesForGauss(sigma, n) {
+  const wIdeal = Math.sqrt(12 * sigma * sigma / n + 1);
+  let wl = Math.floor(wIdeal);
+  if (wl % 2 === 0) wl--;
+  const wu = wl + 2;
+  const mIdeal = (12 * sigma * sigma - n * wl * wl - 4 * n * wl - 3 * n) / (-4 * wl - 4);
+  const m = Math.round(mIdeal);
+  const sizes = [];
+  for (let i = 0; i < n; i++) sizes.push(i < m ? wl : wu);
+  return sizes.map((s) => (s - 1) / 2);
+}
+function boxBlurPass(data, w, h, r, wrap) {
+  if (r < 1) return;
+  const temp = new Float32Array(w * h);
+  const ri = Math.floor(r);
+  const invDiameter = 1 / (ri * 2 + 1);
+  for (let y = 0; y < h; y++) {
+    const row = y * w;
+    let sum = 0;
+    for (let i = -ri; i <= ri; i++) {
+      const px = wrap ? (i % w + w) % w : Math.max(0, Math.min(w - 1, i));
+      sum += data[row + px];
+    }
+    temp[row] = sum * invDiameter;
+    for (let x = 1; x < w; x++) {
+      const removeX = wrap ? ((x - ri - 1) % w + w) % w : Math.max(0, x - ri - 1);
+      const addX = wrap ? ((x + ri) % w + w) % w : Math.min(w - 1, x + ri);
+      sum -= data[row + removeX];
+      sum += data[row + addX];
+      temp[row + x] = sum * invDiameter;
+    }
+  }
+  for (let x = 0; x < w; x++) {
+    let sum = 0;
+    for (let i = -ri; i <= ri; i++) {
+      const py = wrap ? (i % h + h) % h : Math.max(0, Math.min(h - 1, i));
+      sum += temp[py * w + x];
+    }
+    data[x] = sum * invDiameter;
+    for (let y = 1; y < h; y++) {
+      const removeY = wrap ? ((y - ri - 1) % h + h) % h : Math.max(0, y - ri - 1);
+      const addY = wrap ? ((y + ri) % h + h) % h : Math.min(h - 1, y + ri);
+      sum -= temp[removeY * w + x];
+      sum += temp[addY * w + x];
+      data[y * w + x] = sum * invDiameter;
+    }
+  }
+}
+function boxBlur(source, radius, wrapEdges) {
+  if (radius <= 0) return source.clone();
+  const boxes = boxesForGauss(radius, 3);
+  const result = source.emptyClone();
+  for (let c = 0; c < source.channelCount; c++) {
+    const channel = new Float32Array(source.channels[c]);
+    for (const box of boxes) boxBlurPass(channel, source.width, source.height, box, wrapEdges);
+    result.channels[c].set(channel);
+  }
+  return result;
+}
+function gaussianBlur(source, radius, wrapEdges) {
+  if (radius <= 0) return source.clone();
+  const { width, height } = source;
+  const result = source.emptyClone();
+  const kernelSize = Math.ceil(radius * 3) * 2 + 1;
+  const kernel = new Float32Array(kernelSize);
+  const sigma = radius / 3;
+  const twoSigmaSq = 2 * sigma * sigma;
+  const half = kernelSize - 1 >> 1;
+  let sum = 0;
+  for (let i = 0; i < kernelSize; i++) {
+    const x = i - half;
+    const value = Math.exp(-(x * x) / twoSigmaSq);
+    kernel[i] = value;
+    sum += value;
+  }
+  const invSum = 1 / sum;
+  for (let i = 0; i < kernelSize; i++) kernel[i] *= invSum;
+  const wrapX = wrapEdges ? (coord) => (coord % width + width) % width : (coord) => coord < 0 ? 0 : coord >= width ? width - 1 : coord;
+  const wrapY = wrapEdges ? (coord) => (coord % height + height) % height : (coord) => coord < 0 ? 0 : coord >= height ? height - 1 : coord;
+  for (let c = 0; c < source.channelCount; c++) {
+    const src = source.channels[c];
+    const dst = result.channels[c];
+    const temp = new Float32Array(width * height);
+    for (let y = 0; y < height; y++) {
+      const row = y * width;
+      for (let x = 0; x < width; x++) {
+        let acc = 0;
+        for (let k = 0; k < kernelSize; k++) acc += src[row + wrapX(x + k - half)] * kernel[k];
+        temp[row + x] = acc;
+      }
+    }
+    for (let x = 0; x < width; x++) {
+      for (let y = 0; y < height; y++) {
+        let acc = 0;
+        for (let k = 0; k < kernelSize; k++) acc += temp[wrapY(y + k - half) * width + x] * kernel[k];
+        dst[y * width + x] = acc;
+      }
+    }
+  }
+  return result;
+}
+async function executeBlur(context) {
+  const source = await readPlanar(context, context.inputs.image);
+  if (!source) return;
+  const { method, radius, wrapEdges } = context.props;
+  await output(context, method === "gaussian" ? gaussianBlur(source, radius, wrapEdges) : boxBlur(source, radius, wrapEdges));
+}
+async function executeNormalMap(context) {
+  const source = await readPlanar(context, context.inputs.image);
+  if (!source) return;
+  const { scale, flipX, flipY } = context.props;
+  const { width, height } = source;
+  const result = Planar.rgba(width, height);
+  const heightMap = source.channels[0];
+  const [rOut, gOut, bOut, aOut] = result.channels;
+  for (let y = 0; y < height; y++) {
+    for (let x = 0; x < width; x++) {
+      const idx = y * width + x;
+      const h00 = heightMap[idx];
+      const h10 = heightMap[Math.min(x + 1, width - 1) + y * width];
+      const h01 = heightMap[x + Math.min(y + 1, height - 1) * width];
+      const dx = (h10 - h00) * scale;
+      const dy = (h01 - h00) * scale;
+      const nx = -(flipX ? -dx : dx);
+      const ny = -(flipY ? -dy : dy);
+      const nz = 1;
+      const length = Math.sqrt(nx * nx + ny * ny + nz * nz);
+      rOut[idx] = nx / length * 0.5 + 0.5;
+      gOut[idx] = ny / length * 0.5 + 0.5;
+      bOut[idx] = nz / length * 0.5 + 0.5;
+      aOut[idx] = 1;
+    }
+  }
+  await output(context, result);
+}
+async function executeResize(context) {
+  const source = await readPlanar(context, context.inputs.image);
+  if (!source) return;
+  const { props } = context;
+  const scaled = props.mode === "scale";
+  const width = scaled ? Math.round(source.width * props.scale) : props.width;
+  const height = scaled ? Math.round(source.height * props.scale) : props.height;
+  await output(context, resample(source, width, height));
+}
+function pivotPoint(pivot, custom, width, height) {
+  switch (pivot) {
+    case "top-left":
+      return [0, 0];
+    case "top-right":
+      return [width, 0];
+    case "bottom-left":
+      return [0, height];
+    case "bottom-right":
+      return [width, height];
+    case "custom":
+      return [custom[0] * width, custom[1] * height];
+    default:
+      return [width / 2, height / 2];
+  }
+}
+function wrapCoord(coord, size, mode) {
+  if (mode === "clamp") return Math.max(0, Math.min(size - 1, coord));
+  if (mode === "repeat") {
+    coord = coord % size;
+    if (coord < 0) coord += size;
+    return coord;
+  }
+  if (mode === "mirror") {
+    const period = size * 2;
+    coord = Math.abs(coord % period);
+    if (coord >= size) coord = period - coord - 1;
+    return Math.max(0, Math.min(size - 1, coord));
+  }
+  return coord;
+}
+async function executeTransform(context) {
+  const input = await readPlanar(context, context.inputs.image);
+  if (!input) return;
+  const { props } = context;
+  const { width, height } = input;
+  const [tx, ty] = props.translate;
+  const rotation = props.rotation * Math.PI / 180;
+  const sx = props.scale[0];
+  const sy = props.uniformScale ? sx : props.scale[1];
+  const [pivotX, pivotY] = pivotPoint(props.pivot, props.customPivot, width, height);
+  const cosR = Math.cos(-rotation);
+  const sinR = Math.sin(-rotation);
+  const invSx = 1 / sx;
+  const invSy = 1 / sy;
+  const buffer = Planar.rgba(width, height);
+  const channelCount = Math.min(input.channelCount, 4);
+  const nearest = props.filter === "nearest";
+  const wrap = props.wrap;
+  for (let y = 0; y < height; y++) {
+    for (let x = 0; x < width; x++) {
+      const idx = y * width + x;
+      const dx = x - pivotX - tx;
+      const dy = y - pivotY - ty;
+      const srcX = (dx * cosR - dy * sinR) * invSx + pivotX;
+      const srcY = (dx * sinR + dy * cosR) * invSy + pivotY;
+      if (wrap === "transparent" && (srcX < 0 || srcX >= width || srcY < 0 || srcY >= height)) {
+        for (let c = 0; c < 4; c++) buffer.channels[c][idx] = 0;
+        continue;
+      }
+      if (nearest) {
+        const srcIdx = wrapCoord(Math.round(srcY), height, wrap) * width + wrapCoord(Math.round(srcX), width, wrap);
+        for (let c = 0; c < channelCount; c++) buffer.channels[c][idx] = input.channels[c][srcIdx];
+      } else {
+        const x0 = Math.floor(srcX);
+        const y0 = Math.floor(srcY);
+        const fx = srcX - x0;
+        const fy = srcY - y0;
+        const wx0 = wrapCoord(x0, width, wrap);
+        const wx1 = wrapCoord(x0 + 1, width, wrap);
+        const wy0 = wrapCoord(y0, height, wrap);
+        const wy1 = wrapCoord(y0 + 1, height, wrap);
+        for (let c = 0; c < channelCount; c++) {
+          const channel = input.channels[c];
+          const v00 = channel[wy0 * width + wx0];
+          const v10 = channel[wy0 * width + wx1];
+          const v01 = channel[wy1 * width + wx0];
+          const v11 = channel[wy1 * width + wx1];
+          const v0 = v00 + (v10 - v00) * fx;
+          const v1 = v01 + (v11 - v01) * fx;
+          buffer.channels[c][idx] = v0 + (v1 - v0) * fy;
+        }
+      }
+      if (channelCount < 4) buffer.channels[3][idx] = 1;
+    }
+  }
+  await output(context, buffer);
+}
+function blend(base, layer, mode, opacity) {
+  const { width, height } = base;
+  const result = Planar.rgba(width, height);
+  const [r1, g1, b1, a1] = (base.channelCount >= 4 ? base : base.toRGBA()).channels;
+  const [r2, g2, b2, a2] = (layer.channelCount >= 4 ? layer : layer.toRGBA()).channels;
+  const [rOut, gOut, bOut, aOut] = result.channels;
+  for (let i = 0; i < width * height; i++) {
+    const baseR = r1[i], baseG = g1[i], baseB = b1[i], baseA = a1[i];
+    const blendR = r2[i], blendG = g2[i], blendB = b2[i], blendA = a2[i];
+    let r, g, b;
+    switch (mode) {
+      case "normal":
+        r = blendR;
+        g = blendG;
+        b = blendB;
+        break;
+      case "multiply":
+        r = baseR * blendR;
+        g = baseG * blendG;
+        b = baseB * blendB;
+        break;
+      case "screen":
+        r = 1 - (1 - baseR) * (1 - blendR);
+        g = 1 - (1 - baseG) * (1 - blendG);
+        b = 1 - (1 - baseB) * (1 - blendB);
+        break;
+      case "overlay":
+        r = baseR < 0.5 ? 2 * baseR * blendR : 1 - 2 * (1 - baseR) * (1 - blendR);
+        g = baseG < 0.5 ? 2 * baseG * blendG : 1 - 2 * (1 - baseG) * (1 - blendG);
+        b = baseB < 0.5 ? 2 * baseB * blendB : 1 - 2 * (1 - baseB) * (1 - blendB);
+        break;
+      case "darken":
+        r = Math.min(baseR, blendR);
+        g = Math.min(baseG, blendG);
+        b = Math.min(baseB, blendB);
+        break;
+      case "lighten":
+        r = Math.max(baseR, blendR);
+        g = Math.max(baseG, blendG);
+        b = Math.max(baseB, blendB);
+        break;
+      case "color-dodge":
+        r = blendR === 1 ? 1 : Math.min(1, baseR / (1 - blendR));
+        g = blendG === 1 ? 1 : Math.min(1, baseG / (1 - blendG));
+        b = blendB === 1 ? 1 : Math.min(1, baseB / (1 - blendB));
+        break;
+      case "color-burn":
+        r = blendR === 0 ? 0 : Math.max(0, 1 - (1 - baseR) / blendR);
+        g = blendG === 0 ? 0 : Math.max(0, 1 - (1 - baseG) / blendG);
+        b = blendB === 0 ? 0 : Math.max(0, 1 - (1 - baseB) / blendB);
+        break;
+      case "hard-light":
+        r = blendR < 0.5 ? 2 * baseR * blendR : 1 - 2 * (1 - baseR) * (1 - blendR);
+        g = blendG < 0.5 ? 2 * baseG * blendG : 1 - 2 * (1 - baseG) * (1 - blendG);
+        b = blendB < 0.5 ? 2 * baseB * blendB : 1 - 2 * (1 - baseB) * (1 - blendB);
+        break;
+      case "soft-light":
+        r = blendR < 0.5 ? baseR - (1 - 2 * blendR) * baseR * (1 - baseR) : baseR + (2 * blendR - 1) * (Math.sqrt(baseR) - baseR);
+        g = blendG < 0.5 ? baseG - (1 - 2 * blendG) * baseG * (1 - baseG) : baseG + (2 * blendG - 1) * (Math.sqrt(baseG) - baseG);
+        b = blendB < 0.5 ? baseB - (1 - 2 * blendB) * baseB * (1 - baseB) : baseB + (2 * blendB - 1) * (Math.sqrt(baseB) - baseB);
+        break;
+      case "difference":
+        r = Math.abs(baseR - blendR);
+        g = Math.abs(baseG - blendG);
+        b = Math.abs(baseB - blendB);
+        break;
+      case "exclusion":
+        r = baseR + blendR - 2 * baseR * blendR;
+        g = baseG + blendG - 2 * baseG * blendG;
+        b = baseB + blendB - 2 * baseB * blendB;
+        break;
+      case "add":
+      case "linear-dodge":
+        r = Math.min(1, baseR + blendR);
+        g = Math.min(1, baseG + blendG);
+        b = Math.min(1, baseB + blendB);
+        break;
+      case "subtract":
+        r = Math.max(0, baseR - blendR);
+        g = Math.max(0, baseG - blendG);
+        b = Math.max(0, baseB - blendB);
+        break;
+      case "divide":
+        r = blendR === 0 ? 1 : Math.min(1, baseR / blendR);
+        g = blendG === 0 ? 1 : Math.min(1, baseG / blendG);
+        b = blendB === 0 ? 1 : Math.min(1, baseB / blendB);
+        break;
+      case "pin-light":
+        r = blendR < 0.5 ? Math.min(baseR, 2 * blendR) : Math.max(baseR, 2 * (blendR - 0.5));
+        g = blendG < 0.5 ? Math.min(baseG, 2 * blendG) : Math.max(baseG, 2 * (blendG - 0.5));
+        b = blendB < 0.5 ? Math.min(baseB, 2 * blendB) : Math.max(baseB, 2 * (blendB - 0.5));
+        break;
+      case "vivid-light":
+        r = blendR < 0.5 ? blendR === 0 ? 0 : 1 - (1 - baseR) / (2 * blendR) : blendR === 1 ? 1 : baseR / (2 * (1 - blendR));
+        g = blendG < 0.5 ? blendG === 0 ? 0 : 1 - (1 - baseG) / (2 * blendG) : blendG === 1 ? 1 : baseG / (2 * (1 - blendG));
+        b = blendB < 0.5 ? blendB === 0 ? 0 : 1 - (1 - baseB) / (2 * blendB) : blendB === 1 ? 1 : baseB / (2 * (1 - blendB));
+        break;
+      case "linear-burn":
+        r = Math.max(0, baseR + blendR - 1);
+        g = Math.max(0, baseG + blendG - 1);
+        b = Math.max(0, baseB + blendB - 1);
+        break;
+      default:
+        r = blendR;
+        g = blendG;
+        b = blendB;
+    }
+    rOut[i] = baseR + (r - baseR) * opacity * blendA;
+    gOut[i] = baseG + (g - baseG) * opacity * blendA;
+    bOut[i] = baseB + (b - baseB) * opacity * blendA;
+    aOut[i] = baseA + (blendA - baseA) * opacity;
+  }
+  return result;
+}
+async function executeComposite(context) {
+  const { props } = context;
+  const inputs = [await readPlanar(context, context.inputs.image1), await readPlanar(context, context.inputs.image2)];
+  const { width, height } = resolveOutputSize(
+    props.outputResolution,
+    inputs,
+    props.customResolution
+  );
+  const [base, layer] = inputs.map((buffer) => {
+    if (!buffer || buffer.width === width && buffer.height === height) return buffer;
+    return resizeToFit(buffer, width, height, props.fitMode);
+  });
+  if (!base || !layer) return;
+  await output(context, blend(base, layer, props.blendMode, props.opacity));
+}
+export {
+  executeBlur,
+  executeComposite,
+  executeNormalMap,
+  executeResize,
+  executeTransform
+};
+//# sourceMappingURL=filters-6ODFWYK4.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