@field/cascade 0.11.0 → 0.12.0

package/dist/cli/{chunk-A4OAMOZH.js → chunk-NJFMDXHR.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-J7VK7MNF.js";
 import {
   CORE_TYPES
-} from "./chunk-BIJO5OFS.js";
+} from "./chunk-FWMSGKEH.js";
 
 // packages/contracts/src/validate.ts
 var IDENTIFIER = /^[A-Za-z][A-Za-z0-9_]*$/;
@@ -19,7 +19,7 @@ var CAPABILITIES_BY_ENVIRONMENT = {
 var ALLOWED = CAPABILITIES_BY_ENVIRONMENT;
 var fields = (names) => new Set(names.split(" "));
 var TOP_FIELDS = fields(
-  "apiVersion runsOn container capabilities source label description icon inputs outputs props"
+  "apiVersion runsOn container capabilities gpuLimits source label description icon inputs outputs props"
 );
 var DATA_FIELDS = fields(
   "kind type default description variadic min max step accept control options schema fields"
@@ -111,6 +111,16 @@ function validateNodeDefinition(value) {
       add("duplicate-capability", `${String(capability)} is duplicated`, path);
     seen.add(capability);
   }
+  if (value.gpuLimits !== void 0) {
+    if (!seen.has("gpu"))
+      add("gpu-limits-without-gpu", "gpuLimits needs the gpu capability", "gpuLimits");
+    if (!isRecord(value.gpuLimits))
+      add("invalid-gpu-limits", "gpuLimits must be an object of WebGPU limit names to numbers", "gpuLimits");
+    else
+      for (const [name, limit] of Object.entries(value.gpuLimits))
+        if (typeof limit !== "number" || !Number.isFinite(limit) || limit < 0)
+          add("invalid-gpu-limits", `gpuLimits.${name} must be a non-negative number`, `gpuLimits.${name}`);
+  }
   const inward = /* @__PURE__ */ new Map();
   const outward = /* @__PURE__ */ new Map();
   for (const section of ["inputs", "outputs", "props"]) {
@@ -307,4 +317,4 @@ export {
   CAPABILITIES_BY_ENVIRONMENT,
   validateNodeDefinition
 };
-//# sourceMappingURL=chunk-A4OAMOZH.js.map
+//# sourceMappingURL=chunk-NJFMDXHR.js.map

package/dist/cli/{chunk-3JTJHF7V.js → chunk-OM6BEME6.js}

@@ -3,14 +3,14 @@ import {
   moduleId,
   projectModuleFile,
   validateNodeModuleArchitecture
-} from "./chunk-EUIAC3U3.js";
+} from "./chunk-MP653A5O.js";
 import {
   builtinNodeRegistration
-} from "./chunk-36P5K3SD.js";
+} from "./chunk-MI5JLQYA.js";
 import {
   ProjectRoot,
   extractNodeDefinition
-} from "./chunk-RQZ4SX5R.js";
+} from "./chunk-2JEU3MGB.js";
 
 // src/cli/webBuild.ts
 import fs from "node:fs/promises";
@@ -264,4 +264,4 @@ export {
   inside,
   exists
 };
-//# sourceMappingURL=chunk-3JTJHF7V.js.map
+//# sourceMappingURL=chunk-OM6BEME6.js.map

package/dist/cli/{chunk-DUIUFVU2.js → chunk-ST6LROUG.js}

@@ -1,53 +1,60 @@
-import {
-  RunTrace,
-  captureNodeConsole
-} from "./chunk-4UDFYF5G.js";
-import {
-  installProjectStages
-} from "./chunk-QBBKRNGY.js";
 import {
   setEmbeddedCompiler,
   setProjectModuleCompiler
 } from "./chunk-2KXB47FP.js";
+import {
+  installHeadlessCanvas
+} from "./chunk-EZRWJ4G2.js";
 import {
   parseFrameSpec
 } from "./chunk-BP7UKF36.js";
 import {
   encodeMp4,
   timelineFrameSpec
-} from "./chunk-YAT5Y25U.js";
+} from "./chunk-7QE2ZNSN.js";
 import {
   applyEnv
 } from "./chunk-ZL4JTG5Y.js";
 import {
-  cascadeVersion,
-  compileEmbedded,
-  compileProjectModule,
-  formatStageTrace
-} from "./chunk-MIIEFUGG.js";
-import {
+  RunTrace,
+  captureNodeConsole,
   checkProjectGraph,
+  cookingNode,
   inspectProjectGraph,
   installProjectIo,
+  installProjectStages,
   renderDeterministicProjectFrames,
   runDeterministicProjectGraph,
   saveStillImages,
   validateProjectGraph
-} from "./chunk-EUIAC3U3.js";
+} from "./chunk-MP653A5O.js";
 import {
   graphSeed
-} from "./chunk-GFS6W3C5.js";
+} from "./chunk-L6B6FUQP.js";
 import {
-  ProjectRoot
-} from "./chunk-RQZ4SX5R.js";
+  frameRange
+} from "./chunk-CO22XHNG.js";
 import {
-  installHeadlessCanvas
-} from "./chunk-WIH4TEIS.js";
+  compileEmbedded,
+  compileProjectModule
+} from "./chunk-EU4ZFZ7Y.js";
+import {
+  cascadeVersion,
+  formatStageTrace
+} from "./chunk-5ORUQ6ES.js";
+import {
+  ProjectRoot
+} from "./chunk-2JEU3MGB.js";
 
 // src/cli/runner.ts
 import * as fs from "fs/promises";
 import * as path from "path";
 import { existsSync } from "node:fs";
+var RENDER_SUGGESTION_FRAMES = 30;
+function renderSuggestion(file, frames, count) {
+  if (count < RENDER_SUGGESTION_FRAMES) return null;
+  return `${count} frames in one process. cascade render ${file} --frames ${frames} renders them across worker processes (and encodes a preview mp4; --no-video for frames only).`;
+}
 async function runGraph(options) {
   const { file, entryNode, nodes, validateOnly, checkOnly, inspectOnly, strict, verbose, frames, fps, out } = options;
   if (verbose) {
@@ -98,6 +105,10 @@ async function runGraph(options) {
     setEmbeddedCompiler(async (code) => (await compileEmbedded(project, code)).code);
     disposeStageBridge = installProjectStages(project, {
       verbose,
+      // A render worker starts Python while the probe frames run.
+      prewarm: Boolean(options.worker),
+      // A render worker is already one of several processes: one Python each.
+      ...options.worker ? { poolSize: 1 } : {},
       onTrace: (stage) => {
         trace.recordStage(stage);
         if (verbose) console.log(`[stage] ${formatStageTrace(stage)}`);
@@ -108,10 +119,11 @@ async function runGraph(options) {
       onOutput: (stage, stream, line) => {
         const text = `[${stage ?? "stage-worker"}] ${line}`;
         if (verbose) (stream === "stderr" ? console.warn : console.log)(text);
+        else if (stage === null) cookingNode.exit(() => trace.recordLog(stream, text));
         else trace.recordLog(stream, text);
       }
     });
-    disposeIoBridge = installProjectIo(project);
+    disposeIoBridge = installProjectIo(project, { resident: true });
   } catch (error) {
     if (verbose) console.warn(`No project context for ${file}: ${error instanceof Error ? error.message : error}`);
   }
@@ -123,6 +135,10 @@ async function runGraph(options) {
     if (verbose) console.warn(canvasError.message);
   }
   const frameSpec = frames ? frames === "timeline" ? timelineFrameSpec(graphData) : parseFrameSpec(frames) : null;
+  if (frameSpec && frames && !options.worker) {
+    const hint = renderSuggestion(file, frames, frameRange(frameSpec.start, frameSpec.end, frameSpec.step ?? 1).length);
+    if (hint) (options.json ? console.error : console.log)(hint);
+  }
   const restoreConsole = captureNodeConsole(trace);
   const restoreEnv = applyEnv(options.env);
   if (options.env) trace.setEnvNames(Object.keys(options.env));
@@ -159,7 +175,11 @@ async function runGraph(options) {
         ...options.outNodes?.length ? { outNodes: options.outNodes } : {},
         ...verbose ? { verbose } : {},
         ...options.fresh ? { fresh: true } : {},
-        ...options.worker ? { frameSource: options.worker.frameSource, onFrame: options.worker.onFrame } : {},
+        ...options.worker ? { frameSource: options.worker.frameSource } : {},
+        onFrame: async (frame) => {
+          trace.recordSaved(frame.durationMs);
+          await options.worker?.onFrame(frame);
+        },
         observe
       });
       if (rendered && options.worker) {
@@ -194,11 +214,15 @@ async function runGraph(options) {
       const target = options.outNodes?.length || (nodes?.length ?? 0) > 1 ? void 0 : nodes?.[0] ?? entryNode;
       const saveImages = async (graph) => {
         if (!project) return;
+        const saving = performance.now();
         images = await saveStillImages(graph, project, {
           ...out ? { out } : {},
           ...nodes?.length ? { nodes } : entryNode ? { nodes: [entryNode] } : {},
           ...options.outNodes?.length ? { extra: options.outNodes } : {}
         });
+        const runs = trace.toJSON().runs;
+        const cook = runs[runs.length - 1]?.ms;
+        if (cook !== void 0) trace.recordSaved(cook + performance.now() - saving);
       };
       if (await runDeterministicProjectGraph(file, graphData, target, observe, saveImages)) {
         if (verbose) console.log("Graph execution completed");
@@ -236,6 +260,8 @@ Run trace: ${tracePath}`;
 }
 
 export {
+  RENDER_SUGGESTION_FRAMES,
+  renderSuggestion,
   runGraph
 };
-//# sourceMappingURL=chunk-DUIUFVU2.js.map
+//# sourceMappingURL=chunk-ST6LROUG.js.map

package/dist/cli/{chunk-RLCAJBVR.js → chunk-TJW67QSI.js}

@@ -1,15 +1,16 @@
 import {
   browserAssetCapability
-} from "./chunk-53NMBJAO.js";
+} from "./chunk-ZSCUZE6I.js";
 import {
   attachDefinition
-} from "./chunk-SGJAET2L.js";
+} from "./chunk-BPODRH52.js";
 import {
-  createGpuHost
-} from "./chunk-GFS6W3C5.js";
+  createGpuHost,
+  requestDeviceWithAdapterLimits
+} from "./chunk-L6B6FUQP.js";
 import {
   validateNodeDefinition
-} from "./chunk-A4OAMOZH.js";
+} from "./chunk-NJFMDXHR.js";
 
 // src/nodes/definition/browserShellCapability.ts
 var capability = null;
@@ -125,7 +126,7 @@ function createBrowserGpuHost() {
           "No WebGPU adapter is available \u2014 the browser reports WebGPU but the system offers no GPU to render on."
         );
       }
-      const device = await adapter.requestDevice();
+      const device = await requestDeviceWithAdapterLimits(adapter);
       const info = adapter.info;
       return {
         device,
@@ -221,4 +222,4 @@ export {
   moduleNodeFunction,
   adaptModule
 };
-//# sourceMappingURL=chunk-RLCAJBVR.js.map
+//# sourceMappingURL=chunk-TJW67QSI.js.map

package/dist/cli/chunk-WGKPJZDY.js

@@ -0,0 +1,364 @@
+// packages/runtime/src/builtins/image/planar.ts
+var Planar = class _Planar {
+  constructor(width, height, channels) {
+    pixelCount(width, height);
+    this.width = width;
+    this.height = height;
+    this.channels = channels;
+  }
+  static grayscale(width, height) {
+    return new _Planar(width, height, [new Float32Array(pixelCount(width, height))]);
+  }
+  static rgba(width, height) {
+    const size = pixelCount(width, height);
+    return new _Planar(width, height, [
+      new Float32Array(size),
+      new Float32Array(size),
+      new Float32Array(size),
+      new Float32Array(size)
+    ]);
+  }
+  /** From 8-bit RGBA, unpremultiplied. */
+  static fromPixels(pixels) {
+    const { width, height, data } = pixels;
+    const size = width * height;
+    const r = new Float32Array(size);
+    const g = new Float32Array(size);
+    const b = new Float32Array(size);
+    const a = new Float32Array(size);
+    const inv255 = 1 / 255;
+    for (let i = 0; i < size; i++) {
+      const idx = i * 4;
+      r[i] = data[idx] * inv255;
+      g[i] = data[idx + 1] * inv255;
+      b[i] = data[idx + 2] * inv255;
+      a[i] = data[idx + 3] * inv255;
+    }
+    return new _Planar(width, height, [r, g, b, a]);
+  }
+  static solid(width, height, color) {
+    const buffer = _Planar.rgba(width, height);
+    buffer.fill(0, color.r);
+    buffer.fill(1, color.g);
+    buffer.fill(2, color.b);
+    buffer.fill(3, color.a ?? 1);
+    return buffer;
+  }
+  get channelCount() {
+    return this.channels.length;
+  }
+  get pixelCount() {
+    return this.width * this.height;
+  }
+  fill(channel, value) {
+    this.channels[channel].fill(value);
+  }
+  clone() {
+    return new _Planar(this.width, this.height, this.channels.map((channel) => new Float32Array(channel)));
+  }
+  emptyClone() {
+    return new _Planar(this.width, this.height, this.channels.map(() => new Float32Array(this.pixelCount)));
+  }
+  toRGBA() {
+    if (this.channels.length >= 4) return this.clone();
+    const result = _Planar.rgba(this.width, this.height);
+    const [r, g = r, b = r] = this.channels.length === 1 ? [this.channels[0]] : this.channels;
+    result.channels[0].set(r);
+    result.channels[1].set(g);
+    result.channels[2].set(b);
+    result.channels[3].fill(1);
+    return result;
+  }
+  /** To 8-bit RGBA: a grey image fills red, green and blue, and no alpha is opaque. */
+  toPixels() {
+    const size = this.pixelCount;
+    const data = new Uint8ClampedArray(size * 4);
+    const r = this.channels[0];
+    const g = this.channels.length > 1 ? this.channels[1] : r;
+    const b = this.channels.length > 2 ? this.channels[2] : r;
+    const a = this.channels.length > 3 ? this.channels[3] : null;
+    for (let i = 0; i < size; i++) {
+      const idx = i << 2;
+      let v = r[i] * 255 + 0.5 | 0;
+      data[idx] = v < 0 ? 0 : v > 255 ? 255 : v;
+      v = g[i] * 255 + 0.5 | 0;
+      data[idx + 1] = v < 0 ? 0 : v > 255 ? 255 : v;
+      v = b[i] * 255 + 0.5 | 0;
+      data[idx + 2] = v < 0 ? 0 : v > 255 ? 255 : v;
+      if (a) {
+        v = a[i] * 255 + 0.5 | 0;
+        data[idx + 3] = v < 0 ? 0 : v > 255 ? 255 : v;
+      } else {
+        data[idx + 3] = 255;
+      }
+    }
+    return { width: this.width, height: this.height, data };
+  }
+  /** Bilinear, clamped at the edges (or wrapped). */
+  sample(x, y, channel = 0, wrap = false) {
+    const x0 = Math.floor(x);
+    const y0 = Math.floor(y);
+    const fx = x - x0;
+    const fy = y - y0;
+    const ch = this.channels[channel];
+    const w = this.width;
+    const h = this.height;
+    const px0 = edge(x0, w, wrap);
+    const px1 = edge(x0 + 1, w, wrap);
+    const py0 = edge(y0, h, wrap);
+    const py1 = edge(y0 + 1, h, wrap);
+    const v0 = ch[py0 * w + px0] * (1 - fx) + ch[py0 * w + px1] * fx;
+    const v1 = ch[py1 * w + px0] * (1 - fx) + ch[py1 * w + px1] * fx;
+    return v0 * (1 - fy) + v1 * fy;
+  }
+};
+function edge(coord, max, wrap) {
+  return wrap ? (coord % max + max) % max : Math.max(0, Math.min(max - 1, coord));
+}
+function pixelCount(width, height) {
+  const count = width * height;
+  if (!Number.isSafeInteger(width) || !Number.isSafeInteger(height) || width < 1 || height < 1 || !Number.isSafeInteger(count)) {
+    throw new RangeError(`Image dimensions must be positive safe integers; received ${width}\xD7${height}`);
+  }
+  return count;
+}
+function resample(source, width, height) {
+  const result = Planar.rgba(width, height);
+  const scaleX = source.width / width;
+  const scaleY = source.height / height;
+  for (let c = 0; c < Math.min(source.channelCount, 4); c++) {
+    const dst = result.channels[c];
+    for (let y = 0; y < height; y++) {
+      for (let x = 0; x < width; x++) {
+        dst[y * width + x] = source.sample(x * scaleX, y * scaleY, c);
+      }
+    }
+  }
+  if (source.channelCount < 4) result.fill(3, 1);
+  return result;
+}
+function resolveOutputSize(mode, inputs, customSize) {
+  const valid = inputs.filter((buffer) => buffer !== null);
+  const area = (buffer) => buffer.width * buffer.height;
+  switch (mode) {
+    case "input":
+    case "input1":
+      if (valid[0]) return { width: valid[0].width, height: valid[0].height };
+      break;
+    case "input2": {
+      const chosen = valid[1] ?? valid[0];
+      if (chosen) return { width: chosen.width, height: chosen.height };
+      break;
+    }
+    case "largest":
+    case "smallest":
+      if (valid.length > 0) {
+        let best = valid[0];
+        let bestArea = mode === "largest" ? 0 : Infinity;
+        for (const buffer of valid) {
+          if (mode === "largest" ? area(buffer) > bestArea : area(buffer) < bestArea) {
+            bestArea = area(buffer);
+            best = buffer;
+          }
+        }
+        return { width: best.width, height: best.height };
+      }
+      break;
+    case "custom":
+      if (customSize) return { width: customSize[0], height: customSize[1] };
+      break;
+  }
+  if (valid[0]) return { width: valid[0].width, height: valid[0].height };
+  return { width: 512, height: 512 };
+}
+function resizeToFit(source, targetWidth, targetHeight, fitMode = "fill") {
+  if (source.width === targetWidth && source.height === targetHeight) return source;
+  const result = Planar.rgba(targetWidth, targetHeight);
+  const srcAspect = source.width / source.height;
+  const dstAspect = targetWidth / targetHeight;
+  let srcX = 0, srcY = 0, srcW = source.width, srcH = source.height;
+  let dstX = 0, dstY = 0, dstW = targetWidth, dstH = targetHeight;
+  const black = () => {
+    result.fill(0, 0);
+    result.fill(1, 0);
+    result.fill(2, 0);
+    result.fill(3, 1);
+  };
+  switch (fitMode) {
+    case "fill":
+      if (srcAspect > dstAspect) {
+        srcW = Math.round(source.height * dstAspect);
+        srcX = Math.round((source.width - srcW) / 2);
+      } else {
+        srcH = Math.round(source.width / dstAspect);
+        srcY = Math.round((source.height - srcH) / 2);
+      }
+      break;
+    case "fit":
+      if (srcAspect > dstAspect) {
+        dstH = Math.round(targetWidth / srcAspect);
+        dstY = Math.round((targetHeight - dstH) / 2);
+      } else {
+        dstW = Math.round(targetHeight * srcAspect);
+        dstX = Math.round((targetWidth - dstW) / 2);
+      }
+      black();
+      break;
+    case "stretch":
+      break;
+    case "native":
+      dstW = Math.min(source.width, targetWidth);
+      dstH = Math.min(source.height, targetHeight);
+      srcW = dstW;
+      srcH = dstH;
+      dstX = Math.round((targetWidth - dstW) / 2);
+      dstY = Math.round((targetHeight - dstH) / 2);
+      srcX = Math.round((source.width - srcW) / 2);
+      srcY = Math.round((source.height - srcH) / 2);
+      black();
+      break;
+  }
+  const scaleX = srcW / dstW;
+  const scaleY = srcH / dstH;
+  for (let c = 0; c < Math.min(source.channelCount, 4); c++) {
+    const dst = result.channels[c];
+    for (let y = 0; y < dstH; y++) {
+      for (let x = 0; x < dstW; x++) {
+        dst[(dstY + y) * targetWidth + (dstX + x)] = source.sample(srcX + x * scaleX, srcY + y * scaleY, c);
+      }
+    }
+  }
+  if (source.channelCount < 4 && fitMode !== "fit" && fitMode !== "native") {
+    const alpha = result.channels[3];
+    for (let y = 0; y < dstH; y++) {
+      for (let x = 0; x < dstW; x++) alpha[(dstY + y) * targetWidth + (dstX + x)] = 1;
+    }
+  }
+  return result;
+}
+
+// packages/runtime/src/builtins/image/io.ts
+var NO_CANVAS = 'cascade.image: this host has no canvas. In a browser this needs OffscreenCanvas; headless, Cascade installs @napi-rs/canvas before a run (install it with "npm install @napi-rs/canvas" if it is missing).';
+function canvasGlobals() {
+  return globalThis;
+}
+function surface(width, height) {
+  const Canvas = canvasGlobals().OffscreenCanvas;
+  if (!Canvas) throw new Error(NO_CANVAS);
+  const canvas = new Canvas(width, height);
+  const context = canvas.getContext("2d", { willReadFrequently: true });
+  if (!context) throw new Error("cascade.image: the canvas has no 2D context");
+  return { canvas, context };
+}
+function assetsOf(context) {
+  const assets = context.capabilities.assets;
+  if (!assets) throw new Error(`${context.nodeId}: this host gives cascade.image nodes no assets capability`);
+  return assets;
+}
+function imageReference(value) {
+  if (typeof value === "string") return value ? { path: value } : null;
+  const path = value?.path;
+  return typeof path === "string" && path ? { path } : null;
+}
+async function decodePixels(bytes) {
+  const globals = canvasGlobals();
+  if (!globals.createImageBitmap || !globals.Blob) throw new Error(NO_CANVAS);
+  const bitmap = await globals.createImageBitmap(new globals.Blob([bytes]));
+  try {
+    const { width, height } = bitmap;
+    if (!width || !height) throw new Error("cascade.image: could not decode the image data");
+    const { context } = surface(width, height);
+    context.drawImage(bitmap, 0, 0);
+    return { width, height, data: context.getImageData(0, 0, width, height).data };
+  } finally {
+    bitmap.close?.();
+  }
+}
+function readPixelsFromCanvas(canvas) {
+  const context = canvas.getContext("2d", { willReadFrequently: true });
+  if (!context) throw new Error("cascade.image: the canvas has no 2D context");
+  return { width: canvas.width, height: canvas.height, data: context.getImageData(0, 0, canvas.width, canvas.height).data };
+}
+async function readPixels(context, ref) {
+  const assets = assetsOf(context);
+  const kept = assets.imagePixels?.(ref);
+  if (kept) return kept;
+  return decodePixels(await assets.read(ref, { signal: context.signal }));
+}
+async function readPlanar(context, value) {
+  const ref = imageReference(value);
+  return ref ? Planar.fromPixels(await readPixels(context, ref)) : null;
+}
+async function encodePng(pixels) {
+  const globals = canvasGlobals();
+  if (!globals.ImageData) throw new Error(NO_CANVAS);
+  const { canvas, context } = surface(pixels.width, pixels.height);
+  context.putImageData(new globals.ImageData(pixels.data, pixels.width, pixels.height), 0, 0);
+  const blob = await canvas.convertToBlob({ type: "image/png" });
+  return new Uint8Array(await blob.arrayBuffer());
+}
+async function writePixels(context, pixels) {
+  const assets = assetsOf(context);
+  const name = `${context.nodeId}.png`;
+  const options = { signal: context.signal };
+  const stored = assets.keepImage ? await assets.keepImage(pixels, { suggestedName: name }, options) : await assets.write(await encodePng(pixels), { mediaType: "image/png", suggestedName: name }, options);
+  return { path: stored.path, size: [pixels.width, pixels.height], channels: "rgba", depth: "u8", space: "srgb" };
+}
+async function output(context, image) {
+  context.outputs.image.set(await writePixels(context, image.toPixels()));
+}
+function normalizeColor(input) {
+  if (input && typeof input === "object" && !Array.isArray(input) && "r" in input && "g" in input && "b" in input) {
+    const color = input;
+    const unit = color.r <= 1 && color.g <= 1 && color.b <= 1;
+    return {
+      r: unit ? color.r : color.r / 255,
+      g: unit ? color.g : color.g / 255,
+      b: unit ? color.b : color.b / 255,
+      a: color.a !== void 0 ? unit ? color.a : color.a / 255 : 1
+    };
+  }
+  if (Array.isArray(input)) {
+    const unit = input.every((value) => value <= 1);
+    return {
+      r: unit ? input[0] : input[0] / 255,
+      g: unit ? input[1] : input[1] / 255,
+      b: unit ? input[2] : input[2] / 255,
+      a: input[3] !== void 0 ? unit ? input[3] : input[3] / 255 : 1
+    };
+  }
+  if (typeof input === "string") {
+    const rgb = input.match(/rgb\s*\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*\)/);
+    if (rgb) return { r: parseInt(rgb[1], 10) / 255, g: parseInt(rgb[2], 10) / 255, b: parseInt(rgb[3], 10) / 255, a: 1 };
+    const hex = input.replace("#", "");
+    if (hex.length === 3 || hex.length === 6) {
+      const expanded = hex.length === 3 ? hex.split("").map((digit) => digit + digit).join("") : hex;
+      const parts = /^([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(expanded);
+      if (parts) return { r: parseInt(parts[1], 16) / 255, g: parseInt(parts[2], 16) / 255, b: parseInt(parts[3], 16) / 255, a: 1 };
+    }
+  }
+  return { r: 0, g: 0, b: 0, a: 1 };
+}
+function colorToCss(color) {
+  const r = Math.round(color.r * 255);
+  const g = Math.round(color.g * 255);
+  const b = Math.round(color.b * 255);
+  const a = color.a !== void 0 ? color.a : 1;
+  return a < 1 ? `rgba(${r},${g},${b},${a})` : `rgb(${r},${g},${b})`;
+}
+
+export {
+  Planar,
+  resample,
+  resolveOutputSize,
+  resizeToFit,
+  surface,
+  imageReference,
+  readPixelsFromCanvas,
+  readPlanar,
+  writePixels,
+  output,
+  normalizeColor,
+  colorToCss
+};
+//# sourceMappingURL=chunk-WGKPJZDY.js.map

package/dist/cli/{chunk-D6BUOHUG.js → chunk-X4WKAOQP.js}

@@ -1,10 +1,10 @@
+import {
+  lookAtRotation
+} from "./chunk-DEQSEFFH.js";
 import {
   randomRegistration,
   remapRegistration
 } from "./chunk-RXDIMXN5.js";
-import {
-  lookAtRotation
-} from "./chunk-DEQSEFFH.js";
 
 // packages/runtime/src/builtins/core/bundle.ts
 var pickDefinition = {
@@ -631,4 +631,4 @@ export {
   timeRegistration,
   coreNodeRegistrations
 };
-//# sourceMappingURL=chunk-D6BUOHUG.js.map
+//# sourceMappingURL=chunk-X4WKAOQP.js.map

package/dist/cli/{chunk-VVGSLVSF.js → chunk-X566FWBV.js}

@@ -58,11 +58,16 @@ function readStageConfig(project) {
   if (sources !== void 0 && (!Array.isArray(sources) || sources.some((item) => typeof item !== "string" || !item))) {
     throw new Error("cascade.json exec.stages.sources must be a list of project-relative paths");
   }
+  const workers = value?.workers;
+  if (workers !== void 0 && (typeof workers !== "number" || !Number.isInteger(workers) || workers < 1)) {
+    throw new Error("cascade.json exec.stages.workers must be a whole number of at least 1");
+  }
   return {
     python,
     entrypoint,
     ...worker ? { worker } : {},
     ...sources ? { sources } : {},
+    ...workers !== void 0 ? { workers } : {},
     cache: readCachePolicy(value?.cache)
   };
 }
@@ -148,4 +153,4 @@ export {
   readStageConfig,
   runProjectStage
 };
-//# sourceMappingURL=chunk-VVGSLVSF.js.map
+//# sourceMappingURL=chunk-X566FWBV.js.map