test(tools): fail when a guard rejects a value it must render inert

cubic found the fourth instance of the same pattern: the renders-inert cases
caught any throw and returned, so none of the assertions ran. The suite proved
only that values which build stay inert — a guard that over-tightened and
rejected one it should have encoded passed silently. The surrounding-whitespace
case for ordinary ids had the same hole.

A throw is now a failure unless the parameter is named in strictlyValidated,
which is exactly Supabase table and functionName: validateDatabaseIdentifier
and validateFunctionName predate these guards and legitimately refuse values
the shared guards only render inert. Measured rather than assumed — those ten
pairs are the only ones that reject any MUST_NOT_RESHAPE value.

Verified non-vacuous by over-tightening strictUrlPathSegment to reject '#':
three box_sign cases fail where they previously passed.

Author: waleedlatif1

apps/sim/tools/__tests__/path-safety.ts

@@ -425,6 +425,20 @@ export interface TraversalOptions {
    * rejection cannot quietly regress into a trim.
    */
   rejectsSurroundingWhitespace?: readonly string[]
+  /**
+   * Parameters guarded by a stricter, service-specific validator that predates
+   * these path guards — Supabase's `table` and `column` go through
+   * `validateDatabaseIdentifier`, `functionName` through `validateFunctionName`.
+   *
+   * Those legitimately refuse values the shared guards merely render inert
+   * (`abc#fragment` is a fine URL segment but not a SQL identifier), so a throw
+   * from them is a correct outcome. Everywhere else a throw is a **failure**:
+   * `MUST_NOT_RESHAPE` values must actually reach the wire encoded, and a guard
+   * that over-tightens and rejects one is a regression the suite has to catch.
+   * Listing the exceptions by name is what keeps "tolerated" from silently
+   * becoming "untested".
+   */
+  strictlyValidated?: readonly string[]
 }
 
 /** Asserts the traversal invariant for one (tool, parameter) pair. */
@@ -435,6 +449,7 @@ export function itResistsTraversal(
     basePath,
     preservesWhitespace = false,
     rejectsSurroundingWhitespace = [],
+    strictlyValidated = [],
   }: TraversalOptions
 ): void {
   const baselinePath = buildUrl(tool, paramName, PROBE_ID, context).pathname
@@ -473,7 +488,18 @@ export function itResistsTraversal(
     let url: URL
     try {
       url = buildUrl(tool, paramName, value, context)
-    } catch {
+    } catch (error) {
+      /**
+       * A throw here is only acceptable from a parameter with a stricter
+       * pre-existing validator. Otherwise the value was supposed to survive
+       * encoded, and swallowing the rejection would hide a guard that has
+       * over-tightened — the suite would then prove only that values which
+       * *build* stay inert, which is not the property claimed.
+       */
+      expect(
+        strictlyValidated.includes(paramName),
+        `${paramName} rejected ${JSON.stringify(value)}, which must be rendered inert: ${getErrorMessage(error, 'unknown error')}`
+      ).toBe(true)
       return
     }
 
@@ -561,7 +587,11 @@ export function itResistsTraversal(
     let url: URL
     try {
       url = buildUrl(tool, paramName, padded, context)
-    } catch {
+    } catch (error) {
+      expect(
+        strictlyValidated.includes(paramName),
+        `${paramName} rejected a padded value without being a strictly-validated parameter: ${getErrorMessage(error, 'unknown error')}`
+      ).toBe(true)
       return
     }
 

apps/sim/tools/supabase/path_safety.test.ts

@@ -101,6 +101,12 @@ describe('supabase path traversal safety', () => {
       origin: ORIGIN,
       basePath: BASE_PATH,
       preservesWhitespace: param.paramName === 'path',
+      /**
+       * `table` and `functionName` are refused by `validateDatabaseIdentifier`
+       * and `validateFunctionName`, which predate these guards and legitimately
+       * reject values the shared guards only render inert.
+       */
+      strictlyValidated: ['table', 'functionName'],
     })
   })