@field/cascade 0.2.22

package/dist/assets/core-Bji4aZUU.js

@@ -0,0 +1,965 @@
+import{c as e,o as t}from"./nodeTypeUtils-CweA3NHd.js";import{C as n,S as r,b as i,h as a,v as o,w as s,y as c}from"./index-BXYXSdgh.js";var l={type:`Switch`,name:`Switch`,icon:`GitBranch`,description:`Switch between multiple inputs by index`,category:`routing`},u=class extends r{constructor(e,t){super(e,`Switch`,t)}get activeInputIndex(){let e=this.getVariadicInputs();return Math.min(this.props.index?.value??0,e.length-1)}isInputActive(e){let t=this.getVariadicInputs(),n=this.activeInputIndex;return t.findIndex(t=>t.id===e)===n}setup(){this.setVariadic(),this.output=this.out(`output`),this.addParm(`index`,{value:0,type:`int`,params:{min:0,max:0,step:1},displayName:`Index`}),this.watchProp(`index`,()=>this.update()),this.onUpdate=()=>this.update(),this.onReady=()=>this.update()}update(){let e=this.getVariadicInputs(),t=e.filter(e=>e.connections.length>0).length;this.updatePropParams(`index`,{max:Math.max(0,t-1)});let n=e[Math.min(this.props.index.value,e.length-1)];n?(this.output.setValue(n.value),this.preview=this.isPreviewValue(n.value)?n.value:null):(this.output.setValue(null),this.preview=null)}},d={type:`Merge`,name:`Merge`,icon:`GitMerge`,description:`Combine multiple inputs into an array`,category:`routing`},f=class extends r{constructor(e,t){super(e,`Merge`,t)}setup(){this.setVariadic(),this.output=this.out(`output`),this.addParm(`append`,{value:!1,type:`boolean`,displayName:`Append Mode`,hidden:()=>{let e=this.getVariadicInputs();return!Array.isArray(e[0]?.value)}}),this.watchProp(`append`,()=>this.update()),this.onUpdate=()=>this.update(),this.onReady=()=>this.update()}update(){let e=this.getVariadicInputs().filter(e=>e.value!==null).map(e=>e.value);if(this.props.append.value&&e.length>0&&Array.isArray(e[0])){let t=[...e[0],...e.slice(1)];this.output.setValue(t)}else this.output.setValue(e);this.preview=null;for(let t of e)if(t instanceof HTMLCanvasElement||t instanceof HTMLImageElement){this.preview=t;break}}},p={type:`Subnet`,name:`Subnet`,icon:`Folder`,description:`Network container for organizing nodes`,category:`network`},m=class extends r{constructor(e,t){super(e,`Subnet`,t)}setup(){this.onUpdate=()=>this.update(),this.onReady=()=>{this.syncPorts(),this.update()}}isNetwork(){return!0}addChild(e){e.parent=this,this._children.push(e),(e.type===`Input`||e.type===`Output`)&&this.syncPorts()}removeChild(e){let t=this._children.indexOf(e);if(t!==-1){let n=e.type===`Input`||e.type===`Output`;this._children.splice(t,1),e.parent=null,n&&this.syncPorts()}}syncPorts(){let e=this._children.filter(e=>e.type===`Input`),t=e.reduce((e,t)=>{let n=t.inputIndex??0;return Math.max(e,n)},-1),n=this._children.filter(e=>e.type===`Output`),r=n.reduce((e,t)=>{let n=t.outputIndex??0;return Math.max(e,n)},-1),i=t+1,a=this.inputs.length;for(let t=a;t<i;t++){let n=e.find(e=>e.inputIndex===t),r=this.in(n?.inputName||`input_${t}`,null,{type:n?.dataType||`any`});r.onChange=e=>{this._children.filter(e=>e.type===`Input`&&e.inputIndex===t).forEach(e=>e.markDirty())}}for(let e=i;e<a;e++)this.inputs[e]&&(this.inputs[e].options={...this.inputs[e].options,hidden:!0});for(let t=0;t<i;t++)if(this.inputs[t]){let n=e.find(e=>e.inputIndex===t);this.inputs[t].name=n?.inputName||`input_${t}`,this.inputs[t].dataType=n?.dataType||`any`,this.inputs[t].options={...this.inputs[t].options,hidden:!1}}let o=r+1,s=this.outputs.length;for(let e=s;e<o;e++){let t=n.find(t=>t.outputIndex===e);this.out(t?.outputName||`output_${e}`,`param`,{type:t?.dataType||`any`})}for(let e=o;e<s;e++)this.outputs[e]&&(this.outputs[e].options={...this.outputs[e].options,hidden:!0});for(let e=0;e<o;e++)if(this.outputs[e]){let t=n.find(t=>t.outputIndex===e);this.outputs[e].name=t?.outputName||`output_${e}`,this.outputs[e].dataType=t?.dataType||`any`,this.outputs[e].options={...this.outputs[e].options,hidden:!1}}this.inputs=[...this.inputs],this.outputs=[...this.outputs]}outputNode(){return this._children.find(e=>e.type===`Output`)||this._children.find(e=>e.cook)||(this._children.length>0?this._children[this._children.length-1]:null)}displayNode(){return this._children.find(e=>e.cook)??null}indirectInputs(){return this._children.filter(e=>e.type===`Input`)}update(){let e=this._children.filter(e=>e.type===`Output`),t=new Map;for(let n of e){let e=n.outputIndex??0;t.set(e,n)}for(let e=0;e<this.outputs.length;e++){let n=t.get(e);if(n&&n.inputs.length>0){let t=n.inputs[0].value;this.outputs[e].setValue(t),e===0&&(t instanceof HTMLCanvasElement||t instanceof HTMLImageElement)&&(this.preview=t)}else if(e===0){let t=this._children.find(e=>e.cook);t&&t.outputs.length>0?(this.outputs[e].setValue(t.outputs[0].value),t.preview&&(this.preview=t.preview)):this.outputs[e].setValue(null)}else this.outputs[e].setValue(null)}(this.outputs.length===0||!t.has(0))&&(this._children.find(e=>e.cook)?.preview||(this.preview=null))}},h=c.map(e=>({value:e,label:e})),g={type:`Input`,name:`Input`,icon:`LogIn`,description:`Represents an external input to a subnet`,category:`network`},_=class extends r{constructor(e,t){super(e,`Input`,t)}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:h},displayName:`Data Type`});let e=()=>{this.parent&&this.parent.syncPorts&&this.parent.syncPorts(),this.update()};this.watchProp(`inputIndex`,e),this.watchProp(`inputName`,e),this.watchProp(`dataType`,()=>{this.output.dataType=this.dataType,e()}),this.onUpdate=()=>this.update(),this.onReady=()=>this.update()}get inputIndex(){return this.props.inputIndex?.value??0}get inputName(){return this.props.inputName?.value??``}get dataType(){let e=this.props.dataType?.value;return typeof e==`string`&&i(e)?e:`any`}update(){if(this.parent&&this.parent.inputs.length>0){let e=this.inputIndex,t=this.parent.inputs[e];if(t){this.output.setValue(t.value),this.preview=this.isPreviewValue(t.value)?t.value:null;return}}this.output.setValue(null),this.preview=null}},v=c.map(e=>({value:e,label:e})),y={type:`Output`,name:`Output`,icon:`LogOut`,description:`Defines the output of a subnet`,category:`network`},b=class extends r{constructor(e,t){super(e,`Output`,t)}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:v},displayName:`Data Type`});let e=()=>{this.parent&&this.parent.syncPorts&&this.parent.syncPorts(),this.update()};this.watchProp(`outputIndex`,e),this.watchProp(`outputName`,e),this.watchProp(`dataType`,()=>{this.inputs[0]&&(this.inputs[0].dataType=this.dataType),e()}),this.onUpdate=()=>this.update(),this.onReady=()=>this.update()}get outputIndex(){return this.props.outputIndex?.value??0}get outputName(){return this.props.outputName?.value??``}get dataType(){let e=this.props.dataType?.value;return typeof e==`string`&&i(e)?e:`any`}update(){let e=this.inputs[0];e&&(this.preview=this.isPreviewValue(e.value)?e.value:null)}};function x(e,t=0){let n=((Math.trunc(e)^Math.imul(Math.trunc(t),2654435761))>>>0)+1831565813>>>0;return n=Math.imul(n^n>>>15,n|1),n^=n+Math.imul(n^n>>>7,n|61),((n^n>>>14)>>>0)/4294967296}var S={type:`Random`,name:`Random`,icon:`Dice5`,description:`Generate a deterministic value from an explicit seed`,category:`utility`},C=class extends r{constructor(e,t){super(e,`Random`,t)}setup(){let e=this.in(`seed`,0,{type:`int`}),t=this.in(`sample`,0,{type:`int`}),n=this.out(`value`),r=()=>n.setValue(x(e.value,t.value));e.onChange=r,t.onChange=r,this.onUpdate=r,this.onReady=r}};function w(e,t,n,r,i,a){if(t===n)return r;let o=(e-t)/(n-t);return r+(a?Math.min(1,Math.max(0,o)):o)*(i-r)}var T={type:`Remap`,name:`Remap`,icon:`ArrowRightLeft`,description:`Map a number from one range into another`,category:`utility`},E=class extends r{constructor(e,t){super(e,`Remap`,t)}setup(){let e=this.in(`value`,0,{type:`float`}),t=this.in(`inMin`,0,{type:`float`}),n=this.in(`inMax`,1,{type:`float`}),r=this.in(`outMin`,0,{type:`float`}),i=this.in(`outMax`,1,{type:`float`}),a=this.out(`result`);this.addParm(`clamp`,{value:!1,type:`boolean`,displayName:`Clamp`});let o=()=>a.setValue(w(e.value,t.value,n.value,r.value,i.value,this.props.clamp.value));for(let a of[e,t,n,r,i])a.onChange=o;this.watchProp(`clamp`,o),this.onUpdate=o,this.onReady=o}},D={type:`Select`,name:`Select`,icon:`ListFilter`,description:`Pick an item from an array by index`,category:`utility`},O=class extends r{constructor(e,t){super(e,`Select`,t)}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:!0,type:`boolean`,displayName:`Wrap Index`}),this.watchProp(`index`,()=>this.update()),this.watchProp(`wrap`,()=>this.update()),this.onUpdate=()=>this.update(),this.onReady=()=>this.update()}update(){let e=this.arrayInput.value;if(!Array.isArray(e)||e.length===0){this.itemOutput.setValue(null),this.countOutput.setValue(0),this.updatePropParams(`index`,{max:0});return}this.updatePropParams(`index`,{max:e.length-1});let t=this.props.index?.value??0;t=(this.props.wrap?.value??!0)&&e.length>0?(t%e.length+e.length)%e.length:Math.max(0,Math.min(t,e.length-1));let n=e[t];this.itemOutput.setValue(n),this.countOutput.setValue(e.length),this.preview=n instanceof HTMLCanvasElement||n instanceof HTMLImageElement?n:null}},k={type:`Null`,name:`Null`,icon:`Circle`,description:`Pass its input through unchanged`,category:`routing`},A=class extends r{constructor(e,t){super(e,`Null`,t)}setup(){let e=this.in(`input`,null,{type:`any`}),t=this.out(`output`),n=()=>t.setValue(e.value);e.onChange=n,this.onUpdate=n,this.onReady=n}},j={type:`Freeze`,name:`Freeze`,icon:`Snowflake`,description:`Capture and lock a value`,category:`utility`},M=class extends r{constructor(e,t){super(e,`Freeze`,t),this.frozenValue=null,this.hasCaptured=!1}setup(){this.input=this.in(`input`,null,{type:`any`}),this.output=this.out(`output`,`param`),this.addParm(`frozen`,{value:!1,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(){this.frozenValue=this.deepClone(this.input.value),this.hasCaptured=!0,this.setParm(`frozen`,!0),this.update()}clear(){this.frozenValue=null,this.hasCaptured=!1,this.setParm(`frozen`,!1),this.update()}deepClone(e){if(e==null)return e;if(e instanceof HTMLCanvasElement){let t=document.createElement(`canvas`);return t.width=e.width,t.height=e.height,t.getContext(`2d`)?.drawImage(e,0,0),t}if(e instanceof HTMLImageElement){let t=document.createElement(`canvas`);return t.width=e.naturalWidth||e.width,t.height=e.naturalHeight||e.height,t.getContext(`2d`)?.drawImage(e,0,0),t}if(Array.isArray(e))return e.map(e=>this.deepClone(e));if(typeof e==`object`)try{return JSON.parse(JSON.stringify(e))}catch{return e}return e}update(){(this.props.frozen?.value??!1)&&this.hasCaptured?(this.output.setValue(this.frozenValue),(this.frozenValue instanceof HTMLCanvasElement||this.frozenValue instanceof HTMLImageElement)&&(this.preview=this.frozenValue)):(this.output.setValue(this.input.value),this.preview=this.input.value instanceof HTMLCanvasElement||this.input.value instanceof HTMLImageElement?this.input.value:null)}serialize(){return{hasCaptured:this.hasCaptured}}deserialize(e){this.hasCaptured=e.hasCaptured===!0}},N=`/**
+ * SwitchNode - routes one of multiple inputs to output based on index
+ * Connect multiple inputs and use the index parameter to select which one passes through
+ */
+
+import { Node } from '../../Node.js';
+import type { Graph } from '../../Graph.js';
+import type { OutputPort } from '@/types/node.types';
+
+export const nodeMetadata = {
+  type: 'Switch',
+  name: 'Switch',
+  icon: 'GitBranch',
+  description: 'Switch between multiple inputs by index',
+  category: 'routing'
+};
+
+export class SwitchNode extends Node {
+  private output!: OutputPort<any>;
+
+  constructor(id: string, graph: Graph) {
+    super(id, 'Switch', graph);
+  }
+
+  /**
+   * Get the index of the currently active input
+   * Used by connection rendering to grey out inactive wires
+   */
+  get activeInputIndex(): number {
+    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: string): boolean {
+    const inputs = this.getVariadicInputs();
+    const activeIdx = this.activeInputIndex;
+    const portIndex = inputs.findIndex(p => p.id === portId);
+    return portIndex === activeIdx;
+  }
+
+  protected setup(): void {
+    this.setVariadic();
+    this.output = this.out('output');
+
+    this.addParm('index', {
+      value: 0,
+      type: 'int',
+      params: { min: 0, max: 0, step: 1 },
+      displayName: 'Index'
+    });
+
+    this.watchProp('index', () => this.update());
+
+    this.onUpdate = () => this.update();
+    this.onReady = () => this.update();
+  }
+
+  private update(): void {
+    const inputs = this.getVariadicInputs();
+
+    // Update index max based on connected inputs (triggers UI reactivity)
+    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);
+
+      // Use input's preview if it's a canvas/image
+      if (this.isPreviewValue(selectedInput.value)) {
+        this.preview = selectedInput.value;
+      } else {
+        this.preview = null;
+      }
+    } else {
+      this.output.setValue(null);
+      this.preview = null;
+    }
+  }
+}
+`,P=`/**
+ * MergeNode - combines multiple inputs into an array
+ * Connect multiple inputs to create an array of values
+ */
+
+import { Node } from '../../Node.js';
+import type { Graph } from '../../Graph.js';
+import type { OutputPort } from '@/types/node.types';
+
+export const nodeMetadata = {
+  type: 'Merge',
+  name: 'Merge',
+  icon: 'GitMerge',
+  description: 'Combine multiple inputs into an array',
+  category: 'routing'
+};
+
+export class MergeNode extends Node {
+  private output!: OutputPort<any[]>;
+
+  constructor(id: string, graph: Graph) {
+    super(id, 'Merge', graph);
+  }
+
+  protected setup(): void {
+    this.setVariadic();
+    this.output = this.out('output');
+
+    // Append mode - when first input is an array, append others to it
+    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();
+  }
+
+  private update(): void {
+    const inputs = this.getVariadicInputs();
+
+    // Collect non-null values
+    const values = inputs
+      .filter(p => p.value !== null)
+      .map(p => p.value);
+
+    // Handle append mode
+    const appendMode = this.props.append.value;
+    if (appendMode && values.length > 0 && Array.isArray(values[0])) {
+      // Append subsequent values to the first array
+      const result = [...values[0], ...values.slice(1)];
+      this.output.setValue(result);
+    } else {
+      this.output.setValue(values);
+    }
+
+    // Set preview to first visual element if available
+    this.preview = null;
+    for (const val of values) {
+      if (val instanceof HTMLCanvasElement || val instanceof HTMLImageElement) {
+        this.preview = val;
+        break;
+      }
+    }
+  }
+}
+`,F=`/**
+ * SubnetNode - Network container for organizing nodes hierarchically
+ * A subnet is a node that can contain child nodes, creating a nested graph
+ */
+
+import { Node } from '../../Node.js';
+import type { Graph } from '../../Graph.js';
+import type { InputPort, OutputPort } from '@/types/node.types';
+
+export const nodeMetadata = {
+  type: 'Subnet',
+  name: 'Subnet',
+  icon: 'Folder',
+  description: 'Network container for organizing nodes',
+  category: 'network'
+};
+
+export class SubnetNode extends Node {
+  constructor(id: string, graph: Graph) {
+    super(id, 'Subnet', graph);
+  }
+
+  protected setup(): void {
+    // Ports are dynamically created based on child Input/Output nodes
+    // Start with no ports - they'll be synced when children are added
+    this.onUpdate = () => this.update();
+    this.onReady = () => {
+      this.syncPorts();
+      this.update();
+    };
+  }
+
+  /**
+   * Override: Subnets are networks and can contain children
+   */
+  isNetwork(): boolean {
+    return true;
+  }
+
+  /**
+   * Add a child node to this subnet
+   */
+  addChild(node: Node): void {
+    node.parent = this;
+    this._children.push(node);
+    // Sync ports when Input/Output nodes are added
+    if (node.type === 'Input' || node.type === 'Output') {
+      this.syncPorts();
+    }
+  }
+
+  /**
+   * Remove a child node from this subnet
+   */
+  removeChild(node: Node): void {
+    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;
+      // Sync ports when Input/Output nodes are removed
+      if (wasInputOutput) {
+        this.syncPorts();
+      }
+    }
+  }
+
+  /**
+   * Sync input/output ports based on child Input/Output nodes
+   */
+  syncPorts(): void {
+    // Find all Input nodes and determine required input ports
+    const inputNodes = this._children.filter(n => n.type === 'Input');
+    const maxInputIndex = inputNodes.reduce((max, node) => {
+      const idx = (node as any).inputIndex ?? 0;
+      return Math.max(max, idx);
+    }, -1);
+
+    // Find all Output nodes and determine required output ports
+    const outputNodes = this._children.filter(n => n.type === 'Output');
+    const maxOutputIndex = outputNodes.reduce((max, node) => {
+      const idx = (node as any).outputIndex ?? 0;
+      return Math.max(max, idx);
+    }, -1);
+
+    // Sync input ports
+    const requiredInputs = maxInputIndex + 1;
+    const currentInputs = this.inputs.length;
+
+    // Add missing input ports
+    for (let i = currentInputs; i < requiredInputs; i++) {
+      const boundary = inputNodes.find(n => (n as any).inputIndex === i) as any;
+      const port = this.in(boundary?.inputName || \`input_\${i}\`, null, {
+        type: boundary?.dataType || 'any'
+      });
+      // When input value changes, update any Input nodes referencing this index
+      port.onChange = (value: any) => {
+        this._children
+          .filter(n => n.type === 'Input' && (n as any).inputIndex === i)
+          .forEach(n => n.markDirty());
+      };
+    }
+
+    // Hide excess input ports (don't remove to preserve connections)
+    for (let i = requiredInputs; i < currentInputs; i++) {
+      if (this.inputs[i]) {
+        this.inputs[i].options = { ...this.inputs[i].options, hidden: true };
+      }
+    }
+    // Unhide needed ports
+    for (let i = 0; i < requiredInputs; i++) {
+      if (this.inputs[i]) {
+        const boundary = inputNodes.find(n => (n as any).inputIndex === i) as any;
+        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 };
+      }
+    }
+
+    // Sync output ports - only create if there are Output nodes
+    const requiredOutputs = maxOutputIndex + 1; // 0 if no Output nodes
+    const currentOutputs = this.outputs.length;
+
+    // Add missing output ports
+    for (let i = currentOutputs; i < requiredOutputs; i++) {
+      const boundary = outputNodes.find(n => (n as any).outputIndex === i) as any;
+      this.out(boundary?.outputName || \`output_\${i}\`, 'param', {
+        type: boundary?.dataType || 'any'
+      });
+    }
+
+    // Hide excess output ports
+    for (let i = requiredOutputs; i < currentOutputs; i++) {
+      if (this.outputs[i]) {
+        this.outputs[i].options = { ...this.outputs[i].options, hidden: true };
+      }
+    }
+    // Unhide needed ports
+    for (let i = 0; i < requiredOutputs; i++) {
+      if (this.outputs[i]) {
+        const boundary = outputNodes.find(n => (n as any).outputIndex === i) as any;
+        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 };
+      }
+    }
+
+    // Trigger reactivity
+    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(): Node | null {
+    // 1. Check for explicit Output node
+    const outputNode = this._children.find(n => n.type === 'Output');
+    if (outputNode) return outputNode;
+
+    // 2. Use cooking node
+    const cookingNode = this._children.find(n => n.cook);
+    if (cookingNode) return cookingNode;
+
+    // 3. Fall back to last node
+    return this._children.length > 0 ? this._children[this._children.length - 1] : null;
+  }
+
+  /**
+   * Get the cooking (display) node in this subnet
+   */
+  displayNode(): Node | null {
+    return this._children.find(n => n.cook) ?? null;
+  }
+
+  /**
+   * Get all Input nodes inside this subnet
+   */
+  indirectInputs(): Node[] {
+    return this._children.filter(n => n.type === 'Input');
+  }
+
+  private update(): void {
+    // Update each output based on corresponding Output nodes
+    const outputNodes = this._children.filter(n => n.type === 'Output');
+
+    // Group output nodes by their outputIndex
+    const outputByIndex = new Map<number, Node>();
+    for (const node of outputNodes) {
+      const idx = (node as any).outputIndex ?? 0;
+      outputByIndex.set(idx, node);
+    }
+
+    // Update each output port
+    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);
+
+        // Set preview from first output
+        if (i === 0 && (value instanceof HTMLCanvasElement || value instanceof HTMLImageElement)) {
+          this.preview = value;
+        }
+      } else if (i === 0) {
+        // Fallback for first output: use cooking node if no Output node
+        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);
+      }
+    }
+
+    // Clear preview if no outputs set it
+    if (this.outputs.length === 0 || !outputByIndex.has(0)) {
+      const cookingNode = this._children.find(n => n.cook);
+      if (!cookingNode?.preview) {
+        this.preview = null;
+      }
+    }
+  }
+}
+`,I=`/**
+ * InputNode - Represents an external input to a subnet
+ * Auto-created when wiring into a subnet, or manually for documentation
+ */
+
+import { Node } from '../../Node.js';
+import type { Graph } from '../../Graph.js';
+import type { DataType, OutputPort } from '@/types/node.types';
+import { CORE_TYPES, isCoreType } from '@/types/coreTypes';
+
+const TYPE_CHOICES = CORE_TYPES.map(type => ({ value: type, label: type }));
+
+export const nodeMetadata = {
+  type: 'Input',
+  name: 'Input',
+  icon: 'LogIn',
+  description: 'Represents an external input to a subnet',
+  category: 'network'
+};
+
+export class InputNode extends Node {
+  private output!: OutputPort<any>;
+
+  constructor(id: string, graph: Graph) {
+    super(id, 'Input', graph);
+  }
+
+  protected setup(): void {
+    // Output passes through the external input value
+    this.output = this.out('output');
+
+    // Input index - which external input this represents
+    this.addParm('inputIndex', {
+      value: 0,
+      type: 'int',
+      params: { min: 0, step: 1 },
+      displayName: 'Input Index'
+    });
+
+    // Optional name for documentation
+    this.addParm('inputName', {
+      value: '',
+      type: 'text',
+      displayName: 'Input Name'
+    });
+
+    this.addParm('dataType', {
+      value: 'any',
+      type: 'select',
+      params: { options: TYPE_CHOICES },
+      displayName: 'Data Type'
+    });
+
+    // Watch for index changes to trigger parent port sync
+    const syncParent = () => {
+      if (this.parent && (this.parent as any).syncPorts) {
+        (this.parent as any).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(): number {
+    return this.props.inputIndex?.value ?? 0;
+  }
+
+  /**
+   * Get the input name (for documentation)
+   */
+  get inputName(): string {
+    return this.props.inputName?.value ?? '';
+  }
+
+  get dataType(): DataType {
+    const value = this.props.dataType?.value;
+    return typeof value === 'string' && isCoreType(value) ? value : 'any';
+  }
+
+  private update(): void {
+    // Get value from parent subnet's corresponding input
+    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);
+
+        // Pass through preview
+        if (this.isPreviewValue(parentInput.value)) {
+          this.preview = parentInput.value;
+        } else {
+          this.preview = null;
+        }
+        return;
+      }
+    }
+
+    this.output.setValue(null);
+    this.preview = null;
+  }
+}
+`,L=`/**
+ * OutputNode - Explicitly defines a subnet's output
+ * Overrides the cooking node when present
+ */
+
+import { Node } from '../../Node.js';
+import type { Graph } from '../../Graph.js';
+import type { DataType } from '@/types/node.types';
+import { CORE_TYPES, isCoreType } from '@/types/coreTypes';
+
+const TYPE_CHOICES = CORE_TYPES.map(type => ({ value: type, label: type }));
+
+export const nodeMetadata = {
+  type: 'Output',
+  name: 'Output',
+  icon: 'LogOut',
+  description: 'Defines the output of a subnet',
+  category: 'network'
+};
+
+export class OutputNode extends Node {
+  constructor(id: string, graph: Graph) {
+    super(id, 'Output', graph);
+  }
+
+  protected setup(): void {
+    // Input receives the value to output from the subnet
+    this.in('input', null);
+
+    // Output index - for multiple outputs from a subnet
+    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_CHOICES },
+      displayName: 'Data Type'
+    });
+
+    // Watch for index changes to trigger parent port sync
+    const syncParent = () => {
+      if (this.parent && (this.parent as any).syncPorts) {
+        (this.parent as any).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(): number {
+    return this.props.outputIndex?.value ?? 0;
+  }
+
+  get outputName(): string {
+    return this.props.outputName?.value ?? '';
+  }
+
+  get dataType(): DataType {
+    const value = this.props.dataType?.value;
+    return typeof value === 'string' && isCoreType(value) ? value : 'any';
+  }
+
+  private update(): void {
+    // Pass through the input value and preview
+    const input = this.inputs[0];
+    if (input) {
+      if (this.isPreviewValue(input.value)) {
+        this.preview = input.value;
+      } else {
+        this.preview = null;
+      }
+    }
+  }
+}
+`,R=`import { randomFromSeed } from '../../../../packages/runtime/src/builtins/core/random.js';
+import { Node } from '../../Node.js';
+import type { Graph } from '../../Graph.js';
+
+export const nodeMetadata = {
+  type: 'Random',
+  name: 'Random',
+  icon: 'Dice5',
+  description: 'Generate a deterministic value from an explicit seed',
+  category: 'utility'
+};
+
+export class RandomNode extends Node {
+  constructor(id: string, graph: Graph) {
+    super(id, 'Random', graph);
+  }
+
+  protected setup(): void {
+    const seed = this.in('seed', 0, { type: 'int' });
+    const sample = this.in('sample', 0, { type: 'int' });
+    const value = this.out<number>('value');
+    const update = () => value.setValue(randomFromSeed(seed.value, sample.value));
+    seed.onChange = update;
+    sample.onChange = update;
+    this.onUpdate = update;
+    this.onReady = update;
+  }
+}
+`,z=`import { remap } from '../../../../packages/runtime/src/builtins/core/remap.js';
+import { Node } from '../../Node.js';
+import type { Graph } from '../../Graph.js';
+
+export const nodeMetadata = {
+  type: 'Remap',
+  name: 'Remap',
+  icon: 'ArrowRightLeft',
+  description: 'Map a number from one range into another',
+  category: 'utility'
+};
+
+export class RemapNode extends Node {
+  constructor(id: string, graph: Graph) {
+    super(id, 'Remap', graph);
+  }
+
+  protected setup(): void {
+    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<number>('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;
+  }
+}
+`,B=`/**
+ * SelectNode - Pick an item from an array by index
+ *
+ * Takes an array input and outputs the item at the specified index.
+ * Supports wrapping so indices beyond array length wrap around.
+ */
+
+import { Node } from '../../Node.js';
+import type { Graph } from '../../Graph.js';
+import type { InputPort, OutputPort } from '@/types/node.types';
+
+export const nodeMetadata = {
+	type: 'Select',
+	name: 'Select',
+	icon: 'ListFilter',
+	description: 'Pick an item from an array by index',
+	category: 'utility'
+};
+
+export class SelectNode extends Node {
+	private arrayInput!: InputPort<unknown[]>;
+	private itemOutput!: OutputPort<unknown>;
+	private countOutput!: OutputPort<number>;
+
+	constructor(id: string, graph: Graph) {
+		super(id, 'Select', graph);
+	}
+
+	protected setup(): void {
+		// Inputs (default to empty array, type is 'array')
+		this.arrayInput = this.in<unknown[]>('array', [], { type: 'array' });
+
+		// Outputs (second param is PortType: 'param' | 'trigger')
+		this.itemOutput = this.out('item', 'param');
+		this.countOutput = this.out('count', 'param');
+
+		// Parameters
+		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'
+		});
+
+		// Watch for changes
+		this.watchProp('index', () => this.update());
+		this.watchProp('wrap', () => this.update());
+
+		this.onUpdate = () => this.update();
+		this.onReady = () => this.update();
+	}
+
+	private update(): void {
+		const array = this.arrayInput.value;
+
+		// Handle non-array or empty input
+		if (!Array.isArray(array) || array.length === 0) {
+			this.itemOutput.setValue(null);
+			this.countOutput.setValue(0);
+			this.updatePropParams('index', { max: 0 });
+			return;
+		}
+
+		// Update index max based on array length
+		this.updatePropParams('index', { max: array.length - 1 });
+
+		// Get the index, applying wrapping if enabled
+		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 the item is a canvas or image, show as preview
+		if (
+			item instanceof HTMLCanvasElement ||
+			item instanceof HTMLImageElement
+		) {
+			this.preview = item;
+		} else {
+			this.preview = null;
+		}
+	}
+}
+`,V=`import { Node } from '../../Node.js';
+import type { Graph } from '../../Graph.js';
+
+export const nodeMetadata = {
+  type: 'Null',
+  name: 'Null',
+  icon: 'Circle',
+  description: 'Pass its input through unchanged',
+  category: 'routing',
+};
+
+export class NullNode extends Node {
+  constructor(id: string, graph: Graph) {
+    super(id, 'Null', graph);
+  }
+
+  protected setup(): void {
+    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;
+  }
+}
+`,H=`/**
+ * FreezeNode - Capture and lock a value in place
+ *
+ * When frozen, the node outputs its captured value regardless of input changes.
+ * Useful for preserving a specific state in a workflow.
+ */
+
+import { Node } from '../../Node.js';
+import type { Graph } from '../../Graph.js';
+import type { InputPort, OutputPort } from '@/types/node.types';
+
+export const nodeMetadata = {
+	type: 'Freeze',
+	name: 'Freeze',
+	icon: 'Snowflake',
+	description: 'Capture and lock a value',
+	category: 'utility'
+};
+
+export class FreezeNode extends Node {
+	private input!: InputPort<unknown>;
+	private output!: OutputPort<unknown>;
+	private frozenValue: unknown = null;
+	private hasCaptured: boolean = false;
+
+	constructor(id: string, graph: Graph) {
+		super(id, 'Freeze', graph);
+	}
+
+	protected setup(): void {
+		// Input (default to null, type is 'any')
+		this.input = this.in<unknown>('input', null, { type: 'any' });
+
+		// Output (second param is PortType: 'param' | 'trigger')
+		this.output = this.out<unknown>('output', 'param');
+
+		// Parameters
+		this.addParm('frozen', {
+			value: false,
+			type: 'boolean',
+			displayName: 'Frozen'
+		});
+
+		// Actions
+		this.addAction('capture', {
+			label: 'Capture',
+			icon: 'Camera',
+			callback: () => this.capture()
+		});
+
+		this.addAction('clear', {
+			label: 'Clear',
+			icon: 'Trash2',
+			callback: () => this.clear()
+		});
+
+		// Watch frozen state
+		this.watchProp('frozen', () => this.update());
+
+		this.onUpdate = () => this.update();
+		this.onReady = () => this.update();
+	}
+
+	/**
+	 * Capture the current input value
+	 */
+	capture(): void {
+		this.frozenValue = this.deepClone(this.input.value);
+		this.hasCaptured = true;
+		this.setParm('frozen', true);
+		this.update();
+	}
+
+	/**
+	 * Clear the frozen value
+	 */
+	clear(): void {
+		this.frozenValue = null;
+		this.hasCaptured = false;
+		this.setParm('frozen', false);
+		this.update();
+	}
+
+	/**
+	 * Deep clone a value if possible
+	 */
+	private deepClone(value: unknown): unknown {
+		if (value === null || value === undefined) {
+			return value;
+		}
+
+		// Handle canvas - create a copy
+		if (value instanceof HTMLCanvasElement) {
+			const canvas = document.createElement('canvas');
+			canvas.width = value.width;
+			canvas.height = value.height;
+			const ctx = canvas.getContext('2d');
+			ctx?.drawImage(value, 0, 0);
+			return canvas;
+		}
+
+		// Handle image elements
+		if (value instanceof HTMLImageElement) {
+			const canvas = document.createElement('canvas');
+			canvas.width = value.naturalWidth || value.width;
+			canvas.height = value.naturalHeight || value.height;
+			const ctx = canvas.getContext('2d');
+			ctx?.drawImage(value, 0, 0);
+			return canvas;
+		}
+
+		// Handle arrays
+		if (Array.isArray(value)) {
+			return value.map((item) => this.deepClone(item));
+		}
+
+		// Handle plain objects
+		if (typeof value === 'object') {
+			try {
+				return JSON.parse(JSON.stringify(value));
+			} catch {
+				return value;
+			}
+		}
+
+		// Primitives are already immutable
+		return value;
+	}
+
+	private update(): void {
+		const isFrozen = this.props.frozen?.value ?? false;
+
+		if (isFrozen && this.hasCaptured) {
+			// Output the frozen value
+			this.output.setValue(this.frozenValue);
+
+			// Show preview if it's a visual type
+			if (
+				this.frozenValue instanceof HTMLCanvasElement ||
+				this.frozenValue instanceof HTMLImageElement
+			) {
+				this.preview = this.frozenValue as HTMLCanvasElement | HTMLImageElement;
+			}
+		} else {
+			// Pass through the input
+			this.output.setValue(this.input.value);
+
+			// Show input preview if visual
+			if (
+				this.input.value instanceof HTMLCanvasElement ||
+				this.input.value instanceof HTMLImageElement
+			) {
+				this.preview = this.input.value;
+			} else {
+				this.preview = null;
+			}
+		}
+	}
+
+	/**
+	 * Serialize with frozen state
+	 */
+	serialize(): Record<string, unknown> {
+		// Can't serialize canvas/images directly - would need to convert to data URL
+		// For now, just save the frozen state, not the value
+		return {
+			hasCaptured: this.hasCaptured
+		};
+	}
+
+	/**
+	 * Deserialize and restore frozen state
+	 */
+	deserialize(data: Record<string, unknown>): void {
+		this.hasCaptured = data.hasCaptured === true;
+	}
+}
+`,U=class{constructor(){this._graph=null,this._pwd=null,this._frame=1,this._fps=30,this._selectedNodes=new Set}setGraph(e){this._graph=e,s.setGraph(e)}getGraph(){return this._graph}node(e){return this._graph?e.startsWith(`/`)?this.resolveAbsolutePath(e):this._pwd?this._pwd.node(e):this.resolveAbsolutePath(`/`+e):null}parm(e){let t=e.lastIndexOf(`/`);if(t===-1)return null;let n=e.substring(0,t)||`/`,r=e.substring(t+1);return this.node(n)?.parm(r)??null}root(){return null}pwd(){return this._pwd}setPwd(e){this._pwd=e}cd(e){if(e===`/`){this._pwd=null;return}let t=this.node(e);t&&t.isNetwork()&&(this._pwd=t)}selectedNodes(){return this._graph?Array.from(this._selectedNodes).map(e=>this._graph.getNode(e)).filter(e=>e!==null):[]}selectedNodeIds(){return Array.from(this._selectedNodes)}setSelection(e){this._selectedNodes=new Set(e),this.onSelectionChange?.(e)}clearAllSelected(){this._selectedNodes.clear(),this.onSelectionChange?.([])}frame(){return this._frame}time(){return this._frame/this._fps}fps(){return this._fps}setFrame(e){this._frame=Math.max(1,Math.floor(e)),s.setFrame(this._frame)}setTime(e){this._frame=Math.max(1,Math.floor(e*this._fps)),s.setFrame(this._frame)}setFps(e){this._fps=Math.max(1,e),s.setFps(this._fps)}ch(e){return this.parm(e)?.evalAsFloat()??0}chs(e){return this.parm(e)?.evalAsString()??``}chv(e){let t=this.parm(e)?.eval();return Array.isArray(t)?t:typeof t==`number`?[t]:[]}markTimeDependentDirty(){if(this._graph)for(let e of this._graph.nodes)e.isTimeDependent&&e.markDirty()}getTimeDependentNodes(){return this._graph?this._graph.nodes.filter(e=>e.isTimeDependent):[]}nextFrame(){return this.setFrame(this._frame+1),this.markTimeDependentDirty(),this._frame}resolveAbsolutePath(e){if(!this._graph)return null;let t=e.replace(/^\//,``).split(`/`).filter(e=>e.length>0);if(t.length===0)return null;let n=null,r=this._graph.nodes.filter(e=>!e.parent);for(let e=0;e<t.length;e++){let i=t[e],a=(n?n.children():r).find(e=>e.id===i);if(!a)return null;n=a}return n}},W=new U,G=[l,d,p,g,y,S,T,D,k,j],K={Switch:u,Merge:f,Subnet:m,Input:_,Output:b,Random:C,Remap:E,Select:O,Null:A,Freeze:M};t(`core`,K),e(`Switch`,N),e(`Merge`,P),e(`Subnet`,F),e(`Input`,I),e(`Output`,L),e(`Random`,R),e(`Remap`,z),e(`Select`,B),e(`Null`,V),e(`Freeze`,H);export{U as CascadeContext,n as ExpressionEngine,M as FreezeNode,o as Graph,_ as InputNode,f as MergeNode,r as Node,A as NullNode,b as OutputNode,C as RandomNode,E as RemapNode,O as SelectNode,m as SubnetNode,u as SwitchNode,W as cascade,a as coreLibrary,K as coreNodeClasses,s as expressionEngine,G as nodeMetadataList};