@barefootjs/jsx 0.16.0 → 0.17.1

package/src/expression-parser.ts

@@ -14,7 +14,16 @@ import ts from 'typescript'
 
 export type ParsedExpr =
   | { kind: 'identifier'; name: string }
-  | { kind: 'literal'; value: string | number | boolean | null; literalType: 'string' | 'number' | 'boolean' | 'null' }
+  // `raw` is the numeric literal's `ts.NumericLiteral.text` — the token TS
+  // itself normalises (separators stripped, radix / exponent folded to
+  // decimal: `1_000`/`0x10`/`1e3` → `1000`/`16`/`1000`). It is NOT the
+  // verbatim source spelling. Its value is that it equals the exact string an
+  // adapter's literal lowering already emits, so a structured lowering matches
+  // byte-for-byte — which the lossy `parseFloat` `value` can't guarantee (e.g.
+  // `parseFloat('1_000')` is 1, and large integers lose precision). Only
+  // populated for numeric literals; string / boolean / null carry their
+  // canonical form in `value`.
+  | { kind: 'literal'; value: string | number | boolean | null; literalType: 'string' | 'number' | 'boolean' | 'null'; raw?: string }
   | { kind: 'call'; callee: ParsedExpr; args: ParsedExpr[] }
   | { kind: 'member'; object: ParsedExpr; property: string; computed: boolean }
   // Element access with a NON-literal index (`selected()[index]`,
@@ -30,9 +39,34 @@ export type ParsedExpr =
   | { kind: 'conditional'; test: ParsedExpr; consequent: ParsedExpr; alternate: ParsedExpr }
   | { kind: 'logical'; op: '&&' | '||' | '??'; left: ParsedExpr; right: ParsedExpr }
   | { kind: 'template-literal'; parts: TemplatePart[] }
-  | { kind: 'arrow-fn'; param: string; body: ParsedExpr }
-  | { kind: 'higher-order'; method: 'filter' | 'every' | 'some' | 'find' | 'findIndex' | 'findLast' | 'findLastIndex'; object: ParsedExpr; param: string; predicate: ParsedExpr }
+  // Expression-bodied arrow (`(a, b) => …`), multi-parameter. A
+  // single-`return` block body is normalised to its returned expression;
+  // a single object-binding-pattern param (`({done}) => done`) is rewritten
+  // to a synthetic identifier param with dotted-access body. Higher-order
+  // callbacks (`.filter`/`.sort`/`.reduce`/`.flatMap`) arrive as a generic
+  // `call` whose argument is this kind; the adapter serializes `body` to the
+  // runtime evaluator (#2018). Block bodies with locals / multiple statements,
+  // and array-binding-pattern params, stay `unsupported`.
+  | { kind: 'arrow'; params: string[]; body: ParsedExpr }
+  // A regex literal carried as its exact source text (`/\/+$/`), so the Go
+  // ctor lowering matches the one trailing-slash-strip pattern it recognises
+  // (`String.replace`). Outside that narrow surface a regex resolves to
+  // `unsupported`.
+  | { kind: 'regex'; raw: string }
   | { kind: 'array-literal'; elements: ParsedExpr[] }
+  // Object literal `{ a: 1, b: x }` / shorthand `{ a }`. Carried so an
+  // adapter that lowers an object *value* (Go `map[string]interface{}`,
+  // Perl hashref) can emit from structure instead of re-parsing the
+  // source with `ts.createSourceFile`. Only produced for plain literals:
+  // every property is a non-computed `key: value` or shorthand `{ key }`.
+  // Spreads, computed keys, methods, and getters/setters fall through to
+  // `unsupported` (unchanged). `raw` is the original expression string —
+  // the same value the old `unsupported` fallback carried — so an adapter
+  // that does not yet consume `properties` stays byte-identical by
+  // emitting it exactly as it emits `unsupported`. Extending the type
+  // adds a TS compile error in every exhaustive `ParsedExpr` switch, the
+  // same drift defence used for `array-literal` / `array-method`.
+  | { kind: 'object-literal'; properties: ObjectLiteralProperty[]; raw: string }
   // Non-higher-order array methods. Discriminated by `method` so each
   // adapter handles the full set via one exhaustive switch instead of
   // sprinkling per-method branches across the call / member emitters.
@@ -65,39 +99,6 @@ export type ParsedExpr =
       object: ParsedExpr
       args: ParsedExpr[]
     }
-  // `.sort(cmp)` / `.toSorted(cmp)` (#1448 Tier B). The comparator is
-  // extracted into a structured `SortComparator` at parse time — the
-  // arrow function never reaches `args`, so adapters don't have to
-  // re-walk the arrow-fn ParsedExpr to recover the key / direction
-  // (and the same shape feeds both standalone position and the
-  // `.sort().map()` chained-loop hoist in `jsx-to-ir.ts`). If the
-  // comparator doesn't match the supported catalogue
-  // (`extractSortComparatorFromTS` below), parsing falls
-  // through to `unsupported` so adapters surface BF101 with an
-  // @client suggestion.
-  | {
-      kind: 'array-method'
-      method: 'sort' | 'toSorted'
-      object: ParsedExpr
-      args: []
-      comparator: SortComparator
-    }
-  // `.reduce(fn, init)` (#1448 Tier C). Like sort, the reducer is
-  // extracted into a structured `ReduceOp` at parse time — the
-  // two-param arrow never reaches `args`, so adapters fold via a
-  // runtime helper instead of re-walking the callback. The accepted
-  // catalogue is the arithmetic-fold family only (`acc + key` /
-  // `acc * key`, numeric or string-concat); any other reducer body,
-  // or a missing initial value, falls through to `unsupported` so
-  // adapters surface BF101 with an @client suggestion. See
-  // `extractReduceOpFromTS` below.
-  | {
-      kind: 'array-method'
-      method: 'reduce' | 'reduceRight'
-      object: ParsedExpr
-      args: []
-      reduceOp: ReduceOp
-    }
   // `.flat(depth?)` (#1448 Tier C). The flatten depth is validated and
   // normalised into a structured `FlatDepth` at parse time — the literal
   // never reaches `args`, so adapters fold via a runtime helper instead of
@@ -111,22 +112,29 @@ export type ParsedExpr =
       args: []
       flatDepth: FlatDepth
     }
-  // `.flatMap(fn)` value-returning field projection (#1448 Tier C). The
-  // callback is extracted into a structured `FlatMapOp` (self / field
-  // projection) at parse time, mirroring sort / reduce. The projected
-  // per-item value is flattened one level (flatMap = map + flat(1)).
-  // Array-literal / complex callbacks fall through to `unsupported`; the
-  // JSX-returning `.flatMap` is handled as an `IRLoop` upstream and never
-  // reaches here. See `extractFlatMapOpFromTS` below.
-  | {
-      kind: 'array-method'
-      method: 'flatMap'
-      object: ParsedExpr
-      args: []
-      flatMapOp: FlatMapOp
-    }
   | { kind: 'unsupported'; raw: string; reason: string }
 
+/**
+ * One property of an `object-literal` `ParsedExpr`. The key is the
+ * resolved (non-computed) property name — for `{ a: 1 }` and shorthand
+ * `{ a }` it is `a`; for `{ 'a-b': 1 }` it is `a-b`. Computed keys
+ * (`{ [k]: 1 }`) are not represented; such literals fall through to
+ * `unsupported` at parse time.
+ */
+export type ObjectLiteralProperty = {
+  key: string
+  // The syntactic kind of the key, since `key` normalises all three to a
+  // string and so loses the distinction. A consumer that must treat a numeric
+  // key (`{ 1: 'a' }`) differently from a same-text string key (`{ '1': 'a' }`)
+  // reads this; most consumers ignore it. `identifier` for shorthand.
+  keyKind?: 'identifier' | 'string' | 'numeric'
+  // Shorthand `{ a }` (the value is the identifier `a`) vs explicit
+  // `{ a: <value> }`. The `value` already carries the resolved tree
+  // either way; this flag is kept for re-stringification fidelity.
+  shorthand: boolean
+  value: ParsedExpr
+}
+
 /**
  * One comparison key inside a sort comparator. A simple
  * `(a, b) => a.f - b.f` produces a single key; a multi-key
@@ -152,83 +160,19 @@ export type SortKey = {
 }
 
 /**
- * Structured form of a JS `(a, b) => …` sort comparator. Built once
- * at parse time and consumed by both adapters' arrayMethod emit and
- * (when chained directly before `.map()`) the loop-hoist path in
- * `jsx-to-ir.ts`. The shape is intentionally finite — see
- * `extractSortComparatorFromTS` for the accepted catalogue.
+ * Structured form of a JS `(a, b) => …` sort comparator. Recovered from
+ * the generic `arrow` callback body by {@link sortComparatorFromArrow} as
+ * the LEGACY fallback for a comparator the runtime evaluator can't model
+ * (`localeCompare` string sorts — `serializeParsedExpr` refuses them).
+ * Consumed by the adapters' `bf_sort` / `bf->sort` emit. The shape is
+ * intentionally finite — see {@link sortComparatorFromArrow} for the
+ * accepted catalogue.
  */
 export type SortComparator = {
   // Comparison keys in priority order. A simple comparator has one
   // key; a `||`-chained multi-key comparator has one per operand.
   // Always length >= 1.
   keys: SortKey[]
-  // Original JS source of the comparator body; preserved so `@client`
-  // fallback can re-emit the user's exact expression if the call site
-  // ever gets relocated to the runtime. For block-body comparators
-  // this is the returned expression, not the `{ … }` block — so the
-  // client fallback's synthetic `(a, b) => raw` arrow stays valid.
-  raw: string
-  // The two parameter names the user wrote (e.g. `a`/`b`, or
-  // `lhs`/`rhs`). Only consumed by the client-side `@client`
-  // fallback path that ships the raw comparator body to JS — it
-  // needs to bind these names in a closure so `raw` evaluates
-  // against the right operands. Server-side lowering doesn't read
-  // them.
-  paramA: string
-  paramB: string
-  // Which JS method name the user wrote — both shapes share the same
-  // lowering (templates render a snapshot, so the JS mutate vs new
-  // distinction is moot) but we preserve the original for source maps
-  // and error messages.
-  method: 'sort' | 'toSorted'
-}
-
-/**
- * Structured form of a JS `.reduce((acc, item) => …, init)` call,
- * built once at parse time and consumed by both template adapters'
- * `reduceMethod()` emit (#1448 Tier C). The shape is intentionally
- * finite — only the arithmetic-fold family is lowerable in a
- * declarative template; arbitrary accumulator bodies are not. See
- * `extractReduceOpFromTS` for the accepted catalogue.
- */
-export type ReduceOp = {
-  // The fold operator between accumulator and per-item value. `+`
-  // covers numeric sums and (with a string init) string concatenation;
-  // `*` covers numeric products. Subtraction / division are excluded —
-  // they're order-sensitive and rarely written as a `.reduce`.
-  op: '+' | '*'
-  // What value each item contributes to the fold:
-  //   { kind: 'self' }         → `acc + item`        (primitive array)
-  //   { kind: 'field', field } → `acc + item.field`  (struct-field accessor)
-  key: { kind: 'self' } | { kind: 'field'; field: string }
-  // Numeric fold vs string concatenation. Determined by the init
-  // literal's type: a number init folds numerically; a string init
-  // (only valid with `+`) concatenates. Both template runtimes apply
-  // the same coercion so their output stays byte-equal; this can
-  // diverge from JS for floating-point sums whose decimal expansion
-  // differs by runtime (rare in SSR data — integer sums agree).
-  type: 'numeric' | 'string'
-  // Decoded initial-accumulator value (never raw source). For a numeric
-  // fold this is TypeScript's canonical decimal form (`1_000` -> `1000`,
-  // `0x10` -> `16`) so `strconv.ParseFloat` / Perl agree; for a concat
-  // fold it's the contents of a quoted string literal (only single- or
-  // double-quoted `ts.StringLiteral` seeds are accepted — template
-  // literals and escape-carrying literals are refused at parse time, so
-  // the value is an escape-free single-line string, e.g. the empty
-  // string "" or a separator like ", "). Round-trip emitters re-quote a
-  // string init via `JSON.stringify`; a numeric init re-emits as-is.
-  init: string
-  // Original JS source of the reducer body (the returned expression
-  // for block bodies). Lets the `@client` fallback ship the user's
-  // exact arrow to the JS runtime.
-  raw: string
-  // The two parameter names the user wrote (e.g. `acc`/`item`, or
-  // `sum`/`t`). Only the `@client` fallback reads them — it binds them
-  // in a synthetic `(acc, item) => raw` arrow. Server-side lowering
-  // works off `op` / `key` / `init` and ignores them.
-  paramAcc: string
-  paramItem: string
 }
 
 /**
@@ -241,38 +185,6 @@ export type ReduceOp = {
  */
 export type FlatDepth = number | 'infinity'
 
-/**
- * A single non-computed projection leaf on the flatMap callback param —
- * the item itself (`i`) or one of its fields (`i.field`). Shared by the
- * scalar and tuple `FlatMapOp` projections.
- */
-export type FlatMapLeaf = { kind: 'self' } | { kind: 'field'; field: string }
-
-/**
- * Structured form of a value-returning `.flatMap(fn)` callback (#1448
- * Tier C). The accepted catalogue:
- *
- *   i => i            → self  projection (flatten one level)
- *   i => i.field      → field projection (flatten a per-item array field)
- *   i => [i.a, i.b]   → tuple projection (gather per-item leaves)
- *
- * The scalar `self` / `field` projections return a value that is then
- * flattened one level (flatMap = map + flat(1)) — a non-array value is
- * kept as-is, matching JS. The `tuple` projection returns an array
- * literal; flat(1) removes only that literal's wrapper, so each leaf is
- * appended verbatim (an array-valued leaf is NOT spread). Leaves outside
- * self / field (literals, `i.a + 1`, calls, deep access) refuse with
- * BF101. See `extractFlatMapOpFromTS`.
- */
-export type FlatMapOp = {
-  // What each item projects to before the one-level flatten.
-  projection: FlatMapLeaf | { kind: 'tuple'; elements: FlatMapLeaf[] }
-  // The callback param name the user wrote (for the `@client` round-trip).
-  param: string
-  // Original JS source of the callback body (for the `@client` fallback).
-  raw: string
-}
-
 export type TemplatePart =
   | { type: 'string'; value: string }
   | { type: 'expression'; expr: ParsedExpr }
@@ -335,8 +247,12 @@ export interface SupportResult {
 const UNSUPPORTED_METHODS = new Set([
   // Higher-order array methods. Seven of these (`filter`, `every`,
   // `some`, `find`, `findIndex`, `findLast`, `findLastIndex`) are
-  // intercepted as `higher-order` IR before reaching this gate;
-  // `map` is intercepted as an IRLoop. `reduce` / `reduceRight` stay
+  // intercepted as `higher-order` IR before reaching this gate.
+  // `map` is intercepted as an IRLoop when its callback returns JSX,
+  // and as a `CALLBACK_METHODS` evaluator lowering (`map_eval`, #2073)
+  // when it returns a value — it stays listed here so the fall-throughs
+  // (a bare `arr.map` reference, a function-reference callback) still
+  // refuse loudly. `reduce` / `reduceRight` stay
   // listed here so the shapes the Tier C catalogue can't lower still
   // refuse loudly: the `convertNode` call branch intercepts a matching
   // `.reduce(fn, init)` / `.reduceRight(fn, init)` into the structured
@@ -669,6 +585,73 @@ export function parseExpression(expr: string): ParsedExpr {
   return convertNode(firstStmt.expression, expr)
 }
 
+/**
+ * Convert an already-parsed TypeScript node directly into a {@link ParsedExpr},
+ * for a consumer that already holds a `ts.Node` (e.g. a `.sort()` callback at
+ * the loop-hoist site) and wants the structured conversion without re-parsing
+ * source via `ts.createSourceFile`. An `unsupported` result still carries the
+ * node's text in `raw` for debugging (a synthetic node with no source file
+ * falls back to '').
+ */
+export function tsNodeToParsedExpr(node: ts.Node): ParsedExpr {
+  let raw = ''
+  try {
+    raw = node.getText()
+  } catch {
+    /* synthetic node without a source file */
+  }
+  return convertNode(node, raw)
+}
+
+/**
+ * Higher-order array methods whose callback body the runtime evaluator drives
+ * (#2018). Recognised generically as a `call` whose callee is `<recv>.<method>`
+ * and whose first argument is an `arrow`; the adapter serializes the arrow body
+ * to the evaluator. A JSX-returning `.map` / `.flatMap` is an IRLoop upstream
+ * and never reaches this recognition; the value-returning `.map(cb)` form
+ * (e.g. `tags.map(t => \`#${t}\`).join(' ')`) lowers via `map_eval` (#2073).
+ */
+export const CALLBACK_METHODS: ReadonlySet<string> = new Set([
+  'filter', 'map', 'every', 'some', 'find', 'findIndex', 'findLast', 'findLastIndex',
+  'sort', 'toSorted', 'reduce', 'reduceRight', 'flatMap',
+])
+
+/**
+ * A recognised higher-order callback method call: `<object>.<method>(<arrow>,
+ * …rest)` where `method ∈` {@link CALLBACK_METHODS} and the first argument is a
+ * generic `arrow`. Returns the receiver, the callback arrow, and any trailing
+ * args (e.g. the `.reduce` init), or `null` if the shape doesn't match. The
+ * single recognition point shared by the support gate and the adapter dispatch.
+ */
+export function asCallbackMethodCall(expr: ParsedExpr): {
+  method: string
+  object: ParsedExpr
+  arrow: Extract<ParsedExpr, { kind: 'arrow' }>
+  args: ParsedExpr[]
+} | null {
+  if (expr.kind !== 'call') return null
+  if (expr.callee.kind !== 'member' || expr.callee.computed) return null
+  if (!CALLBACK_METHODS.has(expr.callee.property)) return null
+  const arrow = expr.args[0]
+  if (!arrow || arrow.kind !== 'arrow') return null
+  return { method: expr.callee.property, object: expr.callee.object, arrow, args: expr.args.slice(1) }
+}
+
+/**
+ * Resolve a non-computed object-literal property key to its string name.
+ * Identifier / string / numeric names resolve to their text; a computed
+ * (`[expr]`) or otherwise non-plain key returns null so the caller treats
+ * the whole literal as `unsupported`.
+ */
+function objectLiteralKeyName(
+  name: ts.PropertyName,
+): { key: string; keyKind: 'identifier' | 'string' | 'numeric' } | null {
+  if (ts.isIdentifier(name)) return { key: name.text, keyKind: 'identifier' }
+  if (ts.isStringLiteral(name)) return { key: name.text, keyKind: 'string' }
+  if (ts.isNumericLiteral(name)) return { key: name.text, keyKind: 'numeric' }
+  return null
+}
+
 /**
  * Convert a TypeScript AST node to ParsedExpr.
  */
@@ -683,10 +666,13 @@ function convertNode(node: ts.Node, raw: string): ParsedExpr {
     return { kind: 'literal', value: node.text, literalType: 'string' }
   }
 
-  // Numeric literal: 0, 5, 3.14
+  // Numeric literal: 0, 5, 3.14. Keep `ts.NumericLiteral.text` in `raw` (TS's
+  // normalised token — `1_000`/`0x10`/`1e3` → `1000`/`16`/`1000`) so an adapter
+  // emits the exact string its own literal lowering already produces; `value`
+  // is the parsed number for structural reasoning.
   if (ts.isNumericLiteral(node)) {
     const value = parseFloat(node.text)
-    return { kind: 'literal', value, literalType: 'number' }
+    return { kind: 'literal', value, literalType: 'number', raw: node.text }
   }
 
   // Boolean literals and null
@@ -705,37 +691,26 @@ function convertNode(node: ts.Node, raw: string): ParsedExpr {
     const callee = convertNode(node.expression, raw)
     const args = node.arguments.map(arg => convertNode(arg, raw))
 
-    // Detect higher-order methods: arr.filter(x => pred), arr.every(x => pred), arr.some(x => pred)
-    if (callee.kind === 'member' && ['filter', 'every', 'some', 'find', 'findIndex', 'findLast', 'findLastIndex'].includes(callee.property)) {
-      if (args.length === 1 && args[0].kind === 'arrow-fn') {
-        const arrowFn = args[0] as { kind: 'arrow-fn'; param: string; body: ParsedExpr }
-        return {
-          kind: 'higher-order',
-          method: callee.property as 'filter' | 'every' | 'some' | 'find' | 'findIndex' | 'findLast' | 'findLastIndex',
-          object: callee.object,
-          param: arrowFn.param,
-          predicate: arrowFn.body,
-        }
-      }
-      // .filter(Boolean) — non-arrow callable with a fixed JS semantic
-      // (the identity-truthy predicate). Synthesise the equivalent
-      // `x => x` so adapters can re-use their existing higher-order
-      // lowering instead of needing a separate callee-resolution path.
-      // Other identifier-callable predicates would need #1389-style
-      // user-supplied callee resolution; out of scope here.
-      if (
-        callee.property === 'filter' &&
-        args.length === 1 &&
-        args[0].kind === 'identifier' &&
-        args[0].name === 'Boolean'
-      ) {
-        return {
-          kind: 'higher-order',
-          method: 'filter',
-          object: callee.object,
-          param: '_',
-          predicate: { kind: 'identifier', name: '_' },
-        }
+    // Higher-order callback methods (`.filter`/`.find`/`.every`/`.some`/
+    // `.sort`/`.reduce`/`.flatMap`/…) are NOT folded here (#2018 P5): they
+    // flow through as a generic `call` whose argument is a generic `arrow`,
+    // and the adapter recognises the callback shape at dispatch and serializes
+    // the arrow body to the runtime evaluator. The one exception is the
+    // non-arrow `.filter(Boolean)` callable: synthesise the equivalent
+    // identity arrow `_ => _` so it flows through the same callback lowering
+    // (the adapter keeps a dedicated truthiness fallback for the identity body).
+    if (
+      callee.kind === 'member' &&
+      !callee.computed &&
+      callee.property === 'filter' &&
+      args.length === 1 &&
+      args[0].kind === 'identifier' &&
+      args[0].name === 'Boolean'
+    ) {
+      return {
+        kind: 'call',
+        callee,
+        args: [{ kind: 'arrow', params: ['_'], body: { kind: 'identifier', name: '_' } }],
       }
     }
 
@@ -931,9 +906,12 @@ function convertNode(node: ts.Node, raw: string): ParsedExpr {
       // replacing the FIRST occurrence (JS semantics for a string
       // pattern). Go uses `bf_replace` (`strings.Replace` with n=1);
       // Mojo uses `bf->replace` (index/substr splice, no regex). A
-      // regex-literal pattern parses as `unsupported` (convertNode has
-      // no regex arm), so it's refused explicitly here rather than
-      // emitting a broken `.Replace` — the Perl `s///` vs Go
+      // regex-literal pattern is the deferred form — its `regex` first
+      // arg is carried STRUCTURALLY (not collapsed to `unsupported`) so
+      // the Go ctor lowering can recover the one trailing-slash pattern
+      // it supports without re-parsing (#2039). Template use stays
+      // refused: `isSupported` maps a regex-pattern `.replace` to the
+      // deferred-form BF101 reason — the Perl `s///` vs Go
       // `regexp.ReplaceAllString` flavour gap is the open design
       // question in #1448. `replaceAll` stays refused entirely.
       //
@@ -951,28 +929,30 @@ function convertNode(node: ts.Node, raw: string): ParsedExpr {
           }
         }
         // A regex-literal pattern is the deferred form (the Perl `s///`
-        // vs Go `regexp.ReplaceAllString` flavour gap, #1448) — detect it
-        // on the TS node so the message is accurate. Any OTHER unsupported
-        // pattern/replacement (an object literal, an unsupported call, …)
-        // surfaces ITS OWN reason rather than being mislabelled as the
-        // regex form.
+        // vs Go `regexp.ReplaceAllString` flavour gap, #1448). Its shape
+        // is carried structurally — `args[0]` is a `regex` node (convertNode
+        // line ~1127) — so a consumer that recognises one fixed pattern (the
+        // Go ctor's `/\/+$/` trailing-slash strip → `strings.TrimRight`) reads
+        // it from the tree instead of re-parsing the raw (#2039). Returned
+        // before the object-literal `badArg` check below so the regex form
+        // keeps its dedicated diagnostic precedence; `isSupported` then refuses
+        // any template use with the deferred-form reason.
         const patternNode = node.arguments[0]
         if (patternNode && ts.isRegularExpressionLiteral(patternNode)) {
-          return {
-            kind: 'unsupported',
-            raw,
-            reason:
-              'String.prototype.replace supports only a string pattern + string replacement (the regex form is deferred); use a string pattern or wrap the expression in /* @client */',
-          }
+          return { kind: 'array-method', method: 'replace', object: callee.object, args }
         }
+        // Treat an object-literal argument like `unsupported` — a `.replace`
+        // with an object pattern/replacement isn't lowerable, same as before
+        // the `object-literal` kind existed (byte-identical; Roadmap A-1).
         const badArg =
-          args[0].kind === 'unsupported'
+          args[0].kind === 'unsupported' || args[0].kind === 'object-literal'
             ? args[0]
-            : args[1].kind === 'unsupported'
+            : args[1].kind === 'unsupported' || args[1].kind === 'object-literal'
               ? args[1]
               : undefined
-        if (badArg && badArg.kind === 'unsupported') {
-          return { kind: 'unsupported', raw, reason: badArg.reason }
+        if (badArg) {
+          const reason = badArg.kind === 'unsupported' ? badArg.reason : 'Unsupported syntax: ObjectLiteralExpression'
+          return { kind: 'unsupported', raw, reason }
         }
         return { kind: 'array-method', method: 'replace', object: callee.object, args }
       }
@@ -1004,123 +984,13 @@ function convertNode(node: ts.Node, raw: string): ParsedExpr {
       if (callee.property === 'padStart' || callee.property === 'padEnd') {
         return { kind: 'array-method', method: callee.property, object: callee.object, args }
       }
-      // `.sort(cmp)` / `.toSorted(cmp)` (#1448 Tier B). The comparator
-      // is extracted into a structured `SortComparator` at parse time;
-      // unrecognised shapes fall through to `unsupported` so adapters
-      // surface BF101 (with `@client` as the escape hatch). Supported:
-      // subtraction / localeCompare / relational-ternary leaves, any
-      // of them `||`-chained (multi-key), and single-`return` block
-      // bodies. Function-reference comparators and `localeCompare`
-      // locale/options args stay out of scope — see #1448 Tier B
-      // follow-up.
-      if ((callee.property === 'sort' || callee.property === 'toSorted') && node.arguments.length === 1) {
-        // Extract from the raw TS AST (not args[0] ParsedExpr) — the
-        // standard arrow-fn convertNode path refuses two-param arrows,
-        // so the comparator would otherwise reach us as `unsupported`.
-        const comparator = extractSortComparatorFromTS(node.arguments[0], callee.property)
-        if (comparator) {
-          return {
-            kind: 'array-method',
-            method: callee.property,
-            object: callee.object,
-            args: [],
-            comparator,
-          }
-        }
-        return {
-          kind: 'unsupported',
-          raw,
-          reason:
-            `Sort comparator shape not supported. Accepted:\n` +
-            `  (a, b) => a - b\n` +
-            `  (a, b) => a.field - b.field\n` +
-            `  (a, b) => a.localeCompare(b)\n` +
-            `  (a, b) => a.field.localeCompare(b.field)\n` +
-            `  (a, b) => a.field > b.field ? 1 : -1   (relational ternary)\n` +
-            `  any of the above ||-chained for multi-key tie-breaks\n` +
-            `(reverse the operands for descending order). ` +
-            `Wrap the call in /* @client */ to evaluate at hydration.`,
-        }
-      }
-
-      // `.reduce(fn, init)` / `.reduceRight(fn, init)` (#1448 Tier C).
-      // The reducer + init are extracted into a structured `ReduceOp` at
-      // parse time; the two-param arrow never reaches the standard
-      // convertNode path (which refuses it), so we read the raw TS AST.
-      // Only the arithmetic-fold catalogue lowers — anything else, or a
-      // missing init, falls through to `unsupported` (BF101 + @client
-      // hint). `reduceRight` shares the catalogue; the method name is
-      // preserved so adapters fold right-to-left (only observable for
-      // string concatenation — numeric sum / product are commutative).
-      if (
-        (callee.property === 'reduce' || callee.property === 'reduceRight') &&
-        node.arguments.length === 2
-      ) {
-        const reduceOp = extractReduceOpFromTS(node.arguments[0], node.arguments[1])
-        if (reduceOp) {
-          return {
-            kind: 'array-method',
-            method: callee.property,
-            object: callee.object,
-            args: [],
-            reduceOp,
-          }
-        }
-        const m = callee.property
-        return {
-          kind: 'unsupported',
-          raw,
-          reason:
-            `Reduce shape not supported. Accepted (arithmetic fold, explicit init):\n` +
-            `  arr.${m}((acc, x) => acc + x, 0)\n` +
-            `  arr.${m}((acc, x) => acc + x.field, 0)\n` +
-            `  arr.${m}((acc, x) => acc * x.field, 1)\n` +
-            `  arr.${m}((acc, x) => acc + x.field, '')   (string concat)\n` +
-            `The accumulator must be the left operand and the initial ` +
-            `value a number / string literal. ` +
-            `Wrap the call in /* @client */ to evaluate at hydration.`,
-        }
-      }
-      // A `.reduce(fn)` without an initial value can't be lowered: JS
-      // throws on an empty array, which a template can't mirror. Fall
-      // through to the BF101 gate with the @client escape hatch.
-
-      // `.flatMap(fn)` value-returning projection (#1448 Tier C). The
-      // callback is extracted into a structured `FlatMapOp` (self / field
-      // scalar projection, or an array-literal tuple of self / field
-      // leaves) from the raw TS AST. The JSX-returning form is handled as
-      // an `IRLoop` upstream and never reaches here; richer callbacks
-      // refuse with BF101 + the @client hint. Go uses `bf_flat_map` /
-      // `bf_flat_map_tuple`; Mojo uses `bf->flat_map` / `bf->flat_map_tuple`.
-      // Intercept EVERY `.flatMap(...)` call (not just the 1-arg form) so
-      // the off-catalogue and wrong-arity shapes get this tailored reason
-      // rather than the generic "flatMap has no template lowering" gate
-      // message, which now misleads (the field-projection form does lower).
-      if (callee.property === 'flatMap') {
-        const flatMapOp =
-          node.arguments.length === 1 ? extractFlatMapOpFromTS(node.arguments[0]) : null
-        if (flatMapOp) {
-          return {
-            kind: 'array-method',
-            method: 'flatMap',
-            object: callee.object,
-            args: [],
-            flatMapOp,
-          }
-        }
-        return {
-          kind: 'unsupported',
-          raw,
-          reason:
-            `flatMap shape not supported. Accepted (self / field leaves, no thisArg):\n` +
-            `  arr.flatMap(i => i)          (flatten one level)\n` +
-            `  arr.flatMap(i => i.field)    (flatten a per-item array field)\n` +
-            `  arr.flatMap(i => [i.a, i.b]) (gather per-item fields)\n` +
-            `Richer callbacks (computed / nested access, arithmetic, calls, ` +
-            `literal elements) and the 2-arg \`flatMap(fn, thisArg)\` form ` +
-            `aren't lowered. Wrap the call in /* @client */ to evaluate at hydration.`,
-        }
-      }
+      // `.sort` / `.toSorted` / `.reduce` / `.reduceRight` / `.flatMap`
+      // (callback methods) are NOT folded here (#2018 P5): they fall through
+      // to the generic `call` construction below (callee = member, arg =
+      // generic `arrow`), and the adapter serializes the arrow body to the
+      // runtime evaluator. The localeCompare-sort fallback recovers a
+      // structured comparator from the generic arrow via
+      // `sortComparatorFromArrow`.
     }
 
     return { kind: 'call', callee, args }
@@ -1132,6 +1002,29 @@ function convertNode(node: ts.Node, raw: string): ParsedExpr {
     return { kind: 'array-literal', elements }
   }
 
+  // Object literal: { a: 1, b: x, shorthand }. Only plain literals are
+  // structured — every property must be a non-computed `key: value` or a
+  // shorthand `{ key }`. Anything else (spread, computed key, method,
+  // getter/setter) falls through to the generic `unsupported` fallback
+  // below, exactly as before this kind existed.
+  if (ts.isObjectLiteralExpression(node)) {
+    const properties: ObjectLiteralProperty[] = []
+    for (const prop of node.properties) {
+      if (ts.isPropertyAssignment(prop)) {
+        const k = objectLiteralKeyName(prop.name)
+        if (k === null) return { kind: 'unsupported', raw, reason: `Unsupported syntax: ${ts.SyntaxKind[node.kind]}` }
+        properties.push({ key: k.key, keyKind: k.keyKind, shorthand: false, value: convertNode(prop.initializer, raw) })
+      } else if (ts.isShorthandPropertyAssignment(prop)) {
+        const key = prop.name.text
+        properties.push({ key, keyKind: 'identifier', shorthand: true, value: { kind: 'identifier', name: key } })
+      } else {
+        // Spread assignment, method, getter/setter — not a plain map.
+        return { kind: 'unsupported', raw, reason: `Unsupported syntax: ${ts.SyntaxKind[node.kind]}` }
+      }
+    }
+    return { kind: 'object-literal', properties, raw }
+  }
+
   // Property access: user.name, items().length
   if (ts.isPropertyAccessExpression(node)) {
     const object = convertNode(node.expression, raw)
@@ -1164,7 +1057,10 @@ function convertNode(node: ts.Node, raw: string): ParsedExpr {
     // (the literal forms above fold into a static property path; this
     // one can't). #1897 (data-table).
     const index = convertNode(argNode, raw)
-    if (index.kind === 'unsupported') return index
+    // An object-literal index (`arr[{…}]`) isn't lowerable — surface it
+    // as the whole expression, exactly as an `unsupported` index did
+    // before the kind existed (byte-identical; Roadmap A-1).
+    if (index.kind === 'unsupported' || index.kind === 'object-literal') return index
     return { kind: 'index-access', object, index }
   }
 
@@ -1232,24 +1128,63 @@ function convertNode(node: ts.Node, raw: string): ParsedExpr {
     return { kind: 'literal', value: node.text, literalType: 'string' }
   }
 
-  // Arrow function: x => expr  /  ({field}) => field  /  (x) => expr
-  if (ts.isArrowFunction(node)) {
-    // Only support single parameter
-    if (node.parameters.length !== 1) {
-      return { kind: 'unsupported', raw, reason: 'Only single parameter arrow functions are supported' }
-    }
-    const param = node.parameters[0]
-
-    // Only expression body is supported (not block body). Block bodies
-    // route through `parseBlockBody` at the higher-order recognition
-    // call site so the adapter's filter-block path handles them
-    // separately.
-    if (ts.isBlock(node.body)) {
-      return { kind: 'unsupported', raw, reason: 'Block body arrow functions are not supported' }
+  // Regex literal: `/\/+$/`. Carried as exact source text for the Go ctor
+  // trailing-slash-strip lowering (`String.replace`).
+  if (ts.isRegularExpressionLiteral(node)) {
+    return { kind: 'regex', raw: node.getText() }
+  }
+
+  // Arrow function / function expression: `x => expr`, `(a, b) => expr`,
+  // `({field}) => field`, `function (x) { return … }`. Produces a generic
+  // multi-parameter `arrow` (#2018 P5). A single-`return` block body
+  // normalises to its returned expression; a single object-binding-pattern
+  // param is rewritten to a synthetic identifier param with dotted-access
+  // body (destructure support). Higher-order callbacks reach the adapter as
+  // a generic `call` whose argument is this kind; the adapter serializes
+  // `body` to the runtime evaluator.
+  if (ts.isArrowFunction(node) || ts.isFunctionExpression(node)) {
+    // Resolve the body expression: an expression-bodied arrow carries it
+    // directly; a block body (arrow `=> { … }` or a function expression)
+    // must reduce to exactly one `return <expr>;`. Multi-statement /
+    // local-var bodies stay refused.
+    let body: ParsedExpr
+    if (ts.isArrowFunction(node) && !ts.isBlock(node.body)) {
+      body = convertNode(node.body, raw)
+    } else {
+      const block = node.body as ts.Block
+      const stmts = block.statements
+      // Fast path: a single `return <expr>` keeps the pre-#2040 conversion
+      // (convertNode on the returned node), byte-identical for the existing
+      // corpus.
+      if (stmts.length === 1 && ts.isReturnStatement(stmts[0]) && stmts[0].expression) {
+        body = convertNode(stmts[0].expression, raw)
+      } else {
+        // General value-producing block: normalize `let`-inline + value `if` /
+        // early `return` into a single expression (#2040). Imperative shapes
+        // (raw `for` / `while`, `break`, mutation, side effects) don't parse
+        // into ParsedStatement, or fall through without a value — either way we
+        // refuse with an actionable reason and adapters surface BF101.
+        let sf: ts.SourceFile | undefined
+        try {
+          sf = block.getSourceFile()
+        } catch {
+          sf = undefined
+        }
+        const parsed = sf
+          ? parseBlockBody(block, sf, n => n.getText(sf))
+          : null
+        if (!parsed) {
+          return { kind: 'unsupported', raw, reason: IMPERATIVE_BLOCK_REASON }
+        }
+        const folded = foldBlockToExpr(parsed)
+        if (!folded.ok) {
+          return { kind: 'unsupported', raw, reason: folded.reason }
+        }
+        body = folded.expr
+      }
     }
-    const body = convertNode(node.body, raw)
 
-    // Destructured-object param: `({done}) => done` (#1443),
+    // Single object-binding-pattern param: `({done}) => done` (#1443),
     // `({user: {name}}) => name` (#1530), `({done = false}) => done`
     // (#1531), `({done, ...rest}) => rest.priority` (#1532). We
     // synthesise the equivalent dotted-access form so adapters can
@@ -1262,7 +1197,8 @@ function convertNode(node: ts.Node, raw: string): ParsedExpr {
     // shapes refuse with BF021 (#1532). Array binding patterns,
     // nested rest, and defaults at non-leaf (nested-pattern) slots
     // stay unsupported.
-    if (ts.isObjectBindingPattern(param.name)) {
+    if (node.parameters.length === 1 && ts.isObjectBindingPattern(node.parameters[0].name)) {
+      const bindingPattern = node.parameters[0].name
       const fieldMap = new Map<string, DestructureBinding>()
       // `excludedTopKeys` mirrors the JS rest-binding exclusion set:
       // the source-object keys explicitly consumed at the top level
@@ -1271,7 +1207,7 @@ function convertNode(node: ts.Node, raw: string): ParsedExpr {
       // keys on local rename / leaf names and would miss
       // `({done: d, ...rest}) => rest.done` or `({user: {name}, ...rest}) => rest.user`.
       const excludedTopKeys = new Set<string>()
-      const collect = collectDestructureBindings(param.name, [], fieldMap, raw, excludedTopKeys)
+      const collect = collectDestructureBindings(bindingPattern, [], fieldMap, raw, excludedTopKeys)
       if (!collect.ok) {
         return { kind: 'unsupported', raw, reason: collect.reason }
       }
@@ -1335,37 +1271,20 @@ function convertNode(node: ts.Node, raw: string): ParsedExpr {
       }
       const syntheticParam = pickSyntheticParam(fieldMap, body)
       const rewritten = substituteDestructuredFields(body, fieldMap, syntheticParam, restName)
-      return { kind: 'arrow-fn', param: syntheticParam, body: rewritten }
-    }
-
-    if (!ts.isIdentifier(param.name)) {
-      return { kind: 'unsupported', raw, reason: 'Destructuring parameters are not supported' }
+      return { kind: 'arrow', params: [syntheticParam], body: rewritten }
     }
-    return { kind: 'arrow-fn', param: param.name.text, body }
-  }
 
-  // Function expression: `function (x) { return x.done }` (#1443).
-  // Normalise the single-param + single-return shape into the arrow
-  // form so the higher-order detector at the call site recognises it
-  // alongside `(x) => x.done`. Multi-statement / multi-param / nested-
-  // destructure shapes stay unsupported.
-  if (ts.isFunctionExpression(node)) {
-    if (node.parameters.length !== 1) {
-      return { kind: 'unsupported', raw, reason: 'Only single-parameter function expressions are supported' }
-    }
-    const param = node.parameters[0]
-    if (!ts.isIdentifier(param.name)) {
-      return { kind: 'unsupported', raw, reason: 'Destructured params in function expressions are not supported' }
-    }
-    const stmts = node.body.statements
-    if (stmts.length !== 1 || !ts.isReturnStatement(stmts[0]) || !stmts[0].expression) {
-      return { kind: 'unsupported', raw, reason: 'Function expressions must be `function (x) { return <expr> }`' }
-    }
-    return {
-      kind: 'arrow-fn',
-      param: param.name.text,
-      body: convertNode(stmts[0].expression, raw),
+    // Every (remaining) parameter must be a plain identifier. Multi-param
+    // arrows (sort comparators `(a, b) => …`) and single-param identifier
+    // arrows (`x => …`) both land here.
+    const params: string[] = []
+    for (const p of node.parameters) {
+      if (!ts.isIdentifier(p.name)) {
+        return { kind: 'unsupported', raw, reason: 'Only identifier (or a single object-destructure) function parameters are supported' }
+      }
+      params.push(p.name.text)
     }
+    return { kind: 'arrow', params, body }
   }
 
   // Default: unsupported
@@ -1373,114 +1292,56 @@ function convertNode(node: ts.Node, raw: string): ParsedExpr {
 }
 
 /**
- * Recover a `SortComparator` from the comparator arg of `.sort(cmp)` /
- * `.toSorted(cmp)` (#1448 Tier B). Operates on the raw TS AST rather
- * than the converted ParsedExpr because the standard `convertNode`
- * arrow-fn path rejects two-param arrows (it was built for the
- * single-param higher-order shape `.filter(x => …)`); for sort we
- * need both param names to decide direction (`a-b` asc vs `b-a` desc).
- *
- * The accepted catalogue is finite so the walker stays shallow — no
- * constant folding, no symbol resolution, no inference of "this looks
- * like it might sort numerically". Returns null if the shape doesn't
- * match exactly, in which case the caller emits an `unsupported` IR
- * node and adapters surface BF101.
+ * Recover a {@link SortComparator} from a generic `(a, b) => …` sort callback
+ * arrow (#2018 P5). The LEGACY fallback for a comparator the runtime evaluator
+ * can't model (`localeCompare` string sorts — `serializeParsedExpr` refuses
+ * them); the adapter calls this only when the eval path returns null. Operates
+ * on the generic `arrow` ParsedExpr (params + body subtree) — no `ts` re-parse.
  *
- * Body shapes:
- *   - expression-bodied arrow (`(a, b) => …`)
- *   - single-`return` block body — both arrow (`(a, b) => { return …; }`)
- *     and function expression. Multi-statement / local-var bodies stay
- *     refused (deferred follow-up).
+ * The accepted catalogue is finite so the walker stays shallow — no constant
+ * folding, no symbol resolution. Returns null if the shape doesn't match
+ * exactly, in which case the adapter surfaces BF101.
  *
- * A body is split on top-level `||` into one leaf per operand, giving
- * a multi-key comparator (`a.x - b.x || a.y - b.y` → sort by x, then y).
- * Accepted leaf shapes (each paired ascending / descending by operand
- * order):
+ * A body is split on top-level `||` into one leaf per operand, giving a
+ * multi-key comparator (`a.x - b.x || a.y - b.y` → sort by x, then y). Accepted
+ * leaf shapes (each paired ascending / descending by operand order):
  *
  *   a.field - b.field                → field, numeric
  *   a - b                            → self,  numeric
  *   a.field.localeCompare(b.field)   → field, string
  *   a.localeCompare(b)               → self,  string
  *   a.field > b.field ? 1 : -1       → field, auto (relational ternary)
- *   a.field < b.field ? -1 : 1       → field, auto
  *   a < b ? -1 : a > b ? 1 : 0       → self/field, auto (3-way)
  *   a === b ? 0 : <relational ternary>  → leading-tie 3-way
  *
- * Function-reference comparators and `localeCompare(b, locale, opts)`
- * (the multi-arg form) return null — deferred follow-ups.
+ * Function-reference comparators and `localeCompare(b, locale, opts)` (the
+ * multi-arg form) return null — deferred follow-ups.
  */
-export function extractSortComparatorFromTS(
-  node: ts.Node,
-  method: 'sort' | 'toSorted',
-): SortComparator | null {
-  if (!ts.isArrowFunction(node) && !ts.isFunctionExpression(node)) return null
-  if (node.parameters.length !== 2) return null
-
-  const pA = node.parameters[0]
-  const pB = node.parameters[1]
-  if (!ts.isIdentifier(pA.name) || !ts.isIdentifier(pB.name)) return null
-  const paramA = pA.name.text
-  const paramB = pB.name.text
-
-  // Resolve the comparator body. Expression-bodied arrows carry it
-  // directly; block bodies (both arrow `=> { … }` and function
-  // expressions) must reduce to exactly one `return <expr>;`. Anything
-  // with locals or multiple statements stays refused — a deferred
-  // follow-up.
-  let body: ts.Expression
-  if (ts.isArrowFunction(node) && !ts.isBlock(node.body)) {
-    body = node.body
-  } else {
-    const block = node.body as ts.Block
-    const stmts = block.statements
-    if (stmts.length !== 1 || !ts.isReturnStatement(stmts[0]) || !stmts[0].expression) return null
-    body = stmts[0].expression
-  }
-
-  // Normalise the comparator body source so consumers of
-  // `SortComparator.raw` get the same string regardless of whether
-  // the user wrote an arrow expression (`(a, b) => a.x - b.x`) or a
-  // block body (`(a, b) => { return a.x - b.x }`). For block bodies
-  // this is the returned expression, not the `{ … }` block — so the
-  // `@client` fallback's synthetic `(a, b) => raw` arrow stays valid.
-  //
-  // `body.getText()` resolves against the node's source file via the
-  // parent chain — `ts.createSourceFile`-parsed nodes (the only
-  // shape this helper accepts) carry that wiring.
-  const raw = body.getText()
-
-  // A `||`-chain is a multi-key comparator: each operand is an
-  // independent leaf applied as the next tie-breaker. A non-`||` body
-  // is a single-key comparator (one-element chain).
+export function sortComparatorFromArrow(arrow: ParsedExpr): SortComparator | null {
+  if (arrow.kind !== 'arrow' || arrow.params.length !== 2) return null
+  const [paramA, paramB] = arrow.params
+
+  // A `||`-chain is a multi-key comparator: each operand is an independent
+  // leaf applied as the next tie-breaker. A non-`||` body is single-key.
   const keys: SortKey[] = []
-  for (const operand of flattenLogicalOr(body)) {
+  for (const operand of flattenLogicalOr(arrow.body)) {
     const key = classifyLeafComparator(operand, paramA, paramB)
     if (!key) return null
     keys.push(key)
   }
   if (keys.length === 0) return null
-
-  return { keys, raw, paramA, paramB, method }
-}
-
-/** Strip redundant parentheses so the classifiers see the real node. */
-function unwrapParens(expr: ts.Expression): ts.Expression {
-  let e = expr
-  while (ts.isParenthesizedExpression(e)) e = e.expression
-  return e
+  return { keys }
 }
 
 /**
- * Flatten a left-associative top-level `||` chain into its operands.
- * `a || b || c` parses as `((a || b) || c)`; this returns `[a, b, c]`.
+ * Flatten a top-level `||` chain into its operands (`a || b || c` → `[a, b, c]`).
  * A non-`||` expression returns a single-element list.
  */
-function flattenLogicalOr(expr: ts.Expression): ts.Expression[] {
-  const inner = unwrapParens(expr)
-  if (ts.isBinaryExpression(inner) && inner.operatorToken.kind === ts.SyntaxKind.BarBarToken) {
-    return [...flattenLogicalOr(inner.left), ...flattenLogicalOr(inner.right)]
+function flattenLogicalOr(expr: ParsedExpr): ParsedExpr[] {
+  if (expr.kind === 'logical' && expr.op === '||') {
+    return [...flattenLogicalOr(expr.left), ...flattenLogicalOr(expr.right)]
   }
-  return [inner]
+  return [expr]
 }
 
 /**
@@ -1488,60 +1349,40 @@ function flattenLogicalOr(expr: ts.Expression): ts.Expression[] {
  * Accepts subtraction (numeric), `localeCompare` (string), and
  * relational-ternary (auto) shapes; returns null otherwise.
  */
-function classifyLeafComparator(
-  expr: ts.Expression,
-  paramA: string,
-  paramB: string,
-): SortKey | null {
-  const body = unwrapParens(expr)
-
+function classifyLeafComparator(expr: ParsedExpr, paramA: string, paramB: string): SortKey | null {
   // Subtraction: `a.field - b.field` / `a - b` → numeric.
-  if (ts.isBinaryExpression(body) && body.operatorToken.kind === ts.SyntaxKind.MinusToken) {
-    return classifyComparatorOperands(body.left, body.right, paramA, paramB, 'numeric')
+  if (expr.kind === 'binary' && expr.op === '-') {
+    return classifyComparatorOperands(expr.left, expr.right, paramA, paramB, 'numeric')
   }
 
-  // localeCompare (zero-arg form): `<lhs>.localeCompare(<rhs>)` →
-  // string. The locale/options form (2–3 args) stays refused — it
-  // needs per-adapter collation plumbing (deferred follow-up).
+  // localeCompare (zero-arg form): `<lhs>.localeCompare(<rhs>)` → string. The
+  // locale/options form (2–3 args) stays refused.
   if (
-    ts.isCallExpression(body) &&
-    ts.isPropertyAccessExpression(body.expression) &&
-    body.expression.name.text === 'localeCompare' &&
-    body.arguments.length === 1
+    expr.kind === 'call' &&
+    expr.callee.kind === 'member' &&
+    expr.callee.property === 'localeCompare' &&
+    expr.args.length === 1
   ) {
-    return classifyComparatorOperands(
-      body.expression.expression, // receiver of .localeCompare
-      body.arguments[0],
-      paramA,
-      paramB,
-      'string',
-    )
+    return classifyComparatorOperands(expr.callee.object, expr.args[0], paramA, paramB, 'string')
   }
 
   // Relational-ternary sign comparator → auto.
-  if (ts.isConditionalExpression(body)) {
-    return classifyTernaryComparator(body, paramA, paramB)
+  if (expr.kind === 'conditional') {
+    return classifyTernaryComparator(expr, paramA, paramB)
   }
 
   return null
 }
 
 /**
- * Classify two operands against the comparator's two param names.
- * Both operands must resolve to either:
- *   - the param identifier itself              → `key.kind === 'self'`
- *   - a single-level field access on the param → `key.kind === 'field'`
- * The two operands must reference different params (one paramA, one
- * paramB) and match on key shape + field name. Order of the params
- * determines `direction`: `paramA` first is ascending, reversed is
- * descending.
- *
- * Anything deeper (chained `.x.y`, computed `.[i]`, calls, literals)
- * or mismatched keys returns null.
+ * Classify two operands against the comparator's two param names. Both must
+ * resolve to either the param identifier itself (`self`) or a single-level
+ * field access on it (`field`), reference different params, and match on key
+ * shape + field name. `paramA` first is ascending, reversed is descending.
  */
 function classifyComparatorOperands(
-  left: ts.Expression,
-  right: ts.Expression,
+  left: ParsedExpr,
+  right: ParsedExpr,
   paramA: string,
   paramB: string,
   type: 'numeric' | 'string',
@@ -1560,44 +1401,35 @@ function classifyComparatorOperands(
 
 /**
  * Classify a relational-ternary comparator leaf into an `auto` SortKey.
- * Handles the 2-way sign form (`a.f > b.f ? 1 : -1`), the canonical
- * 3-way (`a.f < b.f ? -1 : a.f > b.f ? 1 : 0`), and a leading
- * equality tie (`a.f === b.f ? 0 : <relational ternary>`).
- *
- * Direction is derived from (relational op, operand order, sign of the
- * `whenTrue` branch); the `whenFalse` branch only needs to be a bounded
- * shape (sign literal or a nested ternary on the same key) so we don't
- * silently accept arbitrary expressions.
+ * Handles the 2-way sign form (`a.f > b.f ? 1 : -1`), the canonical 3-way
+ * (`a.f < b.f ? -1 : a.f > b.f ? 1 : 0`), and a leading equality tie
+ * (`a.f === b.f ? 0 : <relational ternary>`).
  */
 function classifyTernaryComparator(
-  node: ts.ConditionalExpression,
+  node: Extract<ParsedExpr, { kind: 'conditional' }>,
   paramA: string,
   paramB: string,
 ): SortKey | null {
-  const cond = unwrapParens(node.condition)
+  const cond = node.test
 
-  // Leading equality tie: `a.f === b.f ? 0 : <ternary>`. The equality
-  // arm returns 0 (tie); the real ordering lives in the else branch.
+  // Leading equality tie: `a.f === b.f ? 0 : <ternary>`.
   if (
-    ts.isBinaryExpression(cond) &&
-    (cond.operatorToken.kind === ts.SyntaxKind.EqualsEqualsEqualsToken ||
-      cond.operatorToken.kind === ts.SyntaxKind.EqualsEqualsToken) &&
+    cond.kind === 'binary' &&
+    (cond.op === '===' || cond.op === '==') &&
     sameKeyOperands(cond.left, cond.right, paramA, paramB) &&
-    numericSign(node.whenTrue) === 0
+    numericSign(node.consequent) === 0
   ) {
-    const elseBranch = unwrapParens(node.whenFalse)
-    if (ts.isConditionalExpression(elseBranch)) {
+    const elseBranch = node.alternate
+    if (elseBranch.kind === 'conditional') {
       return classifyTernaryComparator(elseBranch, paramA, paramB)
     }
     return null
   }
 
   // Relational condition: `<left> <op> <right>` with op ∈ {<,>,<=,>=}.
-  if (!ts.isBinaryExpression(cond)) return null
-  const op = cond.operatorToken.kind
-  const isGreater =
-    op === ts.SyntaxKind.GreaterThanToken || op === ts.SyntaxKind.GreaterThanEqualsToken
-  const isLess = op === ts.SyntaxKind.LessThanToken || op === ts.SyntaxKind.LessThanEqualsToken
+  if (cond.kind !== 'binary') return null
+  const isGreater = cond.op === '>' || cond.op === '>='
+  const isLess = cond.op === '<' || cond.op === '<='
   if (!isGreater && !isLess) return null
 
   const leftRef = classifySortOperand(cond.left, paramA, paramB)
@@ -1609,37 +1441,21 @@ function classifyTernaryComparator(
     return null
   }
 
-  // whenTrue must be a non-zero sign literal (±1); whenFalse a bounded
-  // shape (sign literal or a nested ternary on the same key).
-  //
-  // Direction is derived solely from this outer comparison — the nested
-  // whenFalse branch is only validated for key agreement, not direction
-  // consistency. A contradictory hand-written 3-way (e.g.
-  // `a.f < b.f ? -1 : a.f < b.f ? 1 : 0`) is therefore lowered per the
-  // outer comparison; the JS-runtime (Hono/CSR) path runs the literal
-  // body, so such a degenerate comparator could order differently
-  // there. The canonical asc/desc 3-way forms agree on both paths.
-  const trueSign = numericSign(node.whenTrue)
+  // whenTrue must be a non-zero sign literal (±1); whenFalse a bounded shape
+  // (sign literal or a nested ternary on the same key). Direction is derived
+  // solely from this outer comparison.
+  const trueSign = numericSign(node.consequent)
   if (trueSign === null || trueSign === 0) return null
-  if (!isBoundedTernaryElse(node.whenFalse, leftRef.key, paramA, paramB)) return null
+  if (!isBoundedTernaryElse(node.alternate, leftRef.key, paramA, paramB)) return null
 
   // Rewrite so the condition reads as `aKey <op> bKey` (paramA left).
-  // `b.f > a.f` ⇔ `a.f < b.f`, so a paramB-on-left operand flips it.
   const greaterForA = leftRef.param === 'A' ? isGreater : !isGreater
-
-  // `a.f > b.f ? +n` → bigger sorts later  → ascending
-  // `a.f < b.f ? +n` → bigger sorts earlier → descending
   const asc = greaterForA ? trueSign > 0 : trueSign < 0
   return { key: leftRef.key, type: 'auto', direction: asc ? 'asc' : 'desc' }
 }
 
 /** True when both operands resolve to the same key on opposite params. */
-function sameKeyOperands(
-  left: ts.Expression,
-  right: ts.Expression,
-  paramA: string,
-  paramB: string,
-): boolean {
+function sameKeyOperands(left: ParsedExpr, right: ParsedExpr, paramA: string, paramB: string): boolean {
   const l = classifySortOperand(left, paramA, paramB)
   const r = classifySortOperand(right, paramA, paramB)
   if (!l || !r) return false
@@ -1650,17 +1466,16 @@ function sameKeyOperands(
 }
 
 /**
- * Sign of a numeric literal with optional unary minus: 1, -1, or 0.
- * Returns null for anything that isn't a (signed) numeric literal.
+ * Sign of a numeric literal with optional unary minus: 1, -1, or 0. Returns
+ * null for anything that isn't a (signed) numeric literal.
  */
-function numericSign(expr: ts.Expression): number | null {
-  const e = unwrapParens(expr)
-  if (ts.isPrefixUnaryExpression(e) && e.operator === ts.SyntaxKind.MinusToken) {
-    const inner = numericSign(e.operand)
+function numericSign(expr: ParsedExpr): number | null {
+  if (expr.kind === 'unary' && expr.op === '-') {
+    const inner = numericSign(expr.argument)
     return inner === null ? null : -inner
   }
-  if (ts.isNumericLiteral(e)) {
-    const n = Number(e.text)
+  if (expr.kind === 'literal' && expr.literalType === 'number' && typeof expr.value === 'number') {
+    const n = expr.value
     if (Number.isNaN(n)) return null
     if (n === 0) return 0
     return n > 0 ? 1 : -1
@@ -1669,21 +1484,18 @@ function numericSign(expr: ts.Expression): number | null {
 }
 
 /**
- * The `whenFalse` arm of a relational ternary is bounded if it's a
- * sign literal (±1 / 0) or a nested ternary on the same key (the
- * canonical 3-way form). The outer comparison already fixes direction,
- * so the nested branch only needs to agree on which key it compares.
+ * The `whenFalse` arm of a relational ternary is bounded if it's a sign
+ * literal (±1 / 0) or a nested ternary on the same key (the canonical 3-way).
  */
 function isBoundedTernaryElse(
-  expr: ts.Expression,
+  expr: ParsedExpr,
   key: { kind: 'self' } | { kind: 'field'; field: string },
   paramA: string,
   paramB: string,
 ): boolean {
-  const e = unwrapParens(expr)
-  if (numericSign(e) !== null) return true
-  if (ts.isConditionalExpression(e)) {
-    const nested = classifyTernaryComparator(e, paramA, paramB)
+  if (numericSign(expr) !== null) return true
+  if (expr.kind === 'conditional') {
+    const nested = classifyTernaryComparator(expr, paramA, paramB)
     return nested !== null && sortKeyEquals(nested.key, key)
   }
   return false
@@ -1698,238 +1510,28 @@ function sortKeyEquals(
   return true
 }
 
+/**
+ * Resolve a sort operand to a `self` / `field` key on param A or B. A bare
+ * param identifier is `self`; a single-level non-computed field access on a
+ * param is `field`. Anything deeper returns null.
+ */
 function classifySortOperand(
-  expr: ts.Expression,
+  expr: ParsedExpr,
   paramA: string,
   paramB: string,
 ): { key: { kind: 'self' } | { kind: 'field'; field: string }; param: 'A' | 'B' } | null {
-  if (ts.isIdentifier(expr)) {
-    if (expr.text === paramA) return { key: { kind: 'self' }, param: 'A' }
-    if (expr.text === paramB) return { key: { kind: 'self' }, param: 'B' }
+  if (expr.kind === 'identifier') {
+    if (expr.name === paramA) return { key: { kind: 'self' }, param: 'A' }
+    if (expr.name === paramB) return { key: { kind: 'self' }, param: 'B' }
     return null
   }
-  if (ts.isPropertyAccessExpression(expr) && ts.isIdentifier(expr.expression)) {
-    if (expr.expression.text === paramA) {
-      return { key: { kind: 'field', field: expr.name.text }, param: 'A' }
-    }
-    if (expr.expression.text === paramB) {
-      return { key: { kind: 'field', field: expr.name.text }, param: 'B' }
-    }
+  if (expr.kind === 'member' && !expr.computed && expr.object.kind === 'identifier') {
+    if (expr.object.name === paramA) return { key: { kind: 'field', field: expr.property }, param: 'A' }
+    if (expr.object.name === paramB) return { key: { kind: 'field', field: expr.property }, param: 'B' }
   }
   return null
 }
 
-/**
- * Recover a `ReduceOp` from the `(reducer, init)` args of
- * `.reduce(...)` (#1448 Tier C). Operates on the raw TS AST because the
- * standard `convertNode` arrow-fn path rejects two-param arrows.
- *
- * The accepted catalogue is intentionally finite — only the
- * arithmetic-fold family lowers to a declarative template:
- *
- *   (acc, x) => acc + x          → self,  numeric (init: number)
- *   (acc, x) => acc + x.field    → field, numeric (init: number)
- *   (acc, x) => acc * x          → self,  numeric (init: number)
- *   (acc, x) => acc * x.field    → field, numeric (init: number)
- *   (acc, x) => acc + x          → self,  string  (init: string → concat)
- *   (acc, x) => acc + x.field    → field, string  (init: string → concat)
- *
- * The accumulator must be the binary expression's *left* operand
- * (canonical reduce form; reversed operands change string-concat
- * order), the per-item value must be the item param itself or a
- * single non-computed field access on it, and the init must be a
- * number or string literal (negative numbers via prefix `-` allowed).
- * String concatenation requires `+`. Block bodies reduce to a single
- * `return`, mirroring the sort extractor. Anything else returns null
- * and the caller emits `unsupported` (BF101).
- */
-export function extractReduceOpFromTS(
-  reducerNode: ts.Node,
-  initNode: ts.Node,
-): ReduceOp | null {
-  const init = classifyReduceInit(initNode)
-  if (!init) return null
-
-  if (!ts.isArrowFunction(reducerNode) && !ts.isFunctionExpression(reducerNode)) return null
-  // Exactly `(acc, item)` — the index / array reducer params can't be
-  // expressed in a template fold, so refuse the 3- / 4-param forms.
-  if (reducerNode.parameters.length !== 2) return null
-  const pAcc = reducerNode.parameters[0]
-  const pItem = reducerNode.parameters[1]
-  if (!ts.isIdentifier(pAcc.name) || !ts.isIdentifier(pItem.name)) return null
-  const paramAcc = pAcc.name.text
-  const paramItem = pItem.name.text
-
-  // Resolve the reducer body: expression-bodied arrow directly; block
-  // bodies (arrow `=> { … }` and function expressions) must reduce to
-  // exactly one `return <expr>;` — mirrors `extractSortComparatorFromTS`.
-  let body: ts.Expression
-  if (ts.isArrowFunction(reducerNode) && !ts.isBlock(reducerNode.body)) {
-    body = reducerNode.body
-  } else {
-    const block = reducerNode.body as ts.Block
-    const stmts = block.statements
-    if (stmts.length !== 1 || !ts.isReturnStatement(stmts[0]) || !stmts[0].expression) return null
-    body = stmts[0].expression
-  }
-  const raw = body.getText()
-
-  const expr = unwrapParens(body)
-  if (!ts.isBinaryExpression(expr)) return null
-  let op: '+' | '*'
-  if (expr.operatorToken.kind === ts.SyntaxKind.PlusToken) op = '+'
-  else if (expr.operatorToken.kind === ts.SyntaxKind.AsteriskToken) op = '*'
-  else return null
-
-  // The accumulator must be the left operand (`acc + x`, not `x + acc`).
-  const left = unwrapParens(expr.left)
-  if (!ts.isIdentifier(left) || left.text !== paramAcc) return null
-
-  const key = classifyReduceKey(unwrapParens(expr.right), paramItem)
-  if (!key) return null
-
-  // String concatenation only makes sense with `+`.
-  const type: 'numeric' | 'string' = init.type
-  if (type === 'string' && op !== '+') return null
-
-  return { op, key, type, init: init.value, raw, paramAcc, paramItem }
-}
-
-/**
- * Recover a `FlatMapOp` from the single-argument callback of a
- * value-returning `.flatMap(fn)` (#1448 Tier C). Operates on the raw TS
- * AST, mirroring `extractReduceOpFromTS`.
- *
- * The accepted catalogue:
- *
- *   i => i            → self  (flatMap(identity) === flat(1))
- *   i => i.field      → field (flatten a per-item array field)
- *   i => [i.a, i.b]   → tuple (gather per-item self / field leaves)
- *
- * The callback must take exactly one identifier param (the index / array
- * params can't be expressed in a template projection), and the body must
- * be the param itself, a single non-computed field access on it, or an
- * array literal whose every element is one of those leaves. Block bodies
- * reduce to a single `return`, like the reduce / sort extractors. Any
- * other body (deep access, computed members, calls, arithmetic, a
- * literal element) returns null and the caller emits `unsupported`
- * (BF101).
- */
-export function extractFlatMapOpFromTS(cbNode: ts.Node): FlatMapOp | null {
-  if (!ts.isArrowFunction(cbNode) && !ts.isFunctionExpression(cbNode)) return null
-  // Exactly `(item)` — a `(item, index)` / `(item, index, array)` callback
-  // can't be lowered to a declarative projection.
-  if (cbNode.parameters.length !== 1) return null
-  const p = cbNode.parameters[0]
-  if (!ts.isIdentifier(p.name)) return null
-  const param = p.name.text
-
-  let body: ts.Expression
-  if (ts.isArrowFunction(cbNode) && !ts.isBlock(cbNode.body)) {
-    body = cbNode.body
-  } else {
-    const block = cbNode.body as ts.Block
-    const stmts = block.statements
-    if (stmts.length !== 1 || !ts.isReturnStatement(stmts[0]) || !stmts[0].expression) return null
-    body = stmts[0].expression
-  }
-  const raw = body.getText()
-  const inner = unwrapParens(body)
-
-  // Array-literal body → tuple projection. Every element must be a
-  // self / field leaf; a literal / computed / nested element refuses the
-  // whole shape (the per-item evaluation of richer expressions isn't
-  // lowered). flat(1) removes only the literal's wrapper, so each leaf is
-  // appended verbatim — handled by the `bf_flat_map_tuple` runtime.
-  if (ts.isArrayLiteralExpression(inner)) {
-    // An empty tuple (`i => []`) is a degenerate no-op projection (always
-    // yields nothing). Refuse it so the emitters never produce a
-    // zero-arg `bf_flat_map_tuple` / `bf->flat_map_tuple(...,)` call.
-    if (inner.elements.length === 0) return null
-    const elements: FlatMapLeaf[] = []
-    for (const el of inner.elements) {
-      // Spread / holes (`[...xs]`, `[, x]`) aren't leaves.
-      if (ts.isSpreadElement(el) || ts.isOmittedExpression(el)) return null
-      const leaf = classifyReduceKey(unwrapParens(el), param)
-      if (!leaf) return null
-      elements.push(leaf)
-    }
-    return { projection: { kind: 'tuple', elements }, param, raw }
-  }
-
-  // Scalar body. Reuse the reduce key classifier — `i` → self,
-  // `i.field` → field, null for anything deeper (`i.a.b`, `i[k]`, a call).
-  const leaf = classifyReduceKey(inner, param)
-  if (!leaf) return null
-
-  return { projection: leaf, param, raw }
-}
-
-/**
- * Classify a reduce per-item operand into a `ReduceOp` key. Accepts
- * the bare item param (`x` → self) and a single non-computed field
- * access (`x.field` → field); returns null for anything deeper
- * (`x.a.b`, `x[k]`, a literal, a call, …).
- */
-function classifyReduceKey(
-  expr: ts.Expression,
-  paramItem: string,
-): { kind: 'self' } | { kind: 'field'; field: string } | null {
-  if (ts.isIdentifier(expr)) {
-    return expr.text === paramItem ? { kind: 'self' } : null
-  }
-  if (ts.isPropertyAccessExpression(expr) && ts.isIdentifier(expr.expression)) {
-    if (expr.expression.text === paramItem) return { kind: 'field', field: expr.name.text }
-  }
-  return null
-}
-
-/**
- * Classify a reduce initial-value node into the *decoded* fold seed.
- * Accepts a numeric literal (optionally prefixed with `-`) and a string
- * literal; returns `{ type, value }` where `value` is the canonical
- * value — never the raw source text. Any other init (a variable, a
- * call, an object) returns null — the fold start value must be
- * statically known.
- *
- * Numeric: `node.text` is TypeScript's canonical decimal form, so
- * separators and non-decimal radices fold uniformly across adapters
- * (`1_000` → `1000`, `0x10` → `16`, `1e3` → `1000`). The Go runtime's
- * `strconv.ParseFloat` and Perl both accept that decimal string —
- * passing the raw source (`0x10`, `1_000`) would silently fold to 0 on
- * Go while Perl accepted it (#1728 review).
- *
- * String: `node.text` is the *unescaped* contents. To keep the three
- * adapters byte-equal without teaching each one to re-decode JS escapes
- * (`\n`, `\u{…}`, `\\`, an escaped quote), we refuse any string literal
- * whose contents differ from its raw inner source — i.e. any literal
- * carrying an escape sequence. Accepted seeds are therefore escape-free
- * single-line strings (`''`, `', '`, `'-'`), which embed safely in both
- * the Go-template `"…"` operand and the Perl single-quoted literal. The
- * realistic concat seed (`''`) is unaffected; richer seeds fall back to
- * the `@client` escape hatch.
- */
-function classifyReduceInit(
-  node: ts.Node,
-): { type: 'numeric' | 'string'; value: string } | null {
-  // Unwrap redundant parens (`(0)` / `(-1)`) so they classify like the
-  // bare literal — matches the extractor's `unwrapParens` use elsewhere.
-  let n: ts.Node = unwrapParens(node as ts.Expression)
-  // `-1` parses as a prefix-minus over a numeric literal.
-  if (ts.isPrefixUnaryExpression(n) && n.operator === ts.SyntaxKind.MinusToken) {
-    if (ts.isNumericLiteral(n.operand)) return { type: 'numeric', value: '-' + n.operand.text }
-    return null
-  }
-  if (ts.isNumericLiteral(n)) return { type: 'numeric', value: n.text }
-  if (ts.isStringLiteral(n)) {
-    // Refuse literals carrying escapes so the decoded value equals its
-    // raw inner source (and thus embeds safely + byte-equal everywhere).
-    const raw = n.getText()
-    if (raw.length < 2 || raw.slice(1, -1) !== n.text) return null
-    return { type: 'string', value: n.text }
-  }
-  return null
-}
 
 /**
  * Per-binding entry stored in `fieldMap`: the dotted path from the
@@ -2070,8 +1672,12 @@ function collectDestructureBindings(
     let defaultExpr: ParsedExpr | undefined
     if (el.initializer) {
       const parsed = convertNode(el.initializer, raw)
-      if (parsed.kind === 'unsupported') {
-        return { ok: false, reason: `Default value in destructured filter param failed to parse: ${parsed.reason}` }
+      // An object-literal default isn't lowered into a destructured filter
+      // predicate yet — refuse it exactly as before the kind existed, with
+      // the same reason text the `unsupported` fallback produced (A-1).
+      if (parsed.kind === 'unsupported' || parsed.kind === 'object-literal') {
+        const reason = parsed.kind === 'unsupported' ? parsed.reason : 'Unsupported syntax: ObjectLiteralExpression'
+        return { ok: false, reason: `Default value in destructured filter param failed to parse: ${reason}` }
       }
       defaultExpr = parsed
     }
@@ -2114,6 +1720,7 @@ function findImpureDefaultNode(expr: ParsedExpr): string | null {
     case 'literal':
     case 'identifier':
     case 'unsupported':
+    case 'object-literal':
       return null
     case 'member':
       return findImpureDefaultNode(expr.object)
@@ -2144,8 +1751,8 @@ function findImpureDefaultNode(expr: ParsedExpr): string | null {
       return null
     case 'call':
     case 'array-method':
-    case 'higher-order':
-    case 'arrow-fn':
+    case 'arrow':
+    case 'regex':
       return expr.kind
   }
 }
@@ -2249,19 +1856,13 @@ function validateRestUsage(
           if (part.type === 'expression') walk(part.expr)
         }
         return
-      case 'arrow-fn':
-        // Inner arrow that re-uses `restName` as its own parameter
-        // shadows the outer rest binding — references inside its
-        // body belong to the inner param, not us (#1532 review).
-        if (e.param === restName) return
+      case 'arrow':
+        // Inner arrow that re-uses `restName` as one of its own
+        // parameters shadows the outer rest binding — references inside
+        // its body belong to the inner param, not us (#1532 review).
+        if (e.params.includes(restName)) return
         walk(e.body)
         return
-      case 'higher-order':
-        walk(e.object)
-        // The predicate is the inner-callback body; its `param`
-        // shadows the outer rest binding when names match.
-        if (e.param !== restName) walk(e.predicate)
-        return
       case 'array-literal':
         for (const el of e.elements) walk(el)
         return
@@ -2271,6 +1872,7 @@ function validateRestUsage(
         return
       case 'literal':
       case 'unsupported':
+      case 'object-literal':
         return
     }
   }
@@ -2370,13 +1972,9 @@ function collectIdentifiers(expr: ParsedExpr, out: Set<string>): void {
         if (part.type === 'expression') collectIdentifiers(part.expr, out)
       }
       return
-    case 'arrow-fn':
+    case 'arrow':
       collectIdentifiers(expr.body, out)
       return
-    case 'higher-order':
-      collectIdentifiers(expr.object, out)
-      collectIdentifiers(expr.predicate, out)
-      return
     case 'array-literal':
       expr.elements.forEach(e => collectIdentifiers(e, out))
       return
@@ -2385,7 +1983,11 @@ function collectIdentifiers(expr: ParsedExpr, out: Set<string>): void {
       expr.args.forEach(e => collectIdentifiers(e, out))
       return
     case 'literal':
+    case 'regex':
     case 'unsupported':
+    // Mirror `unsupported`: an object literal was not carried before this
+    // kind existed, so it collects no identifiers (byte-identical A-1).
+    case 'object-literal':
       return
   }
 }
@@ -2463,49 +2065,29 @@ function substituteDestructuredFields(
             p.type === 'expression' ? { type: 'expression', expr: walk(p.expr) } : p,
           ),
         }
-      case 'arrow-fn':
+      case 'arrow':
         // A nested arrow inside the predicate body shadows the outer
-        // param. Leave its body alone — its own param-resolution path
-        // handles closure references against the outer fieldMap on its
-        // own terms. This matches how JS scope rules treat the outer
-        // destructured `done` once a shadowing inner arrow declares a
-        // different name (the inner arrow's body sees the outer
-        // `done` only if it doesn't shadow it, which we can't know
-        // without per-scope tracking). Skipping the rewrite is the
-        // conservative choice — worst case the resulting predicate
-        // doesn't lower and the adapter emits BF101.
-        return e
-      case 'higher-order':
+        // param (a higher-order callback like `.sort(cmp)` / `.filter(p)`
+        // reaches here as the arrow argument of a generic `call`). Leave
+        // its body alone — its comparator/predicate references its own
+        // params, never the enclosing destructure. Skipping the rewrite is
+        // the conservative choice; worst case the adapter emits BF101.
         return e
       case 'array-literal':
         return { kind: 'array-literal', elements: e.elements.map(walk) }
       case 'array-method':
-        if (e.method === 'sort' || e.method === 'toSorted') {
-          // Sort comparator is a structured value, not a ParsedExpr —
-          // destructured-field substitution doesn't apply (the
-          // comparator references its own paramA / paramB, never the
-          // enclosing destructure). Preserve verbatim.
-          return { kind: 'array-method', method: e.method, object: walk(e.object), args: [], comparator: e.comparator }
-        }
-        if (e.method === 'reduce' || e.method === 'reduceRight') {
-          // `ReduceOp` is a structured value referencing its own
-          // paramAcc / paramItem, never the enclosing destructure —
-          // preserve verbatim, same as the sort comparator above.
-          return { kind: 'array-method', method: e.method, object: walk(e.object), args: [], reduceOp: e.reduceOp }
-        }
         if (e.method === 'flat') {
           // `flatDepth` is a normalised literal — no destructure refs to
-          // substitute. Preserve verbatim, same as sort / reduce above.
+          // substitute. Preserve verbatim.
           return { kind: 'array-method', method: 'flat', object: walk(e.object), args: [], flatDepth: e.flatDepth }
         }
-        if (e.method === 'flatMap') {
-          // `FlatMapOp` references its own callback param, never the
-          // enclosing destructure — preserve verbatim, like reduce / sort.
-          return { kind: 'array-method', method: 'flatMap', object: walk(e.object), args: [], flatMapOp: e.flatMapOp }
-        }
         return { kind: 'array-method', method: e.method, object: walk(e.object), args: e.args.map(walk) }
       case 'literal':
+      case 'regex':
       case 'unsupported':
+      // Mirror `unsupported`: object literals were not substituted into
+      // before this kind existed — return verbatim (byte-identical A-1).
+      case 'object-literal':
         return e
     }
   }
@@ -2567,57 +2149,27 @@ function checkSupport(expr: ParsedExpr): SupportResult {
     case 'unsupported':
       return { supported: false, reason: expr.reason }
 
+    // A bare object literal is still refused as a standalone template
+    // expression — adapters that lower one as a *value* (Go map / Perl
+    // hashref) do so in their own emitter, like `array-literal`, not
+    // through this support gate. The reason string is the exact text the
+    // `unsupported` fallback produced before the `object-literal` kind
+    // existed, so diagnostics stay byte-identical (Roadmap A-1).
+    case 'object-literal':
+      return { supported: false, reason: 'Unsupported syntax: ObjectLiteralExpression' }
+
     case 'identifier':
       return { supported: true, level: 'L1' }
 
     case 'literal':
       return { supported: true, level: 'L1' }
 
-    case 'arrow-fn': {
-      // Arrow functions are only supported as arguments to higher-order methods
-      // They shouldn't appear standalone in supported contexts
-      return { supported: false, reason: 'Standalone arrow functions are not supported' }
-    }
-
-    case 'higher-order': {
-      // Check if predicate uses L1-L4 features
-      const predSupport = checkSupport(expr.predicate)
-      if (!predSupport.supported) {
-        return {
-          supported: false,
-          level: 'L5_UNSUPPORTED',
-          reason: `Higher-order method '${expr.method}()' with complex predicate. ${predSupport.reason || 'Simplify the predicate.'}`,
-        }
-      }
-      // Nested higher-order INSIDE the predicate body (e.g.
-      // `x => x.tags.filter(t => t.active).length > 0`) was refused
-      // here historically because adapter emitters would produce
-      // broken output for `[grep ...]->{length}` style chains. Note
-      // this check is intentionally NOT extended to `expr.object`:
-      // chained-receiver forms like `arr.filter(p).filter(q)` lower
-      // correctly via the emitter's recursive `emit(object)` (which
-      // wraps the inner result in another `grep`). The Copilot
-      // review on #1444 asked us to either update this comment or
-      // also reject chained receivers — preserving the chained
-      // case is the right move because it already works.
-      if (containsHigherOrder(expr.predicate)) {
-        return {
-          supported: false,
-          level: 'L5_UNSUPPORTED',
-          reason: `Nested higher-order methods inside a predicate body are not supported. Use @client directive.`,
-        }
-      }
-      // The source array also has to be lowerable. Skipping this check
-      // (matching the pre-#1443 behaviour) silently let `array-literal`
-      // sources fall through to the adapter's `unsupported` arm and
-      // through the regex pipeline — the recursion that #1421 / #1427
-      // worked around.
-      const objSupport = checkSupport(expr.object)
-      if (!objSupport.supported) {
-        return objSupport
-      }
-      return { supported: true, level: 'L5' }
-    }
+    case 'arrow':
+    case 'regex':
+      // Arrow functions / regex literals are only supported as the
+      // argument of a recognised higher-order callback call (handled in
+      // the `call` arm below); they're unsupported standalone.
+      return { supported: false, reason: 'Standalone arrow functions / regex literals are not supported' }
 
     case 'array-literal': {
       // Array literal is lowerable iff every element is. Adapters that
@@ -2633,6 +2185,17 @@ function checkSupport(expr: ParsedExpr): SupportResult {
     }
 
     case 'array-method': {
+      // A regex-pattern `.replace` is carried structurally (a `regex` first
+      // arg) but is the deferred form (#1448) — no template language lowers it.
+      // Refuse with the dedicated reason rather than the generic standalone-regex
+      // message, preserving the diagnostic the parser used to emit directly.
+      if (expr.method === 'replace' && expr.args[0]?.kind === 'regex') {
+        return {
+          supported: false,
+          reason:
+            'String.prototype.replace supports only a string pattern + string replacement (the regex form is deferred); use a string pattern or wrap the expression in /* @client */',
+        }
+      }
       const objSupport = checkSupport(expr.object)
       if (!objSupport.supported) return objSupport
       for (const arg of expr.args) {
@@ -2644,6 +2207,36 @@ function checkSupport(expr: ParsedExpr): SupportResult {
 
 
     case 'call': {
+      // Higher-order callback methods (`.filter`/`.sort`/`.reduce`/… with an
+      // arrow argument) lower via the runtime evaluator (#2018). Supported iff
+      // the receiver and the callback BODY are supported. Recognised before the
+      // `UNSUPPORTED_METHODS` gate so the eval-lowered shapes aren't refused
+      // (a BARE method reference — `arr.filter` uncalled, no arrow arg — still
+      // falls through to the gate). A nested callback inside the body is NOT
+      // refused here: the evaluator refuses it (`serializeParsedExpr` → null)
+      // and each adapter then either lowers it faithfully (Mojo's inline
+      // `grep`, Go's `len (bf_filter_eval …)`) or surfaces BF101 at its
+      // predicate fallback's exact degrade points (#2038) — a blanket refusal
+      // here would break the faithful shapes (#1443 PR4).
+      const cb = asCallbackMethodCall(expr)
+      if (cb) {
+        const objSupport = checkSupport(cb.object)
+        if (!objSupport.supported) return objSupport
+        const bodySupport = checkSupport(cb.arrow.body)
+        if (!bodySupport.supported) {
+          return {
+            supported: false,
+            level: 'L5_UNSUPPORTED',
+            reason: `Higher-order method '.${cb.method}()' with complex callback. ${bodySupport.reason || 'Simplify the callback.'}`,
+          }
+        }
+        for (const rest of cb.args) {
+          const restSupport = checkSupport(rest)
+          if (!restSupport.supported) return restSupport
+        }
+        return { supported: true, level: 'L5' }
+      }
+
       // Check if callee is supported
       const calleeSupport = checkSupport(expr.callee)
       if (!calleeSupport.supported) {
@@ -2778,12 +2371,13 @@ function checkSupport(expr: ParsedExpr): SupportResult {
 }
 
 /**
- * Check if expression contains any higher-order method calls.
+ * Check if expression contains any higher-order callback method call
+ * (`.filter`/`.sort`/`.reduce`/… with an arrow argument — see
+ * {@link asCallbackMethodCall}) anywhere in the tree.
  */
 export function containsHigherOrder(expr: ParsedExpr): boolean {
+  if (asCallbackMethodCall(expr) !== null) return true
   switch (expr.kind) {
-    case 'higher-order':
-      return true
     case 'call':
       return expr.args.some(containsHigherOrder) || containsHigherOrder(expr.callee)
     case 'member':
@@ -2798,7 +2392,7 @@ export function containsHigherOrder(expr: ParsedExpr): boolean {
       return containsHigherOrder(expr.left) || containsHigherOrder(expr.right)
     case 'conditional':
       return containsHigherOrder(expr.test) || containsHigherOrder(expr.consequent) || containsHigherOrder(expr.alternate)
-    case 'arrow-fn':
+    case 'arrow':
       return containsHigherOrder(expr.body)
     case 'array-literal':
       return expr.elements.some(containsHigherOrder)
@@ -2847,6 +2441,29 @@ export function parseBlockBody(
   return statements
 }
 
+/**
+ * Like {@link parseBlockBody} but tolerant: a statement `parseStatement` can't
+ * represent is **skipped** rather than failing the whole block. Used to carry a
+ * block-body memo's structure on the IR for adapters that only pattern-match a
+ * recognised prefix of statements (e.g. a `const k = getter(); if (!k) return
+ * CONST` guard) and ignore the rest — including a trailing client-directive
+ * (`@client`) return that the strict parser would reject. Mirrors the tolerant
+ * `continue`-on-unrecognised walks those adapters previously ran over a
+ * re-parsed source string, so it never carries a *more* permissive result.
+ */
+export function parseBlockBodyTolerant(
+  block: ts.Block,
+  sourceFile: ts.SourceFile,
+  getJS: (node: ts.Node) => string
+): ParsedStatement[] {
+  const statements: ParsedStatement[] = []
+  for (const stmt of block.statements) {
+    const parsed = parseStatement(stmt, sourceFile, getJS)
+    if (parsed !== null) statements.push(parsed)
+  }
+  return statements
+}
+
 /**
  * Parse a single statement into ParsedStatement.
  */
@@ -2876,8 +2493,17 @@ function parseStatement(
       // return; (no value) -> return undefined, treat as return true
       return { kind: 'return', value: { kind: 'literal', value: true, literalType: 'boolean' } }
     }
-    const valueText = getJS(stmt.expression)
-    const value = parseExpression(valueText)
+    // A bare object-literal return (`return { a: 1 }`) re-parses as a *block*
+    // statement if its braces lead the source, yielding `unsupported`. Unwrap
+    // any parens, and when the returned expression is an object literal, wrap
+    // the text in parens to force expression context so it parses as an
+    // `object-literal` ParsedExpr (consumed by the Go object-memo lowering).
+    let retExpr: ts.Expression = stmt.expression
+    while (ts.isParenthesizedExpression(retExpr)) retExpr = retExpr.expression
+    const valueText = getJS(retExpr)
+    const value = parseExpression(
+      ts.isObjectLiteralExpression(retExpr) ? `(${valueText})` : valueText,
+    )
     if (value.kind === 'unsupported') {
       return null
     }
@@ -2888,7 +2514,7 @@ function parseStatement(
   if (ts.isIfStatement(stmt)) {
     const conditionText = getJS(stmt.expression)
     const condition = parseExpression(conditionText)
-    if (condition.kind === 'unsupported') {
+    if (condition.kind === 'unsupported' || condition.kind === 'object-literal') {
       return null
     }
 
@@ -2925,6 +2551,435 @@ function parseStatement(
   return null
 }
 
+// =============================================================================
+// Block → Expression Normalization (#2040)
+// =============================================================================
+
+/**
+ * The actionable refusal reason for a block body that is not purely-functionally
+ * expressible. Carried on the `unsupported` ParsedExpr so adapters surface it as
+ * the BF101 message. A loop that mutates a local to accumulate a value is a fold
+ * (already expressible via `.reduce`); a loop that does anything else, a `break`,
+ * a re-assignment, or a side-effecting/I-O call is genuinely imperative and has
+ * no value-position lowering.
+ */
+export const IMPERATIVE_BLOCK_REASON =
+  'Block body cannot be normalized to a value expression. Only pure ' +
+  '`const` bindings, value-producing `if` / early `return`, and a final ' +
+  '`return` are supported. Imperative shapes (raw `for` / `while` loops, ' +
+  '`break`, local re-assignment, side-effecting or I/O calls) are not. ' +
+  'Rewrite an accumulation loop as `.reduce(...)`, or move the imperative ' +
+  'body to a `/* @client */` value so it runs natively on the client.'
+
+/**
+ * Whether a statement sequence always reaches a `return` on every control-flow
+ * path (so anything textually after it is dead). A bare `return` terminates; an
+ * `if` terminates only when it has an `else` and both branches terminate. Used
+ * by {@link foldBlockToExpr} to decide whether the statements following an `if`
+ * belong to the fall-through (else) path.
+ */
+function statementsTerminate(stmts: ParsedStatement[]): boolean {
+  for (const s of stmts) {
+    if (s.kind === 'return') return true
+    if (
+      s.kind === 'if' &&
+      s.alternate !== undefined &&
+      statementsTerminate(s.consequent) &&
+      statementsTerminate(s.alternate)
+    ) {
+      return true
+    }
+  }
+  return false
+}
+
+/**
+ * Refusal reason when inlining a `const` binding would capture a free variable
+ * of its initializer under a nested callback parameter of the same name. The
+ * let-inline substitution is not a hygienic (alpha-renaming) substitution, so
+ * rather than silently miscompile the callback we refuse and adapters surface
+ * BF101.
+ */
+export const CAPTURE_BLOCK_REASON =
+  'Block body cannot be normalized: inlining a `const` binding would capture ' +
+  'one of its free variables under a nested callback parameter of the same ' +
+  'name (e.g. `const x = a; … list.map(a => a + x)`). Rename the inner ' +
+  'parameter, or move the body to a `/* @client */` value so it runs natively ' +
+  'on the client.'
+
+/**
+ * Refusal reason when a `const` initializer may have side effects (it contains
+ * a function/method call) and the binding is NOT used exactly once on a single
+ * runtime path. Let-inline substitutes the initializer at each use site, which
+ * would drop the effect (zero uses) or duplicate it (multiple uses / a use
+ * inside a callback that runs per element) — exactly the side-effecting shape
+ * the fold must refuse rather than miscompile.
+ */
+export const IMPURE_INLINE_BLOCK_REASON =
+  'Block body cannot be normalized: a `const` whose initializer may have side ' +
+  'effects (a function or method call) is not used exactly once on every path, ' +
+  'so inlining it would drop the effect on some path or duplicate it on ' +
+  'another. Bind a pure value, use the binding exactly once unconditionally, ' +
+  'or move the body to a `/* @client */` value so it runs natively on the client.'
+
+/**
+ * Options for {@link foldBlockToExpr}.
+ */
+export interface FoldBlockOptions {
+  /**
+   * Names of zero-argument calls that are idempotent reads with no observable
+   * side effect — chiefly reactive getters (signal / memo accessors), which
+   * return the same value each time within a render. Inlining such a read at
+   * multiple sites is evaluation-count-neutral, so the fold may treat
+   * `getter()` as pure. The caller (e.g. `jsx-to-ir`) supplies the set from its
+   * analyzer-collected signal/memo names; callers without that context (the
+   * plain `convertNode` callback path) omit it and every call stays "possibly
+   * impure". A non-empty arg list or a member-call (`a.b()`) is never treated as
+   * pure by this set.
+   */
+  pureCallNames?: ReadonlySet<string>
+}
+
+/**
+ * Whether an expression is provably free of side effects, so it is safe to
+ * inline at any number of use sites. Conservative: a function / method call is
+ * possibly impure, EXCEPT a zero-arg call to a name in `pureCallNames` (an
+ * idempotent reactive getter read). Member access is treated as pure, matching
+ * `substituteDestructuredFields` and the rest of the compiler's expression
+ * handling.
+ */
+function isPureInit(e: ParsedExpr, pureCallNames?: ReadonlySet<string>): boolean {
+  const pure = (x: ParsedExpr) => isPureInit(x, pureCallNames)
+  switch (e.kind) {
+    case 'identifier':
+    case 'literal':
+    case 'regex':
+      return true
+    case 'member':
+      return pure(e.object)
+    case 'index-access':
+      return pure(e.object) && pure(e.index)
+    case 'binary':
+    case 'logical':
+      return pure(e.left) && pure(e.right)
+    case 'unary':
+      return pure(e.argument)
+    case 'conditional':
+      return pure(e.test) && pure(e.consequent) && pure(e.alternate)
+    case 'template-literal':
+      return e.parts.every(p => p.type !== 'expression' || pure(p.expr))
+    case 'array-literal':
+      return e.elements.every(pure)
+    case 'object-literal':
+      return e.properties.every(p => pure(p.value))
+    case 'call':
+      // A zero-arg reactive getter read (`filter()`, `count()`) is idempotent;
+      // any other call may be effectful or non-deterministic.
+      return (
+        e.callee.kind === 'identifier' &&
+        e.args.length === 0 &&
+        pureCallNames !== undefined &&
+        pureCallNames.has(e.callee.name)
+      )
+    // A method call may be effectful; an arrow value can capture impurity;
+    // `unsupported` is opaque. Treat all as possibly impure.
+    case 'array-method':
+    case 'arrow':
+    case 'unsupported':
+      return false
+  }
+}
+
+/**
+ * The `{ min, max }` number of times `name` is evaluated on a single runtime
+ * path through `expr` — the minimum-cost path and the maximum-cost path. Used to
+ * decide whether inlining a possibly-impure init is evaluation-count-preserving:
+ * sound only when it is evaluated **exactly once on every path** (`min === 1 &&
+ * max === 1`), so the substituted call neither drops nor duplicates its effect.
+ *
+ * Path semantics:
+ *   - `conditional` evaluates the test then exactly one arm → test + the min/max
+ *     of the two arms (a binding used in only one arm has `min` 0: it is skipped
+ *     on the other path).
+ *   - `logical` (`&&` / `||` / `??`) evaluates the left, then the right only on
+ *     some paths (short-circuit) → the right contributes to `max` but not `min`.
+ *   - a nested `arrow` body may run any number of times (a callback invoked per
+ *     element / comparison, or never) → a use inside has `min` 0 and `max`
+ *     `Infinity`, forcing an impure binding referenced from a callback to be
+ *     refused.
+ */
+function usesPerPath(name: string, expr: ParsedExpr): { min: number; max: number } {
+  const add = (a: { min: number; max: number }, b: { min: number; max: number }) => ({
+    min: a.min + b.min,
+    max: a.max + b.max,
+  })
+  const sum = (xs: ParsedExpr[]) => xs.reduce((acc, x) => add(acc, walk(x)), { min: 0, max: 0 })
+  const walk = (e: ParsedExpr): { min: number; max: number } => {
+    switch (e.kind) {
+      case 'identifier':
+        return e.name === name ? { min: 1, max: 1 } : { min: 0, max: 0 }
+      case 'literal':
+      case 'regex':
+      case 'unsupported':
+        return { min: 0, max: 0 }
+      case 'member':
+        return walk(e.object)
+      case 'index-access':
+        return add(walk(e.object), walk(e.index))
+      case 'binary':
+        return add(walk(e.left), walk(e.right))
+      case 'logical': {
+        // The right operand is only evaluated on some paths (short-circuit), so
+        // it contributes to the max but never to the guaranteed min.
+        const l = walk(e.left)
+        const r = walk(e.right)
+        return { min: l.min, max: l.max + r.max }
+      }
+      case 'unary':
+        return walk(e.argument)
+      case 'conditional': {
+        const t = walk(e.test)
+        const c = walk(e.consequent)
+        const a = walk(e.alternate)
+        return { min: t.min + Math.min(c.min, a.min), max: t.max + Math.max(c.max, a.max) }
+      }
+      case 'template-literal':
+        return sum(e.parts.flatMap(p => (p.type === 'expression' ? [p.expr] : [])))
+      case 'call':
+        return add(walk(e.callee), sum(e.args))
+      case 'array-literal':
+        return sum(e.elements)
+      case 'array-method':
+        return add(walk(e.object), e.method === 'flat' ? { min: 0, max: 0 } : sum(e.args))
+      case 'object-literal':
+        return sum(e.properties.map(p => p.value))
+      case 'arrow':
+        // A callback body may run any number of times (per element, or never).
+        return walk(e.body).max > 0 ? { min: 0, max: Number.POSITIVE_INFINITY } : { min: 0, max: 0 }
+    }
+  }
+  return walk(expr)
+}
+
+/**
+ * Inline `name → value` everywhere it appears free in `expr` (the let-inline
+ * step). Returns `null` if the substitution would capture a free variable of
+ * `value` under a nested callback parameter of the same name — that shape is
+ * unsound to inline non-hygienically, so the caller refuses with
+ * {@link CAPTURE_BLOCK_REASON}. A nested arrow parameter that shadows `name`
+ * leaves that inner reference untouched (it is the parameter, not the binding).
+ * Mirrors the structural walk of `substituteDestructuredFields`; every
+ * `ParsedExpr` kind is handled so a new kind surfaces as a compile error here.
+ */
+function inlineBinding(
+  expr: ParsedExpr,
+  name: string,
+  value: ParsedExpr,
+): ParsedExpr | null {
+  // Free variables of `value` that an enclosing callback parameter could capture.
+  const valueFree = new Set<string>()
+  collectIdentifiers(value, valueFree)
+  let captured = false
+
+  const walk = (e: ParsedExpr, enclosing: ReadonlySet<string>): ParsedExpr => {
+    switch (e.kind) {
+      case 'identifier': {
+        if (e.name !== name) return e
+        // Shadowed by an enclosing callback param → this is the parameter, not
+        // the binding; leave it.
+        if (enclosing.has(e.name)) return e
+        // Inlining here: does any enclosing param capture a free var of `value`?
+        for (const p of enclosing) {
+          if (valueFree.has(p)) {
+            captured = true
+            return e
+          }
+        }
+        return value
+      }
+      case 'call':
+        return { kind: 'call', callee: walk(e.callee, enclosing), args: e.args.map(a => walk(a, enclosing)) }
+      case 'member':
+        return { kind: 'member', object: walk(e.object, enclosing), property: e.property, computed: e.computed }
+      case 'index-access':
+        return { kind: 'index-access', object: walk(e.object, enclosing), index: walk(e.index, enclosing) }
+      case 'binary':
+        return { kind: 'binary', op: e.op, left: walk(e.left, enclosing), right: walk(e.right, enclosing) }
+      case 'logical':
+        return { kind: 'logical', op: e.op, left: walk(e.left, enclosing), right: walk(e.right, enclosing) }
+      case 'unary':
+        return { kind: 'unary', op: e.op, argument: walk(e.argument, enclosing) }
+      case 'conditional':
+        return { kind: 'conditional', test: walk(e.test, enclosing), consequent: walk(e.consequent, enclosing), alternate: walk(e.alternate, enclosing) }
+      case 'template-literal':
+        return {
+          kind: 'template-literal',
+          parts: e.parts.map(p =>
+            p.type === 'expression' ? { type: 'expression', expr: walk(p.expr, enclosing) } : p,
+          ),
+        }
+      case 'arrow': {
+        const innerEnclosing = e.params.length === 0 ? enclosing : new Set([...enclosing, ...e.params])
+        return { kind: 'arrow', params: e.params, body: walk(e.body, innerEnclosing) }
+      }
+      case 'array-literal':
+        return { kind: 'array-literal', elements: e.elements.map(el => walk(el, enclosing)) }
+      case 'array-method':
+        if (e.method === 'flat') {
+          return { kind: 'array-method', method: 'flat', object: walk(e.object, enclosing), args: [], flatDepth: e.flatDepth }
+        }
+        return { kind: 'array-method', method: e.method, object: walk(e.object, enclosing), args: e.args.map(a => walk(a, enclosing)) }
+      case 'object-literal':
+        return {
+          kind: 'object-literal',
+          properties: e.properties.map(p => ({ ...p, value: walk(p.value, enclosing) })),
+          raw: e.raw,
+        }
+      case 'literal':
+      case 'regex':
+      case 'unsupported':
+        return e
+    }
+  }
+
+  const result = walk(expr, new Set())
+  return captured ? null : result
+}
+
+/**
+ * Fold a value-producing block body — a {@link ParsedStatement} sequence of
+ * `const` bindings, value-producing `if` / early `return`, and a terminal
+ * `return` — into a single {@link ParsedExpr}, so block-bodied memos / derived /
+ * callbacks flow through the same expression surface as expression-bodied ones
+ * (#2040, carved from #2018 stage 5). This generalizes the per-idiom block-memo
+ * recognizers (#1897 / #1945 / #2015) the same way the evaluator replaced the
+ * `bf_sort` / `bf_reduce` catalogue: one normalization, no growing pattern list.
+ *
+ * Transformations:
+ *   - `const x = <init>; …` → inline `x`'s init into the rest (let-inline).
+ *   - `if (c) <then> [else <else>] …` → `c ? fold(then-path) : fold(else-path)`,
+ *     where a branch that does not itself terminate continues into the
+ *     statements following the `if` (the early-return idiom).
+ *   - `return <v>` → `<v>`.
+ *
+ * The rest is folded first, leaving each binding as a free identifier, so its
+ * use count can be measured before inlining. Inlining is refused (→ `ok: false`)
+ * when it would be unsound:
+ *   - a possibly-impure init (one containing a call) used zero or more than once
+ *     on a path would drop or duplicate the side effect (a pure init is always
+ *     safe to inline any number of times);
+ *   - a substitution would capture a free variable of the init under a nested
+ *     callback parameter of the same name (substitution is not hygienic).
+ *
+ * Returns `{ ok: false }` for a sequence that cannot produce a value on some
+ * path (falls through with no `return`) — the genuinely-imperative residue that
+ * {@link IMPERATIVE_BLOCK_REASON} describes. The input is assumed to be the
+ * STRICT parse ({@link parseBlockBody}, not the tolerant variant): every source
+ * statement is represented, so a `false` here reflects the real shape rather
+ * than a silently-dropped statement.
+ */
+export function foldBlockToExpr(
+  stmts: ParsedStatement[],
+  opts?: FoldBlockOptions,
+): { ok: true; expr: ParsedExpr } | { ok: false; reason: string } {
+  if (stmts.length === 0) {
+    return { ok: false, reason: IMPERATIVE_BLOCK_REASON }
+  }
+  const [head, ...rest] = stmts
+  switch (head.kind) {
+    case 'var-decl': {
+      // Fold the remaining statements first, leaving `head.name` free so its use
+      // count can drive the soundness check. Any earlier-binding references in
+      // the rest are inlined by the enclosing `var-decl` frames; references to
+      // `head.name` inside `head.init` cannot occur (a `const` can't read itself).
+      const restFold = foldBlockToExpr(rest, opts)
+      if (!restFold.ok) return restFold
+      const uses = usesPerPath(head.name, restFold.expr)
+      // A possibly-impure init is only safe to inline when it is evaluated
+      // exactly once on EVERY path — same as the original block, which runs the
+      // `const` initializer unconditionally once. `min !== 1` catches an effect
+      // dropped on some path (unused, or used in only one ternary arm / a
+      // short-circuited operand / a callback); `max !== 1` catches duplication.
+      // A pure init is safe at any count (drop / duplicate is unobservable);
+      // idempotent reactive getter reads in `pureCallNames` count as pure.
+      if (!isPureInit(head.init, opts?.pureCallNames) && !(uses.min === 1 && uses.max === 1)) {
+        return { ok: false, reason: IMPURE_INLINE_BLOCK_REASON }
+      }
+      const inlined = inlineBinding(restFold.expr, head.name, head.init)
+      if (inlined === null) {
+        return { ok: false, reason: CAPTURE_BLOCK_REASON }
+      }
+      return { ok: true, expr: inlined }
+    }
+    case 'return':
+      return { ok: true, expr: head.value }
+    case 'if': {
+      // A branch that doesn't return falls through to the statements after the
+      // `if` (early-return idiom). A branch that returns makes `rest` dead for
+      // that path, so it is not appended. `rest` is intentionally duplicated
+      // into both fall-through paths; because each path is a separate ternary
+      // arm, a binding used once per arm is still evaluated at most once per
+      // runtime path.
+      const thenPath = statementsTerminate(head.consequent)
+        ? head.consequent
+        : [...head.consequent, ...rest]
+      const elseBase = head.alternate ?? []
+      const elsePath = statementsTerminate(elseBase)
+        ? elseBase
+        : [...elseBase, ...rest]
+      const consequent = foldBlockToExpr(thenPath, opts)
+      if (!consequent.ok) return consequent
+      const alternate = foldBlockToExpr(elsePath, opts)
+      if (!alternate.ok) return alternate
+      return {
+        ok: true,
+        expr: {
+          kind: 'conditional',
+          test: head.condition,
+          consequent: consequent.expr,
+          alternate: alternate.expr,
+        },
+      }
+    }
+  }
+}
+
+/**
+ * Rewrite a ternary whose arms are used in BOOLEAN context — e.g. the result of
+ * folding a block-bodied filter predicate (`if (c) return A; return B` →
+ * `c ? A : B`) — into an equivalent `&&` / `||` expression, so it flows through
+ * the ordinary boolean-expression lowering instead of needing a dedicated
+ * block-condition renderer per adapter (#2040). Boolean-literal arms collapse:
+ *
+ *   c ? true  : false  →  c
+ *   c ? true  : f      →  c || f
+ *   c ? t     : false  →  c && t
+ *   c ? false : f      →  !c && f
+ *   c ? t     : true   →  !c || t
+ *   c ? t     : f      →  (c && t) || (!c && f)
+ *
+ * Arms are flattened recursively (an `else if` chain is a nested ternary); the
+ * test is left as-is. Only valid where the consumer interprets the value as a
+ * boolean (a filter predicate). Non-conditional input is returned unchanged.
+ */
+export function predicateTernaryToLogical(expr: ParsedExpr): ParsedExpr {
+  if (expr.kind !== 'conditional') return expr
+  const cond = expr.test
+  const t = predicateTernaryToLogical(expr.consequent)
+  const f = predicateTernaryToLogical(expr.alternate)
+  const isTrue = (x: ParsedExpr) => x.kind === 'literal' && x.literalType === 'boolean' && x.value === true
+  const isFalse = (x: ParsedExpr) => x.kind === 'literal' && x.literalType === 'boolean' && x.value === false
+  const not = (x: ParsedExpr): ParsedExpr => ({ kind: 'unary', op: '!', argument: x })
+  const and = (a: ParsedExpr, b: ParsedExpr): ParsedExpr => ({ kind: 'logical', op: '&&', left: a, right: b })
+  const or = (a: ParsedExpr, b: ParsedExpr): ParsedExpr => ({ kind: 'logical', op: '||', left: a, right: b })
+  if (isTrue(t) && isFalse(f)) return cond
+  if (isTrue(t)) return or(cond, f)
+  if (isFalse(f)) return and(cond, t)
+  if (isFalse(t)) return and(not(cond), f)
+  if (isTrue(f)) return or(not(cond), t)
+  return or(and(cond, t), and(not(cond), f))
+}
+
 /**
  * Parse an if branch (then or else) into ParsedStatement array.
  */
@@ -2975,28 +3030,17 @@ export function exprToString(expr: ParsedExpr): string {
       return '`' + expr.parts.map(p =>
         p.type === 'string' ? p.value : `\${${exprToString(p.expr)}}`
       ).join('') + '`'
-    case 'arrow-fn':
-      return `${expr.param} => ${exprToString(expr.body)}`
-    case 'higher-order':
-      return `${exprToString(expr.object)}.${expr.method}(${expr.param} => ${exprToString(expr.predicate)})`
+    case 'arrow': {
+      // Single-param arrows round-trip without parens (`x => …`); multi-param
+      // need them (`(a, b) => …`).
+      const params = expr.params.length === 1 ? expr.params[0] : `(${expr.params.join(', ')})`
+      return `${params} => ${exprToString(expr.body)}`
+    }
+    case 'regex':
+      return expr.raw
     case 'array-literal':
       return `[${expr.elements.map(exprToString).join(', ')}]`
     case 'array-method':
-      if (expr.method === 'sort' || expr.method === 'toSorted') {
-        // Reconstruct against the user's actual param names — the
-        // comparator body in `raw` references them directly, so
-        // hardcoding `(a,b)` would produce un-re-parseable output
-        // for any user who wrote e.g. `(lhs, rhs) => lhs - rhs`.
-        const { paramA, paramB, raw } = expr.comparator
-        return `${exprToString(expr.object)}.${expr.method}((${paramA},${paramB}) => ${raw})`
-      }
-      if (expr.method === 'reduce' || expr.method === 'reduceRight') {
-        const { paramAcc, paramItem, raw, type, init } = expr.reduceOp
-        // `init` is the decoded value: re-quote a string seed, re-emit a
-        // numeric seed as-is (it's already a valid number literal).
-        const initSrc = type === 'string' ? JSON.stringify(init) : init
-        return `${exprToString(expr.object)}.${expr.method}((${paramAcc},${paramItem}) => ${raw}, ${initSrc})`
-      }
       if (expr.method === 'flat') {
         // Preserve the normalised depth so diagnostics don't misleadingly
         // print `.flat()` for a `.flat(2)` / `.flat(Infinity)` source.
@@ -3004,12 +3048,11 @@ export function exprToString(expr: ParsedExpr): string {
         const depthSrc = d === 'infinity' ? 'Infinity' : String(d)
         return `${exprToString(expr.object)}.flat(${d === 1 ? '' : depthSrc})`
       }
-      if (expr.method === 'flatMap') {
-        const { param, raw } = expr.flatMapOp
-        return `${exprToString(expr.object)}.flatMap(${param} => ${raw})`
-      }
       return `${exprToString(expr.object)}.${expr.method}(${expr.args.map(exprToString).join(', ')})`
     case 'unsupported':
+    // `raw` holds the original expression string (same value the old
+    // `unsupported` carried), so the round-trip stays byte-identical.
+    case 'object-literal':
       return `[UNSUPPORTED: ${expr.raw}]`
   }
 }
@@ -3058,30 +3101,19 @@ export function stringifyParsedExpr(expr: ParsedExpr): string {
       return '`' + expr.parts.map(p =>
         p.type === 'string' ? p.value : `\${${stringifyParsedExpr(p.expr)}}`
       ).join('') + '`'
-    case 'arrow-fn':
-      return `${expr.param} => ${stringifyParsedExpr(expr.body)}`
-    case 'higher-order':
-      return `${stringifyParsedExpr(expr.object)}.${expr.method}(${expr.param} => ${stringifyParsedExpr(expr.predicate)})`
+    case 'arrow': {
+      // Round-trip to valid JS for the CSR / Hono path and downstream
+      // re-parsers. A higher-order callback (`.sort`/`.filter`/…) reaches here
+      // as the arrow argument of a generic `call`. Single-param arrows round-
+      // trip without parens (`x => …`); multi-param need them (`(a, b) => …`).
+      const params = expr.params.length === 1 ? expr.params[0] : `(${expr.params.join(', ')})`
+      return `${params} => ${stringifyParsedExpr(expr.body)}`
+    }
+    case 'regex':
+      return expr.raw
     case 'array-literal':
       return `[${expr.elements.map(stringifyParsedExpr).join(', ')}]`
     case 'array-method':
-      if (expr.method === 'sort' || expr.method === 'toSorted') {
-        // Round-trip the original param names so downstream
-        // re-parsers (templatePrimitive substitution etc.) see
-        // valid JS — `raw` references the user's names verbatim.
-        const { paramA, paramB, raw } = expr.comparator
-        return `${stringifyParsedExpr(expr.object)}.${expr.method}((${paramA},${paramB}) => ${raw})`
-      }
-      if (expr.method === 'reduce' || expr.method === 'reduceRight') {
-        // Round-trip the user's param names + init so downstream
-        // re-parsers (the CSR / Hono JS path, templatePrimitive
-        // substitution) see valid JS — `raw` references the names
-        // verbatim. `init` is the decoded value: re-quote a string
-        // seed via JSON.stringify, re-emit a numeric seed as-is.
-        const { paramAcc, paramItem, raw, type, init } = expr.reduceOp
-        const initSrc = type === 'string' ? JSON.stringify(init) : init
-        return `${stringifyParsedExpr(expr.object)}.${expr.method}((${paramAcc},${paramItem}) => ${raw}, ${initSrc})`
-      }
       if (expr.method === 'flat') {
         // Round-trip the normalised depth back to JS for the CSR / Hono
         // path: `'infinity'` → `Infinity`, `1` is left implicit (`.flat()`).
@@ -3089,18 +3121,432 @@ export function stringifyParsedExpr(expr: ParsedExpr): string {
         const depthSrc = d === 'infinity' ? 'Infinity' : String(d)
         return `${stringifyParsedExpr(expr.object)}.flat(${d === 1 ? '' : depthSrc})`
       }
-      if (expr.method === 'flatMap') {
-        // Round-trip the user's callback param + body so the CSR / Hono
-        // path re-parses valid JS (`raw` references the param verbatim).
-        const { param, raw } = expr.flatMapOp
-        return `${stringifyParsedExpr(expr.object)}.flatMap(${param} => ${raw})`
-      }
       return `${stringifyParsedExpr(expr.object)}.${expr.method}(${expr.args.map(stringifyParsedExpr).join(', ')})`
     case 'unsupported':
+    // `raw` is the original expression string, so re-stringification is
+    // byte-identical to the pre-`object-literal` behaviour (Roadmap A-1).
+    case 'object-literal':
       return expr.raw
   }
 }
 
+/**
+ * Rewrite every zero-arg `call` node whose callee is a bare identifier in
+ * `names` into that identifier — `tag()` → `tag` — leaving everything else
+ * untouched. Returns a new tree; the input is never mutated.
+ *
+ * Rationale: in an SSR seed/constructor context a signal/memo getter call
+ * reads the already-computed SEEDED value, so `tag()` reduces to "the value
+ * bound to `tag`". Materialising the call lets the runtime evaluator (which
+ * refuses any non-builtin call, {@link toEvalNode}'s `evalBuiltinCalleeName`
+ * gate) evaluate a predicate that reads sibling memos — e.g. a `.filter`
+ * predicate `(p) => !tag() || p.tags.includes(tag())` — with the getter's
+ * value supplied through the evaluator's `base_env` instead of an
+ * unsupported call node. `names` is caller-supplied (typically the sibling
+ * signals/memos seeded alongside the derived memo being lowered), so a call
+ * to an unrelated function is left as a `call` node and still refused by the
+ * evaluator's builtin gate if it reaches `serializeParsedExpr`.
+ */
+export function materializeGetterCalls(expr: ParsedExpr, names: ReadonlySet<string>): ParsedExpr {
+  const rw = (e: ParsedExpr): ParsedExpr => materializeGetterCalls(e, names)
+  switch (expr.kind) {
+    case 'call':
+      if (
+        expr.args.length === 0 &&
+        expr.callee.kind === 'identifier' &&
+        names.has(expr.callee.name)
+      ) {
+        return { kind: 'identifier', name: expr.callee.name }
+      }
+      return { kind: 'call', callee: rw(expr.callee), args: expr.args.map(rw) }
+    case 'binary':
+      return { kind: 'binary', op: expr.op, left: rw(expr.left), right: rw(expr.right) }
+    case 'logical':
+      return { kind: 'logical', op: expr.op, left: rw(expr.left), right: rw(expr.right) }
+    case 'unary':
+      return { kind: 'unary', op: expr.op, argument: rw(expr.argument) }
+    case 'conditional':
+      return {
+        kind: 'conditional',
+        test: rw(expr.test),
+        consequent: rw(expr.consequent),
+        alternate: rw(expr.alternate),
+      }
+    case 'member':
+      return { kind: 'member', object: rw(expr.object), property: expr.property, computed: expr.computed }
+    case 'index-access':
+      return { kind: 'index-access', object: rw(expr.object), index: rw(expr.index) }
+    case 'template-literal':
+      return {
+        kind: 'template-literal',
+        parts: expr.parts.map(p => (p.type === 'string' ? p : { type: 'expression', expr: rw(p.expr) })),
+      }
+    case 'array-literal':
+      return { kind: 'array-literal', elements: expr.elements.map(rw) }
+    case 'array-method':
+      // `flat`'s `args` is always `[]` (the depth is carried structurally in
+      // `flatDepth`, not `args`) — still rewrite `object`, just skip the
+      // `args.map` that every other method needs.
+      if (expr.method === 'flat') return { ...expr, object: rw(expr.object) }
+      return { ...expr, object: rw(expr.object), args: expr.args.map(rw) }
+    case 'object-literal':
+      return {
+        kind: 'object-literal',
+        raw: expr.raw,
+        properties: expr.properties.map(p => ({ ...p, value: rw(p.value) })),
+      }
+    case 'arrow':
+      return { kind: 'arrow', params: expr.params, body: rw(expr.body) }
+    // Leaves / opaque shapes — nothing to rewrite.
+    case 'identifier':
+    case 'literal':
+    case 'regex':
+    case 'unsupported':
+      return expr
+  }
+}
+
+/**
+ * Serialize a pure-expression `ParsedExpr` (a higher-order callback body) into
+ * the minimal JSON the runtime evaluator consumes — the format pinned by the
+ * `eval-vectors` golden cases and read by Go `eval.go` `EvalNode` / Perl
+ * `Evaluator.pm` `evaluate`. Only the evaluator-recognized fields are emitted
+ * per kind (a literal carries just `value`; `literalType` / `raw` are dropped —
+ * the evaluator never reads them; `member.computed` is kept when set so a
+ * computed member stays distinguishable), keeping the embedded body blob small
+ * and stable.
+ *
+ * Returns `null` when the tree contains a shape outside the evaluator's surface
+ * — a folded `higher-order` / `array-method`, an `arrow-fn`, an `unsupported`
+ * node, an operator the evaluator doesn't implement, or a `call` whose callee
+ * isn't an allowlisted builtin (`Math.*` / `String` / `Number` / `Boolean`) — so
+ * the caller refuses the body (BF101 / `@client`) instead of emitting a blob the
+ * evaluator would read as nil. The evaluator's support criterion is
+ * purely-functional expressibility; this is its compile-time gate. (#2018)
+ */
+export function serializeParsedExpr(expr: ParsedExpr): string | null {
+  const node = toEvalNode(expr)
+  return node === null ? null : JSON.stringify(node)
+}
+
+/**
+ * The free variables a higher-order callback body references — every bare
+ * identifier in a value position, minus the callback's own `params`. The
+ * adapter materializes each into the evaluator's `base_env` (mapping the JS name
+ * to its SSR value). Walks exactly the value positions {@link serializeParsedExpr}
+ * serializes (so it sees object-literal *values* and template-expression parts,
+ * and skips member property names / object keys, which are not references).
+ * Returns a sorted, de-duplicated list for stable emit. (#2018)
+ */
+export function freeVarsInBody(body: ParsedExpr, params: ReadonlySet<string>): string[] {
+  const found = new Set<string>()
+  const visit = (e: ParsedExpr): void => {
+    switch (e.kind) {
+      case 'identifier':
+        if (!params.has(e.name)) found.add(e.name)
+        return
+      case 'binary':
+      case 'logical':
+        visit(e.left)
+        visit(e.right)
+        return
+      case 'unary':
+        visit(e.argument)
+        return
+      case 'conditional':
+        visit(e.test)
+        visit(e.consequent)
+        visit(e.alternate)
+        return
+      case 'member':
+        visit(e.object)
+        return
+      case 'index-access':
+        visit(e.object)
+        visit(e.index)
+        return
+      case 'call':
+        // A builtin callee (`String`/`Number`/`Boolean`, or `Math.<fn>`) is
+        // resolved syntactically by the evaluator — its identifier is NOT a
+        // captured free var. Visiting it would add `Math` / `String` to the
+        // env, making the adapter emit an undefined `$Math` / `.Math` base_env
+        // entry (Copilot review #2031). Skip the callee identifier in that
+        // case; the arguments are still real references and are visited.
+        if (evalBuiltinCalleeName(e.callee) === null) visit(e.callee)
+        e.args.forEach(visit)
+        return
+      case 'template-literal':
+        for (const p of e.parts) if (p.type === 'expression') visit(p.expr)
+        return
+      case 'array-literal':
+        e.elements.forEach(visit)
+        return
+      case 'object-literal':
+        // Object *values* are references; keys are not. (Shorthand `{ x }`
+        // carries the ref on its `value` identifier, which is visited here.)
+        for (const p of e.properties) visit(p.value)
+        return
+      case 'array-method':
+        // Only `.includes(x)` is serializable ({@link toEvalNode}); its
+        // `object` (the receiver) and `args` (the needle) are the value
+        // positions serialized, so visit both when the tree reaches here
+        // with that method. Every other `array-method` is non-serializable
+        // and doesn't occur in a serializable body.
+        if (e.method === 'includes') {
+          visit(e.object)
+          e.args.forEach(visit)
+        }
+        return
+      // Non-serializable kinds don't occur in a serializable body
+      // (serializeParsedExpr returns null for them); nothing to collect.
+      case 'literal':
+      case 'arrow':
+      case 'regex':
+      case 'unsupported':
+        return
+    }
+  }
+  visit(body)
+  return [...found].sort()
+}
+
+/**
+ * Every value-position identifier in `expr` NOT bound by an enclosing arrow's
+ * own parameters — with proper lexical scoping: an arrow's params bind only
+ * within that arrow's body, and nested arrows accumulate onto the enclosing
+ * bound set. Unlike {@link freeVarsInBody} (which assumes a single flat param
+ * set and never recurses into nested `arrow` nodes, since a serializable
+ * evaluator body never contains one), this walks the full source-level tree —
+ * including arrows — so a caller can ask "is this name free ANYWHERE in the
+ * expression, honoring each arrow's own scope" rather than only within one
+ * callback body.
+ *
+ * Walks the same value positions as {@link serializeParsedExpr} /
+ * {@link freeVarsInBody}: call callee (skipped when it resolves to an
+ * evaluator builtin — see {@link evalBuiltinCalleeName} — so `Math.floor(x)`
+ * doesn't report `Math` as free) + args, binary/logical/unary operands,
+ * conditional branches, a member's OBJECT only (the property name is not a
+ * reference), an index-access's object + index, template-literal expression
+ * parts, array-literal elements, array-method object + args, and an
+ * object-literal's property VALUES (not keys). An `arrow` recurses into its
+ * body with its own params added to the bound set.
+ *
+ * Returns `null` when the tree contains an `unsupported` node (or any other
+ * shape this walk can't analyze) — the caller must fail safe rather than
+ * assume nothing is free.
+ */
+export function freeIdentifiers(expr: ParsedExpr): Set<string> | null {
+  const free = new Set<string>()
+
+  function visit(e: ParsedExpr, bound: ReadonlySet<string>): boolean {
+    switch (e.kind) {
+      case 'literal':
+      case 'regex':
+        return true
+      case 'identifier':
+        if (!bound.has(e.name)) free.add(e.name)
+        return true
+      case 'call': {
+        const isBuiltinCallee = evalBuiltinCalleeName(e.callee) !== null
+        if (!isBuiltinCallee && !visit(e.callee, bound)) return false
+        for (const a of e.args) if (!visit(a, bound)) return false
+        return true
+      }
+      case 'member':
+        return visit(e.object, bound)
+      case 'index-access':
+        return visit(e.object, bound) && visit(e.index, bound)
+      case 'binary':
+      case 'logical':
+        return visit(e.left, bound) && visit(e.right, bound)
+      case 'unary':
+        return visit(e.argument, bound)
+      case 'conditional':
+        return visit(e.test, bound) && visit(e.consequent, bound) && visit(e.alternate, bound)
+      case 'template-literal':
+        for (const p of e.parts) {
+          if (p.type === 'expression' && !visit(p.expr, bound)) return false
+        }
+        return true
+      case 'array-literal':
+        for (const el of e.elements) if (!visit(el, bound)) return false
+        return true
+      case 'array-method':
+        if (!visit(e.object, bound)) return false
+        for (const a of e.args) if (!visit(a, bound)) return false
+        return true
+      case 'object-literal':
+        for (const p of e.properties) if (!visit(p.value, bound)) return false
+        return true
+      case 'arrow': {
+        const inner = new Set(bound)
+        for (const p of e.params) inner.add(p)
+        return visit(e.body, inner)
+      }
+      case 'unsupported':
+        return false
+    }
+  }
+
+  return visit(expr, new Set()) ? free : null
+}
+
+// Operators the evaluator implements (Go `eval.go` evalBinary / evalUnary, Perl
+// `Evaluator.pm` _binary / _unary). An op outside these sets — loose `==`,
+// `instanceof`, `**`, bitwise/shift, or the parser's `'unknown'` sentinel — is
+// refused so the body falls back to BF101 rather than serializing an op the
+// evaluator would silently mis-handle.
+const EVAL_BINARY_OPS: ReadonlySet<string> = new Set([
+  '+', '-', '*', '/', '%', '<', '<=', '>', '>=', '===', '!==',
+])
+const EVAL_UNARY_OPS: ReadonlySet<string> = new Set(['!', '-', '+'])
+
+// The only call shapes the evaluator executes (Go `eval.go` evalBuiltinName /
+// evalCallBuiltin, Perl `Evaluator.pm` _call_builtin): a bare `String` / `Number`
+// / `Boolean`, or a NON-computed `Math.<fn>` for a fixed `<fn>` set. Any other
+// callee — a bare function (`foo(x)`), a method (`x.bar(...)`), or a *computed*
+// builtin (`Math['max']`, which the evaluator rejects) — evaluates to nil at
+// runtime, so the gate refuses it at compile time instead (BF101 / `@client`).
+const EVAL_BUILTIN_IDENTS: ReadonlySet<string> = new Set(['String', 'Number', 'Boolean'])
+const EVAL_MATH_METHODS: ReadonlySet<string> = new Set([
+  'max', 'min', 'abs', 'floor', 'ceil', 'round',
+])
+
+/** The allowlisted builtin name a call callee resolves to (`Math.max` / `String`), or null. */
+function evalBuiltinCalleeName(callee: ParsedExpr): string | null {
+  if (callee.kind === 'identifier') {
+    return EVAL_BUILTIN_IDENTS.has(callee.name) ? callee.name : null
+  }
+  if (
+    callee.kind === 'member' &&
+    !callee.computed &&
+    callee.object.kind === 'identifier' &&
+    callee.object.name === 'Math' &&
+    EVAL_MATH_METHODS.has(callee.property)
+  ) {
+    return `Math.${callee.property}`
+  }
+  return null
+}
+
+/** Build the evaluator's minimal node object, or null for an out-of-surface kind. */
+function toEvalNode(e: ParsedExpr): Record<string, unknown> | null {
+  switch (e.kind) {
+    case 'literal':
+      return { kind: 'literal', value: e.value }
+    case 'identifier':
+      return { kind: 'identifier', name: e.name }
+    case 'binary': {
+      if (!EVAL_BINARY_OPS.has(e.op)) return null
+      const left = toEvalNode(e.left)
+      const right = toEvalNode(e.right)
+      return left && right ? { kind: 'binary', op: e.op, left, right } : null
+    }
+    case 'logical': {
+      // `op` is the fixed `&&` | `||` | `??` union — all evaluator-supported.
+      const left = toEvalNode(e.left)
+      const right = toEvalNode(e.right)
+      return left && right ? { kind: 'logical', op: e.op, left, right } : null
+    }
+    case 'unary': {
+      if (!EVAL_UNARY_OPS.has(e.op)) return null
+      const argument = toEvalNode(e.argument)
+      return argument ? { kind: 'unary', op: e.op, argument } : null
+    }
+    case 'conditional': {
+      const test = toEvalNode(e.test)
+      const consequent = toEvalNode(e.consequent)
+      const alternate = toEvalNode(e.alternate)
+      return test && consequent && alternate
+        ? { kind: 'conditional', test, consequent, alternate }
+        : null
+    }
+    case 'member': {
+      const object = toEvalNode(e.object)
+      if (!object) return null
+      // Carry `computed` only when set (absent reads as `false`): the evaluator
+      // reads it to reject a computed builtin (`Math['max']`), so preserving it
+      // keeps a computed member distinguishable from a plain `.prop` access. (A
+      // computed builtin *call* is already refused by the callee gate above.)
+      const node: Record<string, unknown> = { kind: 'member', object, property: e.property }
+      if (e.computed) node.computed = true
+      return node
+    }
+    case 'index-access': {
+      const object = toEvalNode(e.object)
+      const index = toEvalNode(e.index)
+      return object && index ? { kind: 'index-access', object, index } : null
+    }
+    case 'call': {
+      // The evaluator executes only the builtin allowlist; a non-builtin callee
+      // would evaluate to nil at runtime, so refuse it here (the purity gate).
+      if (evalBuiltinCalleeName(e.callee) === null) return null
+      const callee = toEvalNode(e.callee)
+      if (!callee) return null
+      const args: Record<string, unknown>[] = []
+      for (const a of e.args) {
+        const c = toEvalNode(a)
+        if (!c) return null
+        args.push(c)
+      }
+      return { kind: 'call', callee, args }
+    }
+    case 'template-literal': {
+      const parts: Record<string, unknown>[] = []
+      for (const p of e.parts) {
+        if (p.type === 'string') {
+          parts.push({ type: 'string', value: p.value })
+        } else {
+          const expr = toEvalNode(p.expr)
+          if (!expr) return null
+          parts.push({ type: 'expression', expr })
+        }
+      }
+      return { kind: 'template-literal', parts }
+    }
+    case 'array-literal': {
+      const elements: Record<string, unknown>[] = []
+      for (const el of e.elements) {
+        const c = toEvalNode(el)
+        if (!c) return null
+        elements.push(c)
+      }
+      return { kind: 'array-literal', elements }
+    }
+    case 'object-literal': {
+      const properties: Record<string, unknown>[] = []
+      for (const p of e.properties) {
+        const value = toEvalNode(p.value)
+        if (!value) return null
+        properties.push({ key: p.key, value })
+      }
+      return { kind: 'object-literal', properties }
+    }
+    case 'array-method': {
+      // `.includes(x)` is the one `array-method` the evaluator executes
+      // (Go `eval.go` / Perl `Evaluator.pm`, includes support): the
+      // receiver-type dispatch (array SameValueZero membership vs string
+      // substring) happens at evaluator runtime, same as the SSR template
+      // lowering's `bf_includes` / `$bf->includes`. Every other
+      // `array-method` (`join`, `slice`, `flat`, …) is outside the
+      // evaluator's surface and refuses below.
+      if (e.method === 'includes' && e.args.length === 1) {
+        const object = toEvalNode(e.object)
+        const arg = toEvalNode(e.args[0])
+        return object && arg ? { kind: 'array-method', method: 'includes', object, args: [arg] } : null
+      }
+      return null
+    }
+    // Outside the evaluator's pure-expression surface — refuse so the caller
+    // falls back to BF101 / `@client`. A nested `arrow` (a callback inside the
+    // body) is refused here, keeping the evaluator non-recursive.
+    case 'arrow':
+    case 'regex':
+    case 'unsupported':
+      return null
+  }
+}
+
 /**
  * Extract the textual identifier path from a parsed expression's
  * callee — `{kind:'identifier', name:'String'}` → `"String"`,