@field/cascade 0.11.0 → 0.13.0

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/generators-YU7GB4MD.js

@@ -0,0 +1,210 @@
+import {
+  Planar,
+  normalizeColor,
+  output
+} from "./chunk-WGKPJZDY.js";
+
+// packages/runtime/src/builtins/image/simplex.ts
+var SQRT3 = Math.sqrt(3);
+var F2 = 0.5 * (SQRT3 - 1);
+var G2 = (3 - SQRT3) / 6;
+var fastFloor = (x) => Math.floor(x) | 0;
+var grad2 = new Float64Array([1, 1, -1, 1, 1, -1, -1, -1, 1, 0, -1, 0, 1, 0, -1, 0, 0, 1, 0, -1, 0, 1, 0, -1]);
+function buildPermutationTable(random) {
+  const tableSize = 512;
+  const p = new Uint8Array(tableSize);
+  for (let i = 0; i < tableSize / 2; i++) p[i] = i;
+  for (let i = 0; i < tableSize / 2 - 1; i++) {
+    const r = i + ~~(random() * (256 - i));
+    const aux = p[i];
+    p[i] = p[r];
+    p[r] = aux;
+  }
+  for (let i = 256; i < tableSize; i++) p[i] = p[i - 256];
+  return p;
+}
+function createNoise2D(random) {
+  const perm = buildPermutationTable(random);
+  const permGrad2x = new Float64Array(perm).map((v) => grad2[v % 12 * 2]);
+  const permGrad2y = new Float64Array(perm).map((v) => grad2[v % 12 * 2 + 1]);
+  return function noise2D(x, y) {
+    let n0 = 0;
+    let n1 = 0;
+    let n2 = 0;
+    const s = (x + y) * F2;
+    const i = fastFloor(x + s);
+    const j = fastFloor(y + s);
+    const t = (i + j) * G2;
+    const X0 = i - t;
+    const Y0 = j - t;
+    const x0 = x - X0;
+    const y0 = y - Y0;
+    let i1, j1;
+    if (x0 > y0) {
+      i1 = 1;
+      j1 = 0;
+    } else {
+      i1 = 0;
+      j1 = 1;
+    }
+    const x1 = x0 - i1 + G2;
+    const y1 = y0 - j1 + G2;
+    const x2 = x0 - 1 + 2 * G2;
+    const y2 = y0 - 1 + 2 * G2;
+    const ii = i & 255;
+    const jj = j & 255;
+    let t0 = 0.5 - x0 * x0 - y0 * y0;
+    if (t0 >= 0) {
+      const gi0 = ii + perm[jj];
+      t0 *= t0;
+      n0 = t0 * t0 * (permGrad2x[gi0] * x0 + permGrad2y[gi0] * y0);
+    }
+    let t1 = 0.5 - x1 * x1 - y1 * y1;
+    if (t1 >= 0) {
+      const gi1 = ii + i1 + perm[jj + j1];
+      t1 *= t1;
+      n1 = t1 * t1 * (permGrad2x[gi1] * x1 + permGrad2y[gi1] * y1);
+    }
+    let t2 = 0.5 - x2 * x2 - y2 * y2;
+    if (t2 >= 0) {
+      const gi2 = ii + 1 + perm[jj + 1];
+      t2 *= t2;
+      n2 = t2 * t2 * (permGrad2x[gi2] * x2 + permGrad2y[gi2] * y2);
+    }
+    return 70 * (n0 + n1 + n2);
+  };
+}
+
+// packages/runtime/src/builtins/image/generators.ts
+function size(resolution) {
+  return [resolution[0], resolution[1]];
+}
+async function executeColor(context) {
+  const [width, height] = size(context.props.resolution);
+  await output(context, Planar.solid(width, height, normalizeColor(context.props.color)));
+}
+async function executeCheckers(context) {
+  const { props } = context;
+  const [width, height] = size(props.resolution);
+  const color1 = normalizeColor(props.color1);
+  const color2 = normalizeColor(props.color2);
+  const checkerSize = props.mode === "size" ? props.size : width / props.divisions;
+  let offsetX = 0;
+  let offsetY = 0;
+  if (props.centered) {
+    offsetX = width / 2 % checkerSize - checkerSize / 2;
+    offsetY = height / 2 % checkerSize - checkerSize / 2;
+  }
+  const buffer = Planar.rgba(width, height);
+  const [r, g, b, a] = buffer.channels;
+  for (let y = 0; y < height; y++) {
+    for (let x = 0; x < width; x++) {
+      const idx = y * width + x;
+      const even = (Math.floor((x - offsetX) / checkerSize) + Math.floor((y - offsetY) / checkerSize)) % 2 === 0;
+      const color = even ? color1 : color2;
+      r[idx] = color.r;
+      g[idx] = color.g;
+      b[idx] = color.b;
+      a[idx] = color.a;
+    }
+  }
+  await output(context, buffer);
+}
+async function executeNoise(context) {
+  const { props } = context;
+  const [width, height] = size(props.resolution);
+  let rng = props.seed;
+  const noise2D = createNoise2D(() => {
+    rng = (rng * 9301 + 49297) % 233280;
+    return rng / 233280;
+  });
+  const buffer = Planar.grayscale(width, height);
+  const gray = buffer.channels[0];
+  for (let y = 0; y < height; y++) {
+    for (let x = 0; x < width; x++) {
+      let value = 0;
+      let amplitude = 1;
+      let frequency = props.scale;
+      let maxValue = 0;
+      for (let i = 0; i < props.iterations; i++) {
+        value += noise2D(x * frequency, y * frequency) * amplitude;
+        maxValue += amplitude;
+        amplitude *= 0.5;
+        frequency *= 2;
+      }
+      gray[y * width + x] = (value / maxValue + 1) * 0.5;
+    }
+  }
+  await output(context, buffer);
+}
+function interpolateColor(color1, color2, t, interpolation) {
+  if (interpolation === "constant") return t < 0.5 ? color1 : color2;
+  if (interpolation === "smooth") t = t * t * (3 - 2 * t);
+  return {
+    r: color1.r + (color2.r - color1.r) * t,
+    g: color1.g + (color2.g - color1.g) * t,
+    b: color1.b + (color2.b - color1.b) * t,
+    a: (color1.a ?? 1) + ((color2.a ?? 1) - (color1.a ?? 1)) * t
+  };
+}
+function colorAt(points, position) {
+  const sorted = [...points].sort((a, b) => a.position - b.position);
+  position = Math.max(0, Math.min(1, position));
+  let before = null;
+  let after = null;
+  for (const point of sorted) {
+    if (point.position <= position) before = point;
+    if (point.position >= position && !after) {
+      after = point;
+      break;
+    }
+  }
+  if (!before && after) return normalizeColor(after.color);
+  if (before && !after) return normalizeColor(before.color);
+  if (!before || !after) return { r: 0, g: 0, b: 0, a: 1 };
+  if (before.position === position) return normalizeColor(before.color);
+  if (after.position === position) return normalizeColor(after.color);
+  const t = (position - before.position) / (after.position - before.position);
+  return interpolateColor(normalizeColor(before.color), normalizeColor(after.color), t, after.interpolation || "linear");
+}
+async function executeRamp(context) {
+  const { props } = context;
+  const [width, height] = size(props.resolution);
+  const points = props.points ?? [];
+  if (points.length === 0) return;
+  const buffer = Planar.rgba(width, height);
+  const [r, g, b, a] = buffer.channels;
+  const centerX = width / 2;
+  const centerY = height / 2;
+  const maxDist = Math.sqrt(centerX * centerX + centerY * centerY);
+  for (let y = 0; y < height; y++) {
+    for (let x = 0; x < width; x++) {
+      let position = 0;
+      if (props.type === "horizontal") {
+        position = x / width;
+      } else if (props.type === "vertical") {
+        position = y / height;
+      } else if (props.type === "radial") {
+        position = (Math.atan2(y - centerY, x - centerX) + Math.PI) / (2 * Math.PI);
+      } else if (props.type === "concentric") {
+        const dx = x - centerX;
+        const dy = y - centerY;
+        position = Math.sqrt(dx * dx + dy * dy) / maxDist;
+      }
+      const color = colorAt(points, position);
+      const idx = y * width + x;
+      r[idx] = color.r;
+      g[idx] = color.g;
+      b[idx] = color.b;
+      a[idx] = color.a ?? 1;
+    }
+  }
+  await output(context, buffer);
+}
+export {
+  executeCheckers,
+  executeColor,
+  executeNoise,
+  executeRamp
+};
+//# sourceMappingURL=generators-YU7GB4MD.js.map

package/dist/cli/{geo-4RNK3QVN.js → geo-6ZPGKZRU.js}

@@ -1,22 +1,22 @@
 import {
   browserAssetCapability
-} from "./chunk-53NMBJAO.js";
+} from "./chunk-ZSCUZE6I.js";
 import {
   registerDefinitionNodes
-} from "./chunk-SGJAET2L.js";
-import "./chunk-FCDXJ6EK.js";
+} from "./chunk-BPODRH52.js";
+import "./chunk-CTPLRSWF.js";
 import "./chunk-RUU3YWXU.js";
 import {
   geoNodeDefinitions,
   geoNodeRegistrations
-} from "./chunk-35D343DC.js";
+} from "./chunk-GRIN2DDP.js";
 import "./chunk-DEQSEFFH.js";
 import "./chunk-HSNOBIVT.js";
-import "./chunk-GFS6W3C5.js";
+import "./chunk-L6B6FUQP.js";
 import "./chunk-HFHWYL55.js";
 import "./chunk-CO22XHNG.js";
 import "./chunk-J7VK7MNF.js";
-import "./chunk-BIJO5OFS.js";
+import "./chunk-FWMSGKEH.js";
 
 // src/nodes/geo/library.ts
 var geoLibrary = {
@@ -40,4 +40,4 @@ registerDefinitionNodes(geoNodeRegistrations, { assets: browserAssetCapability }
 export {
   geoLibrary
 };
-//# sourceMappingURL=geo-4RNK3QVN.js.map
+//# sourceMappingURL=geo-6ZPGKZRU.js.map

package/dist/cli/{graphCommands-6BMAKGQE.js → graphCommands-MULQ7VD2.js}

@@ -1,12 +1,12 @@
 import {
   VERBS,
   graphOptions
-} from "./chunk-POMMNKZZ.js";
+} from "./chunk-G23A2BZZ.js";
 
 // src/cli/graphCommands.ts
 import fs from "node:fs/promises";
 import path from "node:path";
-var loadGraphFile = async () => (await import("./graphFile-VPSQ6OF7.js")).GraphFile;
+var loadGraphFile = async () => (await import("./graphFile-CITF36ZM.js")).GraphFile;
 async function runGraphCommand(args, options) {
   const parsed = parseArguments(args);
   const [command, ...rest] = parsed.positional;
@@ -21,7 +21,7 @@ async function runGraphCommand(args, options) {
     }
     if (sub === "read") {
       const graph = await (await loadGraphFile()).open(required(file2, "cascade graph read <graph>"));
-      const { readGraph } = await import("./edit-JHCPTQFT.js");
+      const { readGraph } = await import("./edit-S5KEQ5RA.js");
       const read = readGraph(graph.document, optional(parsed.values.in, "in"));
       if (!options.json) printGraph(read);
       return { file: graph.file, ...read };
@@ -181,4 +181,4 @@ export {
   applyEdits,
   runGraphCommand
 };
-//# sourceMappingURL=graphCommands-6BMAKGQE.js.map
+//# sourceMappingURL=graphCommands-MULQ7VD2.js.map