p5 2.2.2 → 2.2.3-rc.1

package/dist/strands/p5.strands.js

@@ -8,7 +8,7 @@ import 'acorn';
 import 'acorn-walk';
 import 'escodegen';
 import './strands_FES.js';
-import '../ir_builders-w12-GSxu.js';
+import '../ir_builders-Cd6rU9Vm.js';
 import './strands_builtins.js';
 import './strands_conditionals.js';
 import './strands_phi_utils.js';
@@ -42,7 +42,6 @@ function strands(p5, fn) {
     ctx.vertexDeclarations = new Set();
     ctx.fragmentDeclarations = new Set();
     ctx.hooks = [];
-    ctx.globalAssignments = [];
     ctx.backend = backend;
     ctx.active = active;
     ctx.renderer = renderer;
@@ -50,6 +49,7 @@ function strands(p5, fn) {
     ctx.previousFES = p5.disableFriendlyErrors;
     ctx.windowOverrides = {};
     ctx.fnOverrides = {};
+    ctx.graphicsOverrides = {};
     if (active) {
       p5.disableFriendlyErrors = true;
     }
@@ -63,7 +63,6 @@ function strands(p5, fn) {
     ctx.vertexDeclarations = new Set();
     ctx.fragmentDeclarations = new Set();
     ctx.hooks = [];
-    ctx.globalAssignments = [];
     ctx.active = false;
     p5.disableFriendlyErrors = ctx.previousFES;
     for (const key in ctx.windowOverrides) {
@@ -72,6 +71,17 @@ function strands(p5, fn) {
     for (const key in ctx.fnOverrides) {
       fn[key] = ctx.fnOverrides[key];
     }
+    // Clean up the hooks temporarily installed on p5.Graphics.prototype (#8549)
+    const GraphicsProto = p5.Graphics?.prototype;
+    if (GraphicsProto) {
+      for (const key in ctx.graphicsOverrides) {
+        if (ctx.graphicsOverrides[key] === undefined) {
+          delete GraphicsProto[key];
+        } else {
+          GraphicsProto[key] = ctx.graphicsOverrides[key];
+        }
+      }
+    }
   }
 
   const strandsContext = {};
@@ -197,7 +207,7 @@ if (typeof p5 !== "undefined") {
  * }
  *
  * function material() {
- *   let t = uniformFloat();
+ *   let t = millis();
  *   worldInputs.begin();
  *   // Move the vertex up and down in a wave in world space
  *   // In world space, moving the object (e.g., with translate()) will affect these coordinates
@@ -209,7 +219,6 @@ if (typeof p5 !== "undefined") {
  * function draw() {
  *   background(255);
  *   shader(myShader);
- *   myShader.setUniform('t', millis());
  *   lights();
  *   noStroke();
  *   fill('red');
@@ -298,9 +307,7 @@ if (typeof p5 !== "undefined") {
  *          A value between `0.0` and `1.0`
  *
  * @example
- * <div modernizr="webgl">
- * <code>
- * // Example 1: A soft vertical fade using smoothstep (no uniforms)
+ * // Example 1: A soft vertical fade using smoothstep
  *
  * let fadeShader;
  *
@@ -319,31 +326,25 @@ if (typeof p5 !== "undefined") {
  *
  * function setup() {
  *   createCanvas(300, 200, WEBGL);
- *   fadeShader = baseFilterShader().modify(fadeCallback);
+ *   fadeShader = buildFilterShader(fadeCallback);
  * }
  *
  * function draw() {
  *   background(0);
  *   filter(fadeShader);
  * }
- * </code>
- * </div>
  *
  * @example
- * <div modernizr="webgl">
- * <code>
- * // Example 2: Animate the smooth transition using a uniform
+ * // Example 2: Animate the smooth transition over time
  *
  * let animatedShader;
  *
  * function animatedFadeCallback() {
- *   const time = uniformFloat(() => millis() * 0.001);
- *
  *   getColor((inputs) => {
  *     let x = inputs.texCoord.x;
  *
  *     // Move the smoothstep band back and forth over time
- *     let center = 0.5 + 0.25 * sin(time);
+ *     let center = 0.5 + 0.25 * sin(millis() * 0.001);
  *     let t = smoothstep(center - 0.05, center + 0.05, x);
  *
  *     return [t, t, t, 1];
@@ -352,15 +353,13 @@ if (typeof p5 !== "undefined") {
  *
  * function setup() {
  *   createCanvas(300, 200, WEBGL);
- *   animatedShader = baseFilterShader().modify(animatedFadeCallback);
+ *   animatedShader = buildFilterShader(animatedFadeCallback);
  * }
  *
  * function draw() {
  *   background(0);
  *   filter(animatedShader);
  * }
- * </code>
- * </div>
  */
 
 /**
@@ -477,7 +476,7 @@ if (typeof p5 !== "undefined") {
  * }
  *
  * function material() {
- *   let t = uniformFloat();
+ *   let t = millis();
  *   pixelInputs.begin();
  *   // Animate alpha (transparency) based on x position
  *   pixelInputs.color.a = 0.5 + 0.5 *
@@ -488,7 +487,6 @@ if (typeof p5 !== "undefined") {
  * function draw() {
  *   background(240);
  *   shader(myShader);
- *   myShader.setUniform('t', millis());
  *   lights();
  *   noStroke();
  *   fill('purple');
@@ -640,7 +638,8 @@ if (typeof p5 !== "undefined") {
  *     filterColor.texCoord.x,
  *     filterColor.texCoord.y + 0.1 * sin(filterColor.texCoord.x * 10)
  *   ];
- *   filterColor.set(getTexture(canvasContent, warped));
+ *   let tex = filterColor.canvasContent;
+ *   filterColor.set(getTexture(tex, warped));
  *   filterColor.end();
  * }
  *
@@ -678,7 +677,7 @@ if (typeof p5 !== "undefined") {
  * }
  *
  * function material() {
- *   let t = uniformFloat();
+ *   let t = millis();
  *   objectInputs.begin();
  *   // Create a sine wave along the object
  *   objectInputs.position.y += sin(t * 0.001 + objectInputs.position.x);
@@ -688,7 +687,6 @@ if (typeof p5 !== "undefined") {
  * function draw() {
  *   background(220);
  *   shader(myShader);
- *   myShader.setUniform('t', millis());
  *   noStroke();
  *   fill('orange');
  *   sphere(50);
@@ -720,7 +718,7 @@ if (typeof p5 !== "undefined") {
  * }
  *
  * function material() {
- *   let t = uniformFloat();
+ *   let t = millis();
  *   cameraInputs.begin();
  *   // Move vertices in camera space based on their x position
  *   cameraInputs.position.y += 30 * sin(cameraInputs.position.x * 0.05 + t * 0.001);
@@ -732,7 +730,6 @@ if (typeof p5 !== "undefined") {
  * function draw() {
  *   background(200);
  *   shader(myShader);
- *   myShader.setUniform('t', millis());
  *   noStroke();
  *   fill('red');
  *   sphere(50);
@@ -779,8 +776,6 @@ if (typeof p5 !== "undefined") {
  * will behave as a vec4 holding components r, g, b, and a (alpha), with each component being in the range 0.0 to 1.0.
  *
  * @example
- * <div modernizr='webgl'>
- * <code>
  * // A filter shader (using p5.strands) which will
  * // sample and invert the color of each pixel
  * // from the canvas.
@@ -813,12 +808,8 @@ if (typeof p5 !== "undefined") {
  *
  *   filterColor.end();
  * }
- * </code>
- *
  *
  * @example
- * <div modernizr='webgl'>
- * <code>
  * // This primitive edge-detection filter samples
  * // and compares the colors of the current pixel
  * // on the canvas, and a little to the right.
@@ -875,8 +866,6 @@ if (typeof p5 !== "undefined") {
  *   rotate(frameCount / 300);
  *   square(0, 0, 30);
  * }
- * </code>
- * </div>
  */
 
 /**

package/dist/strands/strands_api.js

@@ -1,4 +1,4 @@
-import { u as unaryOpNode, c as createStrandsNode, s as statementNode, v as variableNode, S as StrandsNode, p as primitiveConstructorNode, f as functionCallNode, a as structInstanceNode, b as structConstructorNode, d as binaryOpNode } from '../ir_builders-w12-GSxu.js';
+import { u as unaryOpNode, c as createStrandsNode, S as StrandsNode, p as primitiveConstructorNode, v as variableNode, b as binaryOpNode, s as statementNode, f as functionCallNode, a as structInstanceNode, d as structConstructorNode } from '../ir_builders-Cd6rU9Vm.js';
 import { OperatorTable, StatementType, NodeType, DataType, BaseType, BlockType, isStructType, structType } from './ir_types.js';
 import { strandsBuiltinFunctions } from './strands_builtins.js';
 import { StrandsConditional } from './strands_conditionals.js';
@@ -101,6 +101,42 @@ function installBuiltinGlobalAccessors(strandsContext) {
   strandsContext._builtinGlobalsAccessorsInstalled = true;
 }
 
+//////////////////////////////////////////////
+// Prototype mirroring helpers
+//////////////////////////////////////////////
+
+/*
+ * Permanently augment both p5.prototype (fn) and p5.Graphics.prototype
+ * with a strands function. Overwrites unconditionally - strands wrappers
+ * are the correct dual mode implementation.
+ */
+function augmentFn(fn, p5, name, value) {
+  fn[name] = value;
+  const GraphicsProto = p5?.Graphics?.prototype;
+  if (GraphicsProto) {
+    GraphicsProto[name] = value;
+  }
+}
+
+/*
+ * Temporarily augment window, p5.prototype (fn), and p5.Graphics.prototype
+ * with a hook function. Saves previous values into strandsContext override
+ * stores so deinitStrandsContext can restore them.
+ */
+function augmentFnTemporary(fn, strandsContext, name, value) {
+  strandsContext.windowOverrides[name] = window[name];
+  strandsContext.fnOverrides[name] = fn[name];
+  window[name] = value;
+  fn[name] = value;
+  const GraphicsProto = strandsContext.p5?.Graphics?.prototype;
+  if (GraphicsProto) {
+    strandsContext.graphicsOverrides[name] = Object.prototype.hasOwnProperty.call(GraphicsProto, name)
+      ? GraphicsProto[name]
+      : undefined;
+    GraphicsProto[name] = value;
+  }
+}
+
 //////////////////////////////////////////////
 // User nodes
 //////////////////////////////////////////////
@@ -124,27 +160,27 @@ function initGlobalStrandsAPI(p5, fn, strandsContext) {
   //////////////////////////////////////////////
   // Unique Functions
   //////////////////////////////////////////////
-  fn.discard = function() {
+  augmentFn(fn, p5, 'discard', function() {
     statementNode(strandsContext, StatementType.DISCARD);
-  };
-  fn.break = function() {
+  });
+  augmentFn(fn, p5, 'break', function() {
     statementNode(strandsContext, StatementType.BREAK);
-  };
+  });
   p5.break = fn.break;
-  fn.instanceID = function() {
+  augmentFn(fn, p5, 'instanceID', function() {
     const node = variableNode(strandsContext, { baseType: BaseType.INT, dimension: 1 }, strandsContext.backend.instanceIdReference());
     return createStrandsNode(node.id, node.dimension, strandsContext);
-  };
+  });
   // Internal methods use p5 static methods; user-facing methods use fn.
   // Some methods need to be used by both.
   p5.strandsIf = function(conditionNode, ifBody) {
     return new StrandsConditional(strandsContext, conditionNode, ifBody);
   };
-  fn.strandsIf = p5.strandsIf;
+  augmentFn(fn, p5, 'strandsIf', p5.strandsIf);
   p5.strandsFor = function(initialCb, conditionCb, updateCb, bodyCb, initialVars) {
     return new StrandsFor(strandsContext, initialCb, conditionCb, updateCb, bodyCb, initialVars).build();
   };
-  fn.strandsFor = p5.strandsFor;
+  augmentFn(fn, p5, 'strandsFor', p5.strandsFor);
   p5.strandsEarlyReturn = function(value) {
     const { dag, cfg } = strandsContext;
 
@@ -177,7 +213,7 @@ function initGlobalStrandsAPI(p5, fn, strandsContext) {
 
     return valueNode;
   };
-  fn.strandsEarlyReturn = p5.strandsEarlyReturn;
+  augmentFn(fn, p5, 'strandsEarlyReturn', p5.strandsEarlyReturn);
   p5.strandsNode = function(...args) {
     if (args.length === 1 && args[0] instanceof StrandsNode) {
       return args[0];
@@ -185,7 +221,20 @@ function initGlobalStrandsAPI(p5, fn, strandsContext) {
     if (args.length > 4) {
       userError("type error", "It looks like you've tried to construct a p5.strands node implicitly, with more than 4 components. This is currently not supported.");
     }
-    const { id, dimension } = primitiveConstructorNode(strandsContext, { baseType: BaseType.FLOAT, dimension: null }, args.flat());
+    // Filter out undefined/null values
+    const flatArgs = args.flat();
+    const definedArgs = flatArgs.filter(a => a !== undefined && a !== null);
+
+    // If all args are undefined, this is likely a `let myVar` at the
+    // start of an if statement and it will be assigned within the branches.
+    // For that, we use an assign-on-use node, meaning we'll take the type of the
+    // values assigned to it.
+    if (definedArgs.length === 0) {
+      const { id, dimension } = primitiveConstructorNode(strandsContext, { baseType: BaseType.ASSIGN_ON_USE, dimension: null }, [0]);
+      return createStrandsNode(id, dimension, strandsContext);
+    }
+
+    const { id, dimension } = primitiveConstructorNode(strandsContext, { baseType: BaseType.FLOAT, dimension: null }, definedArgs);
     return createStrandsNode(id, dimension, strandsContext);//new StrandsNode(id, dimension, strandsContext);
   };
   //////////////////////////////////////////////
@@ -195,16 +244,16 @@ function initGlobalStrandsAPI(p5, fn, strandsContext) {
     const isp5Function = overrides[0].isp5Function;
     if (isp5Function) {
       const originalFn = fn[functionName];
-      fn[functionName] = function(...args) {
+      augmentFn(fn, p5, functionName, function(...args) {
         if (strandsContext.active) {
           const { id, dimension } =  functionCallNode(strandsContext, functionName, args);
           return createStrandsNode(id, dimension, strandsContext);
         } else {
           return originalFn.apply(this, args);
         }
-      };
+      });
     } else {
-      fn[functionName] = function (...args) {
+      augmentFn(fn, p5, functionName, function (...args) {
         if (strandsContext.active) {
           const { id, dimension } = functionCallNode(strandsContext, functionName, args);
           return createStrandsNode(id, dimension, strandsContext);
@@ -213,11 +262,11 @@ function initGlobalStrandsAPI(p5, fn, strandsContext) {
             `It looks like you've called ${functionName} outside of a shader's modify() function.`
           );
         }
-      };
+      });
     }
   }
 
-  fn.getTexture = function (...rawArgs) {
+  augmentFn(fn, p5, 'getTexture', function (...rawArgs) {
     if (strandsContext.active) {
       const { id, dimension } = strandsContext.backend.createGetTextureCall(strandsContext, rawArgs);
       return createStrandsNode(id, dimension, strandsContext);
@@ -226,17 +275,17 @@ function initGlobalStrandsAPI(p5, fn, strandsContext) {
         `It looks like you've called getTexture outside of a shader's modify() function.`
       );
     }
-  };
+  });
 
   // Add texture function as alias for getTexture with p5 fallback
   const originalTexture = fn.texture;
-  fn.texture = function (...args) {
+  augmentFn(fn, p5, 'texture', function (...args) {
     if (strandsContext.active) {
       return this.getTexture(...args);
     } else {
       return originalTexture.apply(this, args);
     }
-  };
+  });
 
   // Add noise function with backend-agnostic implementation
   const originalNoise = fn.noise;
@@ -246,16 +295,16 @@ function initGlobalStrandsAPI(p5, fn, strandsContext) {
   strandsContext._noiseOctaves = null;
   strandsContext._noiseAmpFalloff = null;
 
-  fn.noiseDetail = function (lod, falloff = 0.5) {
+  augmentFn(fn, p5, 'noiseDetail', function (lod, falloff = 0.5) {
     if (!strandsContext.active) {
       return originalNoiseDetail.apply(this, arguments);
     }
 
     strandsContext._noiseOctaves = lod;
     strandsContext._noiseAmpFalloff = falloff;
-  };
+  });
 
-  fn.noise = function (...args) {
+  augmentFn(fn, p5, 'noise', function (...args) {
     if (!strandsContext.active) {
       return originalNoise.apply(this, args); // fallback to regular p5.js noise
     }
@@ -302,9 +351,9 @@ function initGlobalStrandsAPI(p5, fn, strandsContext) {
       }]
     });
     return createStrandsNode(id, dimension, strandsContext);
-  };
+  });
 
-  fn.millis = function (...args) {
+  augmentFn(fn, p5, 'millis', function (...args) {
     if (!strandsContext.active) {
       return originalMillis.apply(this, args);
     }
@@ -317,14 +366,14 @@ function initGlobalStrandsAPI(p5, fn, strandsContext) {
         return instance ? instance.millis() : undefined;
       }
     );
-  };
+  });
 
   // Next is type constructors and uniform functions.
   // For some of them, we have aliases so that you can write either a more human-readable
   // variant or also one more directly translated from GLSL, or to be more compatible with
   // APIs we documented at the release of 2.x and have to continue supporting.
   for (const type in DataType) {
-    if (type === BaseType.DEFER || type === 'sampler') {
+    if (type === BaseType.DEFER || type === BaseType.ASSIGN_ON_USE || type === 'sampler') {
       continue;
     }
     const typeInfo = DataType[type];
@@ -346,13 +395,13 @@ function initGlobalStrandsAPI(p5, fn, strandsContext) {
         typeAliases.push(pascalTypeName.replace('Vec', 'Vector'));
       }
     }
-    fn[`uniform${pascalTypeName}`] = function(name, defaultValue) {
+    augmentFn(fn, p5, `uniform${pascalTypeName}`, function(name, defaultValue) {
       const { id, dimension } = variableNode(strandsContext, typeInfo, name);
       strandsContext.uniforms.push({ name, typeInfo, defaultValue });
       return createStrandsNode(id, dimension, strandsContext);
-    };
+    });
     // Shared variables with smart context detection
-    fn[`shared${pascalTypeName}`] = function(name) {
+    augmentFn(fn, p5, `shared${pascalTypeName}`, function(name) {
       const { id, dimension } = variableNode(strandsContext, typeInfo, name);
 
       // Initialize shared variables tracking if not present
@@ -365,24 +414,23 @@ function initGlobalStrandsAPI(p5, fn, strandsContext) {
         typeInfo,
         usedInVertex: false,
         usedInFragment: false,
-        declared: false
       });
 
       return createStrandsNode(id, dimension, strandsContext);
-    };
+    });
 
     // Alias varying* as shared* for backward compatibility
-    fn[`varying${pascalTypeName}`] = fn[`shared${pascalTypeName}`];
+    augmentFn(fn, p5, `varying${pascalTypeName}`, fn[`shared${pascalTypeName}`]);
 
     for (const typeAlias of typeAliases) {
       // For compatibility, also alias uniformVec2 as uniformVector2, what we initially
       // documented these as
-      fn[`uniform${typeAlias}`] = fn[`uniform${pascalTypeName}`];
-      fn[`varying${typeAlias}`] = fn[`varying${pascalTypeName}`];
-      fn[`shared${typeAlias}`] = fn[`shared${pascalTypeName}`];
+      augmentFn(fn, p5, `uniform${typeAlias}`, fn[`uniform${pascalTypeName}`]);
+      augmentFn(fn, p5, `varying${typeAlias}`, fn[`varying${pascalTypeName}`]);
+      augmentFn(fn, p5, `shared${typeAlias}`, fn[`shared${pascalTypeName}`]);
     }
     const originalp5Fn = fn[typeInfo.fnName];
-    fn[typeInfo.fnName] = function(...args) {
+    augmentFn(fn, p5, typeInfo.fnName, function(...args) {
       if (strandsContext.active) {
         if (args.length === 1 && args[0].dimension && args[0].dimension === typeInfo.dimension) {
           const { id, dimension } = functionCallNode(
@@ -414,7 +462,7 @@ function initGlobalStrandsAPI(p5, fn, strandsContext) {
           `It looks like you've called ${typeInfo.fnName} outside of a shader's modify() function.`
         );
       }
-    };
+    });
   }
 }
 //////////////////////////////////////////////
@@ -695,10 +743,7 @@ function createShaderHooksFunctions(strandsContext, fn, shader) {
     }
 
     for (const name of aliases) {
-      strandsContext.windowOverrides[name] = window[name];
-      strandsContext.fnOverrides[name] = fn[name];
-      window[name] = hook;
-      fn[name] = hook;
+      augmentFnTemporary(fn, strandsContext, name, hook);
     }
     hook.earlyReturns = [];
   }

package/dist/strands/strands_codegen.js

@@ -47,18 +47,6 @@ function generateShaderCode(strandsContext) {
       backend.generateBlock(blockID, strandsContext, generationContext);
     }
 
-    // Process any unvisited global assignments to ensure side effects are generated
-    for (const assignmentNodeID of strandsContext.globalAssignments) {
-      if (!generationContext.visitedNodes.has(assignmentNodeID)) {
-        // This assignment hasn't been visited yet, so we need to generate it
-        backend.generateAssignment(generationContext, strandsContext.dag, assignmentNodeID);
-        generationContext.visitedNodes.add(assignmentNodeID);
-      }
-    }
-
-    // Reset global assignments for next hook
-    strandsContext.globalAssignments = [];
-
     const firstLine = backend.hookEntry(hookType);
     let returnType;
     if (hookType.returnType.properties) {

package/dist/strands/strands_conditionals.js

@@ -1,7 +1,7 @@
 import { createBasicBlock, addEdge, pushBlock, popBlock, pushBlockForModification, recordInBasicBlock } from './ir_cfg.js';
 import { getOrCreateNode } from './ir_dag.js';
 import { BlockType, NodeType } from './ir_types.js';
-import { c as createStrandsNode } from '../ir_builders-w12-GSxu.js';
+import { c as createStrandsNode } from '../ir_builders-Cd6rU9Vm.js';
 import { createPhiNode } from './strands_phi_utils.js';
 import './strands_FES.js';
 import './strands_builtins.js';

package/dist/strands/strands_for.js

@@ -1,7 +1,7 @@
 import { createBasicBlock, addEdge, pushBlock, popBlock, pushBlockForModification, recordInBasicBlock } from './ir_cfg.js';
 import { getNodeDataFromID, createNodeData, getOrCreateNode } from './ir_dag.js';
 import { BlockType, NodeType, StatementType, OpCode, BaseType } from './ir_types.js';
-import { c as createStrandsNode, p as primitiveConstructorNode } from '../ir_builders-w12-GSxu.js';
+import { c as createStrandsNode, p as primitiveConstructorNode } from '../ir_builders-Cd6rU9Vm.js';
 import { createPhiNode } from './strands_phi_utils.js';
 import './strands_FES.js';
 import './strands_builtins.js';

package/dist/strands/strands_node.js

@@ -1,4 +1,4 @@
-export { S as StrandsNode, c as createStrandsNode } from '../ir_builders-w12-GSxu.js';
+export { S as StrandsNode, c as createStrandsNode } from '../ir_builders-Cd6rU9Vm.js';
 import './ir_types.js';
 import './ir_dag.js';
 import './ir_cfg.js';

package/dist/strands/strands_phi_utils.js

@@ -1,6 +1,6 @@
 import { recordInBasicBlock } from './ir_cfg.js';
-import { getNodeDataFromID, getOrCreateNode } from './ir_dag.js';
-import { NodeType } from './ir_types.js';
+import { getNodeDataFromID, propagateTypeToAssignOnUse, getOrCreateNode } from './ir_dag.js';
+import { BaseType, NodeType } from './ir_types.js';
 import './strands_FES.js';
 
 function createPhiNode(strandsContext, phiInputs, varName) {
@@ -9,13 +9,31 @@ function createPhiNode(strandsContext, phiInputs, varName) {
   if (validInputs.length === 0) {
     throw new Error(`No valid inputs for phi node for variable ${varName}`);
   }
-  // Get dimension and baseType from first valid input
-  let firstInput = validInputs
-    .map((input) => getNodeDataFromID(strandsContext.dag, input.value.id))
-    .find((input) => input.dimension) ??
-      getNodeDataFromID(strandsContext.dag, validInputs[0].value.id);
-  const dimension = firstInput.dimension;
-  const baseType = firstInput.baseType;
+
+  // Get dimension and baseType from first valid input, skipping ASSIGN_ON_USE nodes
+  const inputNodes = validInputs.map((input) => getNodeDataFromID(strandsContext.dag, input.value.id));
+
+  // Find first non-ASSIGN_ON_USE input to determine type
+  let typeSource = inputNodes.find((input) => input.baseType !== BaseType.ASSIGN_ON_USE && input.dimension) ??
+    inputNodes.find((input) => input.baseType !== BaseType.ASSIGN_ON_USE);
+
+  // If all are ASSIGN_ON_USE, fall back to first input
+  if (!typeSource) {
+    typeSource = inputNodes[0];
+  }
+
+  const dimension = typeSource.dimension;
+  const baseType = typeSource.baseType;
+
+  // Propagate the type to all ASSIGN_ON_USE inputs
+  if (baseType !== BaseType.ASSIGN_ON_USE) {
+    for (const input of inputNodes) {
+      if (input.baseType === BaseType.ASSIGN_ON_USE) {
+        propagateTypeToAssignOnUse(strandsContext.dag, input.id, baseType, dimension);
+      }
+    }
+  }
+
   const nodeData = {
     nodeType: NodeType.PHI,
     dimension,