@barefootjs/jsx 0.31.8 → 0.31.10

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

@@ -103,6 +103,211 @@ describe('extractSsrDefaults', () => {
     expect(defaults?.n).toEqual({ value: 0 })
   })
 
+  test('self-derived signal collision (#2669, shape A): entry stays a PROP entry, not the evaluated signal value', () => {
+    // `props.label` and the signal getter `label` share a name — the
+    // bare-props-arg form is the only shape where this collides (a
+    // destructured-arg `function C({ label })` + `const [label] = ...`
+    // is a JS redeclaration error, so it can't happen there). The
+    // emitted template reads the stash var `label` as the RAW caller
+    // prop and OVERWRITES it with the derived signal value under that
+    // SAME name (`{% set label = (label if label is defined else
+    // 'Default') %}`). Seeding the stash with the pre-fix `{ value:
+    // 'Default' }` (the EVALUATED signal value, discarding `propName`)
+    // means a caller-passed `label` can never win — production seeds
+    // 'Default', the template sees a non-none value, and keeps it. The
+    // fix: this entry must stay a PROP entry (`propName` set, `value:
+    // null`) so the template's own `?? 'Default'` guard supplies the
+    // real fallback, and a caller-supplied prop still wins via
+    // `propName`.
+    const metadata = metadataFor(`
+      'use client'
+      import { createSignal } from '@barefootjs/client'
+      function C(props: { label?: string }) {
+        const [label, setLabel] = createSignal(props.label ?? 'Default')
+        return <span>{label()}</span>
+      }
+    `)
+
+    const defaults = extractSsrDefaults(metadata)
+    expect(defaults?.label).toEqual({ propName: 'label', value: null })
+  })
+
+  test('self-derived signal collision (#2669, shape B): non-idempotent derivation must not seed the pre-fix double-applied value', () => {
+    // `(props.count ?? 1) * 2` is NOT idempotent: seeding the stash with
+    // the pre-fix EVALUATED value (2, for no caller prop) makes the
+    // template's own recompute apply the `* 2` a second time (`2 * 2 =
+    // 4`) — wrong even with no caller props at all. Pin that the entry
+    // is the RAW-prop shape (`value: null`), not `{ value: 2 }`.
+    const metadata = metadataFor(`
+      'use client'
+      import { createSignal } from '@barefootjs/client'
+      function C(props: { count?: number }) {
+        const [count, setCount] = createSignal((props.count ?? 1) * 2)
+        return <span>{count()}</span>
+      }
+    `)
+
+    const defaults = extractSsrDefaults(metadata)
+    expect(defaults?.count).toEqual({ propName: 'count', value: null })
+  })
+
+  test('self-derived memo collision (#2669): the same rule applies to a memo whose computation derives from a same-named prop', () => {
+    // Same collision, memo flavor: `createMemo(() => (props.label ??
+    // 'Default') + n())` — the memo's OWN name (`label`) is the
+    // template variable the emitted template both reads (raw prop) and
+    // overwrites (derived memo value). `n` is an unrelated ordinary
+    // signal and must be unaffected (plain `{ value }` entry, no
+    // `propName`).
+    const metadata = metadataFor(`
+      'use client'
+      import { createSignal, createMemo } from '@barefootjs/client'
+      function C(props: { label?: string }) {
+        const [n, setN] = createSignal(0)
+        const label = createMemo(() => (props.label ?? 'Default') + n())
+        return <span>{label()}</span>
+      }
+    `)
+
+    const defaults = extractSsrDefaults(metadata)
+    expect(defaults?.label).toEqual({ propName: 'label', value: null })
+    expect(defaults?.n).toEqual({ value: 0 })
+  })
+
+  test('NON-self-derived collision (#2669, shape C — out of scope, must be unchanged): signal value still wins, no `propName`', () => {
+    // Same-named `label` getter and `label` prop, but the signal's OWN
+    // initializer does NOT derive from `props.label` (it's a plain
+    // string literal) — the JSX body separately reads `label()` AND
+    // `props.label`. That's a template-variable-ALIASING defect (both
+    // expressions lower to the same template variable, so no seeding
+    // choice can be right for both readers) — a different bug, tracked
+    // separately, and this fix must leave it byte-identical: the entry
+    // stays the plain evaluated-signal-value shape with no `propName`.
+    const metadata = metadataFor(`
+      'use client'
+      import { createSignal } from '@barefootjs/client'
+      function C(props: { label?: string }) {
+        const [label, setLabel] = createSignal('sig')
+        return <span>{label()}{props.label}</span>
+      }
+    `)
+
+    const defaults = extractSsrDefaults(metadata)
+    expect(defaults?.label).toEqual({ value: 'sig' })
+  })
+
+  test('self-derived signal collision THROUGH a component-scope const (#2685 review): entry stays a PROP entry', () => {
+    // One hop of pure indirection past #2669's shape A: `referencesOwnProp`
+    // (built on `collectPropRefs`) only saw a DIRECT `props.<name>` access
+    // in the initializer — a `const mid = props.label` sitting between the
+    // prop read and `createSignal(mid ?? 'Default')` defeated the
+    // detection, so this entry regressed to the pre-#2669 `{ value:
+    // 'Default' }` shape (no `propName`) even after the #2669 fix landed.
+    // Same fix, widened: `collectPropRefsTransitive` now looks through
+    // component-scope const locals.
+    const metadata = metadataFor(`
+      'use client'
+      import { createSignal } from '@barefootjs/client'
+      function C(props: { label?: string }) {
+        const mid = props.label
+        const [label, setLabel] = createSignal(mid ?? 'Default')
+        return <span>{label()}</span>
+      }
+    `)
+
+    const defaults = extractSsrDefaults(metadata)
+    expect(defaults?.label).toEqual({ propName: 'label', value: null })
+  })
+
+  test('self-derived memo collision THROUGH a component-scope const (#2685 review)', () => {
+    const metadata = metadataFor(`
+      'use client'
+      import { createMemo } from '@barefootjs/client'
+      function C(props: { label?: string }) {
+        const mid = props.label
+        const label = createMemo(() => mid ?? 'Default')
+        return <span>{label()}</span>
+      }
+    `)
+
+    const defaults = extractSsrDefaults(metadata)
+    expect(defaults?.label).toEqual({ propName: 'label', value: null })
+  })
+
+  test('multi-hop const chain resolves transitively (#2685 review): `const a = props.x; const b = a`', () => {
+    // Two hops of indirection (`b` reads `a`, `a` reads `props.x`) — the
+    // signal here is named `count`, a DIFFERENT name from the prop `x`, so
+    // this exercises the bare-props safety net's transitive resolution
+    // (not the self-derivation `propName` collision path above): `x` must
+    // still be seeded, or the template-stash adapters' bare-scalar
+    // recompute for `x` aborts at render time (#1297/#2126).
+    const metadata = metadataFor(`
+      'use client'
+      import { createSignal } from '@barefootjs/client'
+      function C(props: { x?: number }) {
+        const a = props.x
+        const b = a
+        const [count, setCount] = createSignal(b ?? 1)
+        return <span>{count()}</span>
+      }
+    `)
+
+    const defaults = extractSsrDefaults(metadata)
+    expect(defaults?.count).toEqual({ value: 1 })
+    expect(defaults?.x).toEqual({ propName: 'x', value: null })
+  })
+
+  test('safety-net seeding sees a prop through a component-scope const (#2685 review)', () => {
+    // The #1297/#2126 bare-props safety net (`collectPropRefs` at the
+    // bottom of `extractSsrDefaults`) only saw a DIRECT `props.X` access
+    // too — this is that same gap, single hop: `const mid = props.initial;
+    // createSignal(mid ?? 0)` misses seeding `initial`, which is a
+    // `Global symbol "$initial" requires explicit package name` render
+    // abort on Perl-strict backends. `count` (the signal's own name) is
+    // unrelated to `initial`, so this is NOT the self-collision path —
+    // purely the safety net.
+    const metadata = metadataFor(`
+      'use client'
+      import { createSignal } from '@barefootjs/client'
+      function Counter(props: { initial?: number }) {
+        const mid = props.initial
+        const [count, setCount] = createSignal(mid ?? 0)
+        return <p>{count()}</p>
+      }
+    `)
+
+    const defaults = extractSsrDefaults(metadata)
+    expect(defaults?.count).toEqual({ value: 0 })
+    expect(defaults?.initial).toEqual({ propName: 'initial', value: null })
+  })
+
+  test('NEGATIVE (#2685 review): a const NOT derived from props keeps the signal-wins behavior', () => {
+    // Same-named `label` getter and `label` prop, wrapped in a const — but
+    // the const's OWN value doesn't read `props` at all, so
+    // `collectPropRefsTransitive` must NOT report a collision here. Must
+    // stay the plain evaluated-signal-value shape with no `propName` — the
+    // const-chain widening only ever ADDS prop references it finds by
+    // actually walking through `props.X`, never invents one.
+    //
+    // (The value resolves to `null`, not `'sig'`: `tryStaticEval` doesn't
+    // bind component-scope const locals into its evaluation `bindings` —
+    // see the signal loop's `bindings` comment above — so `mid` itself is
+    // unresolved for VALUE purposes independent of this fix; only the
+    // separate `propName`-detection walk this test is pinning follows the
+    // const chain.)
+    const metadata = metadataFor(`
+      'use client'
+      import { createSignal } from '@barefootjs/client'
+      function C(props: { label?: string }) {
+        const mid = 'sig'
+        const [label, setLabel] = createSignal(mid)
+        return <span>{label()}{props.label}</span>
+      }
+    `)
+
+    const defaults = extractSsrDefaults(metadata)
+    expect(defaults?.label).toEqual({ value: null })
+  })
+
   test('aliased destructured prop (#2460): `propName` is the CALLER-facing key, not the local binding', () => {
     // `{ n: count }` — the caller passes `n`, the template variable (and
     // stash entry key) is the local binding `count`. The manifest
@@ -302,6 +507,31 @@ describe('deriveStashFromDefaults', () => {
     expect(deriveStashFromDefaults(defaults, { n: 0 })).toEqual({ count: 0 })
   })
 
+  test('self-derived signal collision (#2669): the caller-supplied prop now wins, and an absent prop falls back to null', () => {
+    // End-to-end proof of the fix's effect at the `deriveStashFromDefaults`
+    // layer: run the real `extractSsrDefaults` output for shape A through
+    // the seeding function. Pre-fix, this entry was `{ value: 'Default' }`
+    // (propName-less) so a caller's `label: 'Hello'` was IGNORED —
+    // `deriveStashFromDefaults` had no `propName` to resolve against and
+    // always used the static value. Post-fix the entry is a PROP entry, so
+    // the caller's value wins, and an absent prop resolves to the RAW
+    // fallback `null` (not the old evaluated `'Default'`) — the emitted
+    // template's own `?? 'Default'` guard supplies the real default from
+    // there.
+    const metadata = metadataFor(`
+      'use client'
+      import { createSignal } from '@barefootjs/client'
+      function C(props: { label?: string }) {
+        const [label, setLabel] = createSignal(props.label ?? 'Default')
+        return <span>{label()}</span>
+      }
+    `)
+    const defaults = extractSsrDefaults(metadata)!
+
+    expect(deriveStashFromDefaults(defaults, { label: 'Hello' })).toEqual({ label: 'Hello' })
+    expect(deriveStashFromDefaults(defaults, {})).toEqual({ label: null })
+  })
+
   test('propName-less entry (signal / memo local): always uses the static value', () => {
     // A caller cannot override an internal signal/memo by construction —
     // even a same-named caller prop must not leak in.

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

@@ -209,4 +209,76 @@ describe('computeSsrSeedPlan', () => {
       expect(on.frees).toEqual(['props'])
     }
   })
+
+  test('prop-derived signal init THROUGH a component-scope const (#2685 review): still derived, resolves to the prop free', () => {
+    // Pre-fix, `mid` (a component-scope const, not part of `baseScope`)
+    // was a free identifier `classify` couldn't find in `available`, so
+    // this step fell to `opaque` — no adapter emits an in-template
+    // recompute for it at all (a DIFFERENT, worse-than-#2669 defect: even
+    // with `propName` restored on the manifest side, an absent caller prop
+    // would render permanently empty instead of the signal's own
+    // `'Default'`). `resolveThroughLocalConsts` inlines `mid` to
+    // `props.defaultOn` before classification, so this now derives exactly
+    // like the direct-access form above.
+    const plan = planFor(`
+      'use client'
+      import { createSignal } from '@barefootjs/client'
+      function Toggle(props: { defaultOn?: boolean }) {
+        const mid = props.defaultOn
+        const [on, setOn] = createSignal(mid ?? false)
+        return <button aria-pressed={on()}>t</button>
+      }
+    `)
+
+    const on = step(plan, 'on')
+    expect(on.kind).toBe('derived')
+    if (on.kind === 'derived') {
+      expect(on.origin).toBe('signal')
+      // The RESOLVED free set names `props` (what the inlined form reads),
+      // never the intermediate const `mid` — a consumer emitting `on`'s
+      // seed line never needs to know `mid` existed.
+      expect(on.frees).toEqual(['props'])
+    }
+  })
+
+  test('multi-hop const chain THROUGH TWO component-scope consts (#2685 review): still derived', () => {
+    const plan = planFor(`
+      'use client'
+      import { createSignal } from '@barefootjs/client'
+      function C(props: { x?: number }) {
+        const a = props.x
+        const b = a
+        const [count, setCount] = createSignal(b ?? 1)
+        return <p>{count()}</p>
+      }
+    `)
+
+    const count = step(plan, 'count')
+    expect(count.kind).toBe('derived')
+    if (count.kind === 'derived') {
+      expect(count.frees).toEqual(['props'])
+    }
+  })
+
+  test('const chain that bottoms out on an UNAVAILABLE name → opaque (fails safe, not a wrong substitution)', () => {
+    // `mid` inlines to `laterMemo`, a memo declared AFTER `on` in source —
+    // per the plan's ordering guarantee, `laterMemo` is not yet in
+    // `available` when `on` is classified, so this must stay `opaque`
+    // exactly like a direct forward-reference would (mirrors the existing
+    // "forward reference … → opaque" case above, one hop of const
+    // indirection removed).
+    const plan = planFor(`
+      'use client'
+      import { createSignal, createMemo } from '@barefootjs/client'
+      function C() {
+        const mid = laterMemo()
+        const [on, setOn] = createSignal(mid ?? false)
+        const laterMemo = createMemo(() => true)
+        return <button aria-pressed={on()}>{laterMemo()}</button>
+      }
+    `)
+
+    const on = step(plan, 'on')
+    expect(on.kind).toBe('opaque')
+  })
 })

package/src/__tests__/text-slot-escaping.test.ts

@@ -1,15 +1,23 @@
 /**
- * Text-slot HTML-escaping emit shape (#1694 + follow-up).
+ * Text-slot HTML-escaping emit shape (#1694 + follow-up, #2651).
  *
- * Pins which interpolations the client template wraps in `escapeText`:
- *   - a plain text slot (`{stringValue}`) IS escaped — it becomes the
- *     slot's text content under `innerHTML`;
+ * Pins which interpolations the client template wraps in an escape call:
+ *   - a plain, non-conditional dynamic text slot (`{stringValue}`) IS
+ *     escaped — it becomes the slot's text content under `innerHTML`. Since
+ *     #2651 this goes through `escapeTextOrMarkup`, not bare `escapeText`:
+ *     the slot is claim-plan `kind: 'markup'` (the value may be a live
+ *     `Node`, or a `bfMarkup()`-branded JSX-element-prop value), and
+ *     `escapeTextOrMarkup` is a strict superset of `escapeText` for every
+ *     non-branded value — this pin's actual escaping behaviour for a plain
+ *     string is unchanged, only the call name changed to match the
+ *     REACTIVE side's existing `escapeTextOrNode` classification;
  *   - a branch-slot expression (Child-position value inside a conditional
  *     `template()` arrow) is routed through `__bfSlot` and must NOT be
- *     wrapped in `escapeText`. `__bfSlot` returns raw `<!--bf-slot:N-->`
- *     markers for live nodes; escaping the whole call corrupts them and
- *     drops slotted content (the regression that broke `e2e-site-ui`).
- *     `__bfSlot` escapes its own plain-string path internally instead.
+ *     wrapped in either escape call. `__bfSlot` returns raw
+ *     `<!--bf-slot:N-->` markers for live nodes; escaping the whole call
+ *     corrupts them and drops slotted content (the regression that broke
+ *     `e2e-site-ui`). `__bfSlot` escapes its own plain-string path
+ *     internally instead.
  */
 
 import { describe, test, expect } from 'bun:test'
@@ -27,7 +35,7 @@ function getClientJs(source: string, filename: string): string {
 }
 
 describe('text-slot escaping', () => {
-  test('a plain text slot is wrapped in escapeText', () => {
+  test('a plain text slot is wrapped in escapeTextOrMarkup (#2651)', () => {
     const clientJs = getClientJs(
       `'use client'
        export function Label({ text }: { text: string }) {
@@ -35,10 +43,10 @@ describe('text-slot escaping', () => {
        }`,
       'Label.tsx',
     )
-    expect(clientJs).toMatch(/<!--bf:\w+-->\$\{escapeText\(_p\.text\)\}<!--\/-->/)
+    expect(clientJs).toMatch(/<!--bf:\w+-->\$\{escapeTextOrMarkup\(_p\.text\)\}<!--\/-->/)
   })
 
-  test('a branch-slot expression is NOT wrapped in escapeText', () => {
+  test('a branch-slot expression is NOT wrapped in escapeTextOrMarkup or escapeText', () => {
     const clientJs = getClientJs(
       `'use client'
        import { createSignal } from '@barefootjs/client'
@@ -50,7 +58,8 @@ describe('text-slot escaping', () => {
     )
     // The branch value goes through __bfSlot (raw markers preserved)…
     expect(clientJs).toMatch(/\$\{__bfSlot\(/)
-    // …and must never be double-wrapped by the text escape.
+    // …and must never be double-wrapped by either text-escape call.
+    expect(clientJs).not.toMatch(/escapeTextOrMarkup\(\s*__bfSlot/)
     expect(clientJs).not.toMatch(/escapeText\(\s*__bfSlot/)
   })
 })

package/src/analyzer.ts

@@ -3429,6 +3429,82 @@ function collectKeysFromMembers(
   return keys
 }
 
+/**
+ * Decide whether a member's `TypeInfo` is admissible for
+ * `collectMemberTypes`'s destructured-parameter resolution (#2677 —
+ * widened from the original string/number/boolean-only gate).
+ *
+ * #2150 originally restricted the gate to string/number/boolean, because a
+ * non-primitive `TypeInfo` there used to mean "the typed adapters will emit
+ * an unchecked scalar assertion (`in.X.(int)`) that panics" for a shape the
+ * template layer had no representation for. That reasoning does NOT extend
+ * to a rich type with a CATALOGUED lowering (#2274: `Date` → the `date`
+ * helper): its propsParams `TypeInfo` is consumed only as call-site
+ * evidence for `resolveReceiverType` (rich-type-evidence.ts) — never
+ * emitted as a concrete field type (`typeInfoToGo`'s `interface` case falls
+ * through to `interface{}` for an unbacked host name exactly as `unknown`
+ * already did) — so there is no assertion to panic. Gating on
+ * `CATALOGUED_RICH_TYPE_NAMES` specifically (not `HOST_RICH_TYPE_NAMES`
+ * wholesale) keeps an un-catalogued rich type (`Map`, `Set`, …) at
+ * `unknown`, i.e. avoids resurrecting the #2150 mistake for a shape no
+ * lowering plugin exists for yet.
+ *
+ * Nor does it extend to a STRUCTURAL shape (`kind: 'array'` /
+ * `kind: 'object'`) any more. `typeNodeToTypeInfo` already builds these
+ * fully recursively (`elementType`, `properties`) — the same walk the
+ * `props`-object form (`extractPropsFromTypeMembers`) always got — and
+ * go-template's `emitSynthPropStructs` (#2674/#2676) synthesizes a real,
+ * json-tagged Go struct for any anonymous object type it reaches through
+ * `ir.metadata.propsParams[].type`, array-element positions included. A
+ * structural `TypeInfo` is representable today, so admitting it here no
+ * longer resurrects #2150 either — it lets `propsParams[].type` carry the
+ * SAME shape the props-object form already resolved, closing the
+ * asymmetry #2677 reports (`{ items }: { items: {...}[] }` degrading to
+ * `unknown` while `(props: { items: {...}[] })` resolved fully).
+ *
+ * `array`/`object` admit only when EVERY reachable leaf resolves — an
+ * array's element type and an object's every property type must pass this
+ * same check, recursively. A union, a function, or an un-catalogued named
+ * type reachable ANYWHERE inside the shape declines the WHOLE member (not
+ * just that one leaf): `collectMemberTypes` is an all-or-nothing gate per
+ * member, so a partially-resolvable structural type must still decline —
+ * per-field graceful degradation is `typeInfoToGo`'s job downstream, not
+ * this gate's.
+ *
+ * The `object` arm requires `properties` to be PRESENT, not merely falsy-
+ * coalesced to `[]` — an absent-members claim and a zero-members claim are
+ * different things, and `.every()` on a defaulted-to-`[]` array would admit
+ * both identically (vacuously `true`), which is the #2150 failure mode
+ * wearing a different hat: a concrete representation with no evidence
+ * behind it. `typeNodeToTypeInfo`'s `object` arm DOES omit `properties`
+ * entirely in its `synthetic` mode (the checker-driven `tsTypeToTypeInfo`
+ * path, used for e.g. `createMemo` inference off a resolved `ts.Type`,
+ * which has no source positions for `membersToProperties`' `getText()`).
+ * This gate's only caller (`collectMemberTypes`'s `fromMembers`) always
+ * calls the NON-synthetic 2-arg form, so `properties` is in practice always
+ * at least `[]` here today — but `isResolvableMemberType` is a module-level
+ * function, not a closure scoped to that one caller, so it guards the
+ * general case rather than trust a caller-specific invariant. A genuinely
+ * EMPTY object literal (`{}`, real zero members) DOES resolve — an empty
+ * synthesized struct is exactly as faithful a representation as the type
+ * itself claims, nothing is being guessed.
+ */
+function isResolvableMemberType(info: TypeInfo): boolean {
+  switch (info.kind) {
+    case 'primitive':
+      return info.primitive === 'string' || info.primitive === 'number' || info.primitive === 'boolean'
+    case 'interface':
+      return CATALOGUED_RICH_TYPE_NAMES.has(baseTypeName(info.raw))
+    case 'array':
+      return !!info.elementType && isResolvableMemberType(info.elementType)
+    case 'object':
+      return info.properties !== undefined && info.properties.every(prop => isResolvableMemberType(prop.type))
+    // Unions, functions, and `unknown` all decline — see docstring.
+    default:
+      return false
+  }
+}
+
 /**
  * Build a property-name -> { type, optional } map from a props type
  * annotation, for destructured params (`{ value }: Props`) so they carry the
@@ -3443,36 +3519,17 @@ function collectKeysFromMembers(
  *   degraded to `unknown` -> `interface{}` for attribute omission, because
  *   #2252's nullish-flip machinery supplies the nillable representation
  *   exactly where absence is semantically observable (#2259).
- * - Only PRIMITIVE members (string/number/boolean) resolve a type. Those are
- *   the types that otherwise produce an unchecked scalar assertion (`in.X.(int)`)
- *   that panics. Arrays/objects/functions are left as `unknown` because typed
- *   adapters lower them through interface{}-based helpers (`bf_flat`, spread,
- *   `bf_json`); giving them concrete types would break that lowering and is a
- *   larger, separate change.
+ * - A member resolves a type when it is a PRIMITIVE (string/number/boolean),
+ *   a CATALOGUED rich type (`Date`), or a STRUCTURAL shape (array/object)
+ *   built entirely out of those, recursively (#2677). Unions, functions, and
+ *   un-catalogued named types (`Map`, `Set`, …) are left as `unknown` — see
+ *   `isResolvableMemberType`'s own docstring for why the structural cases
+ *   are safe to admit and why those three still are not.
  */
 function collectMemberTypes(
   typeNode: ts.TypeNode,
   ctx: AnalyzerContext
 ): Map<string, { type: TypeInfo | null; optional: boolean }> | null {
-  // #2150 originally restricted this gate to string/number/boolean only,
-  // because a non-primitive TypeInfo here used to mean "the typed adapters
-  // will emit an unchecked scalar assertion (`in.X.(int)`) that panics" for
-  // a shape the template layer has no representation for. That reasoning
-  // does NOT extend to a rich type with a CATALOGUED lowering (#2274: `Date`
-  // → the `date` helper): its propsParams TypeInfo is consumed only as
-  // call-site evidence for `resolveReceiverType` (rich-type-evidence.ts) —
-  // never emitted as a concrete field type (`typeInfoToGo`'s `interface`
-  // case falls through to `interface{}` for an unbacked host name exactly
-  // as `unknown` already did) — so there is no assertion to panic. Gating on
-  // `CATALOGUED_RICH_TYPE_NAMES` specifically (not `HOST_RICH_TYPE_NAMES`
-  // wholesale) keeps an un-catalogued rich type (`Map`, `Set`, …) at
-  // `unknown`, i.e. avoids resurrecting the #2150 mistake for a shape no
-  // lowering plugin exists for yet.
-  const isResolvablePrimitive = (info: TypeInfo): boolean =>
-    (info.kind === 'primitive' &&
-      (info.primitive === 'string' || info.primitive === 'number' || info.primitive === 'boolean')) ||
-    (info.kind === 'interface' && CATALOGUED_RICH_TYPE_NAMES.has(baseTypeName(info.raw)))
-
   const fromMembers = (
     members: ts.NodeArray<ts.TypeElement>
   ): Map<string, { type: TypeInfo | null; optional: boolean }> => {
@@ -3481,7 +3538,7 @@ function collectMemberTypes(
       if (ts.isPropertySignature(member) && member.name) {
         const info = member.type ? typeNodeToTypeInfo(member.type, ctx.sourceFile) : null
         map.set(member.name.getText(ctx.sourceFile), {
-          type: info && isResolvablePrimitive(info) ? info : null,
+          type: info && isResolvableMemberType(info) ? info : null,
           optional: !!member.questionToken,
         })
       }

package/src/expression-parser.ts

@@ -3037,8 +3037,17 @@ function usesPerPath(name: string, expr: ParsedExpr): { min: number; max: number
  * 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.
+ *
+ * Exported for `computeSsrSeedPlan` (`ssr-seed-plan.ts`), which reuses this
+ * SAME let-inline step to resolve a signal/memo initializer through
+ * component-scope `const` locals sitting between it and the prop it reads
+ * (`const mid = props.label; createSignal(mid ?? 'Default')`) — the
+ * structural (never string-splicing) analogue of what `foldBlockToExpr`
+ * already does for a block-bodied memo's own internal `const`s, and of what
+ * the CSR client-JS emitter's `csrSubstitute` does over TS source text for
+ * the compiled JS domain (#2685 review).
  */
-function inlineBinding(
+export function inlineBinding(
   expr: ParsedExpr,
   name: string,
   value: ParsedExpr,

package/src/ir-to-client-js/collect-elements.ts

@@ -7,7 +7,7 @@ import type { ClientJsContext, ConditionalBranchChildComponent, ConditionalBranc
 import { attrValueToString, freeIdsFromRefs, quotePropName, PROPS_PARAM } from './utils.ts'
 import { classifyReactivity, decideWrapForAttr, decideWrapForChildProp, decideWrapFromAstFlags, collectEventHandlersFromIR, collectConditionalBranchEvents, collectConditionalBranchRefs, collectConditionalBranchChildComponents, collectLoopChildEventsWithNesting, collectLoopChildReactiveAttrs, collectLoopChildReactiveTexts, collectLoopChildRefs, emptyLoopChildBindings, buildLoopRowScope, anyNameIn } from './reactivity.ts'
 import { irToHtmlTemplate, irToPlaceholderTemplate, irChildrenToJsExpr, buildLoopSkeletonTemplate, computeSkeletonSlotPaths, renderFlatMapClientBody, renderFlatMapProjectionClientBody, flatMapCallbackHasKeyedLeaf, type SkeletonSlotPaths } from './html-template.ts'
-import { templateRootIsSvg } from './control-flow/stringify/template-parse.ts'
+import { detectRootNamespaceWrapTag } from './control-flow/stringify/template-parse.ts'
 import { expandDynamicPropValue, expandConstantForReactivity } from './prop-handling.ts'
 import { extractFreeIdentifiersFromText } from './csr-substitute.ts'
 import { walkIR, stopAt } from './walker.ts'
@@ -463,6 +463,29 @@ function jsxChildrenContainComponent(nodes: IRNode[]): boolean {
   return false
 }
 
+/**
+ * Narrow gate for branding a `jsx-children` getter's value with `bfMarkup()`
+ * (#2651). The constructor (`jsx-to-ir.ts`'s `processComponentProps`) always
+ * stores exactly one node here (`AttrValueOf.jsxChildren([...])`), so
+ * `nodes[0]` is the whole payload; `irChildrenToJsExpr` (`html-template.ts`)
+ * turns a single `'element'` node into ONE HTML-string template literal —
+ * the same shape the `renderChild` / `irToComponentTemplateWithOpts` /
+ * `generateCsrTemplateWithOpts` "jsx-children" doors always produce (they
+ * join every child into one string regardless of shape), and the shape
+ * this fixture's `header={<strong>Title</strong>}` exercises.
+ *
+ * Deliberately narrow — NOT a general "does this reduce to one string"
+ * check: a `'fragment'` node (`header={<>text<strong/></>}`, multiple
+ * children) or a `'conditional'` node reduces through `irChildrenToJsExpr`
+ * to an array literal or a nested ternary of un-escaped-vs-escaped parts,
+ * for which `escapeTextOrNode`/`escapeTextOrMarkup` have no (array) or an
+ * unproven (ternary) contract. Those shapes are left unbranded — see
+ * #2651's door inventory — rather than guessed at here.
+ */
+function isSingleElementJsxChildren(nodes: IRNode[]): boolean {
+  return nodes.length === 1 && nodes[0].type === 'element'
+}
+
 /** Build rest spread names from context (rest/props spreads handled by applyRestAttrs, not spreadAttrs). */
 function buildRestSpreadNames(ctx: ClientJsContext): Set<string> {
   const names = new Set<string>()
@@ -502,6 +525,15 @@ function buildComponentPropsExpr(props: IRProp[], ctx: ClientJsContext): string
         const jsxExpr = irChildrenToJsExpr(prop.value.children)
         if (jsxChildrenContainComponent(prop.value.children)) {
           propsForInit.push(`get ${quotePropName(prop.name)}() { return __slot(() => ${jsxExpr}) }`)
+        } else if (prop.name !== 'children' && isSingleElementJsxChildren(prop.value.children)) {
+          // Brand (#2651): `jsxExpr` is the single HTML-string template
+          // literal `irChildrenToJsExpr` builds for a lone 'element' node —
+          // see `isSingleElementJsxChildren`'s docstring for why only this
+          // shape is branded here. Excludes an explicit `children={<jsx/>}`
+          // prop (out of scope, unchanged) — the child's `{children}`
+          // interpolation is a bare passthrough with no unwrap call, so a
+          // branded object there would stringify to `[object Object]`.
+          propsForInit.push(`get ${quotePropName(prop.name)}() { return bfMarkup(${jsxExpr}) }`)
         } else {
           propsForInit.push(`get ${quotePropName(prop.name)}() { return ${jsxExpr} }`)
         }
@@ -761,10 +793,11 @@ export function collectElements(
           }
           skeletonTemplate = buildLoopSkeletonTemplate(l.children[0], skeletonSafeSlots) ?? undefined
           // Direct child-index paths (perf, #2143): only attempted when the
-          // skeleton itself hoisted, and skipped for SVG roots for now (the
-          // `<svg>`-wrap namespace fix-up is orthogonal and untested against
-          // this path model — safe fallback to qsa/$t for those loops).
-          if (skeletonTemplate && !templateRootIsSvg(skeletonTemplate)) {
+          // skeleton itself hoisted, and skipped for SVG/MathML roots for
+          // now (the `<svg>`/`<math>`-wrap namespace fix-up is orthogonal
+          // and untested against this path model — safe fallback to
+          // qsa/$t for those loops).
+          if (skeletonTemplate && !detectRootNamespaceWrapTag(skeletonTemplate)) {
             skeletonPaths = computeSkeletonSlotPaths(l.children[0], skeletonSafeSlots) ?? undefined
           }
         }

package/src/ir-to-client-js/control-flow/stringify/inner-loop.ts

@@ -33,7 +33,7 @@
 import { keyAttrName, profileBindingId, varSlotId } from '../../utils.ts'
 import { emitComponentAndEventSetup } from '../shared.ts'
 import { emitAttrUpdate } from '../../emit-reactive.ts'
-import { emitMultiRootTemplateCloneLines, templateRootIsSvg } from './template-parse.ts'
+import { emitMultiRootTemplateCloneLines, namespaceWrapForTemplate } from './template-parse.ts'
 import { emitLoopChildRefs } from './loop.ts'
 import { claimPlanLiteral, claimWriterVarName, type ClaimSlotSpec } from './claim-plan.ts'
 import type {
@@ -83,15 +83,15 @@ function emitReactive(lines: string[], inner: InnerLoopPlan, indent: string, pc:
     lines.push(`${innerIndent}  __innerEl${uid}.__bfExtras = __innerExtras${uid}`)
     lines.push(`${indent}  }`)
   } else {
-    // SVG-rooted item templates must parse inside a synthetic `<svg>` wrap
-    // (#2219): `template.innerHTML` parses in the HTML namespace, so a bare
-    // `<line>`/`<circle>` root clones as an HTMLUnknownElement and the SVG
-    // renderer silently draws nothing. Mirrors `templateRootIsSvg` handling
-    // on the top-level (#135/#1088) and branch-arm paths; HTML-rooted
-    // templates keep byte-identical output.
-    const isSvg = templateRootIsSvg(emit.wrappedTemplate)
-    const innerHtml = isSvg ? `<svg>${emit.wrappedTemplate}</svg>` : emit.wrappedTemplate
-    const childPath = isSvg ? '.firstElementChild.firstElementChild' : '.firstElementChild'
+    // SVG/MathML-rooted item templates must parse inside a synthetic
+    // namespace wrap (#2219, #1096): `template.innerHTML` parses in the
+    // HTML namespace, so a bare `<line>`/`<circle>`/`<mrow>` root clones as
+    // an HTMLUnknownElement and the SVG/MathML renderer silently draws
+    // nothing. Mirrors `namespaceWrapForTemplate` handling on the top-level
+    // (#135/#1088) and branch-arm paths; HTML-rooted templates keep
+    // byte-identical output.
+    const { wrapTag, childPath } = namespaceWrapForTemplate(emit.wrappedTemplate)
+    const innerHtml = wrapTag ? `<${wrapTag}>${emit.wrappedTemplate}</${wrapTag}>` : emit.wrappedTemplate
     lines.push(`${indent}  let __innerEl${uid} = __existing ?? (() => { const __t = document.createElement('template'); __t.innerHTML = \`${innerHtml}\`; return __t.content${childPath}.cloneNode(true) })()`)
   }
   if (emit.wrappedKey) {