@field/cascade 0.11.0 → 0.12.0

package/dist/cli/chunk-36P5K3SD.js

@@ -1,631 +0,0 @@
-import {
-  coreNodeRegistrations,
-  isCamera
-} from "./chunk-D6BUOHUG.js";
-import {
-  mathNodeRegistrations
-} from "./chunk-QQPA2ZHH.js";
-import {
-  popNodeRegistrations
-} from "./chunk-KH4MUBKF.js";
-import {
-  LIGHT_DEFAULTS,
-  geoNodeRegistrations,
-  isLight,
-  isScene
-} from "./chunk-35D343DC.js";
-
-// packages/runtime/src/builtins/scene/definitions.ts
-var SCENE_NAMESPACE = "cascade.scene";
-function sceneModuleId(name) {
-  return `${SCENE_NAMESPACE}.${name}`;
-}
-var sceneDefinition = {
-  apiVersion: 1,
-  label: "Scene",
-  description: "Geometry, a camera and lights, assembled into a scene. Attach anything to the input.",
-  icon: "Box",
-  runsOn: "portable",
-  inputs: {
-    inputs: {
-      kind: "data",
-      type: "any",
-      variadic: true,
-      description: "Geometry, one camera, and lights, in any order. Scenes are flattened."
-    }
-  },
-  outputs: {
-    scene: { kind: "data", type: "scene" }
-  },
-  props: {}
-};
-function executeScene(context) {
-  const geometry = [];
-  const lights = [];
-  let camera = null;
-  let cameraFrom = -1;
-  context.inputs.inputs.forEach((value, index) => {
-    if (value === void 0 || value === null) return;
-    if (isScene(value)) {
-      geometry.push(...value.geometry);
-      lights.push(...value.lights);
-      if (value.camera !== null) {
-        if (camera !== null)
-          throw new Error(
-            `cascade.scene.Scene has two cameras, on inputs ${cameraFrom} and ${index}. A scene has one viewpoint; remove one or use a Switch to choose between them.`
-          );
-        camera = value.camera;
-        cameraFrom = index;
-      }
-      return;
-    }
-    if (isCamera(value)) {
-      if (camera !== null)
-        throw new Error(
-          `cascade.scene.Scene has two cameras, on inputs ${cameraFrom} and ${index}. A scene has one viewpoint; remove one or use a Switch to choose between them.`
-        );
-      camera = value;
-      cameraFrom = index;
-      return;
-    }
-    if (isLight(value)) {
-      lights.push(value);
-      return;
-    }
-    if (typeof value === "object" && value.kind === "geometry") {
-      geometry.push(value);
-      return;
-    }
-    throw new Error(
-      `cascade.scene.Scene input ${index} is not geometry, a camera, a light or a scene (received ${describe(value)}). A scene can only hold those.`
-    );
-  });
-  context.outputs.scene.set({ geometry, camera, lights });
-}
-function describe(value) {
-  if (Array.isArray(value)) return `an array of ${value.length}`;
-  if (typeof value === "object" && value !== null) {
-    const kind = value.kind;
-    return typeof kind === "string" ? `an object of kind "${kind}"` : "an object";
-  }
-  return `a ${typeof value}`;
-}
-var lightDefinition = {
-  apiVersion: 1,
-  label: "Light",
-  description: "A light, following Houdini's /obj/hlight. Nothing shades with lights yet \u2014 the viewport draws wireframe and points.",
-  icon: "Lightbulb",
-  runsOn: "portable",
-  inputs: {
-    translate: {
-      kind: "data",
-      type: "vec3",
-      default: [0, 0, 5],
-      description: "World position. Ignored for a distant or ambient light."
-    },
-    direction: {
-      kind: "data",
-      type: "vec3",
-      default: [0, 0, -1],
-      description: "Direction the light points. Used by distant and spot."
-    },
-    color: {
-      kind: "data",
-      type: "color",
-      default: [1, 1, 1, 1],
-      description: "Houdini light_color."
-    },
-    intensity: {
-      kind: "data",
-      type: "float",
-      default: 1,
-      min: 0,
-      description: "Houdini light_intensity."
-    }
-  },
-  outputs: {
-    light: { kind: "data", type: "light" }
-  },
-  props: {
-    type: {
-      type: "string",
-      default: "point",
-      label: "Light Type",
-      control: "select",
-      options: [
-        { value: "point", label: "Point" },
-        { value: "distant", label: "Distant - directional" },
-        { value: "ambient", label: "Ambient" },
-        { value: "spot", label: "Spot" }
-      ],
-      description: "Houdini light_type. Distant is what other renderers call directional."
-    },
-    coneangle: {
-      type: "float",
-      default: 45,
-      min: 0,
-      max: 180,
-      label: "Cone Angle",
-      description: "Degrees. Spot only."
-    }
-  }
-};
-function executeLight(context) {
-  const type = context.props.type;
-  context.outputs.light.set({
-    type: type === "distant" || type === "ambient" || type === "spot" ? type : LIGHT_DEFAULTS.type,
-    translate: context.inputs.translate ?? LIGHT_DEFAULTS.translate,
-    direction: context.inputs.direction ?? LIGHT_DEFAULTS.direction,
-    color: context.inputs.color ?? LIGHT_DEFAULTS.color,
-    intensity: context.inputs.intensity ?? LIGHT_DEFAULTS.intensity,
-    coneangle: context.props.coneangle
-  });
-}
-var sceneRegistration = {
-  kind: "definition-v1",
-  moduleId: sceneModuleId("Scene"),
-  definition: sceneDefinition,
-  loadExecute: async () => executeScene
-};
-var lightRegistration = {
-  kind: "definition-v1",
-  moduleId: sceneModuleId("Light"),
-  definition: lightDefinition,
-  loadExecute: async () => executeLight
-};
-var sceneNodeRegistrations = Object.freeze([sceneRegistration, lightRegistration]);
-var sceneNodeDefinitions = Object.freeze([
-  [sceneModuleId("Scene"), sceneDefinition],
-  [sceneModuleId("Light"), lightDefinition]
-]);
-
-// packages/runtime/src/builtins/index.ts
-var builtinNodeRegistrations = Object.freeze([
-  ...coreNodeRegistrations,
-  ...geoNodeRegistrations,
-  ...mathNodeRegistrations,
-  ...popNodeRegistrations,
-  ...sceneNodeRegistrations
-]);
-var registrationsById = new Map(
-  builtinNodeRegistrations.map((registration) => [
-    registration.moduleId,
-    registration
-  ])
-);
-function builtinNodeRegistration(moduleId) {
-  return registrationsById.get(moduleId);
-}
-
-// packages/runtime/src/builtins/image/contactSheet.ts
-var contactSheetDefinition = {
-  apiVersion: 1,
-  label: "Contact Sheet",
-  description: "Lay images out as one labelled grid.",
-  icon: "LayoutGrid",
-  runsOn: "portable",
-  capabilities: ["assets"],
-  inputs: {
-    images: { kind: "data", type: "image", variadic: true },
-    /** More images after the wired ones: image values or project-relative paths. */
-    list: { kind: "data", type: "array" }
-  },
-  outputs: {
-    image: { kind: "data", type: "image" },
-    asset: { kind: "data", type: "asset" }
-  },
-  props: {
-    columns: { type: "int", default: 0, min: 0, max: 64, description: "0: as square as the count allows." },
-    gap: { type: "int", default: 16, min: 0, max: 512 },
-    background: { type: "color", default: [1, 1, 1, 1], label: "Background" },
-    cellWidth: { type: "int", default: 0, min: 0, max: 8192, description: "0: images at their own size. Otherwise each is scaled to fit this width." },
-    labels: { type: "string", default: "", description: "One label per line, in image order." },
-    labelSize: { type: "int", default: 14, min: 6, max: 128 },
-    labelColor: { type: "color", default: [0.1, 0.1, 0.1, 1], label: "Label Colour" },
-    filename: { type: "string", default: "contact-sheet.png", label: "Filename" }
-  }
-};
-function contactSheetLayout(sizes, options = {}) {
-  const count = sizes.length;
-  if (!count) throw new Error("cascade.image.ContactSheet needs at least one image");
-  for (const [width, height] of sizes) {
-    if (!(width > 0 && height > 0)) throw new Error(`cascade.image.ContactSheet: an image is ${width}x${height}`);
-  }
-  const gap = Math.max(0, Math.round(options.gap ?? 16));
-  const columns = Math.min(count, options.columns && options.columns > 0 ? Math.round(options.columns) : Math.ceil(Math.sqrt(count)));
-  const rows = Math.ceil(count / columns);
-  const scaled = Boolean(options.cellWidth && options.cellWidth > 0);
-  const cellWidth = scaled ? Math.round(options.cellWidth) : Math.max(...sizes.map(([width]) => width));
-  const cellHeight = scaled ? Math.max(...sizes.map(([width, height]) => Math.round(height * cellWidth / width))) : Math.max(...sizes.map(([, height]) => height));
-  const labelHeight = Math.max(0, Math.round(options.labelHeight ?? 0));
-  const cells = sizes.map(([width, height], index) => {
-    const column = index % columns;
-    const row = Math.floor(index / columns);
-    const fit = Math.min(cellWidth / width, cellHeight / height);
-    const scale = scaled ? fit : Math.min(1, fit);
-    const drawnWidth = Math.max(1, Math.round(width * scale));
-    const drawnHeight = Math.max(1, Math.round(height * scale));
-    const left = gap + column * (cellWidth + gap);
-    const top = gap + row * (cellHeight + labelHeight + gap);
-    return {
-      x: left + Math.floor((cellWidth - drawnWidth) / 2),
-      y: top + Math.floor((cellHeight - drawnHeight) / 2),
-      width: drawnWidth,
-      height: drawnHeight,
-      labelX: left,
-      labelY: top + cellHeight
-    };
-  });
-  return {
-    width: gap + columns * (cellWidth + gap),
-    height: gap + rows * (cellHeight + labelHeight + gap),
-    columns,
-    rows,
-    cell: [cellWidth, cellHeight],
-    labelHeight,
-    cells
-  };
-}
-function host() {
-  const globals = globalThis;
-  const Canvas = globals.OffscreenCanvas;
-  const createBitmap = globals.createImageBitmap;
-  if (!Canvas || !createBitmap || !globals.Blob) {
-    throw new Error("cascade.image.ContactSheet needs OffscreenCanvas and createImageBitmap, which this host does not provide");
-  }
-  const BlobType = globals.Blob;
-  return {
-    surface: (width, height) => new Canvas(width, height),
-    decode: (bytes) => createBitmap(new BlobType([bytes]))
-  };
-}
-function css(colour, fallback) {
-  const [r = 0, g = 0, b = 0, a = 1] = colour ?? fallback;
-  return `rgba(${Math.round(r * 255)}, ${Math.round(g * 255)}, ${Math.round(b * 255)}, ${a})`;
-}
-async function composeContactSheet(images, options = {}) {
-  const canvas = host();
-  const bitmaps = [];
-  try {
-    for (const bytes of images) bitmaps.push(await canvas.decode(bytes));
-    const labels = options.labels ?? [];
-    const labelSize = Math.round(options.labelSize ?? 14);
-    const labelled = labels.some((label) => label.trim().length > 0);
-    const layout = contactSheetLayout(bitmaps.map((bitmap) => [bitmap.width, bitmap.height]), {
-      columns: options.columns,
-      gap: options.gap,
-      cellWidth: options.cellWidth,
-      labelHeight: labelled ? Math.round(labelSize * 1.8) : 0
-    });
-    const surface = canvas.surface(layout.width, layout.height);
-    const context = surface.getContext("2d");
-    if (!context) throw new Error("cascade.image.ContactSheet: no 2D context");
-    context.fillStyle = css(options.background, [1, 1, 1, 1]);
-    context.fillRect(0, 0, layout.width, layout.height);
-    context.imageSmoothingEnabled = true;
-    context.imageSmoothingQuality = "high";
-    layout.cells.forEach((cell, index) => context.drawImage(bitmaps[index], cell.x, cell.y, cell.width, cell.height));
-    if (labelled) {
-      context.fillStyle = css(options.labelColor, [0.1, 0.1, 0.1, 1]);
-      context.font = `${labelSize}px sans-serif`;
-      context.textBaseline = "top";
-      layout.cells.forEach((cell, index) => {
-        const label = labels[index];
-        if (label) context.fillText(label, cell.labelX, cell.labelY + Math.round((layout.labelHeight - labelSize) / 2), layout.cell[0]);
-      });
-    }
-    const blob = await surface.convertToBlob({ type: "image/png" });
-    return { bytes: new Uint8Array(await blob.arrayBuffer()), layout };
-  } finally {
-    for (const bitmap of bitmaps) bitmap.close?.();
-  }
-}
-function imageReference(value) {
-  if (typeof value === "string" && value) return { path: value };
-  const candidate = value?.path;
-  return typeof candidate === "string" && candidate ? { path: candidate } : void 0;
-}
-async function executeContactSheet(context) {
-  const { props } = context;
-  const references = [...context.inputs.images, ...context.inputs.list ?? []].map(imageReference).filter((reference) => reference !== void 0);
-  const bytes = [];
-  for (const reference of references) {
-    bytes.push(await context.capabilities.assets.read(reference, { signal: context.signal }));
-  }
-  const { bytes: sheet, layout } = await composeContactSheet(bytes, {
-    columns: props.columns,
-    gap: props.gap,
-    cellWidth: props.cellWidth,
-    labels: props.labels ? props.labels.split("\n") : [],
-    labelSize: props.labelSize,
-    background: props.background,
-    labelColor: props.labelColor
-  });
-  const asset = await context.capabilities.assets.write(
-    sheet,
-    { mediaType: "image/png", suggestedName: props.filename },
-    { signal: context.signal }
-  );
-  context.outputs.asset.set(asset);
-  context.outputs.image.set({
-    path: asset.path ?? props.filename,
-    size: [layout.width, layout.height],
-    channels: "rgba",
-    depth: "u8",
-    space: "srgb"
-  });
-}
-var contactSheetRegistration = {
-  kind: "definition-v1",
-  moduleId: "cascade.image.ContactSheet",
-  definition: contactSheetDefinition,
-  loadExecute: async () => executeContactSheet
-};
-
-// packages/runtime/src/builtins/image/index.ts
-var imageNodeRegistrations = Object.freeze([contactSheetRegistration]);
-
-// packages/runtime/src/builtins/headless.ts
-var headlessOnlyNodeRegistrations = Object.freeze([...imageNodeRegistrations]);
-var headlessNodeRegistrations = Object.freeze([...builtinNodeRegistrations, ...headlessOnlyNodeRegistrations]);
-var headlessOnlyById = new Map(
-  headlessOnlyNodeRegistrations.map((registration) => [registration.moduleId, registration])
-);
-function headlessNodeRegistration(moduleId) {
-  return builtinNodeRegistration(moduleId) ?? headlessOnlyById.get(moduleId);
-}
-
-// src/cli/assertNodes.ts
-import { inflateSync } from "node:zlib";
-var AssertionFailed = class extends Error {
-  constructor(nodeId, moduleId, detail, message2) {
-    const extra = typeof message2 === "string" && message2.trim() ? ` ${message2.trim()}` : "";
-    super(`Assertion failed in "${nodeId}" (${moduleId}): ${detail}.${extra}`);
-    this.name = "AssertionFailed";
-  }
-};
-var message = { type: "string", default: "" };
-var rangeDefinition = {
-  apiVersion: 1,
-  runsOn: "portable",
-  label: "Assert Range",
-  description: "Fails the run unless value is a finite number in [min, max]; passes value through",
-  icon: "ShieldCheck",
-  inputs: { value: { kind: "data", type: "float", default: 0 } },
-  outputs: { value: { kind: "data", type: "float" } },
-  props: { min: { type: "float", default: 0 }, max: { type: "float", default: 1 }, message }
-};
-var equalsDefinition = {
-  apiVersion: 1,
-  runsOn: "portable",
-  label: "Assert Equals",
-  description: "Fails the run unless value equals expected (JSON-equal; numbers within tolerance); passes value through",
-  icon: "ShieldCheck",
-  inputs: { value: { kind: "data", type: "any", default: null } },
-  outputs: { value: { kind: "data", type: "any" } },
-  props: { expected: { type: "any", default: null }, tolerance: { type: "float", default: 0, min: 0 }, message }
-};
-var trueDefinition = {
-  apiVersion: 1,
-  runsOn: "portable",
-  label: "Assert True",
-  description: "Fails the run unless value is true (wire a condition, or give the prop an expression); passes value through",
-  icon: "ShieldCheck",
-  inputs: { value: { kind: "data", type: "bool", default: false } },
-  outputs: { value: { kind: "data", type: "bool" } },
-  props: { message }
-};
-var notBlankDefinition = {
-  apiVersion: 1,
-  runsOn: "portable",
-  label: "Assert Not Blank",
-  description: "Fails the run when an image (PNG or PPM) is one flat colour or fully transparent; passes the image through",
-  icon: "ShieldCheck",
-  capabilities: ["assets"],
-  inputs: { image: { kind: "data", type: "image" } },
-  outputs: { image: { kind: "data", type: "image" } },
-  props: {
-    tolerance: { type: "int", default: 0, min: 0, max: 255, step: 1 },
-    message
-  }
-};
-var rangeRegistration = {
-  kind: "definition-v1",
-  moduleId: "cascade.assert.Range",
-  definition: rangeDefinition,
-  loadExecute: async () => ({ nodeId, inputs, props, outputs }) => {
-    const value = inputs.value;
-    if (typeof value !== "number" || !Number.isFinite(value)) {
-      throw new AssertionFailed(nodeId, "cascade.assert.Range", `value ${String(value)} is not a finite number`, props.message);
-    }
-    if (value < props.min || value > props.max) {
-      throw new AssertionFailed(nodeId, "cascade.assert.Range", `value ${value} is outside [${props.min}, ${props.max}]`, props.message);
-    }
-    outputs.value.set(value);
-  }
-};
-var equalsRegistration = {
-  kind: "definition-v1",
-  moduleId: "cascade.assert.Equals",
-  definition: equalsDefinition,
-  loadExecute: async () => ({ nodeId, inputs, props, outputs }) => {
-    if (!deepEqual(inputs.value, props.expected, props.tolerance)) {
-      throw new AssertionFailed(nodeId, "cascade.assert.Equals", `got ${preview(inputs.value)}, expected ${preview(props.expected)}`, props.message);
-    }
-    outputs.value.set(inputs.value);
-  }
-};
-var trueRegistration = {
-  kind: "definition-v1",
-  moduleId: "cascade.assert.True",
-  definition: trueDefinition,
-  loadExecute: async () => ({ nodeId, inputs, props, outputs }) => {
-    if (inputs.value !== true) throw new AssertionFailed(nodeId, "cascade.assert.True", `value is ${preview(inputs.value)}`, props.message);
-    outputs.value.set(true);
-  }
-};
-var notBlankRegistration = {
-  kind: "definition-v1",
-  moduleId: "cascade.assert.NotBlank",
-  definition: notBlankDefinition,
-  loadExecute: async () => async ({ nodeId, inputs, props, outputs, capabilities, signal }) => {
-    const image = inputs.image;
-    const ref = typeof image === "string" ? { path: image } : image;
-    if (!ref || typeof ref.path !== "string" || !ref.path) {
-      throw new AssertionFailed(nodeId, "cascade.assert.NotBlank", "no image arrived", props.message);
-    }
-    const bytes = await capabilities.assets.read(ref, { signal });
-    const pixels = decodeImage(bytes);
-    if (!pixels) throw new AssertionFailed(nodeId, "cascade.assert.NotBlank", `${ref.path} is not a PNG or PPM this node can read`, props.message);
-    const verdict = blankness(pixels, props.tolerance);
-    if (verdict) throw new AssertionFailed(nodeId, "cascade.assert.NotBlank", `${ref.path} (${pixels.width}x${pixels.height}) is ${verdict}`, props.message);
-    outputs.image.set(inputs.image);
-  }
-};
-var assertNodeRegistrations = Object.freeze([
-  equalsRegistration,
-  notBlankRegistration,
-  rangeRegistration,
-  trueRegistration
-]);
-function preview(value) {
-  const text = JSON.stringify(value) ?? String(value);
-  return text.length > 120 ? `${text.slice(0, 117)}...` : text;
-}
-function deepEqual(a, b, tolerance) {
-  if (typeof a === "number" && typeof b === "number") return a === b || Math.abs(a - b) <= tolerance;
-  if (Array.isArray(a) && Array.isArray(b)) return a.length === b.length && a.every((item, index) => deepEqual(item, b[index], tolerance));
-  if (a && b && typeof a === "object" && typeof b === "object" && !Array.isArray(a) && !Array.isArray(b)) {
-    const keys = Object.keys(a);
-    if (keys.length !== Object.keys(b).length) return false;
-    return keys.every((key) => key in b && deepEqual(a[key], b[key], tolerance));
-  }
-  return a === b || a == null && b == null;
-}
-function blankness(pixels, tolerance = 0) {
-  const { channels, data } = pixels;
-  const alpha = channels === 2 || channels === 4 ? channels - 1 : -1;
-  const colour = alpha === -1 ? channels : channels - 1;
-  const min = new Array(channels).fill(255);
-  const max = new Array(channels).fill(0);
-  let opaque = alpha === -1;
-  for (let index = 0; index < data.length; index += channels) {
-    if (alpha !== -1 && data[index + alpha] > tolerance) opaque = true;
-    for (let channel = 0; channel < channels; channel += 1) {
-      const value = data[index + channel];
-      if (value < min[channel]) min[channel] = value;
-      if (value > max[channel]) max[channel] = value;
-    }
-  }
-  if (!opaque) return "fully transparent";
-  const spread = Math.max(...max.map((value, channel) => value - min[channel]));
-  if (spread <= tolerance) return colour === 1 ? `one flat grey (${min[0]})` : `one flat colour (rgb ${min.slice(0, 3).join(", ")})`;
-  return null;
-}
-function decodeImage(bytes) {
-  if (bytes[0] === 137 && bytes[1] === 80 && bytes[2] === 78 && bytes[3] === 71) return decodePng(bytes);
-  if (bytes[0] === 80 && (bytes[1] === 54 || bytes[1] === 53)) return decodePnm(bytes);
-  return null;
-}
-function decodePnm(bytes) {
-  const fields = [];
-  let index = 2;
-  while (fields.length < 3 && index < bytes.length) {
-    while (index < bytes.length && /\s/.test(String.fromCharCode(bytes[index]))) index += 1;
-    if (bytes[index] === 35) {
-      while (index < bytes.length && bytes[index] !== 10) index += 1;
-      continue;
-    }
-    let field = "";
-    while (index < bytes.length && !/\s/.test(String.fromCharCode(bytes[index]))) field += String.fromCharCode(bytes[index++]);
-    fields.push(field);
-  }
-  const [width, height, maxValue] = fields.map(Number);
-  if (!width || !height || maxValue !== 255) return null;
-  const channels = bytes[1] === 54 ? 3 : 1;
-  return { width, height, channels, data: bytes.subarray(index + 1, index + 1 + width * height * channels) };
-}
-function decodePng(bytes) {
-  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
-  let offset = 8;
-  let width = 0;
-  let height = 0;
-  let channels = 0;
-  const idat = [];
-  while (offset + 8 <= bytes.length) {
-    const length = view.getUint32(offset);
-    const type = String.fromCharCode(...bytes.subarray(offset + 4, offset + 8));
-    const body = bytes.subarray(offset + 8, offset + 8 + length);
-    if (type === "IHDR") {
-      width = view.getUint32(offset + 8);
-      height = view.getUint32(offset + 12);
-      const depth = body[8];
-      const colourType = body[9];
-      const interlace = body[12];
-      channels = { 0: 1, 4: 2, 2: 3, 6: 4 }[colourType] ?? 0;
-      if (depth !== 8 || !channels || interlace !== 0) return null;
-    } else if (type === "IDAT") idat.push(body);
-    else if (type === "IEND") break;
-    offset += 12 + length;
-  }
-  if (!width || !height || !idat.length) return null;
-  const raw = inflateSync(Buffer.concat(idat));
-  const stride = width * channels;
-  const data = new Uint8Array(stride * height);
-  for (let row = 0; row < height; row += 1) {
-    const filter = raw[row * (stride + 1)];
-    const line = raw.subarray(row * (stride + 1) + 1, (row + 1) * (stride + 1));
-    const out = data.subarray(row * stride, (row + 1) * stride);
-    const previous = row > 0 ? data.subarray((row - 1) * stride, row * stride) : new Uint8Array(stride);
-    for (let x = 0; x < stride; x += 1) {
-      const left = x >= channels ? out[x - channels] : 0;
-      const up = previous[x];
-      const upLeft = x >= channels ? previous[x - channels] : 0;
-      const value = line[x];
-      switch (filter) {
-        case 0:
-          out[x] = value;
-          break;
-        case 1:
-          out[x] = value + left & 255;
-          break;
-        case 2:
-          out[x] = value + up & 255;
-          break;
-        case 3:
-          out[x] = value + (left + up >> 1) & 255;
-          break;
-        case 4: {
-          const estimate = left + up - upLeft;
-          const a = Math.abs(estimate - left);
-          const b = Math.abs(estimate - up);
-          const c = Math.abs(estimate - upLeft);
-          out[x] = value + (a <= b && a <= c ? left : b <= c ? up : upLeft) & 255;
-          break;
-        }
-        default:
-          return null;
-      }
-    }
-  }
-  return { width, height, channels, data };
-}
-
-// src/cli/headlessBuiltins.ts
-var headlessBuiltinRegistrations = Object.freeze([
-  ...headlessNodeRegistrations,
-  ...assertNodeRegistrations
-]);
-var asserts = new Map(assertNodeRegistrations.map((registration) => [registration.moduleId, registration]));
-function headlessBuiltin(moduleId) {
-  return headlessNodeRegistration(moduleId) ?? asserts.get(moduleId);
-}
-
-export {
-  builtinNodeRegistrations,
-  builtinNodeRegistration,
-  composeContactSheet,
-  headlessBuiltinRegistrations,
-  headlessBuiltin
-};
-//# sourceMappingURL=chunk-36P5K3SD.js.map