@barefootjs/jsx 0.32.0 → 0.33.0

package/dist/ssr-seed-plan.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ssr-seed-plan.d.ts","sourceRoot":"","sources":["../src/ssr-seed-plan.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAGH,OAAO,EAAsB,KAAK,eAAe,EAAE,MAAM,0BAA0B,CAAA;AACnF,OAAO,EAML,KAAK,UAAU,EAChB,MAAM,wBAAwB,CAAA;AAC/B,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAA;AAE5C;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,MAAM,WAAW,GACnB;IAAE,IAAI,EAAE,YAAY,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,eAAe,CAAA;CAAE,GAC7D;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,QAAQ,GAAG,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,UAAU,CAAC;IAAC,KAAK,EAAE,MAAM,EAAE,CAAA;CAAE,GAC/G;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,QAAQ,GAAG,MAAM,CAAA;CAAE,CAAA;AAE/D,MAAM,WAAW,WAAW;IAC1B;;;;OAIG;IACH,SAAS,EAAE,MAAM,EAAE,CAAA;IACnB,KAAK,EAAE,WAAW,EAAE,CAAA;CACrB;AA4FD;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,UAAU,GAAG,WAAW,CAqDpE"}
+{"version":3,"file":"ssr-seed-plan.d.ts","sourceRoot":"","sources":["../src/ssr-seed-plan.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAGH,OAAO,EAAsB,KAAK,eAAe,EAAE,MAAM,0BAA0B,CAAA;AACnF,OAAO,EAML,KAAK,UAAU,EAChB,MAAM,wBAAwB,CAAA;AAC/B,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAA;AAE5C;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,MAAM,WAAW,GACnB;IAAE,IAAI,EAAE,YAAY,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,eAAe,CAAA;CAAE,GAC7D;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,QAAQ,GAAG,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,UAAU,CAAC;IAAC,KAAK,EAAE,MAAM,EAAE,CAAA;CAAE,GAC/G;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,QAAQ,GAAG,MAAM,CAAA;CAAE,CAAA;AAE/D,MAAM,WAAW,WAAW;IAC1B;;;;OAIG;IACH,SAAS,EAAE,MAAM,EAAE,CAAA;IACnB,KAAK,EAAE,WAAW,EAAE,CAAA;CACrB;AAiGD;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,UAAU,GAAG,WAAW,CAiEpE"}

package/dist/static-literal.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"static-literal.d.ts","sourceRoot":"","sources":["../src/static-literal.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAA;AACxD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAA;AAE9C;;;;;;;;GAQG;AACH,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,UAAU,EAChB,QAAQ,CAAC,EAAE,WAAW,CAAC,MAAM,EAAE,OAAO,CAAC,GACtC;IAAE,KAAK,EAAE,OAAO,CAAA;CAAE,GAAG,IAAI,CA+D3B;AAED,iFAAiF;AACjF,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAE9D;AAED;;;;;;;;GAQG;AACH,wBAAgB,uBAAuB,CACrC,WAAW,EAAE,UAAU,GAAG,SAAS,EACnC,cAAc,EAAE,aAAa,CAAC,YAAY,CAAC,GAAG,SAAS,EACvD,IAAI,CAAC,EAAE;IAAE,cAAc,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAA;CAAE,GACpD,OAAO,EAAE,GAAG,IAAI,CAYlB"}
+{"version":3,"file":"static-literal.d.ts","sourceRoot":"","sources":["../src/static-literal.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAA;AACxD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAA;AAE9C;;;;;;;;GAQG;AACH,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,UAAU,EAChB,QAAQ,CAAC,EAAE,WAAW,CAAC,MAAM,EAAE,OAAO,CAAC,GACtC;IAAE,KAAK,EAAE,OAAO,CAAA;CAAE,GAAG,IAAI,CA6E3B;AAED,iFAAiF;AACjF,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAE9D;AAED;;;;;;;;GAQG;AACH,wBAAgB,uBAAuB,CACrC,WAAW,EAAE,UAAU,GAAG,SAAS,EACnC,cAAc,EAAE,aAAa,CAAC,YAAY,CAAC,GAAG,SAAS,EACvD,IAAI,CAAC,EAAE;IAAE,cAAc,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAA;CAAE,GACpD,OAAO,EAAE,GAAG,IAAI,CAYlB"}

package/dist/to-locale-date-lowering.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"to-locale-date-lowering.d.ts","sourceRoot":"","sources":["../src/to-locale-date-lowering.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyDG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAY,MAAM,YAAY,CAAA;AACtD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAA;AACxD,OAAO,KAAK,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAA;AAI1E;;;;;;;;;;GAUG;AACH,eAAO,MAAM,eAAe,QAA4C,CAAA;AAKxE;;;;;;;;;;;GAWG;AACH,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAWhE;AASD;;;;GAIG;AACH,MAAM,WAAW,gBAAgB;IAC/B,OAAO,EAAE,MAAM,CAAA;IACf,sEAAsE;IACtE,KAAK,EAAE,MAAM,EAAE,GAAG,IAAI,CAAA;CACvB;AAmFD;;;;GAIG;AACH,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAEtE;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,MAAM,EACd,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GACnC,gBAAgB,GAAG,IAAI,CAOzB;AA0PD,wBAAgB,2BAA2B,CACzC,MAAM,EAAE,UAAU,EAClB,IAAI,EAAE,SAAS,UAAU,EAAE,EAC3B,QAAQ,EAAE,UAAU,GACnB,YAAY,GAAG,IAAI,CAyErB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAmBtF;AAED,eAAO,MAAM,kBAAkB,EAAE,cAMhC,CAAA"}
+{"version":3,"file":"to-locale-date-lowering.d.ts","sourceRoot":"","sources":["../src/to-locale-date-lowering.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyDG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAY,MAAM,YAAY,CAAA;AACtD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAA;AACxD,OAAO,KAAK,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAA;AAI1E;;;;;;;;;;GAUG;AACH,eAAO,MAAM,eAAe,QAA4C,CAAA;AAKxE;;;;;;;;;;;GAWG;AACH,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAWhE;AASD;;;;GAIG;AACH,MAAM,WAAW,gBAAgB;IAC/B,OAAO,EAAE,MAAM,CAAA;IACf,sEAAsE;IACtE,KAAK,EAAE,MAAM,EAAE,GAAG,IAAI,CAAA;CACvB;AAmFD;;;;GAIG;AACH,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAEtE;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,MAAM,EACd,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GACnC,gBAAgB,GAAG,IAAI,CAOzB;AA0PD,wBAAgB,2BAA2B,CACzC,MAAM,EAAE,UAAU,EAClB,IAAI,EAAE,SAAS,UAAU,EAAE,EAC3B,QAAQ,EAAE,UAAU,GACnB,YAAY,GAAG,IAAI,CA6ErB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAmBtF;AAED,eAAO,MAAM,kBAAkB,EAAE,cAMhC,CAAA"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@barefootjs/jsx",
-  "version": "0.32.0",
+  "version": "0.33.0",
   "description": "JSX compiler for BarefootJS - transforms JSX to server HTML + client JS",
   "type": "module",
   "main": "./dist/index.js",
@@ -49,7 +49,7 @@
     "directory": "packages/jsx"
   },
   "dependencies": {
-    "@barefootjs/shared": "0.32.0"
+    "@barefootjs/shared": "0.33.0"
   },
   "peerDependencies": {
     "@barefootjs/client": ">=0.2.0",

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

@@ -1,6 +1,6 @@
 import { describe, test, expect } from 'bun:test'
 import ts from 'typescript'
-import { parseExpression, isSupported, exprToString, stringifyParsedExpr, parseBlockBody, foldBlockToExpr, extractArrowBodyExpression, parseStyleObjectEntries, parseProviderObjectLiteral, asCallbackMethodCall, containsHigherOrder } from '../expression-parser'
+import { parseExpression, isSupported, isSupportedValue, exprToString, stringifyParsedExpr, parseBlockBody, foldBlockToExpr, extractArrowBodyExpression, parseStyleObjectEntries, parseProviderObjectLiteral, asCallbackMethodCall, containsHigherOrder } from '../expression-parser'
 import { collectAllTypeRanges, reconstructWithoutTypes } from '../strip-types'
 
 describe('expression-parser', () => {
@@ -395,12 +395,23 @@ describe('expression-parser', () => {
       expect((parseExpression('true') as { raw?: string }).raw).toBeUndefined()
     })
 
-    test('falls through to unsupported for spread / computed-key object literals', () => {
-      // A spread member is not a plain map property — preserves the
-      // pre-A-1 `unsupported` behaviour (byte-identical).
-      expect(parseExpression('({ ...rest, a: 1 })').kind).toBe('unsupported')
-      // Computed key `[k]: v` can't resolve to a static name.
+    test('falls through to unsupported for computed-key object literals; spread parses as object-literal (#2696 Step 2)', () => {
+      // Computed key `[k]: v` can't resolve to a static name — still
+      // unsupported.
       expect(parseExpression('({ [k]: 1 })').kind).toBe('unsupported')
+      // A spread member (#2696 Step 2) is now a structured `{ kind:
+      // 'spread', expr }` entry, in source order alongside any `prop`
+      // entries — no longer the pre-#2696 blanket `unsupported`.
+      const spread = parseExpression('({ ...rest, a: 1 })')
+      expect(spread).toMatchObject({
+        kind: 'object-literal',
+        properties: [
+          { kind: 'spread', expr: { kind: 'identifier', name: 'rest' } },
+          { kind: 'prop', key: 'a', shorthand: false, value: { kind: 'literal', value: 1 } },
+        ],
+      })
+      // A method / getter / setter still isn't a plain map — still refuses.
+      expect(parseExpression('({ f() { return 1 } })').kind).toBe('unsupported')
     })
 
     test('a bare `{ … }` at statement position is a block, not an object literal', () => {
@@ -1402,6 +1413,32 @@ describe('expression-parser', () => {
       expect(result.supported).toBe(false)
     })
 
+    // #2696 review: `pos` propagates by pure inheritance, with no per-shape
+    // forcing to `value` — a RENDERED entry point's behaviour must stay
+    // byte-identical to before `isSupportedValue` existed, on every shape
+    // that reaches a container-contents position (an array-literal element,
+    // an array-method/callback receiver, a callback body). `isSupportedValue`
+    // admits the identical trees, since the whole tree it's entered on is a
+    // `value` position (a signal/memo initializer).
+    test('a populated object-literal array-literal element is refused at RENDERED, supported at VALUE', () => {
+      const expr = parseExpression('[{ a: 1 }]')
+      expect(expr.kind).toBe('array-literal')
+      expect(isSupported(expr).supported).toBe(false)
+      expect(isSupportedValue(expr).supported).toBe(true)
+    })
+
+    test('an array-of-objects .join() receiver is refused at RENDERED, supported at VALUE', () => {
+      const expr = parseExpression("[{ a: 1 }].join(',')")
+      expect(isSupported(expr).supported).toBe(false)
+      expect(isSupportedValue(expr).supported).toBe(true)
+    })
+
+    test('a .map() callback body returning an object literal is refused at RENDERED, supported at VALUE', () => {
+      const expr = parseExpression('items.map(t => ({ a: t }))')
+      expect(isSupported(expr).supported).toBe(false)
+      expect(isSupportedValue(expr).supported).toBe(true)
+    })
+
     test('L5: filter() with simple predicate IS supported', () => {
       const expr = parseExpression('items().filter(x => x.done)')
       const result = isSupported(expr)

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

@@ -98,12 +98,26 @@ describe('serializeParsedExpr', () => {
     })
   })
 
-  test('map body: object literal carries key + value (no keyKind / shorthand)', () => {
+  test('map body: object literal carries kind + key + value (no keyKind / shorthand)', () => {
+    // #2696 Step 2: each entry now carries its own `kind` tag ('prop' here —
+    // no source spread in this body) so the evaluator can distinguish a
+    // `prop` from a `spread` entry without re-deriving it from field shape.
     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' } },
+        { kind: 'prop', key: 'id', value: { kind: 'member', object: { kind: 'identifier', name: 'item' }, property: 'id' } },
+        { kind: 'prop', key: 'n', value: { kind: 'member', object: { kind: 'identifier', name: 'item' }, property: 'n' } },
+      ],
+    })
+  })
+
+  test('map body: object literal carries a spread entry as `{ kind: "spread", expr }`', () => {
+    // The todo-app motivating shape (#2696): `{ ...t, editing: false }`.
+    expect(evalJSON("({ ...t, editing: false })")).toEqual({
+      kind: 'object-literal',
+      properties: [
+        { kind: 'spread', expr: { kind: 'identifier', name: 't' } },
+        { kind: 'prop', key: 'editing', value: { kind: 'literal', value: false } },
       ],
     })
   })

package/src/__tests__/ssr-defaults.test.ts

@@ -458,6 +458,47 @@ describe('extractSsrDefaults', () => {
     // space mirrors Hono's empty-className interpolation).
     expect(defaults?.classes).toEqual({ value: 'a b c d  tail' })
   })
+
+  // #2698 review: a property access on a non-plain-object base (an array
+  // element bound by `.map()`) must refuse (UNRESOLVED), not silently read
+  // `undefined` via `hasOwnProperty` — an array exposes prototype members
+  // (`.map`, `.filter`, …) that aren't own properties, so the old guard
+  // (`typeof !== 'object'`) let arrays through and misreported them as a
+  // real `undefined` value instead of an unrepresentable read.
+  test('.map() body property-access on an ARRAY element is UNRESOLVED, not undefined', () => {
+    const metadata = metadataFor(`
+      'use client'
+      import { createSignal } from '@barefootjs/client'
+      function C() {
+        const [x] = createSignal([[1, 2], [3, 4]].map(t => t.foo))
+        return <p>{x()}</p>
+      }
+    `)
+
+    const defaults = extractSsrDefaults(metadata)
+    // UNRESOLVED aborts the whole `.map()` (not a per-element `null`) —
+    // resultToJsonable renders the abort as the same `null` a genuinely
+    // undefined value would, but the two paths reach it differently: this
+    // pin exists to keep the array case going through the abort path.
+    expect(defaults?.x).toEqual({ value: null })
+  })
+
+  test('.map() body property-access on a PLAIN-OBJECT element still resolves a missing key to undefined', () => {
+    const metadata = metadataFor(`
+      'use client'
+      import { createSignal } from '@barefootjs/client'
+      function C() {
+        const [x] = createSignal([{ a: 1 }, {}].map(t => t.a))
+        return <p>{x()}</p>
+      }
+    `)
+
+    const defaults = extractSsrDefaults(metadata)
+    // Unlike the array case, a missing key on a plain object resolves that
+    // ONE element to `undefined` (→ `null`) and the `.map()` keeps going —
+    // it does not abort the whole computation.
+    expect(defaults?.x).toEqual({ value: [1, null] })
+  })
 })
 
 // TS twin of the Ruby/Python/PHP/Perl/Rust `derive*FromDefaults` runtime

package/src/__tests__/ssr-seed-plan.test.ts

@@ -158,7 +158,12 @@ describe('computeSsrSeedPlan', () => {
     if (label.kind === 'opaque') expect(label.origin).toBe('memo')
   })
 
-  test('unsupported body (object literal) → opaque', () => {
+  test('object-literal body → derived (#2696: value-position object literal, isSupportedValue)', () => {
+    // Was `opaque` before `checkSupport` gained its `pos` parameter — a
+    // memo's WHOLE body is a value position (an assignment, never a
+    // render), so an object literal there is exactly the shape
+    // `isSupportedValue` now admits (every property value — here `n()` —
+    // is itself supported).
     const plan = planFor(`
       'use client'
       import { createMemo, createSignal } from '@barefootjs/client'
@@ -169,7 +174,12 @@ describe('computeSsrSeedPlan', () => {
       }
     `)
 
-    expect(step(plan, 'obj').kind).toBe('opaque')
+    const obj = step(plan, 'obj')
+    expect(obj.kind).toBe('derived')
+    if (obj.kind === 'derived') {
+      expect(obj.origin).toBe('memo')
+      expect(obj.frees).toEqual(['n'])
+    }
   })
 
   test('literal signal init → derived with empty frees (constant-skip is emit-side)', () => {

package/src/adapters/dangerous-inner-html.ts

@@ -122,6 +122,7 @@ function htmlPropValue(parsed: ParsedExpr): ParsedExpr | null {
   if (parsed.kind !== 'object-literal') return null
   if (parsed.properties.length !== 1) return null
   const [prop] = parsed.properties
+  if (prop.kind === 'spread') return null
   if (prop.key !== '__html') return null
   return prop.value
 }

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

@@ -163,9 +163,11 @@ export interface ParsedExprEmitter {
   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.
+  // Emit an object literal `{ a: 1, b: x, ...rest }` (#2696 Step 2 adds
+  // spread entries — `properties` is ORDER-PRESERVING, so an adapter must
+  // merge left-to-right, later entries winning, to match JS). `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,
@@ -277,6 +279,50 @@ export function groupBinaryOperand(operand: ParsedExpr, emitted: string): string
     : emitted
 }
 
+/**
+ * Split an `object-literal`'s (order-preserving) `properties` into rendered
+ * SEGMENTS an adapter's `objectLiteral()` folds with its own merge idiom
+ * (#2696 Step 2): each maximal run of consecutive `prop` entries collapses
+ * into ONE literal (via `literalOf`), and each `spread` entry becomes its
+ * own segment (its emitted source expression) — so `{ a: 1, b: 2, ...t, c: 3
+ * }` yields `[literal({a,b}), emit(t), literal({c})]`, in source order.
+ *
+ * A caller with NO spread entries at all should keep its pre-#2696 single
+ * `literalOf(properties)` call instead of this (this always returns at
+ * least one segment, but a caller folding 1-segment output through a merge
+ * call — `array_merge(x)`, `{}.merge(x)` — would be needlessly indirect
+ * for the common spread-free case).
+ *
+ * Shared here (not duplicated per adapter) because the grouping itself is
+ * backend-neutral structure — only `literalOf` (the target language's
+ * literal syntax) and the fold (the target language's merge idiom) are
+ * adapter-specific.
+ */
+export function groupObjectLiteralSegments(
+  properties: readonly ObjectLiteralProperty[],
+  literalOf: (run: ReadonlyArray<Extract<ObjectLiteralProperty, { kind: 'prop' }>>) => string,
+  emit: (e: ParsedExpr) => string,
+): string[] {
+  const segments: string[] = []
+  let run: Extract<ObjectLiteralProperty, { kind: 'prop' }>[] = []
+  const flushRun = () => {
+    if (run.length > 0) {
+      segments.push(literalOf(run))
+      run = []
+    }
+  }
+  for (const p of properties) {
+    if (p.kind === 'spread') {
+      flushRun()
+      segments.push(emit(p.expr))
+    } else {
+      run.push(p)
+    }
+  }
+  flushRun()
+  return segments
+}
+
 /**
  * Single point of dispatch from `ParsedExpr.kind` to the adapter's
  * method. Adapters call this once at their entry point; the recursion