@barefootjs/jsx 0.15.2 → 0.17.0

package/src/__tests__/serialize-parsed-expr.test.ts

@@ -0,0 +1,204 @@
+import { describe, expect, test } from 'bun:test'
+import { parseExpression, serializeParsedExpr, freeVarsInBody } from '../expression-parser'
+
+/**
+ * `serializeParsedExpr` emits the minimal JSON the runtime evaluator (Go
+ * `eval.go` `EvalNode` / Perl `Evaluator.pm` `evaluate`) reads. These tests pin
+ * the field contract (only evaluator-read fields per kind) and the purity gate
+ * (folded / non-expression kinds → null). `freeVarsInBody` pins the captured
+ * free-var set used to build the evaluator's `base_env`. (#2018)
+ */
+
+/** Parse a callback-body source and serialize it to the evaluator JSON object. */
+function evalJSON(src: string): unknown {
+  const s = serializeParsedExpr(parseExpression(src))
+  return s === null ? null : JSON.parse(s)
+}
+
+describe('serializeParsedExpr', () => {
+  test('literal carries only `value` (no literalType / raw)', () => {
+    expect(evalJSON('42')).toEqual({ kind: 'literal', value: 42 })
+    expect(evalJSON("'hi'")).toEqual({ kind: 'literal', value: 'hi' })
+    expect(evalJSON('true')).toEqual({ kind: 'literal', value: true })
+    expect(evalJSON('null')).toEqual({ kind: 'literal', value: null })
+  })
+
+  test('identifier carries `name`', () => {
+    expect(evalJSON('acc')).toEqual({ kind: 'identifier', name: 'acc' })
+  })
+
+  test('reducer body: binary over member projection', () => {
+    expect(evalJSON('acc + item.price')).toEqual({
+      kind: 'binary',
+      op: '+',
+      left: { kind: 'identifier', name: 'acc' },
+      // member carries object + property only (no `computed`).
+      right: {
+        kind: 'member',
+        object: { kind: 'identifier', name: 'item' },
+        property: 'price',
+      },
+    })
+  })
+
+  test('comparator body: 3-way ternary', () => {
+    expect(evalJSON('a > b ? 1 : a < b ? -1 : 0')).toEqual({
+      kind: 'conditional',
+      test: { kind: 'binary', op: '>', left: { kind: 'identifier', name: 'a' }, right: { kind: 'identifier', name: 'b' } },
+      consequent: { kind: 'literal', value: 1 },
+      alternate: {
+        kind: 'conditional',
+        test: { kind: 'binary', op: '<', left: { kind: 'identifier', name: 'a' }, right: { kind: 'identifier', name: 'b' } },
+        consequent: { kind: 'unary', op: '-', argument: { kind: 'literal', value: 1 } },
+        alternate: { kind: 'literal', value: 0 },
+      },
+    })
+  })
+
+  test('filter body: logical over member access', () => {
+    expect(evalJSON('item.done && item.priority > 3')).toEqual({
+      kind: 'logical',
+      op: '&&',
+      left: { kind: 'member', object: { kind: 'identifier', name: 'item' }, property: 'done' },
+      right: {
+        kind: 'binary',
+        op: '>',
+        left: { kind: 'member', object: { kind: 'identifier', name: 'item' }, property: 'priority' },
+        right: { kind: 'literal', value: 3 },
+      },
+    })
+  })
+
+  test('index-access carries object + index', () => {
+    expect(evalJSON('item[i]')).toEqual({
+      kind: 'index-access',
+      object: { kind: 'identifier', name: 'item' },
+      index: { kind: 'identifier', name: 'i' },
+    })
+  })
+
+  test('builtin call carries callee + args', () => {
+    expect(evalJSON('Math.max(a, b)')).toEqual({
+      kind: 'call',
+      callee: { kind: 'member', object: { kind: 'identifier', name: 'Math' }, property: 'max' },
+      args: [
+        { kind: 'identifier', name: 'a' },
+        { kind: 'identifier', name: 'b' },
+      ],
+    })
+  })
+
+  test('template literal: string + expression parts', () => {
+    expect(evalJSON('`n=${acc + 1}`')).toEqual({
+      kind: 'template-literal',
+      parts: [
+        { type: 'string', value: 'n=' },
+        { type: 'expression', expr: { kind: 'binary', op: '+', left: { kind: 'identifier', name: 'acc' }, right: { kind: 'literal', value: 1 } } },
+      ],
+    })
+  })
+
+  test('map body: object literal carries key + value (no keyKind / shorthand)', () => {
+    expect(evalJSON('({ id: item.id, n: item.n })')).toEqual({
+      kind: 'object-literal',
+      properties: [
+        { key: 'id', value: { kind: 'member', object: { kind: 'identifier', name: 'item' }, property: 'id' } },
+        { key: 'n', value: { kind: 'member', object: { kind: 'identifier', name: 'item' }, property: 'n' } },
+      ],
+    })
+  })
+
+  test('array literal', () => {
+    expect(evalJSON('[item.a, item.b]')).toEqual({
+      kind: 'array-literal',
+      elements: [
+        { kind: 'member', object: { kind: 'identifier', name: 'item' }, property: 'a' },
+        { kind: 'member', object: { kind: 'identifier', name: 'item' }, property: 'b' },
+      ],
+    })
+  })
+
+  test('purity gate: a folded method call in the body → null', () => {
+    // `.toUpperCase()` folds to `array-method`, outside the evaluator surface.
+    expect(serializeParsedExpr(parseExpression('item.name.toUpperCase()'))).toBeNull()
+    // A higher-order call (`.filter`) likewise.
+    expect(serializeParsedExpr(parseExpression('item.tags.filter(t => t)'))).toBeNull()
+    // An unsupported shape.
+    expect(serializeParsedExpr(parseExpression('a instanceof B'))).toBeNull()
+  })
+
+  test('purity gate: a folded subtree anywhere poisons the whole body', () => {
+    expect(serializeParsedExpr(parseExpression('acc + item.name.toUpperCase()'))).toBeNull()
+  })
+
+  test('purity gate: a non-builtin call is refused (evaluator would read it as nil)', () => {
+    // Bare function call — not on the evaluator allowlist.
+    expect(serializeParsedExpr(parseExpression('foo(item)'))).toBeNull()
+    // Method call on a value — generic `call` with a non-Math member callee.
+    expect(serializeParsedExpr(parseExpression('item.compute(2)'))).toBeNull()
+    // `parseInt` etc. are not the allowlisted `Number`/`String`/`Boolean`.
+    expect(serializeParsedExpr(parseExpression('parseInt(item.s)'))).toBeNull()
+    // A computed builtin reference the evaluator rejects (`Math['max']`).
+    expect(serializeParsedExpr(parseExpression("Math['max'](a, b)"))).toBeNull()
+  })
+
+  test('allowlisted builtins serialize (Math.* / String / Number / Boolean)', () => {
+    expect(serializeParsedExpr(parseExpression('Math.floor(item.x)'))).not.toBeNull()
+    expect(serializeParsedExpr(parseExpression('String(item.n)'))).not.toBeNull()
+    expect(serializeParsedExpr(parseExpression('Number(item.s)'))).not.toBeNull()
+    expect(serializeParsedExpr(parseExpression('Boolean(item.s)'))).not.toBeNull()
+  })
+
+  test('a computed member value carries `computed: true` (plain access omits it)', () => {
+    // `row['price']` folds to a computed `member`; the flag is preserved so a
+    // computed member stays distinguishable. (`row.price` carries no `computed`.)
+    expect(evalJSON("row['price']")).toEqual({
+      kind: 'member',
+      object: { kind: 'identifier', name: 'row' },
+      property: 'price',
+      computed: true,
+    })
+    expect(evalJSON('row.price')).toEqual({
+      kind: 'member',
+      object: { kind: 'identifier', name: 'row' },
+      property: 'price',
+    })
+  })
+})
+
+describe('freeVarsInBody', () => {
+  test('collects refs minus the callback params, sorted & deduped', () => {
+    const body = parseExpression('acc + item.price + acc')
+    expect(freeVarsInBody(body, new Set(['acc', 'item']))).toEqual([])
+    expect(freeVarsInBody(body, new Set(['acc']))).toEqual(['item'])
+    expect(freeVarsInBody(body, new Set())).toEqual(['acc', 'item'])
+  })
+
+  test('captures an outer free var referenced in the body (base_env source)', () => {
+    // `taxRate` is neither param — it must travel as a captured free var.
+    const body = parseExpression('acc + item.price * taxRate')
+    expect(freeVarsInBody(body, new Set(['acc', 'item']))).toEqual(['taxRate'])
+  })
+
+  test('member property names are not references; object-literal values are', () => {
+    // `price` (property) is not a free var; `item` and `factor` are.
+    const body = parseExpression('({ total: item.price * factor })')
+    expect(freeVarsInBody(body, new Set()).sort()).toEqual(['factor', 'item'])
+  })
+
+  test('template + index + call cover their value positions', () => {
+    // `Math` is a builtin callee resolved syntactically by the evaluator — it
+    // is NOT captured (it would emit an undefined `$Math` / `.Math` base_env
+    // entry). The real refs `k`, `n`, `row` are.
+    const body = parseExpression('`${row[k]}-${Math.abs(n)}`')
+    expect(freeVarsInBody(body, new Set())).toEqual(['k', 'n', 'row'])
+  })
+
+  test('builtin call callees (Math.<fn> / String / Number / Boolean) are not captured', () => {
+    // Each builtin is resolved syntactically by the evaluator, so its
+    // identifier must not enter base_env (Copilot review #2031). The
+    // arguments, however, ARE real references.
+    const body = parseExpression('Math.max(a, factor) + Number(label) + String(x) + Boolean(flag)')
+    expect(freeVarsInBody(body, new Set(['a']))).toEqual(['factor', 'flag', 'label', 'x'])
+  })
+})

package/src/__tests__/unsupported-expression.test.ts

@@ -216,10 +216,11 @@ describe('Unsupported Sort Comparator (BF021)', () => {
     expect(bf021[0].message).toContain('not a supported shape')
   })
 
-  test('emits BF021 error for multi-statement block-body sort comparator', () => {
-    // Single-`return` block bodies now lower (#1448 Tier B follow-up),
-    // but multi-statement / local-var bodies stay refused — generalising
-    // over arbitrary statement sequences isn't tractable in a template.
+  test('no BF021 for let-inline block-body sort comparator (#2040)', () => {
+    // #2040: a value-producing block body (pure `const` bindings + a terminal
+    // `return`) normalises to a single expression via let-inline, so a
+    // `{ const x = a.price; return x - b.price }` comparator now lowers exactly
+    // like the expression-bodied `(a, b) => a.price - b.price`.
     const source = `
       'use client'
       import { createSignal } from '@barefootjs/client'
@@ -239,6 +240,32 @@ describe('Unsupported Sort Comparator (BF021)', () => {
     const { errors } = compileToIR(source)
     const bf021 = errors.filter(e => e.code === ErrorCodes.UNSUPPORTED_JSX_PATTERN)
 
+    expect(bf021).toHaveLength(0)
+  })
+
+  test('emits BF021 error for imperative block-body sort comparator (#2040)', () => {
+    // An imperative comparator (local re-assignment / mutation) has no
+    // value-position lowering — `foldBlockToExpr` refuses it, so the arrow stays
+    // `unsupported` and the sort extraction surfaces BF021.
+    const source = `
+      'use client'
+      import { createSignal } from '@barefootjs/client'
+
+      export function TodoList() {
+        const [items, setItems] = createSignal<any[]>([])
+        return (
+          <ul>
+            {items().sort((a, b) => { let r = 0; r = a.price - b.price; return r }).map(t => (
+              <li>{t.name}</li>
+            ))}
+          </ul>
+        )
+      }
+    `
+
+    const { errors } = compileToIR(source)
+    const bf021 = errors.filter(e => e.code === ErrorCodes.UNSUPPORTED_JSX_PATTERN)
+
     expect(bf021).toHaveLength(1)
     expect(bf021[0].message).toContain('not a supported shape')
   })
@@ -583,3 +610,70 @@ describe('Rest Pattern in Filter Predicate (BF021, #1532)', () => {
     expect(bf021).toHaveLength(0)
   })
 })
+
+// Block-bodied filter predicates are normalized to a single boolean expression
+// (#2040). A value-producing block lowers like an expression predicate; an
+// imperative block refuses.
+describe('Block-body filter predicate normalization (#2040)', () => {
+  function loopFilterIR(predicate: string) {
+    const source = `
+      'use client'
+      import { createSignal } from '@barefootjs/client'
+
+      export function TodoList() {
+        const [items, setItems] = createSignal<any[]>([])
+        const [filter, setFilter] = createSignal('all')
+        return (
+          <ul>
+            {items().filter(${predicate}).map(t => (
+              <li>{t.name}</li>
+            ))}
+          </ul>
+        )
+      }
+    `
+    const { ir, errors } = compileToIR(source)
+    const bf021 = errors.filter(e => e.code === ErrorCodes.UNSUPPORTED_JSX_PATTERN)
+    // Find the loop node carrying the filterPredicate.
+    let found: any = null
+    const walk = (n: any) => {
+      if (!n || found) return
+      if (n.filterPredicate) found = n
+      for (const c of n.children ?? []) walk(c)
+    }
+    walk(ir)
+    return { bf021, filterPredicate: found?.filterPredicate }
+  }
+
+  test('value-producing block (let-inline + early return) folds to a predicate', () => {
+    const { bf021, filterPredicate } = loopFilterIR(`t => {
+      const f = filter()
+      if (f === 'active') return !t.done
+      if (f === 'completed') return t.done
+      return true
+    }`)
+    expect(bf021).toHaveLength(0)
+    // No leftover block shape — a single boolean predicate expression.
+    expect(filterPredicate?.predicate).toBeDefined()
+    expect((filterPredicate as any)?.blockBody).toBeUndefined()
+  })
+
+  test('signal read on multiple branches still folds (idempotent getter is pure)', () => {
+    const { bf021, filterPredicate } = loopFilterIR(`t => {
+      const f = filter()
+      if (f === 'active') return !t.done
+      return f === 'completed' ? t.done : true
+    }`)
+    expect(bf021).toHaveLength(0)
+    expect(filterPredicate?.predicate).toBeDefined()
+  })
+
+  test('imperative block (local re-assignment) refuses with BF021', () => {
+    const { bf021 } = loopFilterIR(`t => {
+      let keep = false
+      keep = !t.done
+      return keep
+    }`)
+    expect(bf021.length).toBeGreaterThan(0)
+  })
+})

package/src/adapters/env-signal.ts

@@ -10,41 +10,80 @@ import type { ParsedExpr } from '../expression-parser.ts'
 import type { IRMetadata } from '../types.ts'
 
 /**
- * The local binding name(s) that `searchParams` from `@barefootjs/client` is
- * imported under in this component — the same import the analyzer allow-lists
- * (`CLIENT_EXPORTS`). Usually the single name `searchParams`, but an aliased
- * import (`import { searchParams as sp }`) binds it to `sp`, and the template
- * expression then reads `sp()` — so adapters must gate + match against the
- * LOCAL name(s), not the literal `searchParams`. Empty when the env signal is
- * not imported (the component keeps the generic signal lowering).
+ * Env-signal key → the runtime factory that produces it (`'search'` →
+ * `createSearchParams`). Single source of truth for the reverse of the
+ * analyzer's `ENV_SIGNAL_FACTORIES` (#2057): an env signal is `createSignal`-
+ * shaped for analysis, but every backend that re-emits its declaration (client
+ * JS, JSX/Hono SSR) must call this factory, not `createSignal`, so the value is
+ * the request-scoped reader rather than stored state.
+ */
+export const ENV_SIGNAL_CLIENT_FACTORY: Record<string, string> = {
+  search: 'createSearchParams',
+}
+
+/**
+ * The getter name(s) of the `searchParams` env signal in this component.
+ *
+ * Recognised **structurally** (#2057): the env signal is now declared as a
+ * `createSignal`-shaped `const [searchParams, setSearchParams] =
+ * createSearchParams()`, so the analyzer collects it into `metadata.signals`
+ * with `envReader: 'search'` — exactly like any other signal, but tagged. This
+ * function returns those getters (whatever the destructured name is —
+ * `searchParams`, or an alias), so adapters match the reader `.get()` call
+ * against the binding actually used, with **no `searchParams`-name allow-list**
+ * (this supersedes the import-name matching, and the closed #2055).
  *
- * `ImportSpecifier.name` is the exported name and `alias` the local rebinding
- * (see `collectImport` in analyzer.ts), so the import is detected by `name ===
- * 'searchParams'` and the local binding is `alias ?? name`. Namespace / default
- * specifiers bind a different identifier and are excluded.
+ * Empty when the component declares no env signal (the component keeps the
+ * generic signal lowering).
  */
 export function searchParamsLocalNames(metadata: IRMetadata): Set<string> {
   const names = new Set<string>()
-  for (const imp of metadata.imports) {
-    if (imp.source !== '@barefootjs/client' || imp.isTypeOnly) continue
-    for (const s of imp.specifiers) {
-      if (s.isTypeOnly || s.isNamespace || s.isDefault) continue
-      if (s.name === 'searchParams') names.add(s.alias ?? s.name)
-    }
+  for (const s of metadata.signals) {
+    if (s.envReader === 'search') names.add(s.getter)
   }
   return names
 }
 
 /**
- * True when the component imports the `searchParams` env signal under any local
- * name. Convenience for adapters/harnesses that only need to gate on presence
- * (the lowering itself needs the {@link searchParamsLocalNames} set to match the
- * actual binding in the expression).
+ * True when the component declares the `searchParams` env signal. Convenience
+ * for adapters/harnesses that only need to gate on presence (the lowering
+ * itself needs the {@link searchParamsLocalNames} set to match the actual
+ * binding in the expression).
  */
 export function importsSearchParams(metadata: IRMetadata): boolean {
   return searchParamsLocalNames(metadata).size > 0
 }
 
+/**
+ * The local binding name(s) that `queryHref` is imported under in this component
+ * (#2042) — the pure URL-query builder an adapter lowers to its query helper
+ * (`bf_query` in go-template). Matched by the exported name `queryHref` and bound
+ * to `alias ?? name`, so an aliased import (`import { queryHref as qh }`) is gated
+ * against the LOCAL name. Empty when not imported.
+ *
+ * Both the main `@barefootjs/client` entry and the `@barefootjs/client/runtime`
+ * re-export are accepted: `queryHref` is exported from both, so importing it from
+ * either must enable SSR lowering — otherwise the call's object-literal arg would
+ * hit the support gate (BF101) on the runtime-entry import path.
+ */
+export function queryHrefLocalNames(metadata: IRMetadata): Set<string> {
+  const names = new Set<string>()
+  for (const imp of metadata.imports) {
+    if (!QUERY_HREF_SOURCES.has(imp.source) || imp.isTypeOnly) continue
+    for (const s of imp.specifiers) {
+      if (s.isTypeOnly || s.isNamespace || s.isDefault) continue
+      if (s.name === 'queryHref') names.add(s.alias ?? s.name)
+    }
+  }
+  return names
+}
+
+/** Entry points that re-export `queryHref` (main + the runtime re-export). */
+const QUERY_HREF_SOURCES: ReadonlySet<string> = new Set([
+  '@barefootjs/client',
+  '@barefootjs/client/runtime',
+])
+
 /**
  * Recognise a `<binding>().<method>(<args>)` env-signal method call from a
  * `call` node's callee + args, where `<binding>` is one of the local names

package/src/adapters/jsx-adapter.ts

@@ -12,6 +12,7 @@ import type {
 } from '../types.ts'
 import { BF_SCOPE, BF_SLOT, BF_COND } from '@barefootjs/shared'
 import { BaseAdapter } from './interface.ts'
+import { ENV_SIGNAL_CLIENT_FACTORY } from './env-signal.ts'
 import { formatParamWithType, findReachableNames } from '../module-exports.ts'
 
 export interface JsxAdapterConfig {
@@ -110,6 +111,22 @@ export abstract class JsxAdapter extends BaseAdapter {
 
     for (const signal of ir.metadata.signals) {
       if (signal.isModule) continue
+      if (signal.envReader) {
+        // Env signal (#2057): call the real runtime factory so SSR resolves the
+        // request query through the installed server env reader, not a static
+        // initial value. Emit the factory as written (alias / namespace aware),
+        // matching the import re-emitted into the SSR module; fall back to the
+        // canonical name if the callee text wasn't captured.
+        const factory = signal.envFactory ?? ENV_SIGNAL_CLIENT_FACTORY[signal.envReader]
+        if (factory) {
+          lines.push(
+            signal.setter
+              ? `  const [${signal.getter}, ${signal.setter}] = ${factory}()`
+              : `  const [${signal.getter}] = ${factory}()`,
+          )
+        }
+        continue
+      }
       // Create a getter that returns the initial value for SSR
       const rawInitialValue = preserveTypes
         ? (signal.typedInitialValue ?? signal.initialValue)

package/src/adapters/parsed-expr-emitter.ts

@@ -33,7 +33,8 @@
  *     be added in one place.
  */
 
-import type { ParsedExpr, SortComparator, ReduceOp, FlatDepth, FlatMapOp, TemplatePart } from '../expression-parser.ts'
+import type { ParsedExpr, FlatDepth, TemplatePart, ObjectLiteralProperty } from '../expression-parser.ts'
+import { asCallbackMethodCall } from '../expression-parser.ts'
 
 export type HigherOrderMethod = 'filter' | 'every' | 'some' | 'find' | 'findIndex' | 'findLast' | 'findLastIndex'
 
@@ -139,49 +140,48 @@ export interface ParsedExprEmitter {
     emit: (e: ParsedExpr) => string,
   ): string
   templateLiteral(parts: TemplatePart[], emit: (e: ParsedExpr) => string): string
-  arrowFn(param: string, body: ParsedExpr, emit: (e: ParsedExpr) => string): string
-  higherOrder(
-    method: HigherOrderMethod,
+  // A higher-order callback method call (`<object>.<method>(<arrow>, …rest)`,
+  // method ∈ `CALLBACK_METHODS`): `.filter`/`.find`/`.every`/`.some`/`.sort`/
+  // `.reduce`/`.flatMap`/… (#2018 P5). The adapter serializes the `arrow` body
+  // to the runtime evaluator (eval-first) and falls back to a structured
+  // lowering when the body is outside the evaluator surface. `restArgs` carries
+  // any trailing arguments (e.g. the `.reduce` init).
+  callbackMethod(
+    method: string,
     object: ParsedExpr,
-    param: string,
-    predicate: ParsedExpr,
+    arrow: Extract<ParsedExpr, { kind: 'arrow' }>,
+    restArgs: ParsedExpr[],
     emit: (e: ParsedExpr) => string,
   ): string
+  // A standalone arrow / regex literal. These normally reach an adapter only as
+  // a callback argument (handled by `callbackMethod`); emitted standalone they
+  // have no template form, so adapters route them to their `unsupported` path.
+  arrow(params: string[], body: ParsedExpr, emit: (e: ParsedExpr) => string): string
+  regex(raw: string): string
   arrayLiteral(elements: ParsedExpr[], emit: (e: ParsedExpr) => string): string
+  // Emit an object literal `{ a: 1, b: x }`. `raw` is the original
+  // expression string so an adapter that doesn't lower object values yet
+  // can delegate to `unsupported(raw, …)` and stay byte-identical.
+  objectLiteral(
+    properties: ObjectLiteralProperty[],
+    raw: string,
+    emit: (e: ParsedExpr) => string,
+  ): string
   arrayMethod(
     method: ArrayMethod,
     object: ParsedExpr,
     args: ParsedExpr[],
     emit: (e: ParsedExpr) => string,
   ): string
-  sortMethod(
-    method: SortMethod,
-    object: ParsedExpr,
-    comparator: SortComparator,
-    emit: (e: ParsedExpr) => string,
-  ): string
-  reduceMethod(
-    method: ReduceMethod,
-    object: ParsedExpr,
-    reduceOp: ReduceOp,
-    emit: (e: ParsedExpr) => string,
-  ): string
   // `.flat(depth?)` gets its own dispatcher arm (#1448 Tier C): it carries
   // a structured `FlatDepth` (the validated literal / `'infinity'`) rather
-  // than a `ParsedExpr[]` args list, same rationale as sort / reduce.
+  // than a `ParsedExpr[]` args list. Non-callback, so it is NOT routed
+  // through `callbackMethod`.
   flatMethod(
     object: ParsedExpr,
     depth: FlatDepth,
     emit: (e: ParsedExpr) => string,
   ): string
-  // `.flatMap(fn)` value-returning field projection gets its own arm
-  // (#1448 Tier C): it carries a structured `FlatMapOp` rather than a
-  // `ParsedExpr[]` args list, same rationale as sort / reduce / flat.
-  flatMapMethod(
-    object: ParsedExpr,
-    op: FlatMapOp,
-    emit: (e: ParsedExpr) => string,
-  ): string
   unsupported(raw: string, reason: string): string
 }
 
@@ -201,8 +201,13 @@ export function emitParsedExpr(expr: ParsedExpr, emitter: ParsedExprEmitter): st
       return emitter.identifier(expr.name)
     case 'literal':
       return emitter.literal(expr.value, expr.literalType)
-    case 'call':
+    case 'call': {
+      // A higher-order callback call (`arr.filter(p)` / `arr.sort(cmp)` / …)
+      // routes to the dedicated `callbackMethod` arm; any other call is generic.
+      const cb = asCallbackMethodCall(expr)
+      if (cb) return emitter.callbackMethod(cb.method, cb.object, cb.arrow, cb.args, emit)
       return emitter.call(expr.callee, expr.args, emit)
+    }
     case 'member':
       return emitter.member(expr.object, expr.property, expr.computed, emit)
     case 'index-access':
@@ -217,25 +222,18 @@ export function emitParsedExpr(expr: ParsedExpr, emitter: ParsedExprEmitter): st
       return emitter.conditional(expr.test, expr.consequent, expr.alternate, emit)
     case 'template-literal':
       return emitter.templateLiteral(expr.parts, emit)
-    case 'arrow-fn':
-      return emitter.arrowFn(expr.param, expr.body, emit)
-    case 'higher-order':
-      return emitter.higherOrder(expr.method, expr.object, expr.param, expr.predicate, emit)
+    case 'arrow':
+      return emitter.arrow(expr.params, expr.body, emit)
+    case 'regex':
+      return emitter.regex(expr.raw)
     case 'array-literal':
       return emitter.arrayLiteral(expr.elements, emit)
+    case 'object-literal':
+      return emitter.objectLiteral(expr.properties, expr.raw, emit)
     case 'array-method':
-      if (expr.method === 'sort' || expr.method === 'toSorted') {
-        return emitter.sortMethod(expr.method, expr.object, expr.comparator, emit)
-      }
-      if (expr.method === 'reduce' || expr.method === 'reduceRight') {
-        return emitter.reduceMethod(expr.method, expr.object, expr.reduceOp, emit)
-      }
       if (expr.method === 'flat') {
         return emitter.flatMethod(expr.object, expr.flatDepth, emit)
       }
-      if (expr.method === 'flatMap') {
-        return emitter.flatMapMethod(expr.object, expr.flatMapOp, emit)
-      }
       return emitter.arrayMethod(expr.method, expr.object, expr.args, emit)
     case 'unsupported':
       return emitter.unsupported(expr.raw, expr.reason)