@barefootjs/jsx 0.32.0 → 0.33.0

package/src/expression-parser.ts

@@ -68,16 +68,19 @@ export type ParsedExpr =
   // `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
+  // Object literal `{ a: 1, b: x }` / shorthand `{ a }` / spread
+  // `{ ...t, a: 1 }` (#2696 Step 2). 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`. `properties` is an ORDER-PRESERVING list of
+  // `prop` / `spread` entries — order carries JS's override semantics
+  // (`{...t, k: v}` vs `{k: v, ...t}` differ in which value wins a shared
+  // key), so it is one list, never split into separate spread/prop
+  // arrays. A computed key, method, or getter/setter still falls 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 }
@@ -234,25 +237,45 @@ const _arrayMethodRegistryIsExhaustive: MissingFromArrayMethodRegistry extends n
 void _arrayMethodRegistryIsExhaustive
 
 /**
- * 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.
+ * One entry of an `object-literal` `ParsedExpr`, in SOURCE ORDER — a `prop`
+ * (`{ a: 1 }` / shorthand `{ a }`) or a `spread` (`{ ...t }`, #2696 Step 2).
+ * Kept as one discriminated-union list rather than separate prop/spread
+ * arrays because JS's override semantics are POSITIONAL — `{ ...t, a: 1 }`
+ * and `{ a: 1, ...t }` merge in opposite directions — and only a single
+ * ordered list can carry that. Every direct consumer of `properties`
+ * (emitters, `freeVarsInBody`, `inlineBinding`, the rewrite walkers,
+ * `objectLiteralTo*` adapter helpers, …) is exhaustive over `kind`, so a
+ * TS compile error surfaces any site this Step 2 change didn't already
+ * update.
  */
-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
-}
+export type ObjectLiteralProperty =
+  | {
+      kind: 'prop'
+      // 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.
+      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
+    }
+  | {
+      kind: 'spread'
+      // The spread SOURCE expression (`t` in `{ ...t }`) — carried, not
+      // pre-flattened, so a consumer that can't merge structurally
+      // (`checkSupport`, the walkers) can still recurse into it uniformly
+      // with every other value-position `ParsedExpr`.
+      expr: ParsedExpr
+    }
 
 /**
  * One comparison key inside a sort comparator. A simple
@@ -1000,7 +1023,7 @@ function convertNode(node: ts.Node, raw: string): ParsedExpr {
             // surface — the depth must be *expressible*, even if not
             // known until render time.
             const parsedDepth = convertNode(depthNode, raw)
-            if (checkSupport(parsedDepth).supported) {
+            if (checkSupport(parsedDepth, 'rendered').supported) {
               depthExpr = parsedDepth
               flatDepth = 1 // unused placeholder — consumers must check `depthExpr` first
             } else {
@@ -1215,23 +1238,25 @@ 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.
+  // Object literal: { a: 1, b: x, shorthand, ...spread }. Every property
+  // must be a non-computed `key: value`, a shorthand `{ key }`, or a
+  // spread `{ ...expr }` (#2696 Step 2). Anything else (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) })
+        properties.push({ kind: 'prop', 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 } })
+        properties.push({ kind: 'prop', key, keyKind: 'identifier', shorthand: true, value: { kind: 'identifier', name: key } })
+      } else if (ts.isSpreadAssignment(prop)) {
+        properties.push({ kind: 'spread', expr: convertNode(prop.expression, raw) })
       } else {
-        // Spread assignment, method, getter/setter — not a plain map.
+        // Computed key, method, getter/setter — not a plain map.
         return { kind: 'unsupported', raw, reason: `Unsupported syntax: ${ts.SyntaxKind[node.kind]}` }
       }
     }
@@ -2362,25 +2387,69 @@ function getUnaryOperatorString(op: ts.PrefixUnaryOperator): string {
 // =============================================================================
 
 /**
- * Check if a parsed expression is supported for SSR template conversion.
+ * Check if a parsed expression is supported for SSR template conversion at
+ * a RENDERED position — a standalone template expression (`{expr}`, an
+ * attribute value, a condition test, …) whose value is what actually
+ * reaches the page. See {@link isSupportedValue} for the sibling VALUE-
+ * position entry point, and `checkSupport`'s `pos` parameter for why the two
+ * never converge partway through a tree.
  */
 export function isSupported(expr: ParsedExpr): SupportResult {
-  return checkSupport(expr)
+  return checkSupport(expr, 'rendered')
 }
 
-function checkSupport(expr: ParsedExpr): SupportResult {
+/**
+ * Check if a parsed expression is supported at a VALUE position — a
+ * signal/memo initializer (`computeSsrSeedPlan`'s classify step: an
+ * assignment, never a render). The one behavioural difference from
+ * {@link isSupported}: an `object-literal` anywhere in the tree is admitted
+ * when every property value is itself supported, instead of being refused
+ * outright.
+ */
+export function isSupportedValue(expr: ParsedExpr): SupportResult {
+  return checkSupport(expr, 'value')
+}
+
+/**
+ * Where in the expression tree a node sits, for the ONE shape whose support
+ * depends on it: `object-literal` (refused at `rendered`, admitted at `value`
+ * when every property value is itself supported — see the `object-literal`
+ * case). `pos` is set ONLY by the two entry points ({@link isSupported} /
+ * {@link isSupportedValue}) and propagates UNCHANGED through every recursive
+ * call, with no per-shape forcing — forcing a container's contents to
+ * `value` would let an object literal survive a `.map()`/`array-method`/
+ * array-literal reachable from a RENDERED entry point and reach a string/
+ * equality position (`{[{a:1}]}`, `[{a:1}].join(',')`, `.includes({a:1})`)
+ * that no adapter renders identically to JS — a new silent-divergence class,
+ * not a capability. Pure inheritance keeps `isSupported`'s behaviour
+ * byte-identical to before `pos` existed; only a `value`-ENTERED tree (a
+ * signal/memo initializer) ever admits a populated object literal.
+ */
+type ExprPos = 'rendered' | 'value'
+
+function checkSupport(expr: ParsedExpr, pos: ExprPos): SupportResult {
   switch (expr.kind) {
     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 'object-literal': {
+      // See `ExprPos`'s doc: refused at `rendered` (byte-identical reason to
+      // the pre-`pos` behaviour, Roadmap A-1); admitted at `value` when
+      // every property value is itself supported. Property values inherit
+      // `pos`, which is already `value` here — written as `pos`, not the
+      // literal `'value'`, for consistency with every other recursive call.
+      if (pos !== 'value') {
+        return { supported: false, reason: 'Unsupported syntax: ObjectLiteralExpression' }
+      }
+      for (const prop of expr.properties) {
+        // A spread entry's SOURCE must itself be supported at `value`
+        // position — the same criterion as an explicit property's value,
+        // since the spread source is read (not rendered) at merge time.
+        const propSupport = checkSupport(prop.kind === 'spread' ? prop.expr : prop.value, pos)
+        if (!propSupport.supported) return propSupport
+      }
+      return { supported: true, level: 'L2' }
+    }
 
     case 'identifier':
       return { supported: true, level: 'L1' }
@@ -2396,13 +2465,14 @@ function checkSupport(expr: ParsedExpr): SupportResult {
       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
-      // don't have an array-literal form in their template language
-      // (Go templates) still need to refuse it — they do so in their
-      // own `arrayLiteral` emitter method, not here, because we can't
-      // see which adapter is consuming the IR at this point.
+      // Array literal is lowerable iff every element is; elements inherit
+      // `pos` (see `ExprPos`'s doc). Adapters that don't have an
+      // array-literal form in their template language (Go templates) still
+      // need to refuse it — they do so in their own `arrayLiteral` emitter
+      // method, not here, because we can't see which adapter is consuming
+      // the IR at this point.
       for (const el of expr.elements) {
-        const elSupport = checkSupport(el)
+        const elSupport = checkSupport(el, pos)
         if (!elSupport.supported) return elSupport
       }
       return { supported: true, level: 'L2' }
@@ -2421,20 +2491,22 @@ function checkSupport(expr: ParsedExpr): SupportResult {
             `String.prototype.${expr.method} 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)
+      // Receiver/args inherit `pos` (see `ExprPos`'s doc).
+      const objSupport = checkSupport(expr.object, pos)
       if (!objSupport.supported) return objSupport
       for (const arg of expr.args) {
-        const argSupport = checkSupport(arg)
+        const argSupport = checkSupport(arg, pos)
         if (!argSupport.supported) return argSupport
       }
       // A dynamic `.flat(depth)` carries its depth expression outside
-      // `args` (see the `depthExpr` doc) — check it too. The parser
-      // already gated this at parse time (only a SUPPORTED depth
-      // expression becomes `depthExpr`), so this re-check is defensive:
-      // it keeps `isSupported` total for any `array-method`/`flat` node
-      // regardless of how it was constructed (e.g. by a rewrite walker).
+      // `args` (see the `depthExpr` doc) — check it too, same inherited
+      // `pos`. The parser already gated this at parse time (only a
+      // SUPPORTED depth expression becomes `depthExpr`), so this re-check
+      // is defensive: it keeps `isSupported`/`isSupportedValue` total for
+      // any `array-method`/`flat` node regardless of how it was constructed
+      // (e.g. by a rewrite walker).
       if (expr.method === 'flat' && expr.depthExpr) {
-        const depthSupport = checkSupport(expr.depthExpr)
+        const depthSupport = checkSupport(expr.depthExpr, pos)
         if (!depthSupport.supported) return depthSupport
       }
       return { supported: true, level: 'L2' }
@@ -2453,11 +2525,16 @@ function checkSupport(expr: ParsedExpr): SupportResult {
       // `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).
+      //
+      // Receiver, callback body, and trailing args inherit `pos` (see
+      // `ExprPos`'s doc) — a RENDERED `.map(t => ({...}))` stays refused
+      // (the body value is what ends up rendered), while a VALUE-entered
+      // one (a signal/memo initializer) admits it.
       const cb = asCallbackMethodCall(expr)
       if (cb) {
-        const objSupport = checkSupport(cb.object)
+        const objSupport = checkSupport(cb.object, pos)
         if (!objSupport.supported) return objSupport
-        const bodySupport = checkSupport(cb.arrow.body)
+        const bodySupport = checkSupport(cb.arrow.body, pos)
         if (!bodySupport.supported) {
           return {
             supported: false,
@@ -2466,14 +2543,15 @@ function checkSupport(expr: ParsedExpr): SupportResult {
           }
         }
         for (const rest of cb.args) {
-          const restSupport = checkSupport(rest)
+          const restSupport = checkSupport(rest, pos)
           if (!restSupport.supported) return restSupport
         }
         return { supported: true, level: 'L5' }
       }
 
-      // Check if callee is supported
-      const calleeSupport = checkSupport(expr.callee)
+      // Check if callee is supported. Not container contents — inherits
+      // the CURRENT `pos` (see `ExprPos`'s doc).
+      const calleeSupport = checkSupport(expr.callee, pos)
       if (!calleeSupport.supported) {
         return calleeSupport
       }
@@ -2502,9 +2580,11 @@ function checkSupport(expr: ParsedExpr): SupportResult {
         return { supported: true, level: 'L1' }
       }
 
-      // Other function calls - check args
+      // Other function calls - check args. Not container contents of a
+      // recognised callback/array-method (that path returned above) —
+      // inherits the CURRENT `pos` (see `ExprPos`'s doc).
       for (const arg of expr.args) {
-        const argSupport = checkSupport(arg)
+        const argSupport = checkSupport(arg, pos)
         if (!argSupport.supported) {
           return argSupport
         }
@@ -2513,7 +2593,8 @@ function checkSupport(expr: ParsedExpr): SupportResult {
     }
 
     case 'member': {
-      const objSupport = checkSupport(expr.object)
+      // Not container contents — inherits the CURRENT `pos`.
+      const objSupport = checkSupport(expr.object, pos)
       if (!objSupport.supported) {
         return objSupport
       }
@@ -2527,18 +2608,21 @@ function checkSupport(expr: ParsedExpr): SupportResult {
     case 'index-access': {
       // `arr[index]` — supported when both the receiver and the index
       // expression are themselves supported (the index is typically a
-      // loop variable or arithmetic over one). #1897 (data-table).
-      const objSupport = checkSupport(expr.object)
+      // loop variable or arithmetic over one). #1897 (data-table). Neither
+      // is container contents — both inherit the CURRENT `pos`.
+      const objSupport = checkSupport(expr.object, pos)
       if (!objSupport.supported) return objSupport
-      const indexSupport = checkSupport(expr.index)
+      const indexSupport = checkSupport(expr.index, pos)
       if (!indexSupport.supported) return indexSupport
       return { supported: true, level: 'L2' }
     }
 
     case 'binary': {
-      const leftSupport = checkSupport(expr.left)
+      // Operands inherit the CURRENT `pos` (see `ExprPos`'s doc) — a binary
+      // operand isn't container contents.
+      const leftSupport = checkSupport(expr.left, pos)
       if (!leftSupport.supported) return leftSupport
-      const rightSupport = checkSupport(expr.right)
+      const rightSupport = checkSupport(expr.right, pos)
       if (!rightSupport.supported) return rightSupport
 
       // Comparison operators are L3
@@ -2555,7 +2639,8 @@ function checkSupport(expr: ParsedExpr): SupportResult {
     }
 
     case 'unary': {
-      const argSupport = checkSupport(expr.argument)
+      // Inherits the CURRENT `pos` — not container contents.
+      const argSupport = checkSupport(expr.argument, pos)
       if (!argSupport.supported) return argSupport
 
       // Negation is L4
@@ -2571,7 +2656,8 @@ function checkSupport(expr: ParsedExpr): SupportResult {
     }
 
     case 'logical': {
-      const leftSupport = checkSupport(expr.left)
+      // Operands inherit the CURRENT `pos` — not container contents.
+      const leftSupport = checkSupport(expr.left, pos)
       if (!leftSupport.supported) return leftSupport
 
       // `x ?? {}` — admit an EMPTY object-literal fallback as the right
@@ -2598,27 +2684,35 @@ function checkSupport(expr: ParsedExpr): SupportResult {
         return { supported: true, level: 'L4' }
       }
 
-      const rightSupport = checkSupport(expr.right)
+      const rightSupport = checkSupport(expr.right, pos)
       if (!rightSupport.supported) return rightSupport
 
       return { supported: true, level: 'L4' }
     }
 
     case 'conditional': {
-      const testSupport = checkSupport(expr.test)
+      // Branches inherit the CURRENT `pos` (see `ExprPos`'s doc): whichever
+      // branch is taken becomes the ternary's own value, so at a RENDERED
+      // position both branches are themselves rendered — `cond ? {a:1} :
+      // {b:2}` stays refused there, not admitted just for being a
+      // sub-expression.
+      const testSupport = checkSupport(expr.test, pos)
       if (!testSupport.supported) return testSupport
-      const consSupport = checkSupport(expr.consequent)
+      const consSupport = checkSupport(expr.consequent, pos)
       if (!consSupport.supported) return consSupport
-      const altSupport = checkSupport(expr.alternate)
+      const altSupport = checkSupport(expr.alternate, pos)
       if (!altSupport.supported) return altSupport
 
       return { supported: true, level: 'L4' }
     }
 
     case 'template-literal': {
+      // Interpolated parts inherit the CURRENT `pos` — not container
+      // contents (a template literal always stringifies its holes, so an
+      // object-literal hole has no sensible rendering either way).
       for (const part of expr.parts) {
         if (part.type === 'expression') {
-          const partSupport = checkSupport(part.expr)
+          const partSupport = checkSupport(part.expr, pos)
           if (!partSupport.supported) return partSupport
         }
       }
@@ -2935,7 +3029,7 @@ function isPureInit(e: ParsedExpr, pureCallNames?: ReadonlySet<string>): boolean
     case 'array-literal':
       return e.elements.every(pure)
     case 'object-literal':
-      return e.properties.every(p => pure(p.value))
+      return e.properties.every(p => pure(p.kind === 'spread' ? p.expr : p.value))
     case 'call':
       // A zero-arg reactive getter read (`filter()`, `count()`) is idempotent;
       // any other call may be effectful or non-deterministic.
@@ -3019,7 +3113,7 @@ function usesPerPath(name: string, expr: ParsedExpr): { min: number; max: number
         }
         return add(walk(e.object), sum(e.args))
       case 'object-literal':
-        return sum(e.properties.map(p => p.value))
+        return sum(e.properties.map(p => (p.kind === 'spread' ? p.expr : 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 }
@@ -3115,7 +3209,9 @@ export function inlineBinding(
       case 'object-literal':
         return {
           kind: 'object-literal',
-          properties: e.properties.map(p => ({ ...p, value: walk(p.value, enclosing) })),
+          properties: e.properties.map(p =>
+            p.kind === 'spread' ? { ...p, expr: walk(p.expr, enclosing) } : { ...p, value: walk(p.value, enclosing) },
+          ),
           raw: e.raw,
         }
       case 'literal':
@@ -3487,7 +3583,7 @@ export function materializeGetterCalls(expr: ParsedExpr, names: ReadonlySet<stri
       return {
         kind: 'object-literal',
         raw: expr.raw,
-        properties: expr.properties.map(p => ({ ...p, value: rw(p.value) })),
+        properties: expr.properties.map(p => (p.kind === 'spread' ? { ...p, expr: rw(p.expr) } : { ...p, value: rw(p.value) })),
       }
     case 'arrow':
       return { kind: 'arrow', params: expr.params, body: rw(expr.body) }
@@ -3586,7 +3682,8 @@ export function freeVarsInBody(body: ParsedExpr, params: ReadonlySet<string>): s
       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, bound)
+        // A spread's source expression is likewise a reference.
+        for (const p of e.properties) visit(p.kind === 'spread' ? p.expr : p.value, bound)
         return
       case 'array-method':
         // `.includes(x)` / `.join(sep?)` are serializable ({@link
@@ -3693,7 +3790,7 @@ export function freeIdentifiers(expr: ParsedExpr): Set<string> | null {
         if (e.method === 'flat' && e.depthExpr && !visit(e.depthExpr, bound)) return false
         return true
       case 'object-literal':
-        for (const p of e.properties) if (!visit(p.value, bound)) return false
+        for (const p of e.properties) if (!visit(p.kind === 'spread' ? p.expr : p.value, bound)) return false
         return true
       case 'arrow': {
         const inner = new Set(bound)
@@ -3869,11 +3966,25 @@ function toEvalNode(e: ParsedExpr): Record<string, unknown> | null {
       return { kind: 'array-literal', elements }
     }
     case 'object-literal': {
+      // Each entry carries its own `kind` tag (`prop` | `spread`) — the SAME
+      // discriminant `ObjectLiteralProperty` uses — so every backend
+      // evaluator (Go `eval.go`, Perl `Evaluator.pm`, Python, Ruby, PHP,
+      // Rust) decodes this exactly like the raw `ParsedExpr` shape the
+      // `eval-vectors.json` golden corpus carries (#2696 Step 2): a `prop`
+      // sets one key; a `spread` evaluates its `expr` and shallow-merges the
+      // result's own keys (later entries win; a null/undefined/non-object
+      // spread source is a no-op).
       const properties: Record<string, unknown>[] = []
       for (const p of e.properties) {
+        if (p.kind === 'spread') {
+          const spreadExpr = toEvalNode(p.expr)
+          if (!spreadExpr) return null
+          properties.push({ kind: 'spread', expr: spreadExpr })
+          continue
+        }
         const value = toEvalNode(p.value)
         if (!value) return null
-        properties.push({ key: p.key, value })
+        properties.push({ kind: 'prop', key: p.key, value })
       }
       return { kind: 'object-literal', properties }
     }

package/src/index.ts

@@ -93,7 +93,7 @@ export type {
 export { JsxAdapter } from './adapters/jsx-adapter.ts'
 export type { JsxAdapterConfig } from './adapters/jsx-adapter.ts'
 export { rewriteImportsForTemplate, rewriteDynamicImportsInSource } from './adapters/template-imports.ts'
-export { emitParsedExpr, groupBinaryOperand, isStringTypedOperand, isStringConcatBinary } from './adapters/parsed-expr-emitter.ts'
+export { emitParsedExpr, groupBinaryOperand, groupObjectLiteralSegments, isStringTypedOperand, isStringConcatBinary } from './adapters/parsed-expr-emitter.ts'
 export type { ParsedExprEmitter, HigherOrderMethod, ArrayMethod, SortMethod, LiteralType } from './adapters/parsed-expr-emitter.ts'
 export { collectLoopBoundNames } from './adapters/loop-bound-names.ts'
 export { derivesScopeFromSlot } from './adapters/child-scope.ts'
@@ -211,7 +211,7 @@ export { ErrorCodes, createError, formatError, generateCodeFrame } from './error
 export { isValueReferenceIdentifier, collectValueReferencedNames } from './value-references.ts'
 
 // Expression Parser
-export { parseExpression, tsNodeToParsedExpr, asCallbackMethodCall, CALLBACK_METHODS, sortComparatorFromArrow, serializeParsedExpr, freeVarsInBody, freeIdentifiers, materializeGetterCalls, isSupported, exprToString, stringifyParsedExpr, identifierPath, parseBlockBody, parseBlockBodyTolerant, foldBlockToExpr, predicateTernaryToLogical, containsHigherOrder, extractArrowBodyExpression, parseStyleObjectEntries, hasUnsafeStyleValue, parseProviderObjectLiteral, type ProviderObjectMember, type FoldBlockOptions } from './expression-parser.ts'
+export { parseExpression, tsNodeToParsedExpr, asCallbackMethodCall, CALLBACK_METHODS, sortComparatorFromArrow, serializeParsedExpr, freeVarsInBody, freeIdentifiers, materializeGetterCalls, isSupported, isSupportedValue, exprToString, stringifyParsedExpr, identifierPath, parseBlockBody, parseBlockBodyTolerant, foldBlockToExpr, predicateTernaryToLogical, containsHigherOrder, extractArrowBodyExpression, parseStyleObjectEntries, hasUnsafeStyleValue, parseProviderObjectLiteral, type ProviderObjectMember, type FoldBlockOptions } from './expression-parser.ts'
 export type { StyleObjectEntry } from './expression-parser.ts'
 export { PARSED_EXPR_KINDS, ARRAY_METHOD_NAMES } from './expression-parser.ts'
 export type { ParsedExpr, ObjectLiteralProperty, ParsedStatement, SortComparator, SortKey, FlatDepth, SupportLevel, SupportResult, TemplatePart } from './expression-parser.ts'

package/src/jsx-to-ir.ts

@@ -3296,7 +3296,10 @@ function resolveCallbackMethodFunctionReferences(
           ...(e.method === 'flat' && e.depthExpr ? { depthExpr: visit(e.depthExpr, bound) } : {}),
         } as ParsedExpr
       case 'object-literal':
-        return { ...e, properties: e.properties.map(p => ({ ...p, value: visit(p.value, bound) })) }
+        return {
+          ...e,
+          properties: e.properties.map(p => (p.kind === 'spread' ? { ...p, expr: visit(p.expr, bound) } : { ...p, value: visit(p.value, bound) })),
+        }
       case 'arrow': {
         const inner = e.params.length === 0 ? bound : new Set([...bound, ...e.params])
         return { ...e, body: visit(e.body, inner) }

package/src/query-href-lowering.ts

@@ -58,6 +58,10 @@ export function matchQueryHrefCall(
 
   const triples: QueryHrefTriple[] = []
   for (const p of obj.properties) {
+    // A spread (`{ ...extra, key: v }`, #2696 Step 2) has no static key to
+    // build a triple from — fall back to the generic lowering rather than
+    // dropping the spread's keys silently.
+    if (p.kind === 'spread') return null
     const v = p.value
     if (v.kind === 'conditional' && isOmitBranch(v.alternate)) {
       triples.push({ guard: v.test, key: p.key, value: v.consequent })

package/src/rich-type-refusal.ts

@@ -348,7 +348,7 @@ function checkExpr(
       for (const el of expr.elements) recurse(el)
       break
     case 'object-literal':
-      for (const prop of expr.properties) recurse(prop.value)
+      for (const prop of expr.properties) recurse(prop.kind === 'spread' ? prop.expr : prop.value)
       break
     case 'array-method':
       recurse(expr.object)

package/src/ssr-defaults.ts

@@ -647,12 +647,28 @@ function evalNode(node: ts.Expression, ctx: EvalContext): EvalResult {
   }
 
   if (ts.isPropertyAccessExpression(node)) {
+    const baseResult = evalNode(node.expression, ctx)
     // `props.X` / `props?.X` — read of a binding we know nothing about, so
     // resolve to `undefined`. Chained access (`a.b.c`) collapses the same way
     // because the base read is already undefined.
-    const baseResult = evalNode(node.expression, ctx)
     if (baseResult === undefined) return undefined
-    return UNRESOLVED
+    if (baseResult === UNRESOLVED || baseResult === null || typeof baseResult !== 'object') {
+      return UNRESOLVED
+    }
+    // Own-property reads are only faithful for a plain object. An array (or
+    // any other non-plain object) exposes prototype members (`.map`,
+    // `.length`) that `hasOwnProperty` would wrongly resolve to `undefined`
+    // instead of the real function/value (#2698 review).
+    const proto = Object.getPrototypeOf(baseResult)
+    if (proto !== Object.prototype && proto !== null) return UNRESOLVED
+    // A resolved plain-object base — an object-literal value, e.g. a
+    // `.map()` callback param bound to one element (#2696's `t.a`). Missing
+    // key → JS `undefined`, mirroring `isElementAccessExpression`'s own
+    // missing-key handling above.
+    const key = node.name.text
+    return Object.prototype.hasOwnProperty.call(baseResult, key)
+      ? (baseResult as Record<string, unknown>)[key]
+      : undefined
   }
 
   if (ts.isCallExpression(node)) {
@@ -665,6 +681,39 @@ function evalNode(node: ts.Expression, ctx: EvalContext): EvalResult {
     ) {
       return ctx.bindings[node.expression.text]
     }
+    // `<array>.map(cb)` — a single-param, expression-bodied arrow over a
+    // resolved array receiver; anything else (block body, multi-param,
+    // non-array receiver) stays `UNRESOLVED`, same conservative narrowing as
+    // every other arm here. A `derived` step with empty `frees` gets no
+    // in-template recompute (#2696), so this static value is what production
+    // actually reads.
+    if (
+      ts.isPropertyAccessExpression(node.expression) &&
+      node.expression.name.text === 'map' &&
+      node.arguments.length === 1
+    ) {
+      const arrow = node.arguments[0]
+      if (
+        ts.isArrowFunction(arrow) &&
+        arrow.parameters.length === 1 &&
+        ts.isIdentifier(arrow.parameters[0].name) &&
+        !ts.isBlock(arrow.body)
+      ) {
+        const recv = evalNode(node.expression.expression, ctx)
+        if (Array.isArray(recv)) {
+          const paramName = (arrow.parameters[0].name as ts.Identifier).text
+          const mapped: unknown[] = []
+          for (const item of recv) {
+            const localBindings: Record<string, EvalResult> = { ...ctx.bindings, [paramName]: item }
+            const v = evalNode(arrow.body as ts.Expression, { ...ctx, bindings: localBindings })
+            if (v === UNRESOLVED) return UNRESOLVED
+            mapped.push(v === undefined ? null : v)
+          }
+          return mapped
+        }
+      }
+      return UNRESOLVED
+    }
     // `<array>.join(<sep?>)` — evaluate when the receiver resolves to an array
     // and the separator (default `,`) is a string. Covers `stateClasses =
     // [...].join(' ')` (#checkbox). Other array methods stay unresolved.