@field/cascade 0.8.0 → 0.11.0

package/dist/cli/registerStandardNodes-S2VLMF6J.js

@@ -0,0 +1,3081 @@
+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