@@ -77,7 +77,7 @@ return items.sort(compare)
 return [...items].sort(compare)
 ```
 
-**Do NOT use `toSorted()` / `toReversed()` / `with()` / `toSpliced()`.** They are ES2023 *runtime* methods — and a tsconfig `"lib": ["ES2023"]` only makes them **type-check**, it does not make them **run**. Next/SWC compiles syntax but does **not** polyfill prototype methods, and the default browserslist still includes browsers without them (`toSorted` landed in Safari 16 / iOS 16, so any device capped at iOS 15 throws `TypeError: x.toSorted is not a function` and crashes the page). The perf difference vs `[...arr].sort()` is negligible (both allocate one array), so the copy-then-sort form is used everywhere: whether a module reaches the browser is not visible from its path. `check:utils` flags `toSorted`/`toReversed`/`toSpliced` repo-wide and any `.with(index, value)` call whose second argument is not a function literal; OpenTelemetry's `context.with(ctx, () => …)` passes, and one handed its callback as an identifier needs `// utils-lint-allow: <reason>`.
+**Do NOT use `toSorted()` / `toReversed()` / `with()` / `toSpliced()`.** They are ES2023 *runtime* methods — and a tsconfig `"lib": ["ES2023"]` only makes them **type-check**, it does not make them **run**. Next/SWC compiles syntax but does **not** polyfill prototype methods, and the default browserslist still includes browsers without them (`toSorted` landed in Safari 16 / iOS 16, so any device capped at iOS 15 throws `TypeError: x.toSorted is not a function` and crashes the page). The perf difference vs `[...arr].sort()` is negligible (both allocate one array), so the copy-then-sort form is used everywhere: whether a module reaches the browser is not visible from its path. `check:utils` flags `toSorted`/`toReversed`/`toSpliced` repo-wide and every two-argument `.with(index, value)` call on any receiver except an OpenTelemetry context object (a receiver named like `context`, `otelContext`, `otelContextApi`); a deliberate exception carries `// utils-lint-allow: <reason>`.
 
 ## Run independent awaits in parallel
 
 
@@ -80,7 +80,7 @@ return items.sort(compare)
 return [...items].sort(compare)
 ```
 
-**Do NOT use `toSorted()` / `toReversed()` / `with()` / `toSpliced()`.** They are ES2023 *runtime* methods — and a tsconfig `"lib": ["ES2023"]` only makes them **type-check**, it does not make them **run**. Next/SWC compiles syntax but does **not** polyfill prototype methods, and the default browserslist still includes browsers without them (`toSorted` landed in Safari 16 / iOS 16, so any device capped at iOS 15 throws `TypeError: x.toSorted is not a function` and crashes the page). The perf difference vs `[...arr].sort()` is negligible (both allocate one array), so the copy-then-sort form is used everywhere: whether a module reaches the browser is not visible from its path. `check:utils` flags `toSorted`/`toReversed`/`toSpliced` repo-wide and any `.with(index, value)` call whose second argument is not a function literal; OpenTelemetry's `context.with(ctx, () => …)` passes, and one handed its callback as an identifier needs `// utils-lint-allow: <reason>`.
+**Do NOT use `toSorted()` / `toReversed()` / `with()` / `toSpliced()`.** They are ES2023 *runtime* methods — and a tsconfig `"lib": ["ES2023"]` only makes them **type-check**, it does not make them **run**. Next/SWC compiles syntax but does **not** polyfill prototype methods, and the default browserslist still includes browsers without them (`toSorted` landed in Safari 16 / iOS 16, so any device capped at iOS 15 throws `TypeError: x.toSorted is not a function` and crashes the page). The perf difference vs `[...arr].sort()` is negligible (both allocate one array), so the copy-then-sort form is used everywhere: whether a module reaches the browser is not visible from its path. `check:utils` flags `toSorted`/`toReversed`/`toSpliced` repo-wide and every two-argument `.with(index, value)` call on any receiver except an OpenTelemetry context object (a receiver named like `context`, `otelContext`, `otelContextApi`); a deliberate exception carries `// utils-lint-allow: <reason>`.
 
 ## Run independent awaits in parallel
 
 
@@ -286,11 +286,14 @@ export function findViolations({ root, forbidden }: GuardedRoot): GraphViolation
 /** A module a runtime import can resolve to: not a test, integration test, or declaration file. */
 const RUNTIME_MODULE = /(?<!\.(?:test|spec|integration|d))\.tsx?$/
 
+/** Test-support directories: nothing in them satisfies a runtime import. */
+const TEST_SUPPORT_DIRS = new Set(['__fixtures__', '__mocks__', '__tests__', '__integration__'])
+
 /** Whether `dir` holds a runtime module at any depth. */
 function containsRuntimeModule(dir: string): boolean {
   return readdirSync(dir, { withFileTypes: true }).some((entry) =>
     entry.isDirectory()
-      ? containsRuntimeModule(resolve(dir, entry.name))
+      ? !TEST_SUPPORT_DIRS.has(entry.name) && containsRuntimeModule(resolve(dir, entry.name))
       : RUNTIME_MODULE.test(entry.name)
   )
 }
 
@@ -19,6 +19,8 @@
  */
 import { readdir, readFile } from 'node:fs/promises'
 import path from 'node:path'
+import { parse } from '@babel/parser'
+import { getErrorMessage } from '@sim/utils/errors'
 
 const ROOT = path.resolve(import.meta.dir, '..')
 
@@ -51,11 +53,18 @@ const TRUNCATE_PREFILTER = /\.(?:slice|substring)\(\s*0\s*,[^)]*\)\s*(?:\}|\+)/
 /** Literal gate shared by the `filterUndefined` and `omit` patterns. */
 const FROM_ENTRIES = /Object\.fromEntries\(/
 
+/** Shared by the toSorted/toReversed/toSpliced pattern and the AST-based `.with` check. */
+const ES2023_ARRAY_METHOD = {
+  description:
+    'ES2023 array method (throws on Safari/iOS 15 wherever the module reaches the browser)',
+  suggestion:
+    'a copy you then mutate: [...arr].sort(), [...arr].reverse(), [...arr].splice(), or [...arr] then next[i] = value',
+}
+
 const BANNED_PATTERNS: Array<{
   pattern: RegExp
   description: string
   suggestion: string
-  /** Restricts the pattern to matching files; unrestricted patterns apply everywhere. */
   /** Cheap literal test that skips the pattern on files that cannot match; memoized per file. */
   prefilter?: RegExp
 }> = [
@@ -146,13 +155,8 @@ const BANNED_PATTERNS: Array<{
   },
   // Render-path rules (.claude/rules/sim-react-performance.md, sim-styling.md)
   {
-    /** `.with(i, value)`; a function second argument is OpenTelemetry's `context.with(ctx, fn)`. */
-    pattern:
-      /\.(?:toSorted|toReversed|toSpliced)\s*\(|\.with\(\s*[^,()]+,(?!\s*(?:async\s*)?(?:\([^)]*\)\s*=>|\w+\s*=>|function\b))/g,
-    description:
-      'ES2023 array method (throws on Safari/iOS 15 wherever the module reaches the browser)',
-    suggestion:
-      'a copy you then mutate: [...arr].sort(), [...arr].reverse(), [...arr].splice(), or [...arr] then next[i] = value',
+    pattern: /\.(?:toSorted|toReversed|toSpliced)\s*\(/g,
+    ...ES2023_ARRAY_METHOD,
   },
   {
     pattern: /\buseRef(?:<(?:[^<>]|<[^<>]*>)*>)?\(\s*new\s+[A-Z]\w*/g,
@@ -169,6 +173,75 @@ const BANNED_PATTERNS: Array<{
   },
 ]
 
+/** Cheap gate: only files that contain a `.with(` call are parsed. */
+const WITH_CALL = /\.with\s*\(/
+
+/** OpenTelemetry's `context.with(ctx, fn)` shares the shape; its receivers are named for the context API. */
+const OTEL_CONTEXT_RECEIVER = /context/i
+
+/** A Babel AST node, read structurally rather than through `@babel/types`. */
+interface SyntaxNode extends Record<string, unknown> {
+  type: string
+  start: number
+}
+
+function isSyntaxNode(value: unknown): value is SyntaxNode {
+  return (
+    typeof value === 'object' && value !== null && 'type' in value && typeof value.type === 'string'
+  )
+}
+
+function walkNodes(node: SyntaxNode, visit: (node: SyntaxNode) => void): void {
+  visit(node)
+  for (const value of Object.values(node)) {
+    if (isSyntaxNode(value)) walkNodes(value, visit)
+    else if (Array.isArray(value))
+      for (const item of value) if (isSyntaxNode(item)) walkNodes(item, visit)
+  }
+}
+
+/** The name a member call is made on: `arr` in `arr.with(…)`, `items` in `this.items.with(…)`. */
+function receiverName(receiver: unknown): string | undefined {
+  if (!isSyntaxNode(receiver)) return undefined
+  if (receiver.type === 'Identifier' && typeof receiver.name === 'string') return receiver.name
+  const isMember =
+    receiver.type === 'MemberExpression' || receiver.type === 'OptionalMemberExpression'
+  if (!isMember || receiver.computed === true || !isSyntaxNode(receiver.property)) return undefined
+  return typeof receiver.property.name === 'string' ? receiver.property.name : undefined
+}
+
+/**
+ * Offsets of every `Array.prototype.with(index, value)` call: a two-argument `.with` on any
+ * receiver except an OpenTelemetry context object. Drizzle's one-argument `.with(cte)` and
+ * `index().with({ … })` never match.
+ */
+function findArrayWithCalls(file: string, content: string): number[] {
+  let program: unknown
+  try {
+    program = parse(content, {
+      sourceType: 'module',
+      plugins: ['typescript', ...(/\.[jt]sx$/.test(file) ? (['jsx'] as const) : [])],
+      errorRecovery: true,
+    }).program
+  } catch (error) {
+    throw new Error(`Cannot parse ${file} to check its .with calls: ${getErrorMessage(error)}`)
+  }
+  if (!isSyntaxNode(program)) return []
+
+  const offsets: number[] = []
+  walkNodes(program, (node) => {
+    if (node.type !== 'CallExpression' && node.type !== 'OptionalCallExpression') return
+    if (!Array.isArray(node.arguments) || node.arguments.length !== 2) return
+    const callee = node.callee
+    if (!isSyntaxNode(callee) || callee.computed === true || !isSyntaxNode(callee.property)) return
+    if (callee.type !== 'MemberExpression' && callee.type !== 'OptionalMemberExpression') return
+    if (callee.property.name !== 'with') return
+    if (OTEL_CONTEXT_RECEIVER.test(receiverName(callee.object) ?? '')) return
+    offsets.push(callee.property.start)
+  })
+  return offsets
+}
+
 async function walk(dir: string, results: string[] = []): Promise<string[]> {
   let entries
   try {
@@ -285,6 +358,11 @@ async function main() {
         matches.push({ index: match.index, description, suggestion })
       }
     }
+    if (WITH_CALL.test(content)) {
+      for (const index of findArrayWithCalls(rel, content)) {
+        matches.push({ index, ...ES2023_ARRAY_METHOD })
+      }
+    }
     if (matches.length === 0) continue
 
     const lines = content.split('\n')
 
@@ -1,6 +1,8 @@
 #!/usr/bin/env bun
 import { readdir, readFile } from 'node:fs/promises'
 import path from 'node:path'
+import { parse } from '@babel/parser'
+import { getErrorMessage } from '@sim/utils/errors'
 
 const ROOT = path.resolve(import.meta.dir, '..')
 const APP_DIR = path.join(ROOT, 'apps/sim')
@@ -298,14 +300,121 @@ function auditFile(file: string, source: string): Violation[] {
 const PERSIST_IMPORT =
   /import\s*\{[^}]*\bpersist\b(?:\s+as\s+(\w+))?[^}]*\}\s*from\s*'zustand\/middleware'/
 
-/** Removes comments while leaving string literals (which may contain `//`) intact. */
-function stripComments(code: string): string {
-  return code.replace(
-    /('(?:\\.|[^'\\])*'|"(?:\\.|[^"\\])*"|`(?:\\.|[^`\\])*`)|\/\*[\s\S]*?\*\/|\/\/[^\n]*/g,
-    (_, literal: string | undefined) => literal ?? ''
+/** A Babel AST node, read structurally rather than through `@babel/types`. */
+interface SyntaxNode extends Record<string, unknown> {
+  type: string
+  start: number
+  end: number
+}
+
+function isSyntaxNode(value: unknown): value is SyntaxNode {
+  return (
+    typeof value === 'object' && value !== null && 'type' in value && typeof value.type === 'string'
   )
 }
 
+/** Visits `node` and every node beneath it, depth first; `visit` returning false skips a subtree. */
+function walkNodes(node: SyntaxNode, visit: (node: SyntaxNode) => boolean | undefined): void {
+  if (visit(node) === false) return
+  for (const value of Object.values(node)) {
+    if (isSyntaxNode(value)) walkNodes(value, visit)
+    else if (Array.isArray(value))
+      for (const item of value) if (isSyntaxNode(item)) walkNodes(item, visit)
+  }
+}
+
+/** Strips the type-only wrappers (`as`, `satisfies`, `!`) around an expression. */
+function unwrapExpression(node: unknown): unknown {
+  let current = node
+  while (
+    isSyntaxNode(current) &&
+    (current.type === 'TSAsExpression' ||
+      current.type === 'TSSatisfiesExpression' ||
+      current.type === 'TSNonNullExpression')
+  ) {
+    current = current.expression
+  }
+  return current
+}
+
+function isIdentifierNamed(node: unknown, name: string): boolean {
+  const unwrapped = unwrapExpression(node)
+  return isSyntaxNode(unwrapped) && unwrapped.type === 'Identifier' && unwrapped.name === name
+}
+
+/** `name` itself, or an object literal that spreads `...name` (extra keys still carry everything). */
+function isWholeBinding(node: unknown, name: string): boolean {
+  if (isIdentifierNamed(node, name)) return true
+  const unwrapped = unwrapExpression(node)
+  if (!isSyntaxNode(unwrapped) || unwrapped.type !== 'ObjectExpression') return false
+  const properties = Array.isArray(unwrapped.properties) ? unwrapped.properties : []
+  return properties.some(
+    (property) =>
+      isSyntaxNode(property) &&
+      property.type === 'SpreadElement' &&
+      isIdentifierNamed(property.argument, name)
+  )
+}
+
+/** The expressions a function returns: its expression body, or every `return` in its own block. */
+function returnedExpressions(fn: SyntaxNode): unknown[] {
+  if (!isSyntaxNode(fn.body)) return []
+  if (fn.body.type !== 'BlockStatement') return [fn.body]
+  const returned: unknown[] = []
+  walkNodes(fn.body, (node) => {
+    if (node.type === 'ReturnStatement') returned.push(node.argument)
+    return !/Function|ObjectMethod|ClassMethod/.test(node.type)
+  })
+  return returned
+}
+
+/**
+ * The parameter binding that holds every state field: `s` in `(s) => …`, or `rest` in
+ * `({ a, ...rest }) => …`, which holds every field but the ones named (a deny-list).
+ */
+function wholeStateBinding(param: unknown): { name: string; reason: string } | null {
+  if (!isSyntaxNode(param)) return null
+  if (param.type === 'Identifier' && typeof param.name === 'string') {
+    return { name: param.name, reason: 'persist partialize spreads the whole state' }
+  }
+  if (param.type !== 'ObjectPattern' || !Array.isArray(param.properties)) return null
+  const rest = param.properties.find(
+    (property): property is SyntaxNode => isSyntaxNode(property) && property.type === 'RestElement'
+  )
+  if (!rest || !isSyntaxNode(rest.argument) || typeof rest.argument.name !== 'string') return null
+  return {
+    name: rest.argument.name,
+    reason: 'persist partialize persists everything but the fields it names (a deny-list)',
+  }
+}
+
+/**
+ * Why an inline `partialize` persists more than a whitelist, or null when it returns one:
+ * any return of the whole-state binding itself or of `{ ...binding }`.
+ */
+function partializeLeak(fn: SyntaxNode): string | null {
+  const binding = wholeStateBinding(Array.isArray(fn.params) ? fn.params[0] : undefined)
+  if (!binding) return null
+  return returnedExpressions(fn).some((expression) => isWholeBinding(expression, binding.name))
+    ? `${binding.reason}; return an explicit whitelist of durable fields`
+    : null
+}
+
+/** The top-level `partialize` of a persist options object literal, or null when it has none. */
+function findPartialize(options: SyntaxNode): SyntaxNode | null {
+  const properties = Array.isArray(options.properties) ? options.properties : []
+  for (const property of properties) {
+    if (!isSyntaxNode(property) || property.computed === true) continue
+    if (property.type !== 'ObjectProperty' && property.type !== 'ObjectMethod') continue
+    const key = property.key
+    const keyName = isSyntaxNode(key) ? (key.type === 'Identifier' ? key.name : key.value) : null
+    if (keyName !== 'partialize') continue
+    if (property.type === 'ObjectMethod') return property
+    return isSyntaxNode(property.value) ? property.value : null
+  }
+  return null
+}
+
 /**
  * `.claude/rules/sim-stores.md`: every `persist` names its durable fields in `partialize`.
  * Without one, zustand writes the whole state — transient flags, drag state, `_hasHydrated` —
@@ -315,41 +424,40 @@ function auditPersist(file: string, source: string): Violation[] {
   const persistImport = PERSIST_IMPORT.exec(source)
   if (!persistImport) return []
   const local = persistImport[1] ?? 'persist'
-  /** A call of the imported middleware; `.persist(` (an instance method) is excluded. */
-  const persistCall = new RegExp(`(?<![.\\w$])${local}\\s*(?:<[^()]*?>)?\\s*\\(`, 'g')
+  let program: unknown
+  try {
+    program = parse(source, {
+      sourceType: 'module',
+      plugins: ['typescript', ...(/\.[jt]sx$/.test(file) ? (['jsx'] as const) : [])],
+      errorRecovery: true,
+    }).program
+  } catch (error) {
+    throw new Error(`Cannot parse ${file} to audit its persist calls: ${getErrorMessage(error)}`)
+  }
+  if (!isSyntaxNode(program)) return []
+
   const violations: Violation[] = []
-  for (let match = persistCall.exec(source); match; match = persistCall.exec(source)) {
-    if (hasSafeAnnotation(source, match.index)) continue
-    const openParenIndex = match.index + match[0].length - 1
-    const closeParenIndex = findMatchingParen(source, openParenIndex)
-    if (closeParenIndex === -1) continue
-    const args = splitTopLevelArguments(
-      stripComments(source.slice(openParenIndex + 1, closeParenIndex))
-    )
-    const options = args.length > 1 ? args[args.length - 1] : ''
-    const hasPartialize = /(?:^|[{,])\s*partialize\s*[:(,}]/.test(options)
-    /**
-     * `(s) => s`, `(s) => ({ ...s })`, or a block body returning either — with `s` also bound as
-     * `({ ...s })` — persists the whole state.
-     */
-    const spreadsState =
-      /\bpartialize\s*:\s*\(?\s*(?:\{\s*\.\.\.)?(\w+)[^)]*\)?\s*=>\s*(?:\1\b(?!\s*[.[])|\(\s*\{\s*\.\.\.\1\b|\{[^}]*\breturn\s+(?:\1\b(?!\s*[.[])|\{\s*\.\.\.\1\b))/.test(
-        options
-      )
-    if (hasPartialize && !spreadsState) continue
+  walkNodes(program, (node) => {
+    if (node.type !== 'CallExpression' || !isIdentifierNamed(node.callee, local)) return
+    if (hasSafeAnnotation(source, node.start)) return
+    const args = Array.isArray(node.arguments) ? node.arguments : []
+    const options = args.length > 1 ? unwrapExpression(args[args.length - 1]) : null
+    const partialize =
+      isSyntaxNode(options) && options.type === 'ObjectExpression' ? findPartialize(options) : null
+    const isInlineFunction =
+      partialize !== null &&
+      /^(?:ArrowFunctionExpression|FunctionExpression|ObjectMethod)$/.test(partialize.type)
+    const leak = partialize && isInlineFunction ? partializeLeak(partialize) : null
+    if (partialize && !leak) return
     violations.push({
       file,
-      line: lineNumberAt(source, match.index),
-      description: spreadsState
-        ? 'persist partialize spreads the whole state; return an explicit whitelist of durable fields'
-        : `persist has no partialize; add \`partialize: (state) => ({ <durable fields> })\` (sim-stores.md). If the options object is hoisted into a variable that has one, mark the call // ${SAFE_ANNOTATION} <where>`,
-      snippet: oneLineSnippet(
-        source,
-        match.index,
-        Math.min(closeParenIndex + 1, match.index + 180)
-      ),
+      line: lineNumberAt(source, node.start),
+      description:
+        leak ??
+        `persist has no partialize; add \`partialize: (state) => ({ <durable fields> })\` (sim-stores.md). If the options object is hoisted into a variable that has one, mark the call // ${SAFE_ANNOTATION} <where>`,
+      snippet: oneLineSnippet(source, node.start, Math.min(node.end, node.start + 180)),
     })
-  }
+  })
   return violations
 }