fix(fes): validate shader callbacks, prevent stack leaks, and remove dead code

Author: Ayush4958

src/core/p5.Renderer3D.js

@@ -2722,7 +2722,13 @@ function renderer3D(p5, fn) {
         `buildComputeShader() is only available with the WebGPU renderer. ${webGPUAddonMessage}`
       );
     }
-    return this.baseComputeShader().modify(cb, context, { hook: 'iteration' });
+    const wasInternal = this._isUserCall;
+    this._isUserCall = false;
+    try {
+      return this.baseComputeShader().modify(cb, context, { hook: 'iteration' });
+    } finally {
+      this._isUserCall = wasInternal;
+    }
   };
   p5.registerDecorator('p5.prototype.buildComputeShader', markExperimental('webgpu', p5));
 

src/friendly_errors/param_validator.js

@@ -583,7 +583,7 @@ function validateParams(p5, fn, lifecycles) {
         errorStackParser.parse(Error()).slice(3)
       );
       const locationStr = getFriendlyStack(stacktrace, true);
-      FES.log`${locationStr} ${message}`();
+      FES.log`${locationStr ? locationStr + ' ' : ''}${message}`();
     }
     return message;
   };
@@ -630,18 +630,9 @@ function validateParams(p5, fn, lifecycles) {
     let funcSchemas = activeRegistry.get(func);
 
     if (!funcSchemas) {
-      // Convention-based bypass for shader builder entry-point functions.
-      // All p5 shader builders follow the build*Shader naming convention
-      // (buildMaterialShader, buildComputeShader, etc.). They are called
-      // BEFORE the strands context activates and handle their own validation
-      // and error reporting internally (e.g. "only available with WebGPU").
-      if (/^build\w+Shader$/.test(func) && p5._isStrandsContextActive) {
-        funcSchemas = z.any();
-      }
       // Check _strandsSignatures for explicit bypass entries (value === true)
-      // regardless of strands context, or array-based overload schemas that
-      // only apply inside an active strands context.
-      else if (p5._isStrandsContextActive && p5._strandsSignatures?.has(func)) {
+      // that only apply inside an active strands context.
+      if (p5._isStrandsContextActive && p5._strandsSignatures?.has(func)) {
         funcSchemas = z.any();
       }
 

src/friendly_errors/stacktrace.js

@@ -279,27 +279,29 @@ export const processStack = (error, stacktrace) => {
   let isInternal = false;
   let p5FileName, friendlyStack;
 
+  // Helper to strip query strings and hashes from URLs for consistent matching
+  const cleanUrl = url => (typeof url === 'string' ? url.split('?')[0].split('#')[0] : '');
+
   // Intentionally throw an error that we catch so that we can check the name
   // of the current file. Any errors we see from this file, we treat as
   // internal errors.
   const testStacktrace = errorStackParser.parse(Error());
-  p5FileName = testStacktrace[0].fileName;
+  p5FileName = cleanUrl(testStacktrace[0]?.fileName);
+  const p5BaseName = p5FileName ? p5FileName.split('/').slice(-1)[0] : '';
+  const isP5File = url => {
+    const cleaned = cleanUrl(url);
+    if (!cleaned) return false;
+    if (cleaned === p5FileName) return true;
+    if (p5BaseName && cleaned.split('/').slice(-1)[0] === p5BaseName) return true;
+    return false;
+  };
 
   for (let i = stacktrace.length - 1; i >= 0; i--) {
     let splitted = stacktrace[i].functionName.split('.');
     if (entryPoints.includes(splitted[splitted.length - 1])) {
       // remove everything below an entry point function (setup, draw, etc).
       // (it's usually the internal initialization calls)
       friendlyStack = stacktrace.slice(0, i + 1);
-      // We call the error "internal" if the source of the error was a
-      // function from within the p5.js library file, but called from the
-      // user's code directly. We only need to check the topmost frame in
-      // the stack trace since any function internal to p5 should pass this
-      // check, not just public p5 functions.
-      if (stacktrace[0].fileName === p5FileName) {
-        isInternal = true;
-        break;
-      }
       break;
     }
   }
@@ -309,6 +311,14 @@ export const processStack = (error, stacktrace) => {
   // entire stacktrace for friendlyStack
   if (!friendlyStack) friendlyStack = stacktrace;
 
+  // We call the error "internal" if the source of the error was a
+  // function from within the p5.js library file, but called from the
+  // user's code directly. When error is null (called from param_validator),
+  // it is always an internal validation call.
+  if (error === null || isP5File(stacktrace[0]?.fileName)) {
+    isInternal = true;
+  }
+
   if (isInternal) {
     // the frameIndex property is added before the filter, so frameIndex
     // corresponds to the index of a frame in the original stacktrace.
@@ -319,7 +329,15 @@ export const processStack = (error, stacktrace) => {
         frame.frameIndex = index;
         return frame;
       })
-      .filter(frame => frame.fileName !== p5FileName);
+      .filter(frame => {
+        const cleaned = cleanUrl(frame.fileName);
+        return (
+          cleaned &&
+          !isP5File(frame.fileName) &&
+          cleaned !== '<anonymous>' &&
+          !cleaned.startsWith('eval')
+        );
+      });
 
     // a weird case, if for some reason we can't identify the function called
     // from user's code
@@ -332,16 +350,19 @@ export const processStack = (error, stacktrace) => {
       friendlyStack[0].lineNumber &&
       friendlyStack[0].columnNumber
     ) {
+      const cleanFile = cleanUrl(friendlyStack[0].fileName);
       locationObj = {
-        location: `${friendlyStack[0].fileName}:${
+        location: `${cleanFile}:${
           friendlyStack[0].lineNumber
         }:${friendlyStack[0].columnNumber}`,
-        file: friendlyStack[0].fileName.split('/').slice(-1),
+        file: cleanFile.split('/').slice(-1)[0],
         line: friendlyStack[0].lineNumber
       };
 
       // if already handled by another part of the FES, don't handle again
-      if (p5._fesLogCache[locationObj.location]) return [true, null];
+      if (typeof p5 !== 'undefined' && p5?._fesLogCache?.[locationObj.location]) {
+        return [true, null];
+      }
     }
 
     // Library error
@@ -394,8 +415,16 @@ export function printFriendlyStack(friendlyStack) {
 }
 
 export function getFriendlyStack(stacktrace, compact = false) {
+  if (!stacktrace || !stacktrace.length || !stacktrace[0]?.fileName) {
+    return null;
+  }
+  const rawFile = stacktrace[0].fileName;
+  const cleanFile = (typeof rawFile === 'string' ? rawFile.split('?')[0].split('#')[0] : '').split('/').slice(-1)[0];
+  if (!cleanFile || cleanFile === '<anonymous>' || cleanFile.startsWith('eval')) {
+    return null;
+  }
   if (compact) {
-    return `[${stacktrace[0].fileName.split('/').slice(-1)}, line ${stacktrace[0].lineNumber}]`;
+    return `[${cleanFile}, line ${stacktrace[0].lineNumber}]`;
   } else {
     if (stacktrace.length > 1) {
       let stacktraceMsg = '';

src/strands/strands_api.js

@@ -482,6 +482,7 @@ export function initGlobalStrandsAPI(p5, fn, strandsContext) {
     strandsBuiltinFunctions
   )) {
     p5._strandsSignatures.set(functionName, true);
+    p5._strandsSignatures.set(`p5.${functionName}`, true);
     const isp5Function = overrides[0].isp5Function;
     if (isp5Function) {
       const originalFn = fn[functionName];

src/webgl/material.js

@@ -745,7 +745,13 @@ function material(p5, fn) {
    * @returns {p5.Shader} The material shader
    */
   fn.buildFilterShader = function (callback, scope) {
-    return this.baseFilterShader().modify(callback, scope);
+    const wasInternal = this._isUserCall;
+    this._isUserCall = false;
+    try {
+      return this.baseFilterShader().modify(callback, scope);
+    } finally {
+      this._isUserCall = wasInternal;
+    }
   };
   p5.registerDecorator('p5.prototype.buildFilterShader', markExperimental('p5.strands', p5));
 
@@ -1574,7 +1580,13 @@ function material(p5, fn) {
    * @returns {p5.Shader} The material shader.
    */
   fn.buildMaterialShader = function (cb, scope) {
-    return this.baseMaterialShader().modify(cb, scope);
+    const wasInternal = this._isUserCall;
+    this._isUserCall = false; // Temporarily un-suppress FES so calls inside cb are validated
+    try {
+      return this.baseMaterialShader().modify(cb, scope);
+    } finally {
+      this._isUserCall = wasInternal;
+    }
   };
   p5.registerDecorator('p5.prototype.buildMaterialShader', markExperimental('p5.strands', p5));
 
@@ -1793,7 +1805,13 @@ function material(p5, fn) {
    * @returns {p5.Shader} The normal shader.
    */
   fn.buildNormalShader = function (cb, scope) {
-    return this.baseNormalShader().modify(cb, scope);
+    const wasInternal = this._isUserCall;
+    this._isUserCall = false;
+    try {
+      return this.baseNormalShader().modify(cb, scope);
+    } finally {
+      this._isUserCall = wasInternal;
+    }
   };
   p5.registerDecorator('p5.prototype.buildNormalShader', markExperimental('p5.strands', p5));
 
@@ -1958,7 +1976,13 @@ function material(p5, fn) {
    * @returns {p5.Shader} The color shader.
    */
   fn.buildColorShader = function (cb, scope) {
-    return this.baseColorShader().modify(cb, scope);
+    const wasInternal = this._isUserCall;
+    this._isUserCall = false;
+    try {
+      return this.baseColorShader().modify(cb, scope);
+    } finally {
+      this._isUserCall = wasInternal;
+    }
   };
   p5.registerDecorator('p5.prototype.buildColorShader', markExperimental('p5.strands', p5));
 
@@ -2216,7 +2240,13 @@ function material(p5, fn) {
    * @returns {p5.Shader} The stroke shader.
    */
   fn.buildStrokeShader = function (cb, scope) {
-    return this.baseStrokeShader().modify(cb, scope);
+    const wasInternal = this._isUserCall;
+    this._isUserCall = false;
+    try {
+      return this.baseStrokeShader().modify(cb, scope);
+    } finally {
+      this._isUserCall = wasInternal;
+    }
   };
   p5.registerDecorator('p5.prototype.buildStrokeShader', markExperimental('p5.strands', p5));
 

test/unit/core/param_errors.js

@@ -29,7 +29,9 @@ suite('Validate Params', function () {
       return 'mock p5.Graphics';
     },
     _error: () => {},
-    registerDecorator: () => {}
+    registerDecorator: () => {},
+    _strandsSignatures: new Map([['p5.map', true]]),
+    _isStrandsContextActive: false
   };
   const mockP5Prototype = {};
 
@@ -469,5 +471,12 @@ suite('Validate Params', function () {
       assert.isFalse(result.success);
       assert.isTrue(result.error.toString().includes('Expected at least 5 arguments'));
     });
+
+    test('map(): bypasses FES validation when inside strands context', function () {
+      mockP5._isStrandsContextActive = true;
+      const result = mockP5Prototype._validate('p5.map', ['a', 'b']);
+      assert.isTrue(result.success);
+      mockP5._isStrandsContextActive = false; // reset
+    });
   });
 });