@barefootjs/go-template 0.18.4 → 0.18.7

package/src/adapter/lib/compile-state.ts

@@ -66,6 +66,15 @@ export class CompileState {
    */
   localConstants: IRMetadata['localConstants'] = []
 
+  /**
+   * Every name a `.map()`/`.filter()` loop callback binds as its item/index
+   * parameter anywhere in the component (#2208 fable review). Consulted by
+   * static loop-source resolution (`getBakedStaticChildLoop`) so a const
+   * whose name a DIFFERENT, enclosing loop's own callback param shadows is
+   * never resolved as that const's static value.
+   */
+  staticLoopSourceBoundNames: Set<string> = new Set()
+
   /**
    * Names of component-scope arrow-const helpers (`const sortClass = …`),
    * eligible for call-site inlining.
@@ -137,6 +146,14 @@ export class CompileState {
    */
   nillablePropNames: Set<string> = new Set()
 
+  /**
+   * String-typed signal getter / prop names (#2168 string-concat-plus).
+   * Feeds `isStringName` for `isStringConcatBinary`, which decides whether a
+   * JS `+` operand chain is string concatenation rather than numeric
+   * addition — see `collectStringValueNames` (`props/prop-classes.ts`).
+   */
+  stringValueNames: Set<string> = new Set()
+
   /** Component root scope element(s) — each carries `data-key` for a keyed loop
    *  item. */
   rootScopeNodes: Set<IRNode> = new Set()

package/src/adapter/lib/constants.ts

@@ -17,6 +17,7 @@ export const GO_TEMPLATE_PRIMITIVES: Record<string, PrimitiveSpec> = {
   'Math.floor':     { arity: 1, emit: (args) => `bf_floor ${wrapGoArg(args[0])}` },
   'Math.ceil':      { arity: 1, emit: (args) => `bf_ceil ${wrapGoArg(args[0])}` },
   'Math.round':     { arity: 1, emit: (args) => `bf_round ${wrapGoArg(args[0])}` },
+  'Math.abs':       { arity: 1, emit: (args) => `bf_abs ${wrapGoArg(args[0])}` },
   // Two-arg forms only; an N-arg `Math.min(a, b, c)` falls through to the
   // standard BF101 unsupported-call diagnostic via the arity gate.
   'Math.min':       { arity: 2, emit: (args) => `bf_min ${wrapGoArg(args[0])} ${wrapGoArg(args[1])}` },

package/src/adapter/memo/memo-compute.ts

@@ -366,13 +366,40 @@ export function memoInitialFromParsedBody(
     const operator = body.op
     const operand = String(body.right.value)
 
-    // getter() * N — return the signal's Go initial value times N.
+    // getter() * N — return the signal's (or, #2168 memo-chain, another
+    // memo's) Go initial value times N. `resolveGetterValueAsGo` checks
+    // `signals` first (unchanged behavior for a signal-derived memo like
+    // `doubled = createMemo(() => count() * 2)`), then falls back to
+    // `ctx.state.currentMemos` and recurses — needed for a memo derived from
+    // ANOTHER memo (`label = createMemo(() => doubled() + 1)`), which this
+    // branch previously couldn't recognize at all (a signals-only lookup),
+    // silently folding to the Go zero value instead of "7".
     const depName = getterCallName(body.left)
     if (depName) {
-      const signal = signals.find(s => s.getter === depName)
-      if (signal) {
-        const signalInitial = getSignalInitialValueAsGo(ctx, signal.initialValue, propsParams, propFallbackVars)
-        return `${signalInitial} ${operator} ${operand}`
+      const depInitial = resolveGetterValueAsGo(ctx, depName, signals, propsParams, propFallbackVars, resolving)
+      // `resolveGetterValueAsGo` can return an IIFE (`func() string { ... }()`
+      // / `func() interface{} { ... }()`, e.g. a memo that shadows `props.X
+      // ?? <lit>`, #2075) rather than a plain atom — none of those return
+      // types support Go's `<op>` arithmetic operators, so splicing one in
+      // bare would emit invalid Go (Copilot review, #2200: e.g. `operator
+      // is not defined on interface{}`/`string`). Bail (fall through to the
+      // caller's zero-value default) rather than emit broken arithmetic.
+      const isArithmeticSafe = depInitial !== null && !depInitial.startsWith('func(')
+      if (isArithmeticSafe) {
+        // A signal's own initial value is always a simple atom (a literal,
+        // `in.Field`, a hoisted var) — never needs grouping. A MEMO's initial
+        // value can itself be a compound expression from this exact branch
+        // one level up (`"3 * 2"`), and splicing that in bare under a
+        // DIFFERENT outer operator can silently invert precedence (a memo
+        // chain shaped `inner = () => count() + 1` then `outer = () =>
+        // inner() * 2` would fold to `3 + 1 * 2` = 5 in Go, vs JS's `(3+1)*2`
+        // = 8). Parenthesize whenever `depInitial` is compound (contains
+        // whitespace — a simple atom never does) so precedence is
+        // preserved regardless of which operator combination a memo chain
+        // uses. A simple atom is left bare so existing exact-text
+        // expectations (`Doubled: 3 * 2,`) don't gain a no-op paren.
+        const wrapped = /\s/.test(depInitial) ? `(${depInitial})` : depInitial
+        return `${wrapped} ${operator} ${operand}`
       }
     }
 
@@ -408,12 +435,13 @@ export function memoInitialFromParsedBody(
     }
   }
 
-  // () => getter() — just return the signal's Go initial value.
+  // () => getter() — just return the signal's (or another memo's, #2168
+  // memo-chain) Go initial value.
   const simpleDep = getterCallName(body)
   if (simpleDep) {
-    const signal = signals.find(s => s.getter === simpleDep)
-    if (signal) {
-      return getSignalInitialValueAsGo(ctx, signal.initialValue, propsParams, propFallbackVars)
+    const depInitial = resolveGetterValueAsGo(ctx, simpleDep, signals, propsParams, propFallbackVars, resolving)
+    if (depInitial !== null) {
+      return depInitial
     }
   }
 

package/src/adapter/props/prop-classes.ts

@@ -0,0 +1,70 @@
+/**
+ * Prop classification for the Go template adapter.
+ *
+ * Ported from `packages/adapter-blade/src/adapter/props/prop-classes.ts` (itself
+ * ported from Jinja) — ONE function: string-typed signal/prop names, needed to
+ * decide `+` string-concat vs numeric addition (#2168 string-concat-plus). Pure
+ * function over `ir.metadata`; no adapter instance state.
+ */
+
+import { collectLoopBoundNames, type ComponentIR, type TypeInfo } from '@barefootjs/jsx'
+
+/** True when `type` is the `string` primitive. */
+function isStringTypeInfo(type: TypeInfo): boolean {
+  return type.kind === 'primitive' && type.primitive === 'string'
+}
+
+/** True when `initialValue` is a bare string-literal expression. */
+function isBareStringLiteral(initialValue: string | undefined): boolean {
+  if (!initialValue) return false
+  const v = initialValue.trim()
+  return (v.startsWith("'") && v.endsWith("'")) || (v.startsWith('"') && v.endsWith('"'))
+}
+
+/**
+ * String-typed signals, props, and same-file local consts (#2212, ported
+ * here for #2236). A signal is string-typed when its inferred type is
+ * `string` (or, defensively, when its initial value is a bare string
+ * literal); a prop when its annotated type is `string`; a local const the
+ * same way. Drives `isStringName` for `isStringConcatBinary` — the shared
+ * helper (`@barefootjs/jsx`) that decides whether a JS `+` is string
+ * concatenation rather than numeric addition (Go's `html/template` has no
+ * native `+` at all; `binary()` always emits a runtime call, `bf_add` for
+ * addition or `bf_concat_str` for concatenation — see
+ * `go-template-adapter.ts`'s `binary()`). Local consts matter for exactly
+ * the shadowing shape this exclusion exists for: with a loop-bound `label`
+ * subtracted, an outer `{label + suffix}` (where `suffix = '!'`) must
+ * still classify as string concat via its OTHER operand, or it would fall
+ * back to `bf_add` and render `0`.
+ *
+ * Excludes any name bound as a `.map()`/`.filter()` loop callback's item or
+ * index parameter ANYWHERE in the component (#2212, ported here for #2236):
+ * this lookup is a flat, scope-blind `Set<string>` with no notion of a loop
+ * param shadowing an outer string-typed binding of the same name
+ * (`values.map((label) => 1 + label)` inside a component that also has a
+ * string `label` prop) — left unguarded, that shadowed `label` would be
+ * misdetected as string-typed and `1 + label` would silently lower to
+ * `bf_concat_str` instead of staying numeric `bf_add`. Subtracting loop-bound
+ * names is coarse (it also suppresses a genuinely non-shadowed same-named
+ * string elsewhere in the component) but safe: the suppressed case just
+ * falls back to today's numeric `bf_add` — the same, already-accepted
+ * residual as an unresolvable operand — never silently-wrong output.
+ */
+export function collectStringValueNames(ir: ComponentIR): Set<string> {
+  const names = new Set<string>()
+  for (const s of ir.metadata.signals) {
+    if (isStringTypeInfo(s.type) || isBareStringLiteral(s.initialValue)) {
+      names.add(s.getter)
+    }
+  }
+  for (const p of ir.metadata.propsParams) {
+    if (isStringTypeInfo(p.type)) names.add(p.name)
+  }
+  for (const c of ir.metadata.localConstants) {
+    if ((c.type !== null && isStringTypeInfo(c.type)) || isBareStringLiteral(c.value)) {
+      names.add(c.name)
+    }
+  }
+  for (const bound of collectLoopBoundNames(ir)) names.delete(bound)
+  return names
+}

package/src/adapter/props/prop-types.ts

@@ -5,7 +5,7 @@
  * generators and the nillable-field set so they can't drift.
  */
 
-import type { ComponentIR, IRMetadata } from '@barefootjs/jsx'
+import type { ComponentIR, IRMetadata, IRNode, ParsedExpr } from '@barefootjs/jsx'
 
 import type { GoEmitContext } from '../emit-context.ts'
 import { typeInfoToGo } from '../type/type-codegen.ts'
@@ -35,9 +35,77 @@ export function buildPropTypeOverrides(ctx: GoEmitContext, ir: ComponentIR): Map
       }
     }
   }
+
+  // A bare `number`-typed prop with no other evidence resolves to Go `int`
+  // (`typeInfoToGo`'s blind default) — but `.toFixed()` can only be called on
+  // a real JS number, and the runtime value it formats (e.g. a price, 19.5)
+  // may be fractional, which a Go `int` struct field can't hold (assigning a
+  // fractional untyped constant to it is a compile error: #2168
+  // number-tofixed). Unlike a signal's fractional LITERAL initial value
+  // (rescued by `typeInfoToGo`'s own `defaultValue` consultation — the
+  // math-methods half of the same divergence), a prop with no default has no
+  // literal to read the fraction off of; the usage of `.toFixed()` itself is
+  // the only available evidence, so it's collected by walking the JSX tree.
+  for (const propName of collectToFixedPropNames(ir.root)) {
+    const param = ir.metadata.propsParams.find(p => p.name === propName)
+    if (!param) continue
+    const resolved = overrides.get(propName) ?? typeInfoToGo(ctx, param.type, param.defaultValue)
+    if (resolved === 'int') {
+      overrides.set(propName, 'float64')
+    }
+  }
+
   return overrides
 }
 
+/**
+ * Names of identifiers used as the receiver of `.toFixed(...)` anywhere in
+ * the component's JSX tree (text expressions, conditions, and attribute
+ * values). Deliberately narrow — `.toFixed()` is the one number-shape usage
+ * that needs this rescue (see `buildPropTypeOverrides` above); it isn't a
+ * general "infer number-ness from usage" walker.
+ *
+ * KNOWN LIMITATION: only a DIRECT identifier receiver in the JSX tree is
+ * caught (`{price.toFixed(2)}`). A bare `number` prop with no default is
+ * still silently typed `int` — and hits the exact same `go run` compile
+ * failure (#2168 number-tofixed) on a fractional runtime value — if the
+ * fraction only surfaces indirectly (`.toFixed()` inside a signal's
+ * initial value or a memo's computation, reached via `ir.metadata` rather
+ * than `ir.root`) or via any OTHER fraction-producing operation on the
+ * same bare prop (division, `Math.round`/`Math.floor`, etc. — none of
+ * which carry the same unambiguous "this must be a real JS number" signal
+ * `.toFixed()` does). Widening this walker to those cases is a real,
+ * currently-unaddressed gap, not a hypothetical one — flag it rather than
+ * treating a future occurrence as a fresh regression.
+ */
+function collectToFixedPropNames(root: IRNode): Set<string> {
+  const names = new Set<string>()
+  const checkExpr = (expr: ParsedExpr | undefined) => {
+    if (expr?.kind === 'array-method' && expr.method === 'toFixed' && expr.object.kind === 'identifier') {
+      names.add(expr.object.name)
+    }
+  }
+  const walk = (node: IRNode | null | undefined) => {
+    if (!node) return
+    if (node.type === 'expression') checkExpr(node.parsed)
+    if (node.type === 'conditional') {
+      checkExpr(node.parsedCondition)
+      walk(node.whenTrue)
+      walk(node.whenFalse)
+    }
+    if (node.type === 'element') {
+      for (const attr of node.attrs) {
+        if (attr.value.kind === 'expression') checkExpr(attr.value.parsed)
+      }
+    }
+    if ('children' in node && Array.isArray(node.children)) {
+      node.children.forEach(walk)
+    }
+  }
+  walk(root)
+  return names
+}
+
 /**
  * Resolve a prop param's Go struct-field type using the SAME logic
  * `generatePropsStruct` / `generateInputStruct` use: a `propTypeOverrides` entry

package/src/adapter/type/type-codegen.ts

@@ -18,7 +18,11 @@ import type { GoEmitContext } from '../emit-context.ts'
 /**
  * Convert a `TypeInfo` to a Go type string.
  *
- * @param defaultValue used to infer the type when `typeInfo.kind` is `unknown`
+ * @param defaultValue used to infer the type when `typeInfo.kind` is
+ *   `unknown`, and to distinguish `int` vs `float64` when `kind` is
+ *   `primitive`/`number` (#2168 math-methods/number-tofixed — a bare TS
+ *   `number` blindly mapped to Go `int`, so a fractional signal initial
+ *   value like `-7.6` silently truncated to the Go zero value)
  * @returns the Go type, falling back to `interface{}` when unresolvable
  */
 export function typeInfoToGo(
@@ -32,7 +36,7 @@ export function typeInfoToGo(
         case 'string':
           return 'string'
         case 'number':
-          return 'int'
+          return defaultValue !== undefined ? numberPrimitiveGoType(defaultValue) : 'int'
         case 'boolean':
           return 'bool'
         default:
@@ -99,6 +103,19 @@ export function tsTypeStringToGo(ctx: GoEmitContext, tsType: string): string {
   return 'interface{}'
 }
 
+/**
+ * Distinguish Go `int` vs `float64` for a `number`-typed field from the
+ * literal source text of its default/initial value. Falls back to `int`
+ * when `value` isn't recognizably a bare numeric literal (e.g. a
+ * destructured default that's itself an expression, `props.initial ?? 0`)
+ * — `int` remains the blind fallback for `kind: 'primitive'`; only a
+ * literal fractional value (`-7.6`) is positive enough evidence to widen
+ * to `float64`.
+ */
+function numberPrimitiveGoType(value: string): string {
+  return /^-?\d+\.\d+$/.test(value) ? 'float64' : 'int'
+}
+
 /** Infer a Go type from a JS value literal; `interface{}` when unrecognized. */
 export function inferTypeFromValue(value: string): string {
   if (value === 'true' || value === 'false') return 'bool'

package/src/adapter/value/value-lowering.ts

@@ -42,8 +42,12 @@ export function convertInitialValue(
       return value === 'true' ? 'true' : 'false'
     }
     if (typeInfo.primitive === 'number') {
-      if (/^\d+$/.test(value)) return value
-      if (/^\d+\.\d+$/.test(value)) return value
+      // Leading `-` (#2168 math-methods: `createSignal(-7.6)`) — without it,
+      // a negative initial value never matches either literal shape below
+      // and silently falls to the `0` zero-value fallback, regardless of the
+      // field's Go type.
+      if (/^-?\d+$/.test(value)) return value
+      if (/^-?\d+\.\d+$/.test(value)) return value
       return '0'
     }
     if (typeInfo.primitive === 'string') {
@@ -70,6 +74,27 @@ export function convertInitialValue(
       }
       return '""'
     }
+    // A struct-backed `interface` kind (an explicitly-typed object signal,
+    // `createSignal<User>({...})`) — #2168 signal-object-field. Mirrors the
+    // `array` branch above: `jsLiteralToGo` → `parsedLiteralToGo`'s
+    // object-literal case already bakes an object literal against a named
+    // local struct correctly (proven by the existing typed-array-of-objects
+    // test); it just wasn't reachable from a SCALAR struct signal, which
+    // fell straight through to `nil` — a compile error for a non-pointer
+    // struct field (`cannot use nil as User value in struct literal`), not
+    // merely a silently-dropped initial value.
+    if (ctx.state.localStructFields.has(typeInfo.raw)) {
+      const baked = jsLiteralToGo(ctx, typeInfo, preParsed)
+      if (baked !== null) return baked
+      // Baking failed (a non-literal initial value, or no `preParsed` tree)
+      // — `nil` is STILL invalid Go for this non-pointer struct field, so
+      // the same compile error would resurface for any such case (Copilot
+      // review, #2201). The struct's own zero value (`User{}`) is the
+      // correct fallback here — mirrors this function's own docstring
+      // ("falls back to the type's zero value") for every other typed
+      // branch above.
+      return `${typeInfo.raw}{}`
+    }
   }
 
   return 'nil'

package/src/conformance-pins.ts

@@ -15,19 +15,21 @@ export const conformancePins: ConformancePins = {
   // `style={{ … }}` object literal now lowers to a CSS string with dynamic
   // values interpolated (`background-color:{{.Color}};padding:8px`) via
   // `tryLowerStyleObject` (#1322).
-  // Sibling-imported child component inside a loop body: the adapter
-  // emits `{{template "X" .}}` which only resolves if the user has
-  // compiled the sibling file and registered the template on the
-  // same instance. BF103 makes that requirement loud. (The barefoot
-  // CLI passes `siblingTemplatesRegistered: true` so CLI builds
-  // suppress the diagnostic — see compileJSX `siblingTemplatesRegistered`.)
-  'static-array-children': [{ code: 'BF103', severity: 'error' }],
-  // TodoApp / TodoAppSSR import `TodoItem` from a sibling file and
-  // call it inside a keyed `.map`. Same BF103 surface as
-  // `static-array-children` above — pinned at adapter level so the
-  // shared-component corpus stays adapter-neutral.
-  'todo-app': [{ code: 'BF103', severity: 'error' }],
-  'todo-app-ssr': [{ code: 'BF103', severity: 'error' }],
+  // `todo-app` / `todo-app-ssr` no longer pinned (#2205) — the conformance
+  // harness now passes `siblingTemplatesRegistered: true` for fixtures with
+  // sibling `components`, matching `bf build`'s real semantics, so the
+  // BF103 loop-body cross-template check no longer fires spuriously.
+  // (`todo-app-ssr` is still skipped on this adapter via
+  // `render-divergences.ts` — #2209 — for an unrelated signal-seeding gap;
+  // `todo-app`'s pre-hydration empty render is unaffected.)
+  // `static-array-children` no longer pinned (#2208) — `items`'s
+  // array-literal initializer is now recognized as fully-static and its
+  // per-item ListItem props/data-key are baked directly into
+  // `NewStaticListProps`'s constructor (`analyzeBakeableStaticChildLoop`),
+  // since the loop body is a single child component with a plain-value
+  // prop set. See #2224 for the narrower remaining gap (a plain-ELEMENT
+  // loop body over a static array, or an inline/unnamed array literal —
+  // still refused).
   // `([emoji, users]) => ...` is an array-index tuple destructure — #2087
   // Phase B's widened gate now admits this shape (`destructure-array-index-in-map`
   // exercises the same `segments`-based lowering). The remaining refusal here
@@ -40,13 +42,11 @@ export const conformancePins: ConformancePins = {
   // array bound to such a const. See the `renderLoop` comment at the check
   // site; Jinja / ERB apply the same narrow check for the same reason.
   'static-array-from-props': [{ code: 'BF101', severity: 'error' }],
-  // Same computed-const array as above, plus the pre-existing BF103 (a
-  // sibling-imported child component used inside the loop body) — the
-  // destructure param itself no longer contributes a diagnostic.
-  'static-array-from-props-with-component': [
-    { code: 'BF103', severity: 'error' },
-    { code: 'BF101', severity: 'error' },
-  ],
+  // Same computed-const array as above — the destructure param itself no
+  // longer contributes a diagnostic, and BF103 (sibling-imported child
+  // component in the loop body) no longer fires either now that the
+  // conformance harness passes `siblingTemplatesRegistered: true` (#2205).
+  'static-array-from-props-with-component': [{ code: 'BF101', severity: 'error' }],
   // (`style-3-signals` graduated alongside `style-object-dynamic` — see note
   // above; the `style={{ … }}` object now lowers to a CSS string.)
   // (`tagged-template-classname` graduated by #2092 — the tag resolves
@@ -127,20 +127,14 @@ export const conformancePins: ConformancePins = {
   // `string-trim` no longer pinned — pre-existing `bf_trim`
   // (wraps `strings.TrimSpace`) handles the strip (#1448 Tier A
   // ninth PR, closing out Tier A).
-  // #2073 follow-up: a function-reference `.map(format)` callback has no
-  // arrow body to serialize — not a CALLBACK_METHODS shape — so the
-  // UNSUPPORTED_METHODS gate refuses it with BF101 rather than emitting
-  // a broken template.
-  'array-map-function-reference': [{ code: 'BF101', severity: 'error' }],
-  // Edge-case sweep (Priority 12): `dangerouslySetInnerHTML` requires a
-  // deliberate raw-HTML (unescaped) output affordance in the target
-  // template language. No lowering exists yet, so the compiler refuses
-  // the shape loudly instead of emitting entity-escaped markup that
-  // silently renders tags as text.
-  'dangerous-inner-html': [{ code: 'BF101', severity: 'error' }],
-  // Edge-case sweep (Priority 12): `.replaceAll` has no lowering yet —
-  // only first-occurrence `.replace` is wired to the runtime helpers.
-  // Refused with BF101 rather than reusing the first-only lowering,
-  // which would silently change semantics.
-  'string-replaceall': [{ code: 'BF101', severity: 'error' }],
+  // `array-map-function-reference` no longer pinned — a bare-identifier
+  // `.map(format)` callback now resolves one hop to its declaration
+  // (`resolveCallbackMethodFunctionReferences`, #2206), the same mechanism
+  // #2090 established for `.sort(fnref)`.
+  // `dangerous-inner-html` no longer pinned — a compile-time string-literal
+  // `dangerouslySetInnerHTML={{ __html: '...' }}` is spliced directly into
+  // the template as trusted raw text (`resolveDangerousInnerHtml`, #2207).
+  // A dynamic/signal-derived value still refuses with BF101 — see the
+  // `dangerous-inner-html-dynamic` fixture/pin below (tracked: #2215).
+  'dangerous-inner-html-dynamic': [{ code: 'BF101', severity: 'error', issue: 'https://github.com/piconic-ai/barefootjs/issues/2215' }],
 }

package/src/render-divergences.ts

@@ -17,34 +17,16 @@
 import type { RenderDivergences } from '@barefootjs/jsx'
 
 export const renderDivergences: RenderDivergences = {
-  'html-entity-text':
-    '`©` in JSX literal text: Hono decodes to `©`, this adapter re-emits the raw entity — same DOM, different bytes',
-  'string-concat-plus':
-    "`'Hello, ' + name` renders \"0\" — JS string-concat `+` lowered through numeric addition",
-  'optional-chaining-prop':
-    '`user?.name ?? …` on an object prop: generated Go fails to run (exit 1) — optional chaining into a struct/map prop has no lowering',
-  'number-tofixed':
-    '`.toFixed(2)` on a number PROP: generated Go fails to run (exit 1)',
-  'math-methods':
-    'Math.min/max/abs over a signal: generated Go fails to run (exit 1) — only Math.floor is registered',
-  'static-attr-escape':
-    'static attribute values are not HTML-escaped (`title="Fish & Chips"` emitted raw; Hono escapes)',
-  'object-entries-map':
-    '`Object.entries(prop).map(([k, v]) => …)`: generated Go fails to run (exit 1) — no object-iteration loop lowering',
-  'nested-loop-outer-binding':
-    'nested-loop inner items carry `data-key` where the reference emits the depth-suffixed `data-key-1`',
-  'jsx-element-prop':
-    'a JSX element passed as a NON-children prop renders an empty slot — the element value is silently dropped',
-  'grandchild-composition':
-    "three-level composition: the grandchild's threaded prop renders EMPTY — prop forwarding through two template-render layers loses the value",
-  'child-primitive-props':
-    'numeric/boolean LITERAL props on a child (`count={5}` `active={true}`) render as Go zero values (0 / false)',
-  'memo-chain':
-    'a memo derived from another memo renders EMPTY for the second layer — the constructor folds only one derivation level',
-  'signal-object-field':
-    'object-valued signal (`user().name`): generated Go fails to run (exit 1) — no struct synthesis outside loops',
-  'string-slice':
-    '`.slice()` on a STRING routes through the array `bf_slice` helper and renders "[]" instead of the substring',
-  'string-trim-sided':
-    '`.trimStart()` / `.trimEnd()`: generated Go fails to run (exit 1) — only both-sides `bf_trim` exists',
+  // `todo-app-ssr` no longer diverges (#2209). Two parts: (1) `.Todos`
+  // (the loop's DATUM slice) is already seeded straight from the caller's
+  // Input — the constructor derives it from `initialTodos`, and `[]Todo`
+  // zero-fills `Editing: false`, so the `.map(t => ({ ...t, editing:
+  // false }))` transform in the signal initializer was never actually the
+  // gap on Go, unlike the 7 template-string adapters. (2) The real gap was
+  // `.TodoItems []TodoItemProps` — the loop-body CHILD COMPONENT slice the
+  // template actually ranges over — which has no server-side population
+  // path in this harness (documented as route-handler-populated in
+  // production). `buildDynamicChildLoopSeeding` (this package's
+  // `test-render.ts`) now replicates that documented contract for a
+  // signal-backed dynamic child-component loop.
 }