jz 0.4.0 → 0.5.0

package/src/resolve.js

@@ -0,0 +1,85 @@
+/**
+ * Module-graph resolver — flattens a file's relative-import graph into the
+ * { code, modules } pair that `compile()` expects.
+ *
+ * Every specifier is canonicalized to an absolute path so the same physical
+ * file always produces one module instance. Two relative specifiers from
+ * different importers (e.g. `'../../parse.js'` from a feature module and
+ * `'./parse.js'` from the entry) would otherwise hit prepare.js as separate
+ * modules with separate exports / mangling prefixes — and any module-level
+ * state (like a shared `lookup` registry) would split in two.
+ */
+
+import { readFileSync, existsSync } from 'fs'
+import { dirname, resolve, join } from 'path'
+import { execFileSync } from 'child_process'
+
+// Matches both `import` and `export ... from` statements (statement position).
+// Lazy `[^'"]*?` consumes whatever sits between the keyword and the first quote.
+const importRe = /^\s*(?:import|export)\s+[^'"]*?['"]([^'"]+)['"]/gm
+
+/**
+ * @param {string} entryFile - absolute or cwd-relative path to the entry module.
+ * @param {object} [opts]
+ * @param {boolean} [opts.resolveNode] - resolve bare specifiers via Node resolution.
+ * @returns {{ code: string, modules: Record<string,string> }}
+ *   `code` is the entry rewritten to canonical keys; `modules` maps every
+ *   reachable absolute path to its (also-rewritten) source.
+ */
+export function resolveModuleGraph(entryFile, { resolveNode = false } = {}) {
+  const dir = dirname(resolve(entryFile))
+  const code = readFileSync(resolve(entryFile), 'utf8')
+  const modules = {}              // keyed by canonical absolute path
+  const seenPaths = new Set()
+  const pkgImports = {}           // pkg.imports spec → absolute path
+
+  const pkgFile = join(dir, 'package.json')
+  if (existsSync(pkgFile)) {
+    try {
+      const pkg = JSON.parse(readFileSync(pkgFile, 'utf8'))
+      if (pkg.imports) for (const [spec, path] of Object.entries(pkg.imports))
+        pkgImports[spec] = resolve(dir, path)
+    } catch {}
+  }
+
+  const resolveBareModule = (specifier, fromDir) => execFileSync(
+    process.execPath,
+    ['--input-type=module', '-e', 'process.stdout.write(import.meta.resolve(process.argv[1]))', specifier],
+    { cwd: fromDir, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }
+  ).trim()
+  const resolveAbsPath = (specifier, fromDir) => {
+    if (pkgImports[specifier]) return pkgImports[specifier]
+    if (specifier.startsWith('./') || specifier.startsWith('../')) {
+      const full = resolve(fromDir, specifier)
+      if (existsSync(full)) return full
+      if (existsSync(full + '.js')) return full + '.js'
+      return null
+    }
+    if (resolveNode) {
+      try {
+        const resolved = resolveBareModule(specifier, fromDir)
+        if (resolved.startsWith('file:')) return new URL(resolved).pathname
+      } catch {}
+    }
+    return null
+  }
+  const rewriteImports = (src, fromDir) => src.replace(importRe, (match, spec) => {
+    const abs = resolveAbsPath(spec, fromDir)
+    if (!abs) return match
+    const q = match[match.lastIndexOf(spec) - 1]
+    return match.slice(0, match.lastIndexOf(spec) - 1) + q + abs + q
+  })
+  const resolveModule = (specifier, fromDir) => {
+    const abs = resolveAbsPath(specifier, fromDir)
+    if (!abs || seenPaths.has(abs)) return
+    seenPaths.add(abs)
+    let src; try { src = readFileSync(abs, 'utf8') } catch { return }
+    modules[abs] = rewriteImports(src, dirname(abs))
+    let m; importRe.lastIndex = 0
+    while ((m = importRe.exec(src)) !== null) resolveModule(m[1], dirname(abs))
+  }
+  let m; importRe.lastIndex = 0
+  while ((m = importRe.exec(code)) !== null) resolveModule(m[1], dir)
+
+  return { code: rewriteImports(code, dir), modules }
+}

package/src/vectorize.js

@@ -389,18 +389,52 @@ function firstAccess(node, name) {
 }
 
 /**
- * Match an address expression `(i32.add base (i32.shl (local.get IND) (i32.const K)))`,
- * with optional outer `(local.tee $A ...)`. Stride 1 fallback: `(i32.add base (local.get IND))`.
+ * Match the index-offset operand of a lane address — the part that scales the
+ * induction variable inside `(i32.add base OFFSET)`. OFFSET is one of:
+ *   (i32.shl (local.get IND) (i32.const K))            → strideLog2 K
+ *   (local.get IND)                                    → strideLog2 0
+ *   (local.tee $T <either of the above>)               → records $T
+ *   (local.get $T)  where $T is a recorded offset-tee  → that tee's strideLog2
+ *
+ * The tee'd form arises from CSE: a map loop `b[i] = f(a[i])` over two distinct
+ * base pointers shares one `i << K` offset (`(local.tee $T (i32.shl i K))` in
+ * the first address, `(local.get $T)` in the second). `offsetTees` (Map
+ * name→strideLog2) carries that across calls.
+ *
+ * Returns { strideLog2, teeName?: string } or null.
+ */
+function matchLaneOffset(off, ind, offsetTees) {
+  if (isArr(off) && off[0] === 'local.get' && typeof off[1] === 'string' &&
+      offsetTees && offsetTees.has(off[1])) {
+    return { strideLog2: offsetTees.get(off[1]), teeName: null }
+  }
+  let teeName = null
+  let n = off
+  if (isArr(n) && n[0] === 'local.tee' && n.length === 3) { teeName = n[1]; n = n[2] }
+  // (i32.shl (local.get ind) (i32.const K))
+  if (isArr(n) && n[0] === 'i32.shl' && n.length === 3 && isLocalGet(n[1], ind)) {
+    const k = constNum(n[2])
+    if (k != null && k >= 0 && k <= 3) return { strideLog2: k, teeName }
+  }
+  // (local.get ind) — stride 1
+  if (isLocalGet(n, ind)) return { strideLog2: 0, teeName }
+  return null
+}
+
+/**
+ * Match an address expression `(i32.add base OFFSET)`, with optional outer
+ * `(local.tee $A ...)`. OFFSET is matched by matchLaneOffset (which also
+ * accepts a CSE'd `(local.tee $T (i32.shl ind K))` / `(local.get $T)` pair).
  * Also accepts `(local.get $A)` when $A is a previously-recorded address tee.
  *
- * Returns { strideLog2, base, teeName?: string, viaLocal?: string } or null.
+ * Returns { strideLog2, base, teeName?, offsetTeeName?, viaLocal? } or null.
  *   `strideLog2` = K for i32.shl form, 0 for plain add form.
  *   `base` is the loop-invariant base subtree.
  */
-function matchLaneAddr(addr, ind, addrLocals) {
+function matchLaneAddr(addr, ind, addrLocals, offsetTees) {
   let teeName = null
   let n = addr
-  // (local.get $A) where $A holds a previously-tee'd lane-address.
+  // (local.get $A) where $A holds a previously-tee'd FULL lane-address.
   if (isArr(n) && n[0] === 'local.get' && typeof n[1] === 'string' && addrLocals && addrLocals.has(n[1])) {
     const e = addrLocals.get(n[1])
     return { strideLog2: e.strideLog2, base: e.base, teeName: null, viaLocal: n[1] }
@@ -411,14 +445,40 @@ function matchLaneAddr(addr, ind, addrLocals) {
   }
   if (!isArr(n) || n[0] !== 'i32.add' || n.length !== 3) return null
   const a = n[1], b = n[2]
-  // case 1: (i32.add base (i32.shl (local.get ind) (i32.const K)))
-  if (isArr(b) && b[0] === 'i32.shl' && b.length === 3 && isLocalGet(b[1], ind)) {
-    const k = constNum(b[2])
-    if (k != null && k >= 0 && k <= 3) return { strideLog2: k, base: a, teeName }
+  const off = matchLaneOffset(b, ind, offsetTees)
+  if (!off) return null
+  return { strideLog2: off.strideLog2, base: a, teeName, offsetTeeName: off.teeName }
+}
+
+/**
+ * A scalar i32 local that is ONLY ever assigned a lane offset — `(i32.shl ind K)`
+ * (or bare `ind` for stride 0) — is a CSE'd offset shared across base pointers.
+ * Returns the consistent strideLog2, or null if any write to it diverges.
+ * This soundness check backs every `(local.get $T)` resolved via `offsetTees`.
+ */
+function _offsetLocalStride(body, name, ind) {
+  let stride = null, found = false, ok = true
+  function walk(n) {
+    if (!isArr(n)) return
+    if ((n[0] === 'local.tee' || n[0] === 'local.set') && n[1] === name && n.length === 3) {
+      found = true
+      const v = n[2]
+      let k = null
+      if (isArr(v) && v[0] === 'i32.shl' && v.length === 3 && isLocalGet(v[1], ind)) {
+        k = constNum(v[2])
+        if (k == null || k < 0 || k > 3) ok = false
+      } else if (isLocalGet(v, ind)) {
+        k = 0
+      } else ok = false
+      if (k != null) {
+        if (stride == null) stride = k
+        else if (stride !== k) ok = false
+      }
+    }
+    for (let i = 1; i < n.length; i++) walk(n[i])
   }
-  // case 2: (i32.add base (local.get ind)) — stride 1
-  if (isLocalGet(b, ind)) return { strideLog2: 0, base: a, teeName }
-  return null
+  for (const s of body) walk(s)
+  return found && ok ? stride : null
 }
 
 // ---- Recognize a (block (loop)) pair --------------------------------------
@@ -486,6 +546,9 @@ function tryVectorize(blockNode, fnLocals, freshIdRef) {
   // both validates the load's address AND records NAME so the matching store's
   // `(local.get NAME)` is accepted as the same lane address.
   const addrLocals = new Map()
+  // Offset tees: name → strideLog2. A CSE'd `i << K` shared across base
+  // pointers (map loops over distinct arrays). Soundness re-checked post-scan.
+  const offsetTees = new Map()
 
   function scanForLoadsStores(node, parent, pi) {
     if (!isArr(node)) return true
@@ -497,10 +560,11 @@ function tryVectorize(blockNode, fnLocals, freshIdRef) {
       } else if (LOAD_OPS[op] !== laneType) {
         return false
       }
-      const m = matchLaneAddr(node[1], incVar, addrLocals)
+      const m = matchLaneAddr(node[1], incVar, addrLocals, offsetTees)
       if (!m) return false
       if ((1 << m.strideLog2) !== stride) return false
       if (m.teeName) addrLocals.set(m.teeName, { strideLog2: m.strideLog2, base: m.base })
+      if (m.offsetTeeName) offsetTees.set(m.offsetTeeName, m.strideLog2)
       loadStoreSites.push({ parent, idx: pi, kind: 'load' })
       return true
     }
@@ -508,10 +572,11 @@ function tryVectorize(blockNode, fnLocals, freshIdRef) {
       const sty = STORE_OPS[op]
       if (laneType != null && sty !== laneType) return false
       if (laneType == null) { laneType = sty; stride = LANE_INFO[laneType].stride }
-      const m = matchLaneAddr(node[1], incVar, addrLocals)
+      const m = matchLaneAddr(node[1], incVar, addrLocals, offsetTees)
       if (!m) return false
       if ((1 << m.strideLog2) !== stride) return false
       if (m.teeName) addrLocals.set(m.teeName, { strideLog2: m.strideLog2, base: m.base })
+      if (m.offsetTeeName) offsetTees.set(m.offsetTeeName, m.strideLog2)
       loadStoreSites.push({ parent, idx: pi, kind: 'store' })
       // Recurse into VALUE child (idx 2) — it's data, not address.
       if (!scanForLoadsStores(node[2], node, 2)) return false
@@ -521,10 +586,13 @@ function tryVectorize(blockNode, fnLocals, freshIdRef) {
     // `(local.set $a (i32.add base (i32.shl i 2)))` as a standalone stmt) —
     // record so a later `(local.get $a)` resolves.
     if ((op === 'local.set' || op === 'local.tee') && typeof node[1] === 'string' && node.length === 3) {
-      const valM = matchLaneAddr(['local.tee', node[1], node[2]], incVar, addrLocals)
+      const valM = matchLaneAddr(['local.tee', node[1], node[2]], incVar, addrLocals, offsetTees)
       if (valM && valM.teeName) {
         addrLocals.set(valM.teeName, { strideLog2: valM.strideLog2, base: valM.base })
       }
+      // Standalone offset compute: `(local.set $t (i32.shl i K))`.
+      const offM = matchLaneOffset(node[2], incVar, offsetTees)
+      if (offM) offsetTees.set(node[1], offM.strideLog2)
     }
     // Recurse into all children
     for (let i = 1; i < node.length; i++) {
@@ -538,6 +606,12 @@ function tryVectorize(blockNode, fnLocals, freshIdRef) {
   if (!laneType) return null  // no memory ops — vectorizing buys nothing
   if (loadStoreSites.length === 0) return null
 
+  // Soundness gate for offset-tee resolution: every `(local.get $T)` we
+  // accepted as `i << K` is only valid if EVERY write of $T is that offset.
+  for (const [name, k] of offsetTees) {
+    if (_offsetLocalStride(body, name, incVar) !== k) return null
+  }
+
   // Classify all locals referenced in body.
   // - induction var (incVar): exempt
   // - bound local (if any): must be invariant
@@ -571,7 +645,7 @@ function tryVectorize(blockNode, fnLocals, freshIdRef) {
       // Discriminate lane-data vs address-tee. Address tees hold i32 addresses,
       // not vector data. We classify by checking the local's declared type.
       const decl = fnLocals.get(name)
-      if (decl === 'i32' && _isAddressLocal(body, name, incVar)) {
+      if (decl === 'i32' && (offsetTees.has(name) || _isAddressLocal(body, name, incVar))) {
         localKind.set(name, 'addr')
       } else {
         localKind.set(name, 'lane')
@@ -710,16 +784,18 @@ function tryReduceVectorize(blockNode, fnLocals, freshIdRef) {
   const laneType = reduceEntry.laneType
   const stride = LANE_INFO[laneType].stride
   const addrLocals = new Map()
+  const offsetTees = new Map()
   let loadCount = 0
   function scanExpr(node) {
     if (!isArr(node)) return true
     const op = node[0]
     if (LOAD_OPS[op]) {
       if (LOAD_OPS[op] !== laneType) return false
-      const m = matchLaneAddr(node[1], incVar, addrLocals)
+      const m = matchLaneAddr(node[1], incVar, addrLocals, offsetTees)
       if (!m) return false
       if ((1 << m.strideLog2) !== stride) return false
       if (m.teeName) addrLocals.set(m.teeName, { strideLog2: m.strideLog2, base: m.base })
+      if (m.offsetTeeName) offsetTees.set(m.offsetTeeName, m.strideLog2)
       loadCount++
       return true
     }
@@ -731,6 +807,10 @@ function tryReduceVectorize(blockNode, fnLocals, freshIdRef) {
   }
   if (!scanExpr(exprNode)) return null
   if (loadCount === 0) return null
+  // Soundness gate for offset-tee resolution (see tryVectorize).
+  for (const [name, k] of offsetTees) {
+    if (_offsetLocalStride([exprNode], name, incVar) !== k) return null
+  }
 
   // Classify locals referenced in EXPR. Anything not the induction var or an
   // address-tee is invariant (we forbade local.set/tee in scanExpr).
@@ -744,10 +824,11 @@ function tryReduceVectorize(blockNode, fnLocals, freshIdRef) {
   const localKind = new Map()
   for (const name of referenced) {
     if (name === incVar) continue
-    if (addrLocals.has(name)) { localKind.set(name, 'addr'); continue }
+    if (addrLocals.has(name) || offsetTees.has(name)) { localKind.set(name, 'addr'); continue }
     localKind.set(name, 'invariant')
   }
   for (const name of addrLocals.keys()) localKind.set(name, 'addr')
+  for (const name of offsetTees.keys()) localKind.set(name, 'addr')
 
   const ctx = { laneType, incVar, localKind, newLanedLocals: new Map(), fail: false, failReason: null }
   const liftedExpr = liftExprV(exprNode, ctx)

package/src/ast.js

@@ -1,160 +0,0 @@
-/**
- * AST analysis predicates — pure functions over jz AST arrays.
- *
- * Extracted from emit.js to reduce the God File and enable reuse.
- * These functions walk the jz AST (array-of-atoms format) and answer
- * structural questions without emitting any IR.
- *
- * # Convention
- * AST nodes are either:
- *   - strings (identifiers / bare names)
- *   - numbers (numeric literals)
- *   - arrays where [0] is the operator tag: ['+', a, b], ['let', ...], ['=>', params, body], etc.
- *   - [null, value] for parenthesized/boxed literals
- *
- * @module ast
- */
-
-import { ASSIGN_OPS, intLiteralValue } from './analyze.js'
-import { ctx } from './ctx.js'
-
-/** Detect whether `name` is written to (=, +=, ++, --, etc.) anywhere within `body`.
- *  Conservative over-reject: if unsure, treat as written.
- *  `let`/`const` declarations are NOT reassignments — only the initializer expressions
- *  inside them are scanned. */
-export function isReassigned(body, name) {
-  if (!Array.isArray(body)) return false
-  const op = body[0]
-  if (ASSIGN_OPS.has(op) && body[1] === name) return true
-  if ((op === '++' || op === '--') && body[1] === name) return true
-  if (op === 'let' || op === 'const') {
-    for (let i = 1; i < body.length; i++) {
-      const d = body[i]
-      if (Array.isArray(d) && d[0] === '=' && d[2] != null && isReassigned(d[2], name)) return true
-    }
-    return false
-  }
-  for (let i = 1; i < body.length; i++) if (isReassigned(body[i], name)) return true
-  return false
-}
-
-/** Does `body` contain a `continue` that targets THIS loop?
- *  A `continue` inside a nested `for`/`while`/`do` targets the inner loop, so we don't count it. */
-export function hasOwnContinue(body) {
-  if (!Array.isArray(body)) return false
-  const op = body[0]
-  if (op === 'continue') return true
-  if (op === 'for' || op === 'while' || op === 'do') return false
-  for (let i = 1; i < body.length; i++) if (hasOwnContinue(body[i])) return true
-  return false
-}
-
-export function hasOwnBreakOrContinue(body) {
-  if (!Array.isArray(body)) return false
-  const op = body[0]
-  if (op === 'break' || op === 'continue') return true
-  if (op === 'for' || op === 'while' || op === 'do' || op === '=>') return false
-  for (let i = 1; i < body.length; i++) if (hasOwnBreakOrContinue(body[i])) return true
-  return false
-}
-
-export function containsNestedClosure(body) {
-  if (!Array.isArray(body)) return false
-  if (body[0] === '=>') return true
-  for (let i = 1; i < body.length; i++) if (containsNestedClosure(body[i])) return true
-  return false
-}
-
-export function containsNestedLoop(body) {
-  if (!Array.isArray(body)) return false
-  const op = body[0]
-  if (op === 'for' || op === 'while' || op === 'do') return true
-  if (op === '=>') return false
-  for (let i = 1; i < body.length; i++) if (containsNestedLoop(body[i])) return true
-  return false
-}
-
-/** Recursive loop size estimator — product of trip counts for nested `for (let i=0; i<N; i++)` loops. */
-export function nestedSmallLoopBudget(body) {
-  if (!Array.isArray(body)) return 1
-  if (body[0] === '=>') return 1
-  if (body[0] === 'for') {
-    const [, init, cond, step, loopBody] = body
-    const n = smallConstForTripCount(init, cond, step)
-    return n == null ? MAX_NESTED_FOR_UNROLL + 1 : n * nestedSmallLoopBudget(loopBody)
-  }
-  let max = 1
-  for (let i = 1; i < body.length; i++) max = Math.max(max, nestedSmallLoopBudget(body[i]))
-  return max
-}
-
-export function containsDeclOf(body, name) {
-  if (!Array.isArray(body)) return false
-  const op = body[0]
-  if (op === '=>') return false
-  if (op === 'let' || op === 'const') {
-    for (let i = 1; i < body.length; i++) {
-      const d = body[i]
-      if (d === name) return true
-      if (Array.isArray(d) && d[0] === '=' && d[1] === name) return true
-    }
-  }
-  for (let i = 1; i < body.length; i++) if (containsDeclOf(body[i], name)) return true
-  return false
-}
-
-/** Clone AST node, substituting bare-name matches with [null, value]. Skips into closures. */
-export function cloneWithSubst(node, name, value) {
-  if (node === name) return [null, value]
-  if (!Array.isArray(node)) return node
-  if (node[0] === '=>') return node
-  return node.map(x => cloneWithSubst(x, name, value))
-}
-
-export const MAX_SMALL_FOR_UNROLL = 8
-export const MAX_NESTED_FOR_UNROLL = 64
-
-/** Does `body` access a typed-array element by string name known to the type system? */
-export function containsKnownTypedArrayIndex(body) {
-  if (!Array.isArray(body)) return false
-  if (body[0] === '=>') return false
-  if (body[0] === '[]' && typeof body[1] === 'string' && ctx.types.typedElem?.has(body[1])) return true
-  for (let i = 1; i < body.length; i++) if (containsKnownTypedArrayIndex(body[i])) return true
-  return false
-}
-
-/** Analyze `for (let i=0; i<N; i++)` trip count. Returns N if structurally matches, else null. */
-export function smallConstForTripCount(init, cond, step) {
-  if (!Array.isArray(init) || init[0] !== 'let' || init.length !== 2) return null
-  const decl = init[1]
-  if (!Array.isArray(decl) || decl[0] !== '=' || typeof decl[1] !== 'string') return null
-  const name = decl[1]
-  const start = intLiteralValue(decl[2])
-  if (start !== 0) return null
-
-  if (!Array.isArray(cond) || cond[0] !== '<' || cond[1] !== name) return null
-  const end = intLiteralValue(cond[2])
-  if (end == null || end < 0 || end > MAX_SMALL_FOR_UNROLL) return null
-
-  const stepOk = Array.isArray(step) && (
-    (step[0] === '++' && step[1] === name) ||
-    (step[0] === '-' && Array.isArray(step[1]) && step[1][0] === '++' && step[1][1] === name && intLiteralValue(step[2]) === 1)
-  )
-  return stepOk ? end : null
-}
-
-/** Does `body` always exit the enclosing scope (return / throw / break / continue)? */
-export function isTerminator(body) {
-  if (!Array.isArray(body)) return false
-  const op = body[0]
-  if (op === 'return' || op === 'throw' || op === 'break' || op === 'continue') return true
-  if (op === '{}' || op === ';') {
-    for (let i = body.length - 1; i >= 1; i--) {
-      const s = body[i]
-      if (s == null) continue
-      return isTerminator(s)
-    }
-    return false
-  }
-  return false
-}

package/src/auto-config.js

@@ -1,120 +0,0 @@
-/**
- * Auto-detect optimization tuning from source characteristics.
- *
- * Scans the prepared AST + ctx.func.list to infer program properties
- * and returns suggested optimization overrides. When the user does not
- * explicitly configure individual passes, these suggestions are merged
- * in before resolveOptimize() so the compiler self-tunes.
- *
- * @module auto-config
- */
-
-import { ctx } from './ctx.js'
-
-const LOOP_OPS = new Set(['for', 'while', 'do', 'do-while'])
-const TYPED_CTORS = new Set([
-  'new.Float32Array', 'new.Float64Array', 'new.Int8Array', 'new.Int16Array',
-  'new.Int32Array', 'new.Uint8Array', 'new.Uint16Array', 'new.Uint32Array',
-  'new.Uint8ClampedArray',
-])
-
-function nodeSize(node) {
-  if (!Array.isArray(node)) return 1
-  let n = 1
-  for (let i = 1; i < node.length; i++) n += nodeSize(node[i])
-  return n
-}
-
-function scanNode(node, stats, loopDepth) {
-  if (!Array.isArray(node)) return
-  const op = node[0]
-
-  if (LOOP_OPS.has(op)) {
-    stats.loopCount++
-    const d = loopDepth + 1
-    if (d > stats.maxLoopDepth) stats.maxLoopDepth = d
-    for (let i = 1; i < node.length; i++) scanNode(node[i], stats, d)
-    return
-  }
-
-  if (op === '()') {
-    stats.callSites++
-    const callee = node[1]
-    if (typeof callee === 'string' && TYPED_CTORS.has(callee)) {
-      stats.typedArrayCount++
-      const args = node[2]
-      const argList = args == null ? [] : (Array.isArray(args) && args[0] === ',') ? args.slice(1) : [args]
-      const lenLit = typeof argList[0] === 'number' ? argList[0] : null
-      if (lenLit != null && lenLit > stats.maxTypedArrayLen) stats.maxTypedArrayLen = lenLit
-    }
-  }
-
-  if (op === 'str') stats.stringLiteralCount++
-  if (op === '=>') stats.closureCount++
-
-  for (let i = 1; i < node.length; i++) scanNode(node[i], stats, loopDepth)
-}
-
-function scanStats(ast, code) {
-  const stats = {
-    sourceChars: code?.length || 0,
-    funcCount: 0,
-    maxFuncBodySize: 0,
-    loopCount: 0,
-    maxLoopDepth: 0,
-    typedArrayCount: 0,
-    maxTypedArrayLen: 0,
-    stringLiteralCount: 0,
-    closureCount: 0,
-    callSites: 0,
-  }
-
-  if (ctx.func?.list) {
-    stats.funcCount = ctx.func.list.length
-    for (const f of ctx.func.list) {
-      if (f.body) {
-        const sz = nodeSize(f.body)
-        if (sz > stats.maxFuncBodySize) stats.maxFuncBodySize = sz
-        scanNode(f.body, stats, 0)
-      }
-    }
-  }
-  if (ast) scanNode(ast, stats, 0)
-  return stats
-}
-
-/**
- * Detect optimization config from source characteristics.
- * Returns an object of pass overrides; empty object means "use defaults".
- */
-export function detectOptimizeConfig(ast, code) {
-  const s = scanStats(ast, code)
-  const cfg = {}
-
-  // Machine-generated or large code: watr's WAT-level CSE/DCE/inline fights
-  // jz's already-optimized IR and inflates output. Disable it automatically.
-  const isLarge = s.sourceChars > 4000 || s.funcCount > 40 || s.maxFuncBodySize > 300
-  const isMachineLike = s.callSites > 300 && s.stringLiteralCount < 10
-  if (isLarge || isMachineLike) cfg.watr = false
-
-  // Typed-array heavy: tighten scalarization thresholds when we see large
-  // fixed-size arrays; keep defaults for small/dynamic ones.
-  if (s.typedArrayCount > 0 && s.maxTypedArrayLen > 0) {
-    cfg.scalarTypedArrayLen = Math.min(32, Math.max(8, s.maxTypedArrayLen + 4))
-    cfg.scalarTypedLoopUnroll = s.maxLoopDepth > 1 ? 8 : 16
-    cfg.scalarTypedNestedUnroll = s.maxLoopDepth > 1 ? 32 : 128
-  }
-
-  // String-heavy: ensure pool sorting is on (already default, but explicit).
-  if (s.stringLiteralCount > 30) {
-    cfg.sortStrPoolByFreq = true
-  }
-
-  // Closure-heavy: ptr hoists pay off.
-  if (s.closureCount > 4) {
-    cfg.hoistPtrType = true
-    cfg.hoistInvariantPtrOffset = true
-  }
-
-  return cfg
-}