p5 2.2.1 → 2.2.2-rc.0

package/dist/{ir_builders-DXNgaB9N.js → ir_builders-w12-GSxu.js}

@@ -42,7 +42,7 @@ class StrandsNode {
     const baseType = orig?.baseType ?? BaseType.FLOAT;
 
     let newValueID;
-    if (value instanceof StrandsNode) {
+    if (value?.isStrandsNode) {
       newValueID = value.id;
     } else {
       const newVal = primitiveConstructorNode(
@@ -97,7 +97,7 @@ class StrandsNode {
     const baseType = orig?.baseType ?? BaseType.FLOAT;
 
     let newValueID;
-    if (value instanceof StrandsNode) {
+    if (value?.isStrandsNode) {
       newValueID = value.id;
     } else {
       const newVal = primitiveConstructorNode(
@@ -215,7 +215,7 @@ function unaryOpNode(strandsContext, nodeOrValue, opCode) {
   const { dag, cfg } = strandsContext;
   let dependsOn;
   let node;
-  if (nodeOrValue instanceof StrandsNode) {
+  if (nodeOrValue?.isStrandsNode) {
     node = nodeOrValue;
   } else {
     const { id, dimension } = primitiveConstructorNode(strandsContext, { baseType: BaseType.FLOAT, dimension: null }, nodeOrValue);
@@ -429,6 +429,20 @@ function constructTypeFromIDs(strandsContext, typeInfo, strandsNodesArray) {
 
 function primitiveConstructorNode(strandsContext, typeInfo, dependsOn) {
   const cfg = strandsContext.cfg;
+  dependsOn = (Array.isArray(dependsOn) ? dependsOn : [dependsOn])
+    .flat(Infinity)
+    .map(a => {
+      if (
+        a.isStrandsNode &&
+        a.typeInfo().baseType === BaseType.INT &&
+        // TODO: handle ivec inputs instead of just int scalars
+        a.typeInfo().dimension === 1
+      ) {
+        return castToFloat(strandsContext, a);
+      } else {
+        return a;
+      }
+    });
   const { mappedDependencies, inferredTypeInfo } = mapPrimitiveDepsToIDs(strandsContext, typeInfo, dependsOn);
 
   const finalType = {
@@ -444,6 +458,24 @@ function primitiveConstructorNode(strandsContext, typeInfo, dependsOn) {
   return { id, dimension: finalType.dimension, components: mappedDependencies };
 }
 
+function castToFloat(strandsContext, dep) {
+  const { id, dimension } = functionCallNode(
+    strandsContext,
+    strandsContext.backend.getTypeName('float', dep.typeInfo().dimension),
+    [dep],
+    {
+      overloads: [{
+        params: [dep.typeInfo()],
+        returnType: {
+          ...dep.typeInfo(),
+          baseType: BaseType.FLOAT,
+        },
+      }],
+    }
+  );
+  return createStrandsNode(id, dimension, strandsContext);
+}
+
 function structConstructorNode(strandsContext, structTypeInfo, rawUserArgs) {
   const { cfg, dag } = strandsContext;
   const { identifer, properties } = structTypeInfo;
@@ -663,7 +695,7 @@ function swizzleTrap(id, dimension, strandsContext, onRebind) {
       // This may not be the most efficient way, as we swizzle each component individually,
       // so that .xyz becomes .x, .y, .z
       let scalars = [];
-      if (value instanceof StrandsNode) {
+      if (value?.isStrandsNode) {
         if (value.dimension === 1) {
           scalars = Array(chars.length).fill(value);
         } else if (value.dimension === chars.length) {
@@ -722,4 +754,4 @@ function swizzleTrap(id, dimension, strandsContext, onRebind) {
   return trap;
 }
 
-export { StrandsNode as S, structInstanceNode as a, structConstructorNode as b, createStrandsNode as c, binaryOpNode as d, scalarLiteralNode as e, functionCallNode as f, constructTypeFromIDs as g, swizzleNode as h, swizzleTrap as i, memberAccessNode as m, primitiveConstructorNode as p, statementNode as s, unaryOpNode as u, variableNode as v };
+export { StrandsNode as S, structInstanceNode as a, structConstructorNode as b, createStrandsNode as c, binaryOpNode as d, scalarLiteralNode as e, functionCallNode as f, constructTypeFromIDs as g, castToFloat as h, swizzleNode as i, swizzleTrap as j, memberAccessNode as m, primitiveConstructorNode as p, statementNode as s, unaryOpNode as u, variableNode as v };

package/dist/{main-DvN69W3f.js → main-C5AeICIY.js}

@@ -1,9 +1,9 @@
-import { P as P2D, ac as WEBGL, B as BLEND, al as _DEFAULT_FILL, am as _DEFAULT_STROKE, w as ROUND, b as REMOVE, S as SUBTRACT, D as DARKEST, L as LIGHTEST, an as DIFFERENCE, M as MULTIPLY, E as EXCLUSION, a as SCREEN, R as REPLACE, ao as OVERLAY, ap as HARD_LIGHT, aq as SOFT_LIGHT, ar as DODGE, as as BURN, A as ADD, at as PIE, au as CHORD, q as TWO_PI, x as SQUARE, y as PROJECT, z as BEVEL, I as MITER, a9 as RIGHT, v as CENTER, av as LEFT, aw as BOTTOM, ax as BASELINE, ay as TOP, Q as OPEN, az as VERSION, a3 as constants } from './constants-DQyACdzq.js';
+import { P as P2D, ac as WEBGL, B as BLEND, al as _DEFAULT_FILL, am as _DEFAULT_STROKE, w as ROUND, b as REMOVE, S as SUBTRACT, D as DARKEST, L as LIGHTEST, an as DIFFERENCE, M as MULTIPLY, E as EXCLUSION, a as SCREEN, R as REPLACE, ao as OVERLAY, ap as HARD_LIGHT, aq as SOFT_LIGHT, ar as DODGE, as as BURN, A as ADD, at as PIE, au as CHORD, q as TWO_PI, x as SQUARE, y as PROJECT, z as BEVEL, I as MITER, a9 as RIGHT, v as CENTER, av as LEFT, aw as BOTTOM, ax as BASELINE, ay as TOP, Q as OPEN, az as VERSION, a3 as constants } from './constants-D3npMLOW.js';
 import transform from './core/transform.js';
 import structure from './core/structure.js';
 import environment from './core/environment.js';
-import { G as Graphics, k as rendering, n as graphics } from './rendering-h9unX5K0.js';
-import { R as Renderer, I as Image, r as renderer } from './p5.Renderer-D-5LdCRz.js';
+import { G as Graphics, k as rendering, n as graphics } from './rendering-B8po3Onj.js';
+import { R as Renderer, I as Image, r as renderer } from './p5.Renderer-xpFkUQC6.js';
 import { Element } from './dom/p5.Element.js';
 import { MediaElement } from './dom/p5.MediaElement.js';
 import { b as RGBHDR } from './creating_reading-ZXzcZEsb.js';

package/dist/math/Matrices/Matrix.js

@@ -1,6 +1,6 @@
 import { Vector } from '../p5.Vector.js';
 import { MatrixInterface } from './MatrixInterface.js';
-import '../../constants-DQyACdzq.js';
+import '../../constants-D3npMLOW.js';
 
 /**
  * @module Math

package/dist/math/Matrices/MatrixNumjs.js

@@ -1,7 +1,7 @@
 import nj from '@d4c/numjs/build/module/numjs.min.js';
 import { Vector } from '../p5.Vector.js';
 import { MatrixInterface } from './MatrixInterface.js';
-import '../../constants-DQyACdzq.js';
+import '../../constants-D3npMLOW.js';
 
 let isMatrixArray = x => Array.isArray(x);
 if (typeof Float32Array !== 'undefined') {

package/dist/math/index.js

@@ -4,7 +4,7 @@ import random from './random.js';
 import trigonometry from './trigonometry.js';
 import math$1 from './math.js';
 import vector from './p5.Vector.js';
-import '../constants-DQyACdzq.js';
+import '../constants-D3npMLOW.js';
 
 function math(p5){
   p5.registerAddon(calculation);

package/dist/math/p5.Matrix.js

@@ -1,6 +1,6 @@
 import { Matrix } from './Matrices/Matrix.js';
 import './p5.Vector.js';
-import '../constants-DQyACdzq.js';
+import '../constants-D3npMLOW.js';
 import './Matrices/MatrixInterface.js';
 
 /**

package/dist/math/p5.Vector.js

@@ -1,4 +1,4 @@
-import { q as TWO_PI } from '../constants-DQyACdzq.js';
+import { q as TWO_PI } from '../constants-D3npMLOW.js';
 
 /**
  * @module Math

package/dist/math/trigonometry.js

@@ -1,4 +1,4 @@
-import { a5 as RAD_TO_DEG, a6 as DEG_TO_RAD } from '../constants-DQyACdzq.js';
+import { a5 as RAD_TO_DEG, a6 as DEG_TO_RAD } from '../constants-D3npMLOW.js';
 
 /**
  * @module Math

package/dist/{p5.Renderer-D-5LdCRz.js → p5.Renderer-xpFkUQC6.js}

@@ -1,5 +1,5 @@
 import { C as Color } from './creating_reading-ZXzcZEsb.js';
-import { a2 as NORMAL, aA as WORD, ax as BASELINE, av as LEFT, v as CENTER, p as CORNER, J as INCLUDE } from './constants-DQyACdzq.js';
+import { a2 as NORMAL, aA as WORD, ax as BASELINE, av as LEFT, v as CENTER, p as CORNER, J as INCLUDE } from './constants-D3npMLOW.js';
 import Filters from './image/filters.js';
 import { Vector } from './math/p5.Vector.js';
 import { Shape } from './shape/custom_shapes.js';

package/dist/{rendering-h9unX5K0.js → rendering-B8po3Onj.js}

@@ -1,7 +1,7 @@
-import { p as CORNER, t as CORNERS, v as CENTER, aB as COVER, aC as CONTAIN, a9 as RIGHT, aw as BOTTOM, B as BLEND, aD as FILL, ad as IMAGE, C as CLAMP, w as ROUND, Y as LINES, X as POINTS, c as TRIANGLES, ab as BLUR, D as DARKEST, L as LIGHTEST, A as ADD, S as SUBTRACT, a as SCREEN, E as EXCLUSION, R as REPLACE, M as MULTIPLY, b as REMOVE, as as BURN, ao as OVERLAY, ap as HARD_LIGHT, aq as SOFT_LIGHT, ar as DODGE, d as UNSIGNED_INT, U as UNSIGNED_BYTE, av as LEFT, ax as BASELINE, ay as TOP, aE as SIMPLE, aF as FULL, q as TWO_PI, Q as OPEN, a2 as NORMAL, V as CLOSE, at as PIE, au as CHORD, h as TEXTURE, P as P2D, g as LINEAR, aa as WEBGL2, N as NEAREST, aG as LINEAR_MIPMAP, f as REPEAT, e as MIRROR, F as FLOAT, ac as WEBGL, H as HALF_FLOAT } from './constants-DQyACdzq.js';
+import { p as CORNER, t as CORNERS, v as CENTER, aB as COVER, aC as CONTAIN, a9 as RIGHT, aw as BOTTOM, B as BLEND, aD as FILL, ad as IMAGE, C as CLAMP, w as ROUND, Y as LINES, X as POINTS, c as TRIANGLES, ab as BLUR, D as DARKEST, L as LIGHTEST, A as ADD, S as SUBTRACT, a as SCREEN, E as EXCLUSION, R as REPLACE, M as MULTIPLY, b as REMOVE, as as BURN, ao as OVERLAY, ap as HARD_LIGHT, aq as SOFT_LIGHT, ar as DODGE, d as UNSIGNED_INT, U as UNSIGNED_BYTE, av as LEFT, ax as BASELINE, ay as TOP, aE as SIMPLE, aF as FULL, q as TWO_PI, Q as OPEN, a2 as NORMAL, V as CLOSE, at as PIE, au as CHORD, h as TEXTURE, P as P2D, g as LINEAR, aa as WEBGL2, N as NEAREST, aG as LINEAR_MIPMAP, f as REPEAT, e as MIRROR, F as FLOAT, ac as WEBGL, H as HALF_FLOAT } from './constants-D3npMLOW.js';
 import { C as Color, c as creatingReading, h as RGBA, R as RGB } from './creating_reading-ZXzcZEsb.js';
 import { Element } from './dom/p5.Element.js';
-import { R as Renderer, I as Image } from './p5.Renderer-D-5LdCRz.js';
+import { R as Renderer, I as Image } from './p5.Renderer-xpFkUQC6.js';
 import { MediaElement } from './dom/p5.MediaElement.js';
 import primitives from './shape/2d_primitives.js';
 import attributes from './shape/attributes.js';
@@ -15104,6 +15104,40 @@ function material(p5, fn) {
    * }
    * ```
    *
+   * We can use the `noise()` function built into strands to generate a color for each pixel.  (Again no need here for underlying content for the filter to operate on.)  Again we'll animate by passing in an announced uniform variable  `time` with `setUniform()`, each frame.
+   *
+   * ```js example
+   * let myFilter;
+   *
+   * function setup() {
+   *   createCanvas(100, 100, WEBGL);
+   *   myFilter = buildFilterShader(noiseShaderCallback);
+   *   describe('Evolving animated cloud-like noise in cyan and magenta');
+   * }
+   *
+   * function noiseShaderCallback() {
+   *   let time = uniformFloat();
+   *   filterColor.begin();
+   *   let coord = filterColor.texCoord;
+   *
+   *   //generate a value roughly between 0 and 1
+   *   let noiseVal = noise(coord.x, coord.y, time / 2000);
+   *
+   *   let result = mix(
+   *     [1, 0, 1, 1], // Magenta
+   *     [0, 1, 1, 1], // Cyan
+   *     noiseVal
+   *   );
+   *   filterColor.set(result);
+   *   filterColor.end();
+   * }
+   *
+   * function draw() {
+   *   myFilter.setUniform("time", millis());
+   *   filter(myFilter);
+   * }
+   * ```
+   *
    * Like the `modify()` method on shaders,
    * advanced users can also fill in `filterColor` using <a href="https://developer.mozilla.org/en-US/docs/Games/Techniques/3D_on_the_web/GLSL_Shaders" target="_blank">GLSL</a>
    * instead of JavaScript.
@@ -15118,15 +15152,17 @@ function material(p5, fn) {
    * @beta
    * @submodule p5.strands
    * @param {Function} callback A function building a p5.strands shader.
+   * @param {Object} [scope] An optional scope object passed to .modify().
    * @returns {p5.Shader} The material shader
    */
   /**
    * @method buildFilterShader
    * @param {Object} hooks An object specifying p5.strands hooks in GLSL.
+   * @param {Object} [scope] An optional scope object passed to .modify().
    * @returns {p5.Shader} The material shader
    */
-  fn.buildFilterShader = function (callback) {
-    return this.baseFilterShader().modify(callback);
+  fn.buildFilterShader = function (callback, scope) {
+    return this.baseFilterShader().modify(callback, scope);
   };
 
   /**
@@ -15946,15 +15982,17 @@ function material(p5, fn) {
    * @submodule p5.strands
    * @beta
    * @param {Function} callback A function building a p5.strands shader.
+   * @param {Object} [scope] An optional scope object passed to .modify().
    * @returns {p5.Shader} The material shader.
    */
   /**
    * @method buildMaterialShader
    * @param {Object} hooks An object specifying p5.strands hooks in GLSL.
+   * @param {Object} [scope] An optional scope object passed to .modify().
    * @returns {p5.Shader} The material shader.
    */
-  fn.buildMaterialShader = function (cb) {
-    return this.baseMaterialShader().modify(cb);
+  fn.buildMaterialShader = function (cb, scope) {
+    return this.baseMaterialShader().modify(cb, scope);
   };
 
   /**
@@ -16053,7 +16091,7 @@ function material(p5, fn) {
   /**
    * Returns the base shader used for filters.
    *
-   * Calling <a href="#/p5/buildMaterialShader">`buildFilterShader(shaderFunction)`</a>
+   * Calling <a href="#/p5/buildFilterShader">`buildFilterShader(shaderFunction)`</a>
    * is equivalent to calling `baseFilterShader().modify(shaderFunction)`.
    *
    * Read <a href="#/p5/buildFilterShader">the `buildFilterShader` reference</a> or
@@ -16162,15 +16200,17 @@ function material(p5, fn) {
    * @submodule p5.strands
    * @beta
    * @param {Function} callback A function building a p5.strands shader.
+   * @param {Object} [scope] An optional scope object passed to .modify().
    * @returns {p5.Shader} The normal shader.
    */
   /**
    * @method buildNormalShader
    * @param {Object} hooks An object specifying p5.strands hooks in GLSL.
+   * @param {Object} [scope] An optional scope object passed to .modify().
    * @returns {p5.Shader} The normal shader.
    */
-  fn.buildNormalShader = function (cb) {
-    return this.baseNormalShader().modify(cb);
+  fn.buildNormalShader = function (cb, scope) {
+    return this.baseNormalShader().modify(cb, scope);
   };
 
   /**
@@ -16326,15 +16366,17 @@ function material(p5, fn) {
    * @submodule p5.strands
    * @beta
    * @param {Function} callback A function building a p5.strands shader.
+   * @param {Object} [scope] An optional scope object passed to .modify().
    * @returns {p5.Shader} The color shader.
    */
   /**
    * @method buildColorShader
    * @param {Object} hooks An object specifying p5.strands hooks in GLSL.
+   * @param {Object} [scope] An optional scope object passed to .modify().
    * @returns {p5.Shader} The color shader.
    */
-  fn.buildColorShader = function (cb) {
-    return this.baseColorShader().modify(cb);
+  fn.buildColorShader = function (cb, scope) {
+    return this.baseColorShader().modify(cb, scope);
   };
 
   /**
@@ -16581,15 +16623,17 @@ function material(p5, fn) {
    * @submodule p5.strands
    * @beta
    * @param {Function} callback A function building a p5.strands shader.
+   * @param {Object} [scope] An optional scope object passed to .modify().
    * @returns {p5.Shader} The stroke shader.
    */
   /**
    * @method buildStrokeShader
    * @param {Object} hooks An object specifying p5.strands hooks in GLSL.
+   * @param {Object} [scope] An optional scope object passed to .modify().
    * @returns {p5.Shader} The stroke shader.
    */
-  fn.buildStrokeShader = function (cb) {
-    return this.baseStrokeShader().modify(cb);
+  fn.buildStrokeShader = function (cb, scope) {
+    return this.baseStrokeShader().modify(cb, scope);
   };
 
   /**

package/dist/shape/2d_primitives.js

@@ -1,4 +1,4 @@
-import { p as CORNER, q as TWO_PI, r as HALF_PI, s as PI } from '../constants-DQyACdzq.js';
+import { p as CORNER, q as TWO_PI, r as HALF_PI, s as PI } from '../constants-D3npMLOW.js';
 import canvas from '../core/helpers.js';
 
 /**

package/dist/shape/attributes.js

@@ -1,4 +1,4 @@
-import { p as CORNER, t as CORNERS, u as RADIUS, v as CENTER, w as ROUND, x as SQUARE, y as PROJECT, z as BEVEL, I as MITER } from '../constants-DQyACdzq.js';
+import { p as CORNER, t as CORNERS, u as RADIUS, v as CENTER, w as ROUND, x as SQUARE, y as PROJECT, z as BEVEL, I as MITER } from '../constants-D3npMLOW.js';
 
 /**
  * @module Shape

package/dist/shape/custom_shapes.js

@@ -1,6 +1,6 @@
 import { C as Color } from '../creating_reading-ZXzcZEsb.js';
 import { Vector } from '../math/p5.Vector.js';
-import { J as INCLUDE, K as PATH, O as EMPTY_PATH, Q as OPEN, V as CLOSE, X as POINTS, Y as LINES, c as TRIANGLES, Z as QUADS, _ as TRIANGLE_FAN, T as TRIANGLE_STRIP, $ as QUAD_STRIP, a0 as EXCLUDE, a1 as JOIN } from '../constants-DQyACdzq.js';
+import { J as INCLUDE, K as PATH, O as EMPTY_PATH, Q as OPEN, V as CLOSE, X as POINTS, Y as LINES, c as TRIANGLES, Z as QUADS, _ as TRIANGLE_FAN, T as TRIANGLE_STRIP, $ as QUAD_STRIP, a0 as EXCLUDE, a1 as JOIN } from '../constants-D3npMLOW.js';
 import 'colorjs.io/fn';
 import '../color/color_spaces/hsb.js';
 

package/dist/shape/index.js

@@ -3,7 +3,7 @@ import attributes from './attributes.js';
 import curves from './curves.js';
 import vertex from './vertex.js';
 import customShapes from './custom_shapes.js';
-import '../constants-DQyACdzq.js';
+import '../constants-D3npMLOW.js';
 import '../core/helpers.js';
 import '../creating_reading-ZXzcZEsb.js';
 import 'colorjs.io/fn';

package/dist/strands/ir_builders.js

@@ -2,5 +2,5 @@ import './ir_dag.js';
 import './ir_cfg.js';
 import './strands_FES.js';
 import './ir_types.js';
-export { d as binaryOpNode, g as constructTypeFromIDs, f as functionCallNode, m as memberAccessNode, p as primitiveConstructorNode, e as scalarLiteralNode, s as statementNode, b as structConstructorNode, a as structInstanceNode, h as swizzleNode, i as swizzleTrap, u as unaryOpNode, v as variableNode } from '../ir_builders-DXNgaB9N.js';
+export { d as binaryOpNode, h as castToFloat, g as constructTypeFromIDs, f as functionCallNode, m as memberAccessNode, p as primitiveConstructorNode, e as scalarLiteralNode, s as statementNode, b as structConstructorNode, a as structInstanceNode, i as swizzleNode, j as swizzleTrap, u as unaryOpNode, v as variableNode } from '../ir_builders-w12-GSxu.js';
 import './strands_builtins.js';

package/dist/strands/p5.strands.js

@@ -8,7 +8,7 @@ import 'acorn';
 import 'acorn-walk';
 import 'escodegen';
 import './strands_FES.js';
-import '../ir_builders-DXNgaB9N.js';
+import '../ir_builders-w12-GSxu.js';
 import './strands_builtins.js';
 import './strands_conditionals.js';
 import './strands_phi_utils.js';

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-DXNgaB9N.js';
+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 { OperatorTable, StatementType, NodeType, DataType, BaseType, BlockType, isStructType, structType } from './ir_types.js';
 import { strandsBuiltinFunctions } from './strands_builtins.js';
 import { StrandsConditional } from './strands_conditionals.js';
@@ -43,7 +43,7 @@ function _getBuiltinGlobalsCache(strandsContext) {
 function getBuiltinGlobalNode(strandsContext, name) {
   const spec = BUILTIN_GLOBAL_SPECS[name];
   if (!spec) return null
-  
+
   const cache = _getBuiltinGlobalsCache(strandsContext);
   const uniformName = `_p5_global_${name}`;
   const cached = cache.nodes.get(uniformName);
@@ -141,7 +141,7 @@ function initGlobalStrandsAPI(p5, fn, strandsContext) {
     }
 
     // Convert value to a StrandsNode if it isn't already
-    const valueNode = value instanceof StrandsNode ? value : p5.strandsNode(value);
+    const valueNode = value?.isStrandsNode ? value : p5.strandsNode(value);
 
     // Create a new CFG block for the early return
     const earlyReturnBlockID = createBasicBlock(cfg, BlockType.DEFAULT);
@@ -356,12 +356,17 @@ function initGlobalStrandsAPI(p5, fn, strandsContext) {
     fn[typeInfo.fnName] = function(...args) {
       if (strandsContext.active) {
         if (args.length === 1 && args[0].dimension && args[0].dimension === typeInfo.dimension) {
-          const { id, dimension } = functionCallNode(strandsContext, typeInfo.fnName, args, {
-            overloads: [{
-              params: [args[0].typeInfo()],
-              returnType: typeInfo,
-            }]
-          });
+          const { id, dimension } = functionCallNode(
+            strandsContext,
+            strandsContext.backend.getTypeName(typeInfo.baseType, typeInfo.dimension),
+            args,
+            {
+              overloads: [{
+                params: [args[0].typeInfo()],
+                returnType: typeInfo,
+              }]
+            }
+          );
           return createStrandsNode(id, dimension, strandsContext);
         } else {
           // For vector types with a single argument, repeat it for each component
@@ -418,7 +423,7 @@ function createHookArguments(strandsContext, parameters){
             const oldDependsOn = dag.dependsOn[structNode.id];
             const newDependsOn = [...oldDependsOn];
             let newValueID;
-            if (val instanceof StrandsNode) {
+            if (val?.isStrandsNode) {
               newValueID = val.id;
             }
             else {
@@ -450,7 +455,7 @@ function createHookArguments(strandsContext, parameters){
   return args;
 }
 function enforceReturnTypeMatch(strandsContext, expectedType, returned, hookName) {
-  if (!(returned instanceof StrandsNode)) {
+  if (!(returned?.isStrandsNode)) {
     // try {
       const result = primitiveConstructorNode(strandsContext, expectedType, returned);
       return result.id;
@@ -472,7 +477,12 @@ function enforceReturnTypeMatch(strandsContext, expectedType, returned, hookName
   };
   if (receivedType.dimension !== expectedType.dimension) {
     if (receivedType.dimension !== 1) {
-      userError('type error', `You have returned a vector with ${receivedType.dimension} components in ${hookName} when a ${expectedType.baseType + expectedType.dimension} was expected!`);
+      const receivedTypeDisplay = receivedType.baseType + (receivedType.dimension > 1 ? receivedType.dimension : '');
+      const expectedTypeDisplay = expectedType.baseType + expectedType.dimension;
+      userError('type error',
+        `You have returned a ${receivedTypeDisplay} in ${hookName} when a ${expectedTypeDisplay} was expected!\n\n` +
+        `Make sure your hook returns the correct type.`
+      );
     }
     else {
       const result = primitiveConstructorNode(strandsContext, expectedType, returned);
@@ -559,10 +569,27 @@ function createShaderHooksFunctions(strandsContext, fn, shader) {
       const handleRetVal = (retNode) => {
         if(isStructType(expectedReturnType)) {
           const expectedStructType = structType(expectedReturnType);
-          if (retNode instanceof StrandsNode) {
+          if (retNode?.isStrandsNode) {
             const returnedNode = getNodeDataFromID(strandsContext.dag, retNode.id);
             if (returnedNode.baseType !== expectedStructType.typeName) {
-              userError("type error", `You have returned a ${retNode.baseType} from ${hookType.name} when a ${expectedStructType.typeName} was expected.`);
+              const receivedTypeName = returnedNode.baseType || 'undefined';
+              const receivedDim = dag.dimensions[retNode.id];
+              const receivedTypeDisplay = receivedDim > 1 ?
+                `${receivedTypeName}${receivedDim}` : receivedTypeName;
+
+              const expectedProps = expectedStructType.properties
+                .map(p => p.name).join(', ');
+              userError('type error',
+                `You have returned a ${receivedTypeDisplay} from ${hookType.name} when a ${expectedStructType.typeName} was expected.\n\n` +
+                `The ${expectedStructType.typeName} struct has these properties: { ${expectedProps} }\n\n` +
+                `Instead of returning a different type, you should modify and return the ${expectedStructType.typeName} struct that was passed to your hook.\n\n` +
+                `For example:\n` +
+                `${hookType.name}((inputs) => {\n` +
+                `  // Modify properties of inputs\n` +
+                `  inputs.someProperty = ...;\n` +
+                `  return inputs; // Return the modified struct\n` +
+                `})`
+              );
             }
             const newDeps = returnedNode.dependsOn.slice();
             for (let i = 0; i < expectedStructType.properties.length; i++) {
@@ -581,10 +608,14 @@ function createShaderHooksFunctions(strandsContext, fn, shader) {
               const propName = expectedProp.name;
               const receivedValue = retNode[propName];
               if (receivedValue === undefined) {
-                userError('type error', `You've returned an incomplete struct from ${hookType.name}.\n` +
-                  `Expected: { ${expectedReturnType.properties.map(p => p.name).join(', ')} }\n` +
-                  `Received: { ${Object.keys(retNode).join(', ')} }\n` +
-                  `All of the properties are required!`);
+                const expectedProps = expectedReturnType.properties.map(p => p.name).join(', ');
+                const receivedProps = Object.keys(retNode).join(', ');
+                userError('type error',
+                  `You've returned an incomplete ${expectedStructType.typeName} struct from ${hookType.name}.\n\n` +
+                  `Expected properties: { ${expectedProps} }\n` +
+                  `Received properties: { ${receivedProps} }\n\n` +
+                  `All properties are required! Make sure to include all properties in the returned struct.`
+                );
               }
               const expectedTypeInfo = expectedProp.dataType;
               const returnedPropID = enforceReturnTypeMatch(strandsContext, expectedTypeInfo, receivedValue, hookType.name);

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-DXNgaB9N.js';
+import { c as createStrandsNode } from '../ir_builders-w12-GSxu.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, S as StrandsNode, p as primitiveConstructorNode } from '../ir_builders-DXNgaB9N.js';
+import { c as createStrandsNode, p as primitiveConstructorNode } from '../ir_builders-w12-GSxu.js';
 import { createPhiNode } from './strands_phi_utils.js';
 import './strands_FES.js';
 import './strands_builtins.js';
@@ -310,7 +310,7 @@ class StrandsFor {
     let initialVar = this.initialCb();
 
     // Convert to StrandsNode if it's not already one
-    if (!(initialVar instanceof StrandsNode)) {
+    if (!(initialVar?.isStrandsNode)) {
       const { id, dimension } = primitiveConstructorNode(this.strandsContext, { baseType: BaseType.FLOAT, dimension: 1 }, initialVar);
       initialVar = createStrandsNode(id, dimension, this.strandsContext);
     }

package/dist/strands/strands_node.js

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

package/dist/type/index.js

@@ -1,10 +1,10 @@
 import textCore from './textCore.js';
 import font from './p5.Font.js';
-import '../p5.Renderer-D-5LdCRz.js';
+import '../p5.Renderer-xpFkUQC6.js';
 import '../creating_reading-ZXzcZEsb.js';
 import 'colorjs.io/fn';
 import '../color/color_spaces/hsb.js';
-import '../constants-DQyACdzq.js';
+import '../constants-D3npMLOW.js';
 import '../image/filters.js';
 import '../math/p5.Vector.js';
 import '../shape/custom_shapes.js';

package/dist/type/p5.Font.js

@@ -1,11 +1,11 @@
 import { textCoreConstants } from './textCore.js';
-import { v as CENTER, a9 as RIGHT, u as RADIUS } from '../constants-DQyACdzq.js';
+import { v as CENTER, a9 as RIGHT, u as RADIUS } from '../constants-D3npMLOW.js';
 import { UnicodeRange } from '@japont/unicode-range';
 import { unicodeRanges } from './unicodeRanges.js';
 import { Vector } from '../math/p5.Vector.js';
 import Typr from './lib/Typr.js';
 import { createFromCommands } from '@davepagurek/bezier-path';
-import '../p5.Renderer-D-5LdCRz.js';
+import '../p5.Renderer-xpFkUQC6.js';
 import '../creating_reading-ZXzcZEsb.js';
 import 'colorjs.io/fn';
 import '../color/color_spaces/hsb.js';

package/dist/type/textCore.js

@@ -1,8 +1,8 @@
-import { R as Renderer } from '../p5.Renderer-D-5LdCRz.js';
+import { R as Renderer } from '../p5.Renderer-xpFkUQC6.js';
 import '../creating_reading-ZXzcZEsb.js';
 import 'colorjs.io/fn';
 import '../color/color_spaces/hsb.js';
-import '../constants-DQyACdzq.js';
+import '../constants-D3npMLOW.js';
 import '../image/filters.js';
 import '../math/p5.Vector.js';
 import '../shape/custom_shapes.js';

package/dist/webgl/3d_primitives.js

@@ -1,5 +1,5 @@
-import '../constants-DQyACdzq.js';
-export { p as default } from '../rendering-h9unX5K0.js';
+import '../constants-D3npMLOW.js';
+export { p as default } from '../rendering-B8po3Onj.js';
 import '../math/p5.Vector.js';
 import './p5.Geometry.js';
 import '../math/p5.Matrix.js';
@@ -10,7 +10,7 @@ import '../color/color_spaces/hsb.js';
 import '../dom/p5.Element.js';
 import '../dom/p5.File.js';
 import '../io/p5.XML.js';
-import '../p5.Renderer-D-5LdCRz.js';
+import '../p5.Renderer-xpFkUQC6.js';
 import '../image/filters.js';
 import '../shape/custom_shapes.js';
 import '../core/States.js';

package/dist/webgl/GeometryBuilder.js

@@ -1,4 +1,4 @@
-import { T as TRIANGLE_STRIP, $ as QUAD_STRIP, _ as TRIANGLE_FAN, c as TRIANGLES } from '../constants-DQyACdzq.js';
+import { T as TRIANGLE_STRIP, $ as QUAD_STRIP, _ as TRIANGLE_FAN, c as TRIANGLES } from '../constants-D3npMLOW.js';
 import '../math/p5.Matrix.js';
 import { Geometry } from './p5.Geometry.js';
 import { Matrix } from '../math/Matrices/Matrix.js';

package/dist/webgl/ShapeBuilder.js

@@ -1,4 +1,4 @@
-import { K as PATH, Z as QUADS, $ as QUAD_STRIP, T as TRIANGLE_STRIP, c as TRIANGLES, ad as IMAGE, Y as LINES, _ as TRIANGLE_FAN } from '../constants-DQyACdzq.js';
+import { K as PATH, Z as QUADS, $ as QUAD_STRIP, T as TRIANGLE_STRIP, c as TRIANGLES, ad as IMAGE, Y as LINES, _ as TRIANGLE_FAN } from '../constants-D3npMLOW.js';
 import { Geometry } from './p5.Geometry.js';
 import libtess from 'libtess';
 import { Vector } from '../math/p5.Vector.js';

package/dist/webgl/enums.js

@@ -1,4 +1,4 @@
-import { a3 as constants } from '../constants-DQyACdzq.js';
+import { a3 as constants } from '../constants-D3npMLOW.js';
 
 function getStrokeDefs(shaderConstant) {
   const STROKE_CAP_ENUM = {};