@field/cascade 0.11.0 → 0.12.0

package/dist/cli/registerStandardNodes-S2VLMF6J.js

@@ -1,3081 +0,0 @@
-import {
-  CORE_TYPES,
-  Node,
-  colorToCss,
-  isCoreType,
-  normalizeColor,
-  registerNodeClasses
-} from "./chunk-FCDXJ6EK.js";
-import "./chunk-RUU3YWXU.js";
-import {
-  randomFromSeed,
-  remap
-} from "./chunk-RXDIMXN5.js";
-import "./chunk-HFHWYL55.js";
-import "./chunk-CO22XHNG.js";
-import "./chunk-BIJO5OFS.js";
-
-// src/nodes/core/nodes/SwitchNode.ts
-var SwitchNode = class extends Node {
-  constructor(id, graph) {
-    super(id, "Switch", graph);
-  }
-  /**
-   * Get the index of the currently active input
-   * Used by connection rendering to grey out inactive wires
-   */
-  get activeInputIndex() {
-    const inputs = this.getVariadicInputs();
-    return Math.min(this.props.index?.value ?? 0, inputs.length - 1);
-  }
-  /**
-   * Check if a specific input port is active (for connection coloring)
-   */
-  isInputActive(portId) {
-    const inputs = this.getVariadicInputs();
-    const activeIdx = this.activeInputIndex;
-    const portIndex = inputs.findIndex((p) => p.id === portId);
-    return portIndex === activeIdx;
-  }
-  setup() {
-    this.setVariadic();
-    this.output = this.out("output");
-    const index = this.param("index", 0, { type: "int", min: 0, max: 0, step: 1 });
-    index.documentField = "props";
-    this.watchProp("index", () => this.update());
-    this.onUpdate = () => this.update();
-    this.onReady = () => this.update();
-  }
-  onCook() {
-    this.update();
-  }
-  update() {
-    const inputs = this.getVariadicInputs();
-    const connectedCount = inputs.filter((p) => p.connections.length > 0).length;
-    this.updatePropParams("index", { max: Math.max(0, connectedCount - 1) });
-    const idx = Math.min(this.props.index.value, inputs.length - 1);
-    const selectedInput = inputs[idx];
-    if (selectedInput) {
-      this.output.setValue(selectedInput.value);
-      if (this.isPreviewValue(selectedInput.value)) {
-        this.preview = selectedInput.value;
-      } else {
-        this.preview = null;
-      }
-    } else {
-      this.output.setValue(null);
-      this.preview = null;
-    }
-  }
-};
-
-// src/nodes/core/nodes/MergeNode.ts
-var MergeNode = class extends Node {
-  constructor(id, graph) {
-    super(id, "Merge", graph);
-  }
-  setup() {
-    this.setVariadic();
-    this.output = this.out("output");
-    this.addParm("append", {
-      value: false,
-      type: "boolean",
-      displayName: "Append Mode",
-      hidden: () => {
-        const inputs = this.getVariadicInputs();
-        return !Array.isArray(inputs[0]?.value);
-      }
-    });
-    this.watchProp("append", () => this.update());
-    this.onUpdate = () => this.update();
-    this.onReady = () => this.update();
-  }
-  update() {
-    const inputs = this.getVariadicInputs();
-    const values = inputs.filter((p) => p.value !== null).map((p) => p.value);
-    const appendMode = this.props.append.value;
-    if (appendMode && values.length > 0 && Array.isArray(values[0])) {
-      const result = [...values[0], ...values.slice(1)];
-      this.output.setValue(result);
-    } else {
-      this.output.setValue(values);
-    }
-    this.preview = null;
-    for (const val of values) {
-      if (val instanceof HTMLCanvasElement || val instanceof HTMLImageElement) {
-        this.preview = val;
-        break;
-      }
-    }
-  }
-};
-
-// src/nodes/core/nodes/SubnetNode.ts
-var SubnetNode = class extends Node {
-  constructor(id, graph) {
-    super(id, "Subnet", graph);
-  }
-  setup() {
-    this.onUpdate = () => this.update();
-    this.onReady = () => {
-      this.syncPorts();
-      this.update();
-    };
-  }
-  /**
-   * Override: Subnets are networks and can contain children
-   */
-  isNetwork() {
-    return true;
-  }
-  /**
-   * Add a child node to this subnet
-   */
-  addChild(node) {
-    node.parent = this;
-    this._children.push(node);
-    if (node.type === "Input" || node.type === "Output") {
-      this.syncPorts();
-    }
-  }
-  /**
-   * Remove a child node from this subnet
-   */
-  removeChild(node) {
-    const index = this._children.indexOf(node);
-    if (index !== -1) {
-      const wasInputOutput = node.type === "Input" || node.type === "Output";
-      this._children.splice(index, 1);
-      node.parent = null;
-      if (wasInputOutput) {
-        this.syncPorts();
-      }
-    }
-  }
-  /**
-   * Sync input/output ports based on child Input/Output nodes
-   */
-  syncPorts() {
-    const inputNodes = this._children.filter((n) => n.type === "Input");
-    const maxInputIndex = inputNodes.reduce((max, node) => {
-      const idx = node.inputIndex ?? 0;
-      return Math.max(max, idx);
-    }, -1);
-    const outputNodes = this._children.filter((n) => n.type === "Output");
-    const maxOutputIndex = outputNodes.reduce((max, node) => {
-      const idx = node.outputIndex ?? 0;
-      return Math.max(max, idx);
-    }, -1);
-    const requiredInputs = maxInputIndex + 1;
-    const currentInputs = this.inputs.length;
-    for (let i = currentInputs; i < requiredInputs; i++) {
-      const boundary = inputNodes.find((n) => n.inputIndex === i);
-      const port = this.in(boundary?.inputName || `input_${i}`, null, {
-        type: boundary?.dataType || "any"
-      });
-      port.onChange = (value) => {
-        this._children.filter((n) => n.type === "Input" && n.inputIndex === i).forEach((n) => n.markDirty());
-      };
-    }
-    for (let i = requiredInputs; i < currentInputs; i++) {
-      if (this.inputs[i]) {
-        this.inputs[i].options = { ...this.inputs[i].options, hidden: true };
-      }
-    }
-    for (let i = 0; i < requiredInputs; i++) {
-      if (this.inputs[i]) {
-        const boundary = inputNodes.find((n) => n.inputIndex === i);
-        this.inputs[i].name = boundary?.inputName || `input_${i}`;
-        this.inputs[i].dataType = boundary?.dataType || "any";
-        this.inputs[i].options = { ...this.inputs[i].options, hidden: false };
-      }
-    }
-    const requiredOutputs = maxOutputIndex + 1;
-    const currentOutputs = this.outputs.length;
-    for (let i = currentOutputs; i < requiredOutputs; i++) {
-      const boundary = outputNodes.find((n) => n.outputIndex === i);
-      this.out(boundary?.outputName || `output_${i}`, "param", {
-        type: boundary?.dataType || "any"
-      });
-    }
-    for (let i = requiredOutputs; i < currentOutputs; i++) {
-      if (this.outputs[i]) {
-        this.outputs[i].options = { ...this.outputs[i].options, hidden: true };
-      }
-    }
-    for (let i = 0; i < requiredOutputs; i++) {
-      if (this.outputs[i]) {
-        const boundary = outputNodes.find((n) => n.outputIndex === i);
-        this.outputs[i].name = boundary?.outputName || `output_${i}`;
-        this.outputs[i].dataType = boundary?.dataType || "any";
-        this.outputs[i].options = { ...this.outputs[i].options, hidden: false };
-      }
-    }
-    this.inputs = [...this.inputs];
-    this.outputs = [...this.outputs];
-  }
-  /**
-   * Get the node that defines this subnet's output
-   * Priority: Output node > cooking node > last node
-   */
-  outputNode() {
-    const outputNode = this._children.find((n) => n.type === "Output");
-    if (outputNode) return outputNode;
-    const cookingNode = this._children.find((n) => n.cook);
-    if (cookingNode) return cookingNode;
-    return this._children.length > 0 ? this._children[this._children.length - 1] : null;
-  }
-  /**
-   * Get the cooking (display) node in this subnet
-   */
-  displayNode() {
-    return this._children.find((n) => n.cook) ?? null;
-  }
-  /**
-   * Get all Input nodes inside this subnet
-   */
-  indirectInputs() {
-    return this._children.filter((n) => n.type === "Input");
-  }
-  update() {
-    const outputNodes = this._children.filter((n) => n.type === "Output");
-    const outputByIndex = /* @__PURE__ */ new Map();
-    for (const node of outputNodes) {
-      const idx = node.outputIndex ?? 0;
-      outputByIndex.set(idx, node);
-    }
-    for (let i = 0; i < this.outputs.length; i++) {
-      const outNode = outputByIndex.get(i);
-      if (outNode && outNode.inputs.length > 0) {
-        const value = outNode.inputs[0].value;
-        this.outputs[i].setValue(value);
-        if (i === 0 && (value instanceof HTMLCanvasElement || value instanceof HTMLImageElement)) {
-          this.preview = value;
-        }
-      } else if (i === 0) {
-        const cookingNode = this._children.find((n) => n.cook);
-        if (cookingNode && cookingNode.outputs.length > 0) {
-          this.outputs[i].setValue(cookingNode.outputs[0].value);
-          if (cookingNode.preview) {
-            this.preview = cookingNode.preview;
-          }
-        } else {
-          this.outputs[i].setValue(null);
-        }
-      } else {
-        this.outputs[i].setValue(null);
-      }
-    }
-    if (this.outputs.length === 0 || !outputByIndex.has(0)) {
-      const cookingNode = this._children.find((n) => n.cook);
-      if (!cookingNode?.preview) {
-        this.preview = null;
-      }
-    }
-  }
-};
-
-// src/nodes/core/nodes/InputNode.ts
-var TYPE_CHOICES = CORE_TYPES.map((type) => ({ value: type, label: type }));
-var InputNode = class extends Node {
-  constructor(id, graph) {
-    super(id, "Input", graph);
-  }
-  setup() {
-    this.output = this.out("output");
-    this.addParm("inputIndex", {
-      value: 0,
-      type: "int",
-      params: { min: 0, step: 1 },
-      displayName: "Input Index"
-    });
-    this.addParm("inputName", {
-      value: "",
-      type: "text",
-      displayName: "Input Name"
-    });
-    this.addParm("dataType", {
-      value: "any",
-      type: "select",
-      params: { options: TYPE_CHOICES },
-      displayName: "Data Type"
-    });
-    const syncParent = () => {
-      if (this.parent && this.parent.syncPorts) {
-        this.parent.syncPorts();
-      }
-      this.update();
-    };
-    this.watchProp("inputIndex", syncParent);
-    this.watchProp("inputName", syncParent);
-    this.watchProp("dataType", () => {
-      this.output.dataType = this.dataType;
-      syncParent();
-    });
-    this.onUpdate = () => this.update();
-    this.onReady = () => this.update();
-  }
-  /**
-   * Get the input index this node represents
-   */
-  get inputIndex() {
-    return this.props.inputIndex?.value ?? 0;
-  }
-  /**
-   * Get the input name (for documentation)
-   */
-  get inputName() {
-    return this.props.inputName?.value ?? "";
-  }
-  get dataType() {
-    const value = this.props.dataType?.value;
-    return typeof value === "string" && isCoreType(value) ? value : "any";
-  }
-  update() {
-    if (this.parent && this.parent.inputs.length > 0) {
-      const idx = this.inputIndex;
-      const parentInput = this.parent.inputs[idx];
-      if (parentInput) {
-        this.output.setValue(parentInput.value);
-        if (this.isPreviewValue(parentInput.value)) {
-          this.preview = parentInput.value;
-        } else {
-          this.preview = null;
-        }
-        return;
-      }
-    }
-    this.output.setValue(null);
-    this.preview = null;
-  }
-};
-
-// src/nodes/core/nodes/OutputNode.ts
-var TYPE_CHOICES2 = CORE_TYPES.map((type) => ({ value: type, label: type }));
-var OutputNode = class extends Node {
-  constructor(id, graph) {
-    super(id, "Output", graph);
-  }
-  setup() {
-    this.in("input", null);
-    this.addParm("outputIndex", {
-      value: 0,
-      type: "int",
-      params: { min: 0, step: 1 },
-      displayName: "Output Index"
-    });
-    this.addParm("outputName", {
-      value: "",
-      type: "text",
-      displayName: "Output Name"
-    });
-    this.addParm("dataType", {
-      value: "any",
-      type: "select",
-      params: { options: TYPE_CHOICES2 },
-      displayName: "Data Type"
-    });
-    const syncParent = () => {
-      if (this.parent && this.parent.syncPorts) {
-        this.parent.syncPorts();
-      }
-      this.update();
-    };
-    this.watchProp("outputIndex", syncParent);
-    this.watchProp("outputName", syncParent);
-    this.watchProp("dataType", () => {
-      if (this.inputs[0]) this.inputs[0].dataType = this.dataType;
-      syncParent();
-    });
-    this.onUpdate = () => this.update();
-    this.onReady = () => this.update();
-  }
-  /**
-   * Get the output index this node represents
-   */
-  get outputIndex() {
-    return this.props.outputIndex?.value ?? 0;
-  }
-  get outputName() {
-    return this.props.outputName?.value ?? "";
-  }
-  get dataType() {
-    const value = this.props.dataType?.value;
-    return typeof value === "string" && isCoreType(value) ? value : "any";
-  }
-  update() {
-    const input = this.inputs[0];
-    if (input) {
-      if (this.isPreviewValue(input.value)) {
-        this.preview = input.value;
-      } else {
-        this.preview = null;
-      }
-    }
-  }
-};
-
-// src/nodes/core/nodes/RandomNode.ts
-var RandomNode = class extends Node {
-  constructor(id, graph) {
-    super(id, "Random", graph);
-  }
-  setup() {
-    const seed = this.in("seed", 0, { type: "int" });
-    const sample = this.in("sample", 0, { type: "int" });
-    const value = this.out("value");
-    const update = () => value.setValue(randomFromSeed(seed.value, sample.value));
-    seed.onChange = update;
-    sample.onChange = update;
-    this.onUpdate = update;
-    this.onReady = update;
-  }
-};
-
-// src/nodes/core/nodes/RemapNode.ts
-var RemapNode = class extends Node {
-  constructor(id, graph) {
-    super(id, "Remap", graph);
-  }
-  setup() {
-    const value = this.in("value", 0, { type: "float" });
-    const inMin = this.in("inMin", 0, { type: "float" });
-    const inMax = this.in("inMax", 1, { type: "float" });
-    const outMin = this.in("outMin", 0, { type: "float" });
-    const outMax = this.in("outMax", 1, { type: "float" });
-    const result = this.out("result");
-    this.addParm("clamp", { value: false, type: "boolean", displayName: "Clamp" });
-    const update = () => result.setValue(remap(
-      value.value,
-      inMin.value,
-      inMax.value,
-      outMin.value,
-      outMax.value,
-      this.props.clamp.value
-    ));
-    for (const input of [value, inMin, inMax, outMin, outMax]) input.onChange = update;
-    this.watchProp("clamp", update);
-    this.onUpdate = update;
-    this.onReady = update;
-  }
-};
-
-// src/nodes/core/nodes/SelectNode.ts
-var SelectNode = class extends Node {
-  constructor(id, graph) {
-    super(id, "Select", graph);
-  }
-  setup() {
-    this.arrayInput = this.in("array", [], { type: "array" });
-    this.itemOutput = this.out("item", "param");
-    this.countOutput = this.out("count", "param");
-    this.addParm("index", {
-      value: 0,
-      type: "int",
-      params: { min: 0, max: 0, step: 1 },
-      displayName: "Index"
-    });
-    this.addParm("wrap", {
-      value: true,
-      type: "boolean",
-      displayName: "Wrap Index"
-    });
-    this.watchProp("index", () => this.update());
-    this.watchProp("wrap", () => this.update());
-    this.onUpdate = () => this.update();
-    this.onReady = () => this.update();
-  }
-  update() {
-    const array = this.arrayInput.value;
-    if (!Array.isArray(array) || array.length === 0) {
-      this.itemOutput.setValue(null);
-      this.countOutput.setValue(0);
-      this.updatePropParams("index", { max: 0 });
-      return;
-    }
-    this.updatePropParams("index", { max: array.length - 1 });
-    let index = this.props.index?.value ?? 0;
-    const wrap = this.props.wrap?.value ?? true;
-    if (wrap && array.length > 0) {
-      index = (index % array.length + array.length) % array.length;
-    } else {
-      index = Math.max(0, Math.min(index, array.length - 1));
-    }
-    const item = array[index];
-    this.itemOutput.setValue(item);
-    this.countOutput.setValue(array.length);
-    if (item instanceof HTMLCanvasElement || item instanceof HTMLImageElement) {
-      this.preview = item;
-    } else {
-      this.preview = null;
-    }
-  }
-};
-
-// src/nodes/core/nodes/NullNode.ts
-var NullNode = class extends Node {
-  constructor(id, graph) {
-    super(id, "Null", graph);
-  }
-  setup() {
-    const input = this.in("input", null, { type: "any" });
-    const output = this.out("output");
-    const update = () => output.setValue(input.value);
-    input.onChange = update;
-    this.onUpdate = update;
-    this.onReady = update;
-  }
-};
-
-// src/nodes/image/surface.ts
-var globals = () => globalThis;
-var MissingRenderSurfaceError = class extends Error {
-  constructor(kind) {
-    super(
-      `Cascade has no ${kind} in this environment. Install the optional '@napi-rs/canvas' renderer before cooking a graph that draws.`
-    );
-    this.name = "MissingRenderSurfaceError";
-  }
-};
-function provider() {
-  const host = globals();
-  if (typeof host.document?.createElement === "function") return domProvider;
-  if (typeof host.OffscreenCanvas === "function") return offscreenProvider;
-  return null;
-}
-function surfaceAvailable() {
-  return provider() !== null;
-}
-function createSurface(width, height) {
-  const current = provider();
-  if (!current) throw new MissingRenderSurfaceError("drawing surface");
-  return current.createSurface(width, height);
-}
-function decodeImage(source) {
-  const current = provider();
-  if (!current) throw new MissingRenderSurfaceError("image decoder");
-  return current.decodeImage(source);
-}
-function bytesOf(source) {
-  return source instanceof Uint8Array ? source : new Uint8Array(source);
-}
-async function decodeViaBitmap(source) {
-  const host = globals();
-  if (typeof host.createImageBitmap !== "function" || typeof source === "string") return null;
-  const input = source instanceof Uint8Array || source instanceof ArrayBuffer ? typeof host.Blob === "function" ? new host.Blob([bytesOf(source)]) : bytesOf(source) : source;
-  return host.createImageBitmap(input);
-}
-async function decodeViaImage(source) {
-  const host = globals();
-  if (typeof host.Image !== "function") throw new MissingRenderSurfaceError("image decoder");
-  const image = new host.Image();
-  if (typeof source === "string") {
-    if (!/^(data:|blob:)/.test(source)) image.crossOrigin = "anonymous";
-    image.src = source;
-  } else if (source instanceof Uint8Array || source instanceof ArrayBuffer) {
-    image.src = bytesOf(source);
-  } else {
-    image.src = new Uint8Array(await source.arrayBuffer());
-  }
-  await image.decode();
-  if (!image.width || !image.height) throw new Error("cascade: could not decode image data");
-  return image;
-}
-async function decode(source) {
-  if (typeof source !== "string") {
-    const bitmap = await decodeViaBitmap(source);
-    if (bitmap) return bitmap;
-  }
-  return decodeViaImage(source);
-}
-var domProvider = {
-  name: "DOM canvas",
-  createSurface(width, height) {
-    const surface = globals().document.createElement("canvas");
-    surface.width = width;
-    surface.height = height;
-    return surface;
-  },
-  decodeImage: decode
-};
-var offscreenProvider = {
-  name: "OffscreenCanvas",
-  createSurface(width, height) {
-    const Offscreen = globals().OffscreenCanvas;
-    return new Offscreen(width, height);
-  },
-  decodeImage: decode
-};
-
-// src/nodes/image/ImageBuffer.ts
-function isSurface(value) {
-  return typeof value === "object" && value !== null && typeof value.getContext === "function";
-}
-function hasPixels(value) {
-  if (typeof value !== "object" || value === null) return false;
-  const candidate = value;
-  if (typeof candidate.width !== "number" || typeof candidate.height !== "number") return false;
-  return typeof candidate.getContext === "function" || "src" in candidate || typeof candidate.close === "function";
-}
-function sourceSize(source) {
-  const natural = source;
-  return {
-    width: natural.naturalWidth || source.width,
-    height: natural.naturalHeight || source.height
-  };
-}
-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;
-}
-var ImageBuffer = class _ImageBuffer {
-  constructor(width, height, channels, colorSpace = "srgb") {
-    // Cached data for display - invalidated when data changes
-    this._canvas = null;
-    this._imageData = null;
-    this._dirty = true;
-    pixelCount(width, height);
-    this.width = width;
-    this.height = height;
-    this.channels = channels;
-    this.colorSpace = colorSpace;
-    this._memoryBytes = channels.reduce((sum, ch) => sum + ch.byteLength, 0);
-  }
-  /**
-   * Get memory usage of this buffer in bytes
-   */
-  get memoryBytes() {
-    return this._memoryBytes;
-  }
-  /**
-   * Get memory usage in human-readable format
-   */
-  get memorySizeStr() {
-    const bytes = this._memoryBytes;
-    if (bytes < 1024) return `${bytes}B`;
-    if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)}KB`;
-    return `${(bytes / (1024 * 1024)).toFixed(2)}MB`;
-  }
-  // ============ Factory Methods ============
-  /**
-   * Create a grayscale (single channel) buffer
-   */
-  static grayscale(width, height) {
-    const size = pixelCount(width, height);
-    return new _ImageBuffer(width, height, [new Float32Array(size)]);
-  }
-  /**
-   * Create an RGB (3 channel) buffer
-   */
-  static rgb(width, height) {
-    const size = pixelCount(width, height);
-    return new _ImageBuffer(width, height, [
-      new Float32Array(size),
-      new Float32Array(size),
-      new Float32Array(size)
-    ]);
-  }
-  /**
-   * Create an RGBA (4 channel) buffer
-   */
-  static rgba(width, height) {
-    const size = pixelCount(width, height);
-    return new _ImageBuffer(width, height, [
-      new Float32Array(size),
-      new Float32Array(size),
-      new Float32Array(size),
-      new Float32Array(size)
-    ]);
-  }
-  /** Create from a browser or headless canvas/decoded image. */
-  static fromCanvas(source) {
-    if (isSurface(source)) {
-      const ctx2 = source.getContext("2d");
-      if (!ctx2) throw new Error("cascade: canvas has no 2D context");
-      return _ImageBuffer.fromImageData(ctx2.getImageData(0, 0, source.width, source.height));
-    }
-    const { width, height } = sourceSize(source);
-    const surface = createSurface(width, height);
-    const ctx = surface.getContext("2d");
-    if (!ctx) throw new Error("cascade: canvas has no 2D context");
-    ctx.drawImage(source, 0, 0);
-    return _ImageBuffer.fromImageData(ctx.getImageData(0, 0, width, height));
-  }
-  /**
-   * Create from ImageData (interleaved RGBA Uint8)
-   */
-  static fromImageData(imageData) {
-    const { width, height, data } = imageData;
-    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 _ImageBuffer(width, height, [r, g, b, a]);
-  }
-  /**
-   * Create a filled solid color buffer
-   */
-  static solid(width, height, color) {
-    const buffer = _ImageBuffer.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;
-  }
-  // ============ Properties ============
-  get channelCount() {
-    return this.channels.length;
-  }
-  get layout() {
-    switch (this.channels.length) {
-      case 1:
-        return "gray";
-      case 3:
-        return "rgb";
-      default:
-        return "rgba";
-    }
-  }
-  get pixelCount() {
-    return this.width * this.height;
-  }
-  // ============ Channel Access ============
-  /**
-   * Get a channel by index (0=R/Gray, 1=G, 2=B, 3=A)
-   */
-  getChannel(index) {
-    if (index < 0 || index >= this.channels.length) {
-      throw new Error(`Channel index ${index} out of bounds (0-${this.channels.length - 1})`);
-    }
-    return this.channels[index];
-  }
-  /**
-   * Get channel by name
-   */
-  r() {
-    return this.channels[0];
-  }
-  g() {
-    return this.channels[Math.min(1, this.channels.length - 1)];
-  }
-  b() {
-    return this.channels[Math.min(2, this.channels.length - 1)];
-  }
-  a() {
-    return this.channels.length >= 4 ? this.channels[3] : this.createOpaqueAlpha();
-  }
-  createOpaqueAlpha() {
-    const alpha = new Float32Array(this.pixelCount);
-    alpha.fill(1);
-    return alpha;
-  }
-  // ============ Pixel Access ============
-  /**
-   * Get pixel index from coordinates
-   */
-  index(x, y) {
-    return y * this.width + x;
-  }
-  /**
-   * Get all channel values at a pixel
-   */
-  getPixel(x, y) {
-    const idx = this.index(x, y);
-    return this.channels.map((ch) => ch[idx]);
-  }
-  /**
-   * Set all channel values at a pixel
-   */
-  setPixel(x, y, values) {
-    const idx = this.index(x, y);
-    for (let c = 0; c < Math.min(values.length, this.channels.length); c++) {
-      this.channels[c][idx] = values[c];
-    }
-    this._dirty = true;
-  }
-  /**
-   * Get a single channel value at a pixel
-   */
-  getValue(x, y, channel = 0) {
-    return this.channels[channel][this.index(x, y)];
-  }
-  /**
-   * Set a single channel value at a pixel
-   */
-  setValue(x, y, channel, value) {
-    this.channels[channel][this.index(x, y)] = value;
-    this._dirty = true;
-  }
-  // ============ Bulk Operations ============
-  /**
-   * Fill a channel with a constant value
-   */
-  fill(channel, value) {
-    this.channels[channel].fill(value);
-    this._dirty = true;
-  }
-  /**
-   * Fill all channels
-   */
-  fillAll(values) {
-    for (let c = 0; c < this.channels.length; c++) {
-      this.channels[c].fill(values[c] ?? 0);
-    }
-    this._dirty = true;
-  }
-  /**
-   * Create a deep copy
-   */
-  clone() {
-    const newChannels = this.channels.map((ch) => new Float32Array(ch));
-    return new _ImageBuffer(this.width, this.height, newChannels, this.colorSpace);
-  }
-  /**
-   * Create a copy with different dimensions (doesn't resize data)
-   */
-  emptyClone() {
-    return new _ImageBuffer(
-      this.width,
-      this.height,
-      this.channels.map(() => new Float32Array(this.pixelCount)),
-      this.colorSpace
-    );
-  }
-  /**
-   * Mark buffer as modified (invalidates canvas cache)
-   */
-  markDirty() {
-    this._dirty = true;
-  }
-  // ============ Conversion ============
-  /**
-   * Convert to grayscale (luminance)
-   */
-  toGrayscale() {
-    if (this.channels.length === 1) {
-      return this.clone();
-    }
-    const result = _ImageBuffer.grayscale(this.width, this.height);
-    const gray = result.channels[0];
-    const r = this.channels[0];
-    const g = this.channels[1];
-    const b = this.channels[2];
-    for (let i = 0; i < this.pixelCount; i++) {
-      gray[i] = 0.2126 * r[i] + 0.7152 * g[i] + 0.0722 * b[i];
-    }
-    return result;
-  }
-  /**
-   * Convert grayscale to RGBA
-   */
-  toRGBA() {
-    if (this.channels.length >= 4) {
-      return this.clone();
-    }
-    const result = _ImageBuffer.rgba(this.width, this.height);
-    if (this.channels.length === 1) {
-      const gray = this.channels[0];
-      result.channels[0].set(gray);
-      result.channels[1].set(gray);
-      result.channels[2].set(gray);
-      result.channels[3].fill(1);
-    } else if (this.channels.length === 3) {
-      result.channels[0].set(this.channels[0]);
-      result.channels[1].set(this.channels[1]);
-      result.channels[2].set(this.channels[2]);
-      result.channels[3].fill(1);
-    }
-    return result;
-  }
-  /**
-   * Convert to ImageData (for canvas rendering)
-   * Cached - only rebuilds when dirty
-   */
-  toImageData() {
-    if (this._imageData && !this._dirty) {
-      return this._imageData;
-    }
-    const imageData = new ImageData(this.width, this.height);
-    const data = imageData.data;
-    const size = this.pixelCount;
-    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 hasAlpha = this.channels.length > 3;
-    const a = hasAlpha ? this.channels[3] : null;
-    for (let i = 0; i < size; i++) {
-      const idx = i << 2;
-      let v;
-      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 (hasAlpha) {
-        v = a[i] * 255 + 0.5 | 0;
-        data[idx + 3] = v < 0 ? 0 : v > 255 ? 255 : v;
-      } else {
-        data[idx + 3] = 255;
-      }
-    }
-    this._imageData = imageData;
-    return imageData;
-  }
-  /** Convert to the current host's cached drawing surface. */
-  toSurface() {
-    if (this._canvas && !this._dirty) {
-      return this._canvas;
-    }
-    if (!this._canvas) {
-      this._canvas = createSurface(this.width, this.height);
-    }
-    const ctx = this._canvas.getContext("2d");
-    if (!ctx) throw new Error("cascade: canvas has no 2D context");
-    ctx.putImageData(this.toImageData(), 0, 0);
-    this._dirty = false;
-    return this._canvas;
-  }
-  /** Browser-facing alias retained for compatibility with Studio preview code. */
-  toCanvas() {
-    return this.toSurface();
-  }
-  // ============ Utility ============
-  /**
-   * Check if coordinates are within bounds
-   */
-  inBounds(x, y) {
-    return x >= 0 && x < this.width && y >= 0 && y < this.height;
-  }
-  /**
-   * Get coordinate with edge handling
-   */
-  wrapCoord(coord, max, wrap) {
-    if (wrap) {
-      return (coord % max + max) % max;
-    }
-    return Math.max(0, Math.min(max - 1, coord));
-  }
-  /**
-   * Sample with bilinear interpolation
-   */
-  sample(x, y, channel = 0, wrap = false) {
-    const x0 = Math.floor(x);
-    const y0 = Math.floor(y);
-    const x1 = x0 + 1;
-    const y1 = y0 + 1;
-    const fx = x - x0;
-    const fy = y - y0;
-    const ch = this.channels[channel];
-    const w = this.width;
-    const h = this.height;
-    const px0 = this.wrapCoord(x0, w, wrap);
-    const px1 = this.wrapCoord(x1, w, wrap);
-    const py0 = this.wrapCoord(y0, h, wrap);
-    const py1 = this.wrapCoord(y1, h, wrap);
-    const v00 = ch[py0 * w + px0];
-    const v10 = ch[py0 * w + px1];
-    const v01 = ch[py1 * w + px0];
-    const v11 = ch[py1 * w + px1];
-    const v0 = v00 * (1 - fx) + v10 * fx;
-    const v1 = v01 * (1 - fx) + v11 * fx;
-    return v0 * (1 - fy) + v1 * fy;
-  }
-  /**
-   * Sample all channels with bilinear interpolation
-   */
-  samplePixel(x, y, wrap = false) {
-    return this.channels.map((_, c) => this.sample(x, y, c, wrap));
-  }
-};
-
-// src/nodes/core/nodes/FreezeNode.ts
-function previewWanted() {
-  return typeof document !== "undefined";
-}
-var FreezeNode = class extends Node {
-  constructor(id, graph) {
-    super(id, "Freeze", graph);
-    this.frozenValue = null;
-    this.hasCaptured = false;
-  }
-  setup() {
-    this.input = this.in("input", null, { type: "any" });
-    this.output = this.out("output", "param");
-    this.addParm("frozen", {
-      value: false,
-      type: "boolean",
-      displayName: "Frozen"
-    });
-    this.addAction("capture", {
-      label: "Capture",
-      icon: "Camera",
-      callback: () => this.capture()
-    });
-    this.addAction("clear", {
-      label: "Clear",
-      icon: "Trash2",
-      callback: () => this.clear()
-    });
-    this.watchProp("frozen", () => this.update());
-    this.onUpdate = () => this.update();
-    this.onReady = () => this.update();
-  }
-  /**
-   * Capture the current input value
-   */
-  capture() {
-    this.frozenValue = this.deepClone(this.input.value);
-    this.hasCaptured = true;
-    this.setParm("frozen", true);
-    this.update();
-  }
-  /**
-   * Clear the frozen value
-   */
-  clear() {
-    this.frozenValue = null;
-    this.hasCaptured = false;
-    this.setParm("frozen", false);
-    this.update();
-  }
-  /**
-   * Deep clone a value if possible
-   */
-  deepClone(value) {
-    if (value === null || value === void 0) {
-      return value;
-    }
-    if (hasPixels(value)) {
-      const source = value;
-      const width = source.naturalWidth || source.width;
-      const height = source.naturalHeight || source.height;
-      const canvas = createSurface(width, height);
-      const ctx = canvas.getContext("2d");
-      ctx?.drawImage(value, 0, 0);
-      return canvas;
-    }
-    if (Array.isArray(value)) {
-      return value.map((item) => this.deepClone(item));
-    }
-    if (typeof value === "object") {
-      try {
-        return JSON.parse(JSON.stringify(value));
-      } catch {
-        return value;
-      }
-    }
-    return value;
-  }
-  update() {
-    const isFrozen = this.props.frozen?.value ?? false;
-    if (isFrozen && this.hasCaptured) {
-      this.output.setValue(this.frozenValue);
-      if (previewWanted() && hasPixels(this.frozenValue)) {
-        this.preview = this.frozenValue;
-      }
-    } else {
-      this.output.setValue(this.input.value);
-      if (previewWanted() && hasPixels(this.input.value)) {
-        this.preview = this.input.value;
-      } else {
-        this.preview = null;
-      }
-    }
-  }
-  /**
-   * Serialize with frozen state
-   */
-  serialize() {
-    return {
-      hasCaptured: this.hasCaptured
-    };
-  }
-  /**
-   * Deserialize and restore frozen state
-   */
-  deserialize(data) {
-    this.hasCaptured = data.hasCaptured === true;
-  }
-};
-
-// src/nodes/core/classes.ts
-var coreNodeClasses = {
-  "Switch": SwitchNode,
-  "Merge": MergeNode,
-  "Subnet": SubnetNode,
-  "Input": InputNode,
-  "Output": OutputNode,
-  "Random": RandomNode,
-  "Remap": RemapNode,
-  "Select": SelectNode,
-  "Null": NullNode,
-  "Freeze": FreezeNode
-};
-
-// src/nodes/image/ImageNodeBase.ts
-function previewWanted2() {
-  return typeof document !== "undefined" && surfaceAvailable();
-}
-var ImageNodeBase = class _ImageNodeBase extends Node {
-  // ~30fps
-  constructor(id, type, graph) {
-    super(id, type, graph);
-    // Preview update throttling
-    this._previewPending = false;
-    this._previewBuffer = null;
-    this._lastPreviewTime = 0;
-  }
-  static {
-    this.PREVIEW_INTERVAL = 33;
-  }
-  /**
-   * Override onCook() to call the abstract render() method
-   * Cook timing is handled by Node.execute()
-   */
-  onCook() {
-    return this.render();
-  }
-  /**
-   * Helper for onChange handlers - marks dirty for lazy evaluation
-   * Execution is deferred until output is requested by a consumer (Viewer, etc.)
-   */
-  requestCook() {
-    this.markDirty();
-  }
-  // ============ ImageBuffer Utilities ============
-  /**
-   * Convert any image input to ImageBuffer
-   * Returns null if input is null/invalid
-   */
-  toImageBuffer(input) {
-    if (!input) return null;
-    if (input instanceof ImageBuffer) {
-      return input;
-    }
-    if (hasPixels(input)) {
-      return ImageBuffer.fromCanvas(input);
-    }
-    return null;
-  }
-  /**
-   * Get dimensions from any image input
-   */
-  getImageSize(input) {
-    if (!input) return { width: 0, height: 0 };
-    if (input instanceof ImageBuffer) {
-      return { width: input.width, height: input.height };
-    }
-    if (hasPixels(input)) {
-      const natural = input;
-      return {
-        width: natural.naturalWidth || input.width,
-        height: natural.naturalHeight || input.height
-      };
-    }
-    return { width: 0, height: 0 };
-  }
-  // ============ Resolution Utilities ============
-  /**
-   * Add the standard resolution parameter used by generator nodes
-   * Call this in setup() to add a resolution parameter with automatic cooking
-   */
-  addResolutionParm(defaultWidth = 512, defaultHeight = 512) {
-    this.addParm("resolution", {
-      value: [defaultWidth, defaultHeight],
-      params: {
-        min: [1, 1],
-        max: [4096, 4096],
-        integer: true
-      },
-      displayName: "Resolution",
-      onChange: () => this.requestCook()
-    });
-  }
-  /**
-   * Get the current resolution from the resolution parameter
-   * Returns [width, height] tuple
-   * Requires addResolutionParm() to have been called in setup()
-   */
-  getResolution() {
-    if (!this.props.resolution) {
-      console.warn(`${this.type}: getResolution() called but no resolution parameter exists. Call addResolutionParm() in setup().`);
-      return [512, 512];
-    }
-    return this.props.resolution.value;
-  }
-  /**
-   * Determine output resolution based on mode and inputs
-   */
-  resolveOutputSize(mode, inputs, customSize) {
-    const validInputs = inputs.filter((b) => b !== null);
-    switch (mode) {
-      case "input":
-      case "input1":
-        if (validInputs[0]) {
-          return { width: validInputs[0].width, height: validInputs[0].height };
-        }
-        break;
-      case "input2":
-        if (validInputs[1]) {
-          return { width: validInputs[1].width, height: validInputs[1].height };
-        } else if (validInputs[0]) {
-          return { width: validInputs[0].width, height: validInputs[0].height };
-        }
-        break;
-      case "largest":
-        if (validInputs.length > 0) {
-          let maxArea = 0;
-          let largest = validInputs[0];
-          for (const buf of validInputs) {
-            const area = buf.width * buf.height;
-            if (area > maxArea) {
-              maxArea = area;
-              largest = buf;
-            }
-          }
-          return { width: largest.width, height: largest.height };
-        }
-        break;
-      case "smallest":
-        if (validInputs.length > 0) {
-          let minArea = Infinity;
-          let smallest = validInputs[0];
-          for (const buf of validInputs) {
-            const area = buf.width * buf.height;
-            if (area < minArea) {
-              minArea = area;
-              smallest = buf;
-            }
-          }
-          return { width: smallest.width, height: smallest.height };
-        }
-        break;
-      case "custom":
-        if (customSize) {
-          return { width: customSize[0], height: customSize[1] };
-        }
-        break;
-    }
-    if (validInputs[0]) {
-      return { width: validInputs[0].width, height: validInputs[0].height };
-    }
-    return { width: 512, height: 512 };
-  }
-  /**
-   * Resize a buffer to fit target dimensions using the specified fit mode
-   *
-   * Fit modes:
-   * - 'fill': Scale to fill entire target, cropping if necessary (no letterboxing)
-   * - 'fit': Scale to fit within target, maintaining aspect ratio (may letterbox)
-   * - 'stretch': Stretch to exactly match target dimensions (may distort)
-   * - 'native': Use original size, centered in target (may crop or have empty space)
-   */
-  resizeToFit(source, targetWidth, targetHeight, fitMode = "fill") {
-    if (source.width === targetWidth && source.height === targetHeight) {
-      return source;
-    }
-    const result = ImageBuffer.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;
-    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);
-        }
-        result.fill(0, 0);
-        result.fill(1, 0);
-        result.fill(2, 0);
-        result.fill(3, 1);
-        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);
-        result.fill(0, 0);
-        result.fill(1, 0);
-        result.fill(2, 0);
-        result.fill(3, 1);
-        break;
-    }
-    const scaleX = srcW / dstW;
-    const scaleY = srcH / dstH;
-    for (let c = 0; c < Math.min(source.channelCount, 4); c++) {
-      const dstChannel = result.channels[c];
-      for (let y = 0; y < dstH; y++) {
-        for (let x = 0; x < dstW; x++) {
-          const sx = srcX + x * scaleX;
-          const sy = srcY + y * scaleY;
-          dstChannel[(dstY + y) * targetWidth + (dstX + x)] = source.sample(sx, sy, c);
-        }
-      }
-    }
-    if (source.channelCount < 4 && fitMode !== "fit" && fitMode !== "native") {
-      for (let y = 0; y < dstH; y++) {
-        for (let x = 0; x < dstW; x++) {
-          result.channels[3][(dstY + y) * targetWidth + (dstX + x)] = 1;
-        }
-      }
-    }
-    return result;
-  }
-  /**
-   * Prepare multiple inputs to have matching dimensions
-   * Returns buffers resized to the output resolution
-   */
-  prepareInputs(inputs, resolutionMode = "input", fitMode = "fill", customSize) {
-    const buffers = inputs.map((input) => this.toImageBuffer(input));
-    const { width, height } = this.resolveOutputSize(resolutionMode, buffers, customSize);
-    const resized = buffers.map((buf) => {
-      if (!buf) return null;
-      if (buf.width === width && buf.height === height) return buf;
-      return this.resizeToFit(buf, width, height, fitMode);
-    });
-    return { buffers: resized, width, height };
-  }
-  // ============ Output Utilities ============
-  /**
-   * Set output value and preview from an ImageBuffer
-   * This is the standard way to output from an image node
-   * Preview updates are throttled to ~30fps to avoid excessive canvas conversions
-   */
-  setOutput(output, buffer) {
-    output.setValue(buffer);
-    this._previewBuffer = buffer;
-    this.updatePreviewThrottled();
-  }
-  /** Throttled Studio-only preview update. */
-  updatePreviewThrottled() {
-    if (!previewWanted2()) return;
-    const now = performance.now();
-    const elapsed = now - this._lastPreviewTime;
-    if (elapsed >= _ImageNodeBase.PREVIEW_INTERVAL) {
-      this._lastPreviewTime = now;
-      if (this._previewBuffer) {
-        this.preview = this._previewBuffer.toCanvas();
-      }
-      this._previewPending = false;
-    } else if (!this._previewPending) {
-      this._previewPending = true;
-      const remaining = _ImageNodeBase.PREVIEW_INTERVAL - elapsed;
-      setTimeout(() => {
-        this._previewPending = false;
-        this._lastPreviewTime = performance.now();
-        if (this._previewBuffer && previewWanted2()) {
-          this.preview = this._previewBuffer.toCanvas();
-        }
-      }, remaining);
-    }
-  }
-  // ============ Buffer Info (for debugging/monitoring) ============
-  /**
-   * Get info about the current output buffer
-   */
-  getBufferInfo() {
-    if (!this._previewBuffer) {
-      return null;
-    }
-    const buf = this._previewBuffer;
-    return {
-      hasOutput: true,
-      width: buf.width,
-      height: buf.height,
-      channels: buf.channelCount,
-      layout: buf.layout,
-      memoryBytes: buf.memoryBytes,
-      memorySizeStr: buf.memorySizeStr
-    };
-  }
-};
-
-// src/nodes/image/nodes/ColorNode.ts
-var ColorNode = class extends ImageNodeBase {
-  constructor(id, graph) {
-    super(id, "Color", graph);
-  }
-  setup() {
-    this.addParm("color", {
-      value: { r: 1, g: 1, b: 1 },
-      type: "color",
-      displayName: "Color"
-    });
-    this.addResolutionParm();
-    this.output = this.out("image");
-    this.watchProp("color", () => this.requestCook());
-    this.onReady = () => this.requestCook();
-  }
-  render() {
-    const [width, height] = this.getResolution();
-    const color = normalizeColor(this.props.color.value);
-    const buffer = ImageBuffer.solid(width, height, color);
-    this.setOutput(this.output, buffer);
-  }
-};
-
-// src/nodes/image/nodes/ImageNode.ts
-var ImageNode = class extends ImageNodeBase {
-  constructor(id, graph) {
-    super(id, "File", graph);
-  }
-  setup() {
-    this.imageInput = this.in("image", null);
-    this.addParm("file", {
-      value: "",
-      type: "image",
-      params: {
-        accept: "image/*"
-      },
-      displayName: "File",
-      onChange: () => {
-        if (this.props.file.value && !this.imageInput.value) {
-          this.requestCook();
-        }
-      }
-    });
-    this.addParm("resolutionMode", {
-      value: "original",
-      params: {
-        options: [
-          { value: "original", label: "Original" },
-          { value: "max", label: "Max Resolution" },
-          { value: "fixed", label: "Fixed Resolution" }
-        ]
-      },
-      displayName: "Resolution Mode",
-      onChange: () => {
-        if (this.props.file.value || this.imageInput.value) {
-          this.requestCook();
-        }
-      }
-    });
-    this.addParm("maxResolution", {
-      value: [2048, 2048],
-      params: {
-        min: [1, 1],
-        max: [4096, 4096]
-      },
-      displayName: "Max Resolution",
-      hidden: () => this.props.resolutionMode.value !== "max",
-      onChange: () => {
-        if ((this.props.file.value || this.imageInput.value) && this.props.resolutionMode.value === "max") {
-          this.requestCook();
-        }
-      }
-    });
-    this.addParm("fixedResolution", {
-      value: [512, 512],
-      params: {
-        min: [1, 1],
-        max: [4096, 4096]
-      },
-      displayName: "Fixed Resolution",
-      hidden: () => this.props.resolutionMode.value !== "fixed",
-      onChange: () => {
-        if ((this.props.file.value || this.imageInput.value) && this.props.resolutionMode.value === "fixed") {
-          this.requestCook();
-        }
-      }
-    });
-    this.output = this.out("image");
-    this.imageInput.onChange = () => this.requestCook();
-    this.onReady = () => {
-      if (this.props.file.value || this.imageInput.value) {
-        this.requestCook();
-      }
-    };
-  }
-  async render() {
-    let sourceBuffer = null;
-    if (this.imageInput.value) {
-      if (this.imageInput.value instanceof ImageBuffer) {
-        sourceBuffer = this.imageInput.value;
-      } else if (typeof this.imageInput.value === "string") {
-        sourceBuffer = ImageBuffer.fromCanvas(await decodeImage(this.imageInput.value));
-      } else {
-        sourceBuffer = ImageBuffer.fromCanvas(this.imageInput.value);
-      }
-    } else if (this.props.file.value) {
-      sourceBuffer = ImageBuffer.fromCanvas(await decodeImage(this.props.file.value));
-    }
-    if (!sourceBuffer) {
-      return;
-    }
-    try {
-      const mode = this.props.resolutionMode.value;
-      let outputBuffer;
-      if (mode === "original") {
-        outputBuffer = sourceBuffer;
-      } else if (mode === "max") {
-        const [maxWidth, maxHeight] = this.props.maxResolution.value;
-        const aspectRatio = sourceBuffer.width / sourceBuffer.height;
-        let newWidth = sourceBuffer.width;
-        let newHeight = sourceBuffer.height;
-        if (newWidth > maxWidth) {
-          newWidth = maxWidth;
-          newHeight = maxWidth / aspectRatio;
-        }
-        if (newHeight > maxHeight) {
-          newHeight = maxHeight;
-          newWidth = maxHeight * aspectRatio;
-        }
-        newWidth = Math.round(newWidth);
-        newHeight = Math.round(newHeight);
-        if (newWidth !== sourceBuffer.width || newHeight !== sourceBuffer.height) {
-          outputBuffer = this.resizeBuffer(sourceBuffer, newWidth, newHeight);
-        } else {
-          outputBuffer = sourceBuffer;
-        }
-      } else {
-        const [width, height] = this.props.fixedResolution.value;
-        outputBuffer = this.resizeBuffer(sourceBuffer, width, height);
-      }
-      this.setOutput(this.output, outputBuffer);
-    } catch (error) {
-      this.error = error;
-      console.error("Failed to process image:", error);
-    }
-  }
-  resizeBuffer(source, newWidth, newHeight) {
-    const result = ImageBuffer.rgba(newWidth, newHeight);
-    const scaleX = source.width / newWidth;
-    const scaleY = source.height / newHeight;
-    for (let c = 0; c < Math.min(source.channelCount, 4); c++) {
-      const dstChannel = result.channels[c];
-      for (let y = 0; y < newHeight; y++) {
-        for (let x = 0; x < newWidth; x++) {
-          const srcX = x * scaleX;
-          const srcY = y * scaleY;
-          dstChannel[y * newWidth + x] = source.sample(srcX, srcY, c);
-        }
-      }
-    }
-    if (source.channelCount < 4) {
-      result.fill(3, 1);
-    }
-    return result;
-  }
-};
-
-// src/nodes/image/nodes/CompositeNode.ts
-var CompositeNode = class extends ImageNodeBase {
-  constructor(id, graph) {
-    super(id, "Composite", graph);
-  }
-  setup() {
-    this.image1 = this.in("image1", null);
-    this.image2 = this.in("image2", null);
-    this.addParm("blendMode", {
-      value: "multiply",
-      params: {
-        options: [
-          { value: "normal", label: "Normal" },
-          { value: "multiply", label: "Multiply" },
-          { value: "screen", label: "Screen" },
-          { value: "overlay", label: "Overlay" },
-          { value: "darken", label: "Darken" },
-          { value: "lighten", label: "Lighten" },
-          { value: "color-dodge", label: "Color Dodge" },
-          { value: "color-burn", label: "Color Burn" },
-          { value: "hard-light", label: "Hard Light" },
-          { value: "soft-light", label: "Soft Light" },
-          { value: "difference", label: "Difference" },
-          { value: "exclusion", label: "Exclusion" },
-          { value: "add", label: "Add" },
-          { value: "subtract", label: "Subtract" },
-          { value: "divide", label: "Divide" },
-          { value: "pin-light", label: "Pin Light" },
-          { value: "vivid-light", label: "Vivid Light" },
-          { value: "linear-dodge", label: "Linear Dodge" },
-          { value: "linear-burn", label: "Linear Burn" }
-        ]
-      },
-      displayName: "Blend Mode",
-      onChange: () => this.requestCook()
-    });
-    this.addParm("opacity", {
-      value: 1,
-      params: {
-        min: 0,
-        max: 1,
-        step: 0.01
-      },
-      displayName: "Opacity",
-      onChange: () => this.requestCook()
-    });
-    this.addParm("outputResolution", {
-      value: "input1",
-      params: {
-        options: [
-          { value: "input1", label: "Use Input 1" },
-          { value: "input2", label: "Use Input 2" },
-          { value: "largest", label: "Largest Input" },
-          { value: "smallest", label: "Smallest Input" },
-          { value: "custom", label: "Custom" }
-        ]
-      },
-      displayName: "Output Resolution",
-      onChange: () => this.requestCook()
-    });
-    this.addParm("customResolution", {
-      value: [512, 512],
-      params: {
-        min: [1, 1],
-        max: [4096, 4096],
-        integer: true
-      },
-      displayName: "Resolution",
-      hidden: () => this.props.outputResolution.value !== "custom",
-      onChange: () => this.requestCook()
-    });
-    this.addParm("fitMode", {
-      value: "fill",
-      params: {
-        options: [
-          { value: "fill", label: "Fill (Crop)" },
-          { value: "fit", label: "Fit (Letterbox)" },
-          { value: "stretch", label: "Stretch" },
-          { value: "native", label: "Native (No Scale)" }
-        ]
-      },
-      displayName: "Fit Mode",
-      onChange: () => this.requestCook()
-    });
-    this.output = this.out("image");
-    this.image1.onChange = () => this.requestCook();
-    this.image2.onChange = () => this.requestCook();
-    this.onReady = () => this.requestCook();
-  }
-  blendBuffers(base, blend, mode, opacity) {
-    const width = base.width;
-    const height = base.height;
-    const result = ImageBuffer.rgba(width, height);
-    const baseRGBA = base.channelCount >= 4 ? base : base.toRGBA();
-    const blendRGBA = blend.channelCount >= 4 ? blend : blend.toRGBA();
-    const r1 = baseRGBA.channels[0];
-    const g1 = baseRGBA.channels[1];
-    const b1 = baseRGBA.channels[2];
-    const a1 = baseRGBA.channels[3];
-    const r2 = blendRGBA.channels[0];
-    const g2 = blendRGBA.channels[1];
-    const b2 = blendRGBA.channels[2];
-    const a2 = blendRGBA.channels[3];
-    const rOut = result.channels[0];
-    const gOut = result.channels[1];
-    const bOut = result.channels[2];
-    const aOut = result.channels[3];
-    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":
-          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-dodge":
-          r = Math.min(1, baseR + blendR);
-          g = Math.min(1, baseG + blendG);
-          b = Math.min(1, baseB + 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;
-  }
-  render() {
-    const resolutionMode = this.props.outputResolution.value;
-    const fitMode = this.props.fitMode.value;
-    const customSize = this.props.customResolution.value;
-    const { buffers } = this.prepareInputs(
-      [this.image1.value, this.image2.value],
-      resolutionMode,
-      fitMode,
-      customSize
-    );
-    const [buf1, buf2] = buffers;
-    if (!buf1 || !buf2) {
-      return;
-    }
-    const blendMode = this.props.blendMode.value;
-    const opacity = this.props.opacity.value;
-    try {
-      const result = this.blendBuffers(buf1, buf2, blendMode, opacity);
-      this.setOutput(this.output, result);
-    } catch (error) {
-      console.error("Composite render error:", error);
-      this.error = error;
-    }
-  }
-};
-
-// src/nodes/image/nodes/CheckersNode.ts
-var CheckersNode = class extends ImageNodeBase {
-  constructor(id, graph) {
-    super(id, "Checkers", graph);
-  }
-  setup() {
-    this.addParm("color1", {
-      value: { r: 1, g: 1, b: 1 },
-      type: "color",
-      displayName: "Color 1",
-      onChange: () => this.requestCook()
-    });
-    this.addParm("color2", {
-      value: { r: 0, g: 0, b: 0 },
-      type: "color",
-      displayName: "Color 2",
-      onChange: () => this.requestCook()
-    });
-    this.addParm("mode", {
-      value: "size",
-      params: {
-        options: [
-          { value: "size", label: "Size" },
-          { value: "divisions", label: "Divisions" }
-        ]
-      },
-      displayName: "Mode",
-      onChange: () => this.requestCook()
-    });
-    this.addParm("size", {
-      value: 32,
-      params: {
-        min: 1,
-        max: 512,
-        step: 0.1
-      },
-      displayName: "Size",
-      hidden: () => this.props.mode.value !== "size",
-      onChange: () => this.requestCook()
-    });
-    this.addParm("divisions", {
-      value: 16,
-      params: {
-        min: 1,
-        max: 512,
-        step: 1,
-        integer: true
-      },
-      displayName: "Divisions",
-      hidden: () => this.props.mode.value !== "divisions",
-      onChange: () => this.requestCook()
-    });
-    this.addParm("centered", {
-      value: false,
-      type: "boolean",
-      displayName: "Centered",
-      onChange: () => this.requestCook()
-    });
-    this.addResolutionParm();
-    this.output = this.out("image");
-    this.onReady = () => this.requestCook();
-  }
-  render() {
-    const [width, height] = this.getResolution();
-    const mode = this.props.mode.value;
-    const color1 = normalizeColor(this.props.color1.value);
-    const color2 = normalizeColor(this.props.color2.value);
-    const centered = this.props.centered.value;
-    let checkerSize;
-    if (mode === "size") {
-      checkerSize = this.props.size.value;
-    } else {
-      checkerSize = width / this.props.divisions.value;
-    }
-    let offsetX = 0;
-    let offsetY = 0;
-    if (centered) {
-      offsetX = width / 2 % checkerSize - checkerSize / 2;
-      offsetY = height / 2 % checkerSize - checkerSize / 2;
-    }
-    const buffer = ImageBuffer.rgba(width, height);
-    const r = buffer.r();
-    const g = buffer.g();
-    const b = buffer.b();
-    const a = buffer.a();
-    for (let y = 0; y < height; y++) {
-      for (let x = 0; x < width; x++) {
-        const idx = y * width + x;
-        const isEven = (Math.floor((x - offsetX) / checkerSize) + Math.floor((y - offsetY) / checkerSize)) % 2 === 0;
-        const color = isEven ? color1 : color2;
-        r[idx] = color.r;
-        g[idx] = color.g;
-        b[idx] = color.b;
-        a[idx] = color.a;
-      }
-    }
-    buffer.markDirty();
-    this.setOutput(this.output, buffer);
-  }
-};
-
-// src/nodes/image/nodes/ResizeNode.ts
-var ResizeNode = class extends ImageNodeBase {
-  constructor(id, graph) {
-    super(id, "Resize", graph);
-  }
-  setup() {
-    this.image = this.in("image", null);
-    this.addParm("mode", {
-      value: "scale",
-      params: {
-        options: [
-          { value: "scale", label: "Scale" },
-          { value: "fixed", label: "Fixed" }
-        ]
-      },
-      displayName: "Mode",
-      onChange: () => this.requestCook()
-    });
-    this.addParm("scale", {
-      value: 1,
-      params: {
-        min: 0.1,
-        max: 10,
-        step: 0.1
-      },
-      displayName: "Scale",
-      hidden: () => this.props.mode.value !== "scale",
-      onChange: () => this.requestCook()
-    });
-    this.addParm("width", {
-      value: 512,
-      params: {
-        min: 1,
-        max: 4096,
-        step: 1
-      },
-      displayName: "Width",
-      hidden: () => this.props.mode.value !== "fixed",
-      onChange: () => this.requestCook()
-    });
-    this.addParm("height", {
-      value: 512,
-      params: {
-        min: 1,
-        max: 4096,
-        step: 1
-      },
-      displayName: "Height",
-      hidden: () => this.props.mode.value !== "fixed",
-      onChange: () => this.requestCook()
-    });
-    this.output = this.out("image");
-    this.image.onChange = () => this.requestCook();
-    this.onReady = () => this.requestCook();
-  }
-  resizeBuffer(source, newWidth, newHeight) {
-    const result = ImageBuffer.rgba(newWidth, newHeight);
-    const scaleX = source.width / newWidth;
-    const scaleY = source.height / newHeight;
-    for (let c = 0; c < Math.min(source.channelCount, 4); c++) {
-      const dstChannel = result.channels[c];
-      for (let y = 0; y < newHeight; y++) {
-        for (let x = 0; x < newWidth; x++) {
-          const srcX = x * scaleX;
-          const srcY = y * scaleY;
-          dstChannel[y * newWidth + x] = source.sample(srcX, srcY, c);
-        }
-      }
-    }
-    if (source.channelCount < 4) {
-      result.fill(3, 1);
-    }
-    return result;
-  }
-  render() {
-    const buffer = this.toImageBuffer(this.image.value);
-    if (!buffer) {
-      return;
-    }
-    let newWidth, newHeight;
-    if (this.props.mode.value === "scale") {
-      const scale = this.props.scale.value;
-      newWidth = Math.round(buffer.width * scale);
-      newHeight = Math.round(buffer.height * scale);
-    } else {
-      newWidth = this.props.width.value;
-      newHeight = this.props.height.value;
-    }
-    const resized = this.resizeBuffer(buffer, newWidth, newHeight);
-    this.setOutput(this.output, resized);
-  }
-};
-
-// src/nodes/image/nodes/NormalMapNode.ts
-var NormalMapNode = class extends ImageNodeBase {
-  constructor(id, graph) {
-    super(id, "NormalMap", graph);
-  }
-  setup() {
-    this.image = this.in("image", null);
-    this.addParm("scale", {
-      value: 1,
-      params: {
-        min: 0,
-        max: 10,
-        step: 0.1
-      },
-      displayName: "Scale",
-      onChange: () => this.requestCook()
-    });
-    this.addParm("flipX", {
-      value: false,
-      type: "boolean",
-      displayName: "Flip X",
-      onChange: () => this.requestCook()
-    });
-    this.addParm("flipY", {
-      value: false,
-      type: "boolean",
-      displayName: "Flip Y",
-      onChange: () => this.requestCook()
-    });
-    this.output = this.out("image");
-    this.image.onChange = () => this.requestCook();
-    this.onReady = () => this.requestCook();
-  }
-  computeNormalMap(source, scale, flipX, flipY) {
-    const { width, height } = source;
-    const result = ImageBuffer.rgba(width, height);
-    const heightMap = source.channels[0];
-    const rOut = result.channels[0];
-    const gOut = result.channels[1];
-    const bOut = result.channels[2];
-    const aOut = result.channels[3];
-    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 finalDx = flipX ? -dx : dx;
-        const finalDy = flipY ? -dy : dy;
-        const nx = -finalDx;
-        const ny = -finalDy;
-        const nz = 1;
-        const length = Math.sqrt(nx * nx + ny * ny + nz * nz);
-        const normalizedX = nx / length;
-        const normalizedY = ny / length;
-        const normalizedZ = nz / length;
-        rOut[idx] = normalizedX * 0.5 + 0.5;
-        gOut[idx] = normalizedY * 0.5 + 0.5;
-        bOut[idx] = normalizedZ * 0.5 + 0.5;
-        aOut[idx] = 1;
-      }
-    }
-    return result;
-  }
-  render() {
-    const buffer = this.toImageBuffer(this.image.value);
-    if (!buffer) {
-      return;
-    }
-    const scale = this.props.scale.value;
-    const flipX = this.props.flipX.value;
-    const flipY = this.props.flipY.value;
-    const normalMap = this.computeNormalMap(buffer, scale, flipX, flipY);
-    this.setOutput(this.output, normalMap);
-  }
-};
-
-// src/nodes/image/nodes/RampNode.ts
-var RampNode = class extends ImageNodeBase {
-  constructor(id, graph) {
-    super(id, "Ramp", graph);
-  }
-  setup() {
-    this.addParm("type", {
-      value: "horizontal",
-      params: {
-        options: [
-          { value: "horizontal", label: "Horizontal" },
-          { value: "vertical", label: "Vertical" },
-          { value: "radial", label: "Radial" },
-          { value: "concentric", label: "Concentric" }
-        ]
-      },
-      displayName: "Type",
-      onChange: () => this.requestCook()
-    });
-    this.addParm("points", {
-      value: [
-        { position: 0, color: { r: 0, g: 0, b: 0 }, interpolation: "linear" },
-        { position: 1, color: { r: 1, g: 1, b: 1 }, interpolation: "linear" }
-      ],
-      type: "colorramp",
-      displayName: "Ramp",
-      onChange: () => this.requestCook()
-    });
-    this.addResolutionParm();
-    this.output = this.out("image");
-    this.onReady = () => this.requestCook();
-  }
-  normalizeRampColor(color) {
-    if (typeof color === "object" && color !== null && "r" in color && "g" in color && "b" in color) {
-      const isNormalized = color.r <= 1 && color.g <= 1 && color.b <= 1;
-      return {
-        r: isNormalized ? color.r : color.r / 255,
-        g: isNormalized ? color.g : color.g / 255,
-        b: isNormalized ? color.b : color.b / 255,
-        a: color.a !== void 0 ? isNormalized ? color.a : color.a / 255 : 1
-      };
-    }
-    if (Array.isArray(color)) {
-      const isNormalized = color.every((v) => v <= 1);
-      return {
-        r: isNormalized ? color[0] : color[0] / 255,
-        g: isNormalized ? color[1] : color[1] / 255,
-        b: isNormalized ? color[2] : color[2] / 255,
-        a: color[3] !== void 0 ? isNormalized ? color[3] : color[3] / 255 : 1
-      };
-    }
-    if (typeof color === "string") {
-      const rgbMatch = color.match(/rgb\s*\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*\)/);
-      if (rgbMatch) {
-        return {
-          r: parseInt(rgbMatch[1], 10) / 255,
-          g: parseInt(rgbMatch[2], 10) / 255,
-          b: parseInt(rgbMatch[3], 10) / 255,
-          a: 1
-        };
-      }
-      const hex = color.replace("#", "");
-      if (hex.length === 3 || hex.length === 6) {
-        const expanded = hex.length === 3 ? hex.split("").map((c) => c + c).join("") : hex;
-        const result = /^([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(expanded);
-        if (result) {
-          return {
-            r: parseInt(result[1], 16) / 255,
-            g: parseInt(result[2], 16) / 255,
-            b: parseInt(result[3], 16) / 255,
-            a: 1
-          };
-        }
-      }
-    }
-    return { r: 0, g: 0, b: 0, a: 1 };
-  }
-  interpolateColor(color1, color2, t, interpolation) {
-    if (interpolation === "constant") {
-      return t < 0.5 ? color1 : color2;
-    } else 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
-    };
-  }
-  getColorAtPosition(points, position) {
-    const sortedPoints = [...points].sort((a, b) => a.position - b.position);
-    position = Math.max(0, Math.min(1, position));
-    let before = null;
-    let after = null;
-    for (let i = 0; i < sortedPoints.length; i++) {
-      if (sortedPoints[i].position <= position) {
-        before = sortedPoints[i];
-      }
-      if (sortedPoints[i].position >= position && !after) {
-        after = sortedPoints[i];
-        break;
-      }
-    }
-    if (!before && after) return this.normalizeRampColor(after.color);
-    if (before && !after) return this.normalizeRampColor(before.color);
-    if (!before && !after) return { r: 0, g: 0, b: 0, a: 1 };
-    if (before.position === position) return this.normalizeRampColor(before.color);
-    if (after.position === position) return this.normalizeRampColor(after.color);
-    const t = (position - before.position) / (after.position - before.position);
-    const color1 = this.normalizeRampColor(before.color);
-    const color2 = this.normalizeRampColor(after.color);
-    const interpolation = after.interpolation || "linear";
-    return this.interpolateColor(color1, color2, t, interpolation);
-  }
-  render() {
-    const [width, height] = this.getResolution();
-    const rampType = this.props.type.value;
-    const points = this.props.points.value || [];
-    if (points.length === 0) {
-      return;
-    }
-    const buffer = ImageBuffer.rgba(width, height);
-    const r = buffer.r();
-    const g = buffer.g();
-    const b = buffer.b();
-    const a = buffer.a();
-    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 (rampType === "horizontal") {
-          position = x / width;
-        } else if (rampType === "vertical") {
-          position = y / height;
-        } else if (rampType === "radial") {
-          const dx = x - centerX;
-          const dy = y - centerY;
-          const angle = Math.atan2(dy, dx);
-          position = (angle + Math.PI) / (2 * Math.PI);
-        } else if (rampType === "concentric") {
-          const dx = x - centerX;
-          const dy = y - centerY;
-          const dist = Math.sqrt(dx * dx + dy * dy);
-          position = dist / maxDist;
-        }
-        const color = this.getColorAtPosition(points, position);
-        const idx = y * width + x;
-        r[idx] = color.r;
-        g[idx] = color.g;
-        b[idx] = color.b;
-        a[idx] = color.a ?? 1;
-      }
-    }
-    buffer.markDirty();
-    this.setOutput(this.output, buffer);
-  }
-};
-
-// src/nodes/image/nodes/NoiseNode.ts
-var NoiseNode = class extends ImageNodeBase {
-  constructor(id, graph) {
-    super(id, "Noise", graph);
-    this.noise2D = null;
-    this.currentSeed = null;
-  }
-  setup() {
-    this.addParm("seed", {
-      value: 0,
-      params: {
-        min: 0,
-        max: 1e4,
-        step: 1,
-        integer: true
-      },
-      displayName: "Seed",
-      onChange: () => {
-        void this.initNoise().then(() => {
-          if (this.noise2D) this.requestCook();
-        });
-      }
-    });
-    this.addParm("scale", {
-      value: 0.01,
-      params: {
-        min: 1e-3,
-        max: 1,
-        step: 1e-3
-      },
-      displayName: "Scale",
-      onChange: () => this.requestCook()
-    });
-    this.addParm("iterations", {
-      value: 4,
-      params: {
-        min: 1,
-        max: 8,
-        step: 1,
-        integer: true
-      },
-      displayName: "Iterations",
-      onChange: () => this.requestCook()
-    });
-    this.addResolutionParm();
-    this.output = this.out("image");
-    this.onReady = async () => {
-      await this.initNoise();
-      if (this.noise2D) {
-        this.requestCook();
-      }
-    };
-  }
-  async initNoise() {
-    try {
-      let seededRandom2 = function() {
-        rng = (rng * 9301 + 49297) % 233280;
-        return rng / 233280;
-      };
-      var seededRandom = seededRandom2;
-      const simplexNoise = await this.require("simplex-noise");
-      const { createNoise2D } = simplexNoise;
-      const seed = this.props.seed.value;
-      let rng = seed;
-      this.noise2D = createNoise2D(seededRandom2);
-      this.currentSeed = seed;
-    } catch (error) {
-      console.error("Failed to load simplex-noise:", error);
-      this.error = error;
-    }
-  }
-  render() {
-    if (!this.noise2D) {
-      this.initNoise().then(() => {
-        if (this.noise2D) {
-          this.requestCook();
-        }
-      });
-      return;
-    }
-    const [width, height] = this.getResolution();
-    const scale = this.props.scale.value;
-    const iterations = this.props.iterations.value;
-    const seed = this.props.seed.value;
-    if (seed !== this.currentSeed) {
-      this.initNoise().then(() => {
-        if (this.noise2D) {
-          this.requestCook();
-        }
-      });
-      return;
-    }
-    const buffer = ImageBuffer.grayscale(width, height);
-    const gray = buffer.r();
-    for (let y = 0; y < height; y++) {
-      for (let x = 0; x < width; x++) {
-        let value = 0;
-        let amplitude = 1;
-        let frequency = scale;
-        let maxValue = 0;
-        for (let i = 0; i < iterations; i++) {
-          const nx = x * frequency;
-          const ny = y * frequency;
-          const noiseValue = this.noise2D(nx, ny);
-          value += noiseValue * amplitude;
-          maxValue += amplitude;
-          amplitude *= 0.5;
-          frequency *= 2;
-        }
-        value = (value / maxValue + 1) * 0.5;
-        gray[y * width + x] = value;
-      }
-    }
-    buffer.markDirty();
-    this.setOutput(this.output, buffer);
-  }
-};
-
-// src/nodes/image/nodes/BlurNode.ts
-var BlurNode = class extends ImageNodeBase {
-  constructor(id, graph) {
-    super(id, "Blur", graph);
-  }
-  setup() {
-    this.image = this.in("image", null);
-    this.addParm("method", {
-      value: "box",
-      params: {
-        options: [
-          { value: "box", label: "Box (Fast)" },
-          { value: "gaussian", label: "Gaussian (Accurate)" }
-        ]
-      },
-      displayName: "Method",
-      onChange: () => this.requestCook()
-    });
-    this.addParm("radius", {
-      value: 5,
-      params: {
-        min: 0,
-        max: 100,
-        step: 0.1
-      },
-      displayName: "Radius",
-      onChange: () => this.requestCook()
-    });
-    this.addParm("wrapEdges", {
-      value: false,
-      type: "boolean",
-      displayName: "Wrap Edges",
-      onChange: () => this.requestCook()
-    });
-    this.output = this.out("image");
-    this.image.onChange = () => this.requestCook();
-    this.onReady = () => this.requestCook();
-  }
-  /**
-   * Fast blur using stacked box blur approximation.
-   * 3 passes of box blur closely approximates Gaussian and is O(1) per pixel.
-   */
-  boxBlur(source, radius, wrapEdges) {
-    if (radius <= 0) {
-      return source.clone();
-    }
-    const { width, height } = source;
-    const sigma = radius;
-    const boxes = this.boxesForGauss(sigma, 3);
-    const result = source.emptyClone();
-    for (let c = 0; c < source.channelCount; c++) {
-      const channelData = new Float32Array(source.channels[c]);
-      for (const boxSize of boxes) {
-        this.boxBlurPass(channelData, width, height, boxSize, wrapEdges);
-      }
-      result.channels[c].set(channelData);
-    }
-    return result;
-  }
-  /**
-   * Calculate box sizes for Gaussian approximation.
-   * Returns array of box radii for n passes.
-   */
-  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);
-  }
-  /**
-   * Single box blur pass (horizontal then vertical) - O(1) per pixel
-   */
-  boxBlurPass(data, w, h, r, wrap) {
-    if (r < 1) return;
-    const temp = new Float32Array(w * h);
-    const ri = Math.floor(r);
-    const diameter = ri * 2 + 1;
-    const invDiameter = 1 / diameter;
-    for (let y = 0; y < h; y++) {
-      const rowOffset = 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[rowOffset + px];
-      }
-      temp[rowOffset] = 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[rowOffset + removeX];
-        sum += data[rowOffset + addX];
-        temp[rowOffset + 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;
-      }
-    }
-  }
-  /**
-   * True Gaussian blur using separable convolution.
-   * More accurate but O(radius) per pixel - slower for large radii.
-   */
-  trueGaussianBlur(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;
-    let sum = 0;
-    const halfKernel = kernelSize - 1 >> 1;
-    for (let i = 0; i < kernelSize; i++) {
-      const x = i - halfKernel;
-      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 srcChannel = source.channels[c];
-      const dstChannel = result.channels[c];
-      const temp = new Float32Array(width * height);
-      for (let y = 0; y < height; y++) {
-        const rowOffset = y * width;
-        for (let x = 0; x < width; x++) {
-          let acc = 0;
-          for (let k = 0; k < kernelSize; k++) {
-            const px = wrapX(x + k - halfKernel);
-            acc += srcChannel[rowOffset + px] * kernel[k];
-          }
-          temp[rowOffset + 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++) {
-            const py = wrapY(y + k - halfKernel);
-            acc += temp[py * width + x] * kernel[k];
-          }
-          dstChannel[y * width + x] = acc;
-        }
-      }
-    }
-    return result;
-  }
-  render() {
-    const buffer = this.toImageBuffer(this.image.value);
-    if (!buffer) {
-      return;
-    }
-    const method = this.props.method.value;
-    const radius = this.props.radius.value;
-    const wrapEdges = this.props.wrapEdges.value;
-    const blurred = method === "gaussian" ? this.trueGaussianBlur(buffer, radius, wrapEdges) : this.boxBlur(buffer, radius, wrapEdges);
-    this.setOutput(this.output, blurred);
-  }
-};
-
-// src/nodes/image/nodes/TextNode.ts
-var TextNode = class extends ImageNodeBase {
-  constructor(id, graph) {
-    super(id, "Text", graph);
-  }
-  setup() {
-    this.addParm("text", {
-      value: "Hello, World!",
-      type: "textarea",
-      displayName: "Text"
-    });
-    this.addParm("font", {
-      value: "Inter, system-ui, sans-serif",
-      type: "text",
-      displayName: "Font"
-    });
-    this.addParm("fontSize", {
-      value: 48,
-      type: "slider",
-      params: { min: 1, max: 500, step: 1 },
-      displayName: "Font Size"
-    });
-    this.addParm("fontWeight", {
-      value: "normal",
-      type: "select",
-      params: {
-        options: [
-          { value: "normal", label: "Normal" },
-          { value: "bold", label: "Bold" },
-          { value: "100", label: "Thin (100)" },
-          { value: "200", label: "Extra Light (200)" },
-          { value: "300", label: "Light (300)" },
-          { value: "500", label: "Medium (500)" },
-          { value: "600", label: "Semi Bold (600)" },
-          { value: "700", label: "Bold (700)" },
-          { value: "800", label: "Extra Bold (800)" },
-          { value: "900", label: "Black (900)" }
-        ]
-      },
-      displayName: "Font Weight"
-    });
-    this.addParm("fontStyle", {
-      value: "normal",
-      type: "select",
-      params: {
-        options: [
-          { value: "normal", label: "Normal" },
-          { value: "italic", label: "Italic" },
-          { value: "oblique", label: "Oblique" }
-        ]
-      },
-      displayName: "Font Style"
-    });
-    this.addParm("alignH", {
-      value: "center",
-      type: "select",
-      params: {
-        options: [
-          { value: "left", label: "Left" },
-          { value: "center", label: "Center" },
-          { value: "right", label: "Right" }
-        ]
-      },
-      displayName: "Horizontal Align"
-    });
-    this.addParm("alignV", {
-      value: "middle",
-      type: "select",
-      params: {
-        options: [
-          { value: "top", label: "Top" },
-          { value: "middle", label: "Middle" },
-          { value: "bottom", label: "Bottom" }
-        ]
-      },
-      displayName: "Vertical Align"
-    });
-    this.addParm("color", {
-      value: { r: 1, g: 1, b: 1 },
-      type: "color",
-      displayName: "Color"
-    });
-    this.addParm("backgroundColor", {
-      value: { r: 0, g: 0, b: 0, a: 0 },
-      type: "color",
-      displayName: "Background"
-    });
-    this.addResolutionParm();
-    this.addParm("offset", {
-      value: [0, 0],
-      params: {
-        min: [-2048, -2048],
-        max: [2048, 2048],
-        step: 1
-      },
-      displayName: "Offset"
-    });
-    this.addParm("rotation", {
-      value: 0,
-      type: "slider",
-      params: { min: -180, max: 180, step: 0.1 },
-      displayName: "Rotation"
-    });
-    this.addParm("letterSpacing", {
-      value: 0,
-      type: "slider",
-      params: { min: -50, max: 100, step: 0.5 },
-      displayName: "Letter Spacing"
-    });
-    this.addParm("lineHeight", {
-      value: 1.2,
-      type: "slider",
-      params: { min: 0.5, max: 3, step: 0.05 },
-      displayName: "Line Height"
-    });
-    this.addParm("opacity", {
-      value: 1,
-      type: "slider",
-      params: { min: 0, max: 1, step: 0.01 },
-      displayName: "Opacity"
-    });
-    this.output = this.out("image");
-    const propNames = [
-      "text",
-      "font",
-      "fontSize",
-      "fontWeight",
-      "fontStyle",
-      "alignH",
-      "alignV",
-      "color",
-      "backgroundColor",
-      "offset",
-      "rotation",
-      "letterSpacing",
-      "lineHeight",
-      "opacity"
-    ];
-    propNames.forEach((prop) => this.watchProp(prop, () => this.requestCook()));
-    this.onReady = () => this.requestCook();
-  }
-  render() {
-    const [width, height] = this.getResolution();
-    const text = this.props.text.value;
-    const font = this.props.font.value;
-    const fontSize = this.props.fontSize.value;
-    const fontWeight = this.props.fontWeight.value;
-    const fontStyle = this.props.fontStyle.value;
-    const alignH = this.props.alignH.value;
-    const alignV = this.props.alignV.value;
-    const color = normalizeColor(this.props.color.value);
-    const bgColor = normalizeColor(this.props.backgroundColor.value);
-    const [offsetX, offsetY] = this.props.offset.value;
-    const rotation = this.props.rotation.value;
-    const letterSpacing = this.props.letterSpacing.value;
-    const lineHeight = this.props.lineHeight.value;
-    const opacity = this.props.opacity.value;
-    const canvas = createSurface(width, height);
-    const ctx = canvas.getContext("2d");
-    if (!ctx) {
-      this.setOutput(this.output, ImageBuffer.rgba(width, height));
-      return;
-    }
-    if (bgColor.a > 0) {
-      ctx.fillStyle = colorToCss(bgColor);
-      ctx.fillRect(0, 0, width, height);
-    } else {
-      ctx.clearRect(0, 0, width, height);
-    }
-    ctx.save();
-    ctx.globalAlpha = opacity;
-    const fontString = `${fontStyle} ${fontWeight} ${fontSize}px ${font}`;
-    ctx.font = fontString;
-    ctx.fillStyle = colorToCss(color);
-    const lines = text.split("\n");
-    const lineHeightPx = fontSize * lineHeight;
-    const totalTextHeight = lines.length * lineHeightPx;
-    let anchorX;
-    let anchorY;
-    switch (alignH) {
-      case "left":
-        ctx.textAlign = "left";
-        anchorX = 0;
-        break;
-      case "right":
-        ctx.textAlign = "right";
-        anchorX = width;
-        break;
-      case "center":
-      default:
-        ctx.textAlign = "center";
-        anchorX = width / 2;
-        break;
-    }
-    switch (alignV) {
-      case "top":
-        anchorY = fontSize;
-        break;
-      case "bottom":
-        anchorY = height - totalTextHeight + fontSize;
-        break;
-      case "middle":
-      default:
-        anchorY = (height - totalTextHeight) / 2 + fontSize;
-        break;
-    }
-    anchorX += offsetX;
-    anchorY += offsetY;
-    if (rotation !== 0) {
-      const rotationRad = rotation * Math.PI / 180;
-      ctx.translate(anchorX, anchorY - fontSize / 2 + totalTextHeight / 2);
-      ctx.rotate(rotationRad);
-      ctx.translate(-anchorX, -(anchorY - fontSize / 2 + totalTextHeight / 2));
-    }
-    if (letterSpacing !== 0) {
-      ctx.textAlign = "left";
-      for (let i = 0; i < lines.length; i++) {
-        const line = lines[i];
-        const y = anchorY + i * lineHeightPx;
-        let lineWidth = 0;
-        for (const char of line) {
-          lineWidth += ctx.measureText(char).width + letterSpacing;
-        }
-        lineWidth -= letterSpacing;
-        let x;
-        switch (alignH) {
-          case "left":
-            x = anchorX;
-            break;
-          case "right":
-            x = anchorX - lineWidth;
-            break;
-          case "center":
-          default:
-            x = anchorX - lineWidth / 2;
-            break;
-        }
-        for (const char of line) {
-          ctx.fillText(char, x, y);
-          x += ctx.measureText(char).width + letterSpacing;
-        }
-      }
-    } else {
-      for (let i = 0; i < lines.length; i++) {
-        const y = anchorY + i * lineHeightPx;
-        ctx.fillText(lines[i], anchorX, y);
-      }
-    }
-    ctx.restore();
-    const buffer = ImageBuffer.fromCanvas(canvas);
-    this.setOutput(this.output, buffer);
-  }
-};
-
-// src/nodes/image/nodes/TransformNode.ts
-var TransformNode = class extends ImageNodeBase {
-  constructor(id, graph) {
-    super(id, "Transform", graph);
-  }
-  setup() {
-    this.imageInput = this.in("image", null);
-    this.addParm("translate", {
-      value: [0, 0],
-      params: {
-        min: [-2048, -2048],
-        max: [2048, 2048],
-        step: 1
-      },
-      displayName: "Translate",
-      onChange: () => this.requestCook()
-    });
-    this.addParm("rotation", {
-      value: 0,
-      params: {
-        min: -180,
-        max: 180,
-        step: 0.1
-      },
-      displayName: "Rotation",
-      onChange: () => this.requestCook()
-    });
-    this.addParm("scale", {
-      value: [1, 1],
-      params: {
-        min: [0.01, 0.01],
-        max: [10, 10],
-        step: 0.01
-      },
-      displayName: "Scale",
-      onChange: () => this.requestCook()
-    });
-    this.addParm("uniformScale", {
-      value: true,
-      type: "boolean",
-      displayName: "Uniform Scale",
-      onChange: () => this.requestCook()
-    });
-    this.addParm("pivot", {
-      value: "center",
-      params: {
-        options: [
-          { value: "center", label: "Center" },
-          { value: "top-left", label: "Top Left" },
-          { value: "top-right", label: "Top Right" },
-          { value: "bottom-left", label: "Bottom Left" },
-          { value: "bottom-right", label: "Bottom Right" },
-          { value: "custom", label: "Custom" }
-        ]
-      },
-      displayName: "Pivot",
-      onChange: () => this.requestCook()
-    });
-    this.addParm("customPivot", {
-      value: [0.5, 0.5],
-      params: {
-        min: [0, 0],
-        max: [1, 1],
-        step: 0.01
-      },
-      displayName: "Custom Pivot",
-      hidden: () => this.props.pivot.value !== "custom",
-      onChange: () => this.requestCook()
-    });
-    this.addParm("filter", {
-      value: "bilinear",
-      params: {
-        options: [
-          { value: "nearest", label: "Nearest" },
-          { value: "bilinear", label: "Bilinear" }
-        ]
-      },
-      displayName: "Filter",
-      onChange: () => this.requestCook()
-    });
-    this.addParm("wrap", {
-      value: "clamp",
-      params: {
-        options: [
-          { value: "clamp", label: "Clamp" },
-          { value: "repeat", label: "Repeat" },
-          { value: "mirror", label: "Mirror" },
-          { value: "transparent", label: "Transparent" }
-        ]
-      },
-      displayName: "Wrap Mode",
-      onChange: () => this.requestCook()
-    });
-    this.output = this.out("image");
-    this.imageInput.onChange = () => this.requestCook();
-    this.onReady = () => this.requestCook();
-  }
-  getPivotPoint(width, height) {
-    const pivot = this.props.pivot.value;
-    switch (pivot) {
-      case "center":
-        return [width / 2, height / 2];
-      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":
-        const [px, py] = this.props.customPivot.value;
-        return [px * width, py * height];
-      default:
-        return [width / 2, height / 2];
-    }
-  }
-  wrapCoord(coord, size, mode) {
-    if (mode === "clamp") {
-      return Math.max(0, Math.min(size - 1, coord));
-    } else if (mode === "repeat") {
-      coord = coord % size;
-      if (coord < 0) coord += size;
-      return coord;
-    } else 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;
-  }
-  render() {
-    const input = this.toImageBuffer(this.imageInput.value);
-    if (!input) {
-      return;
-    }
-    const width = input.width;
-    const height = input.height;
-    const [tx, ty] = this.props.translate.value;
-    const rotation = this.props.rotation.value * Math.PI / 180;
-    let [sx, sy] = this.props.scale.value;
-    const uniformScale = this.props.uniformScale.value;
-    const filterMode = this.props.filter.value;
-    const wrapMode = this.props.wrap.value;
-    if (uniformScale) {
-      sy = sx;
-    }
-    const [pivotX, pivotY] = this.getPivotPoint(width, height);
-    const cosR = Math.cos(-rotation);
-    const sinR = Math.sin(-rotation);
-    const invSx = 1 / sx;
-    const invSy = 1 / sy;
-    const buffer = ImageBuffer.rgba(width, height);
-    const channelCount = Math.min(input.channelCount, 4);
-    for (let y = 0; y < height; y++) {
-      for (let x = 0; x < width; x++) {
-        let dx = x - pivotX - tx;
-        let dy = y - pivotY - ty;
-        const rx = dx * cosR - dy * sinR;
-        const ry = dx * sinR + dy * cosR;
-        const srcX = rx * invSx + pivotX;
-        const srcY = ry * invSy + pivotY;
-        if (wrapMode === "transparent") {
-          if (srcX < 0 || srcX >= width || srcY < 0 || srcY >= height) {
-            const idx2 = y * width + x;
-            for (let c = 0; c < 4; c++) {
-              buffer.channels[c][idx2] = c === 3 ? 0 : 0;
-            }
-            continue;
-          }
-        }
-        const idx = y * width + x;
-        if (filterMode === "nearest") {
-          const sx0 = Math.round(srcX);
-          const sy0 = Math.round(srcY);
-          const wx = this.wrapCoord(sx0, width, wrapMode);
-          const wy = this.wrapCoord(sy0, height, wrapMode);
-          const srcIdx = wy * width + wx;
-          for (let c = 0; c < channelCount; c++) {
-            buffer.channels[c][idx] = input.channels[c][srcIdx];
-          }
-          if (channelCount < 4) {
-            buffer.channels[3][idx] = 1;
-          }
-        } else {
-          const x0 = Math.floor(srcX);
-          const y0 = Math.floor(srcY);
-          const x1 = x0 + 1;
-          const y1 = y0 + 1;
-          const fx = srcX - x0;
-          const fy = srcY - y0;
-          const wx0 = this.wrapCoord(x0, width, wrapMode);
-          const wx1 = this.wrapCoord(x1, width, wrapMode);
-          const wy0 = this.wrapCoord(y0, height, wrapMode);
-          const wy1 = this.wrapCoord(y1, height, wrapMode);
-          const idx00 = wy0 * width + wx0;
-          const idx10 = wy0 * width + wx1;
-          const idx01 = wy1 * width + wx0;
-          const idx11 = wy1 * width + wx1;
-          for (let c = 0; c < channelCount; c++) {
-            const v00 = input.channels[c][idx00];
-            const v10 = input.channels[c][idx10];
-            const v01 = input.channels[c][idx01];
-            const v11 = input.channels[c][idx11];
-            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;
-          }
-        }
-      }
-    }
-    buffer.markDirty();
-    this.setOutput(this.output, buffer);
-  }
-};
-
-// src/nodes/image/classes.ts
-var imageNodeClasses = {
-  "Color": ColorNode,
-  "Image": ImageNode,
-  "Composite": CompositeNode,
-  "Checkers": CheckersNode,
-  "Resize": ResizeNode,
-  "NormalMap": NormalMapNode,
-  "Ramp": RampNode,
-  "Noise": NoiseNode,
-  "Blur": BlurNode,
-  "Text": TextNode,
-  "Transform": TransformNode
-};
-
-// src/nodes/registerStandardNodes.ts
-var registered = false;
-function registerStandardNodes() {
-  if (registered) return;
-  registerNodeClasses("core", coreNodeClasses);
-  registerNodeClasses("image", imageNodeClasses);
-  registered = true;
-}
-function standardNodesRegistered() {
-  return registered;
-}
-export {
-  registerStandardNodes,
-  standardNodesRegistered
-};
-//# sourceMappingURL=registerStandardNodes-S2VLMF6J.js.map