@barefootjs/go-template 0.17.0 → 0.18.0

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

@@ -13,10 +13,12 @@
 import type {
   CompilerError,
   ContextConsumer,
+  EnvSignalReader,
   IRMetadata,
   IRNode,
   LoweringMatcher,
   MemoInfo,
+  SsrSeedPlan,
   TypeDefinition,
   TypeInfo,
 } from '@barefootjs/jsx'
@@ -90,6 +92,35 @@ export class CompileState {
    */
   searchParamsLocals: Set<string> = new Set()
 
+  /**
+   * Env-signal getter (local binding name, e.g. `searchParams` or an alias) →
+   * its registered {@link EnvSignalReader}, keyed by the RECEIVER signal's own
+   * `envReader` registration rather than a hardcoded key — so a memo body's
+   * `<local>().<method>(...)` resolves to whichever reader that particular
+   * local belongs to (open-closed for a future second env signal).
+   */
+  envSignalReadersByLocal: Map<string, EnvSignalReader> = new Map()
+
+  /**
+   * The backend-neutral SSR seed plan (`computeSsrSeedPlan`, Package G) for
+   * the IR currently being compiled — single authority for which signal/memo
+   * getters are value-materializable at SSR time (`env-reader` steps are
+   * per-request readers; everything else is `derived`/`opaque`). Populated in
+   * `primeCompileState`; `envSignalReadersByLocal` and `searchParamsLocals`
+   * derive from it there, and the memo-analysis path in `memo-compute.ts`
+   * reads its `steps` directly instead of re-deriving from `metadata`.
+   */
+  ssrSeedPlan: SsrSeedPlan = { baseScope: [], steps: [] }
+
+  /**
+   * Memo name → the hoisted Go local variable name the constructor assigned
+   * its SSR value to (populated by the sibling-memo hoisting pre-pass before
+   * the main memo-field loop runs). When a later filter-arm memo's free-var
+   * resolution finds an entry here, it reuses the local instead of
+   * recomputing the sibling's expression a second time.
+   */
+  hoistedMemoLocals: Map<string, string> = new Map()
+
   /**
    * Call-lowering matchers active for this component (#2057), bound to its
    * metadata at init via `prepareLoweringMatchers`. Each maps a recognised call

package/src/adapter/lib/go-emit.ts

@@ -192,6 +192,26 @@ export function emitFlatMapEval(
   return `bf_flat_map_eval ${wrapIfMultiToken(recv)} "${escapeGoString(json)}" "${param}" ${env}`
 }
 
+/**
+ * Emit a value-producing `.map(cb)` via the evaluator (#2073): the projection
+ * body is serialized and evaluated per element by `bf_map_eval`, one result
+ * per element (no flatten — the JS `.map` contract). Composes through the
+ * array-method chain (`bf_join (bf_map_eval …) " "`). Returns null when the
+ * projection is outside the evaluator surface (→ caller pushes BF101). The
+ * JSX-returning `.map` is an IRLoop upstream and never reaches this emit.
+ */
+export function emitMapEval(
+  recv: string,
+  body: ParsedExpr,
+  param: string,
+  emit: (e: ParsedExpr) => string,
+): string | null {
+  const json = serializeParsedExpr(body)
+  if (json === null) return null
+  const env = emitEvalEnvArg(body, [param], emit)
+  return `bf_map_eval ${wrapIfMultiToken(recv)} "${escapeGoString(json)}" "${param}" ${env}`
+}
+
 /**
  * Make an equality comparison string-tolerant when exactly one side is a Go
  * string literal: JS `sorted === 'asc'` is loosely false for `sorted = false`,

package/src/adapter/lib/go-naming.ts

@@ -49,6 +49,35 @@ export function capitalizeFieldName(name: string): string {
   return name.charAt(0).toUpperCase() + name.slice(1)
 }
 
+/**
+ * Resolve ANY source property key — identifier or not (`data-priority`,
+ * `aria-label`, a numeric key) — to a valid Go struct field name. Splits on
+ * runs of characters that are invalid in a Go identifier (underscores are
+ * VALID and preserved, so a snake_case key round-trips to the exact same
+ * name `capitalizeFieldName` alone has always produced — `foo_bar` →
+ * `Foo_bar`, never `FooBar`; renaming it would break both existing member
+ * emission and consumers' hand-written constructors against generated
+ * types) and PascalCases each segment through `capitalizeFieldName`, so a
+ * hyphenated key gets a real field instead of being silently dropped
+ * (`data-priority` → `DataPriority`). A result that would start with a
+ * digit (numeric key `0`) is prefixed with `Field` (`Field0`), and a key
+ * with no usable characters at all falls back to `Field` — both keep the
+ * emitted struct compiling (not expected from real TS property names, but
+ * keeps the function total).
+ *
+ * Single source of truth for the source-key → Go-name mapping: used for
+ * struct-field generation (#2087 Phase B — `structFieldsFor`), inline-map
+ * baking (`bakeInlineObjectAsGoMap`), and the `member()` dot-access
+ * emitter, so the baked side and the accessor side can never disagree
+ * (PR #2089 review).
+ */
+export function goFieldNameForKey(key: string): string {
+  const parts = key.split(/[^A-Za-z0-9_]+/).filter(Boolean)
+  if (parts.length === 0) return 'Field'
+  const name = parts.map(capitalizeFieldName).join('')
+  return /^[0-9]/.test(name) ? `Field${name}` : name
+}
+
 /**
  * Convert a slot ID (e.g., 's6') to a Go struct field suffix (e.g., 'Slot6').
  * Keeps field names human-readable regardless of the internal slot ID format.

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

@@ -9,10 +9,17 @@
  */
 
 import type { ParsedExpr, ParsedStatement, TypeInfo } from '@barefootjs/jsx'
+import {
+  asCallbackMethodCall,
+  freeVarsInBody,
+  materializeGetterCalls,
+  serializeParsedExpr,
+} from '@barefootjs/jsx'
 
 import type { GoEmitContext } from '../emit-context.ts'
 import type { PropFallbackVar } from '../lib/types.ts'
 import { capitalizeFieldName } from '../lib/go-naming.ts'
+import { escapeGoString } from '../lib/go-emit.ts'
 import { convertInitialValue, getSignalInitialValueAsGo } from '../value/value-lowering.ts'
 import { typeInfoToGo } from '../type/type-codegen.ts'
 import { computeTemplateLiteralMemoInitialValue } from './template-interp.ts'
@@ -21,6 +28,91 @@ import { resolveBlockBodyMemoModuleConst, computeObjectMemoInitialValue } from '
 /** Default for the optional `propFallbackVars` argument. */
 const EMPTY_PROP_FALLBACK_VARS: ReadonlyMap<string, PropFallbackVar> = new Map()
 
+/** A bare zero-arg getter call (`count()`) → its name, else null. */
+function getterCallName(e: ParsedExpr): string | null {
+  return e.kind === 'call' && e.callee.kind === 'identifier' && e.args.length === 0
+    ? e.callee.name
+    : null
+}
+
+/** A `props.X` member access → the prop name, else null. */
+function propsMemberName(e: ParsedExpr): string | null {
+  return e.kind === 'member' &&
+    !e.computed &&
+    e.object.kind === 'identifier' &&
+    e.object.name === 'props'
+    ? e.property
+    : null
+}
+
+/** A `() => props.X.filter((p) => <predicate>)` match: the array prop name,
+ *  the predicate serialized to the runtime evaluator's ParsedExpr JSON, the
+ *  arrow's param name, and the free variable names its predicate captures.
+ *  Null when `body` isn't this shape, `propName` doesn't resolve to a known
+ *  prop, or the predicate isn't representable (`serializeParsedExpr` refusal).
+ *  Shared by the SSR-value emitter ({@link memoInitialFromParsedBody}) and the
+ *  constructor's sibling-memo hoisting pre-pass so both walk the shape
+ *  identically. */
+export function matchFilterArmMemo(
+  ctx: GoEmitContext,
+  body: ParsedExpr,
+  signals: { getter: string; initialValue: string }[],
+  propsParams: { name: string; type?: TypeInfo; defaultValue?: string }[],
+): { propName: string; predJSON: string; paramName: string; freeVars: string[] } | null {
+  const cb = asCallbackMethodCall(body)
+  if (!cb || cb.method !== 'filter') return null
+  const propName = propsMemberName(cb.object)
+  const param = propName ? propsParams.find(p => p.name === propName) : undefined
+  if (!propName || !param) return null
+
+  // Single authority (Package G plan): every step that isn't `env-reader` is
+  // value-materializable at SSR time — env readers are per-request readers
+  // the runtime evaluator can't invoke, so they're excluded here exactly as
+  // the plan's own consumers exclude them.
+  const knownGetterNames = new Set<string>(
+    ctx.state.ssrSeedPlan.steps.filter(s => s.kind !== 'env-reader').map(s => s.name),
+  )
+
+  const materialized = materializeGetterCalls(cb.arrow.body, knownGetterNames)
+  const predJSON = serializeParsedExpr(materialized)
+  if (predJSON === null) return null
+
+  const paramName = cb.arrow.params[0] ?? '_'
+  const freeVars = freeVarsInBody(materialized, new Set(cb.arrow.params))
+  return { propName, predJSON, paramName, freeVars }
+}
+
+/**
+ * Names of EARLIER sibling memos (per `ctx.state.currentMemos` declaration
+ * order) that a filter-arm memo's predicate free variables resolve to — the
+ * constructor generator hoists these into a shared local so the sibling's
+ * expression isn't emitted twice (once for its own field, once inlined in
+ * this memo's `bf.FilterEval` env map, #2075/#2077 review finding 3). Empty
+ * when `memo` isn't a filter-arm memo or references nothing hoistable.
+ */
+export function filterArmEarlierSiblingRefs(
+  ctx: GoEmitContext,
+  memo: { name: string; parsed?: ParsedExpr },
+  signals: { getter: string; initialValue: string }[],
+  propsParams: { name: string; type?: TypeInfo; defaultValue?: string }[],
+): string[] {
+  if (!memo.parsed) return []
+  const match = matchFilterArmMemo(ctx, memo.parsed, signals, propsParams)
+  if (!match) return []
+  // `currentMemos` order equals the plan's memo-step order (plan lists
+  // signals first, then memos, both in declaration order) — kept here rather
+  // than filtering `ssrSeedPlan.steps` since this index is memo-only already.
+  const memos = ctx.state.currentMemos ?? []
+  const currentIndex = memos.findIndex(m => m.name === memo.name)
+  if (currentIndex < 0) return []
+  const refs: string[] = []
+  for (const name of match.freeVars) {
+    const idx = memos.findIndex(m => m.name === name)
+    if (idx >= 0 && idx < currentIndex) refs.push(name)
+  }
+  return refs
+}
+
 /**
  * Compute a memo's SSR initial value as a Go expression — e.g.
  * `() => count() * 2` → `in.Initial * 2`, `() => props.value * 10` →
@@ -39,8 +131,11 @@ export function computeMemoInitialValue(
   propFallbackVars: ReadonlyMap<string, PropFallbackVar> = EMPTY_PROP_FALLBACK_VARS,
   goType?: string,
 ): string {
+  // Seed the resolution stack with this memo's own name — every external call
+  // is a fresh top-level computation, so self-reference must be caught on the
+  // very first recursion, not only on the second visit.
   const resolved = computeMemoInitialValueOrNull(
-    ctx, memo, signals, propsParams, propFallbackVars,
+    ctx, memo, signals, propsParams, propFallbackVars, new Set([memo.name]),
   )
   if (resolved !== null) return resolved
   // Zero value for the memo's Go type: `false` for bool, `""` for string,
@@ -76,25 +171,112 @@ export function memoInitialFromParsedBody(
   signals: { getter: string; initialValue: string }[],
   propsParams: { name: string; type?: TypeInfo; defaultValue?: string }[],
   propFallbackVars: ReadonlyMap<string, PropFallbackVar>,
+  currentMemoName: string,
+  resolving: ReadonlySet<string> = new Set(),
 ): string | null {
   const propRef = (propName: string): string => {
     const hoisted = propFallbackVars.get(propName)
     if (hoisted) return hoisted.varName
     return `in.${capitalizeFieldName(propName)}`
   }
-  // A bare zero-arg getter call (`count()`) → its name, else null.
-  const getterCallName = (e: ParsedExpr): string | null =>
-    e.kind === 'call' && e.callee.kind === 'identifier' && e.args.length === 0
-      ? e.callee.name
-      : null
-  // A `props.X` member access → the prop name, else null.
-  const propsMemberName = (e: ParsedExpr): string | null =>
-    e.kind === 'member' &&
-    !e.computed &&
-    e.object.kind === 'identifier' &&
-    e.object.name === 'props'
-      ? e.property
-      : null
+  // A request-scoped env-signal read (`searchParams().get('k')`, any local
+  // alias, #1922) → the literal key and the reader's canonical field name,
+  // else null. Constraints: the receiver must be a zero-arg call of a local
+  // bound to a registered env signal (`ctx.state.envSignalReadersByLocal`,
+  // keyed by that reader's own registration — not a hardcoded key); the
+  // method must be one that reader's `methods` set recognises; the key
+  // argument must be a string literal.
+  const envGetKey = (e: ParsedExpr): { key: string; fieldName: string } | null => {
+    if (e.kind !== 'call' || e.callee.kind !== 'member' || e.callee.computed) return null
+    const recvName = getterCallName(e.callee.object)
+    if (recvName === null) return null
+    const reader = ctx.state.envSignalReadersByLocal.get(recvName)
+    if (!reader || !reader.methods.has(e.callee.property)) return null
+    const arg = e.args[0]
+    if (!arg || arg.kind !== 'literal' || arg.literalType !== 'string') return null
+    return { key: String(arg.value), fieldName: capitalizeFieldName(reader.canonicalName) }
+  }
+
+  // () => searchParams().get('k') — a derived memo over the env signal
+  // (#2069). The constructor reads the canonical `in.SearchParams` reader the
+  // handler fills per request, so the memo SSR-computes instead of zero-valuing.
+  {
+    const m = envGetKey(body)
+    if (m !== null) return `in.${m.fieldName}.Get(${JSON.stringify(m.key)})`
+  }
+
+  // () => searchParams().get('k') ?? '<lit>' — the defaulted form. Go's
+  // `SearchParams.Get` returns "" for an absent key (it can't surface JS's
+  // null), so the default fires on "" — the same documented `?? → or`
+  // divergence as the template-position lowering (`or (.SearchParams.Get
+  // "k") "<lit>"`); the two positions stay consistent.
+  if (
+    body.kind === 'logical' &&
+    (body.op === '??' || body.op === '||') &&
+    body.right.kind === 'literal' &&
+    body.right.literalType === 'string'
+  ) {
+    const m = envGetKey(body.left)
+    if (m !== null) {
+      const def = JSON.stringify(String(body.right.value))
+      return `func() string { if v := in.${m.fieldName}.Get(${JSON.stringify(m.key)}); v != "" { return v }; return ${def} }()`
+    }
+  }
+
+  // () => props.X.filter((p) => <predicate>) — a LIST-valued derived memo
+  // chained off a sibling memo the predicate closes over (e.g. a
+  // searchParams()-derived `tag`). Env-signal getters are excluded from the
+  // free-var materialization set: they're per-request READERS, not values,
+  // and the runtime evaluator has no way to invoke one.
+  {
+    const match = matchFilterArmMemo(ctx, body, signals, propsParams)
+    if (match) {
+      const { propName, predJSON, paramName, freeVars } = match
+      const currentIndex = (ctx.state.currentMemos ?? []).findIndex(m => m.name === currentMemoName)
+      const envEntries: string[] = []
+      let unresolved = false
+      for (const name of freeVars) {
+        let goExpr: string | null = null
+        const siblingIndex = (ctx.state.currentMemos ?? []).findIndex(m => m.name === name)
+        if (siblingIndex >= 0) {
+          // Only a sibling declared EARLIER than the memo being computed is
+          // eligible — mirrors JS declaration order and rules out both
+          // self-reference and any mutual pair (at most one direction can
+          // satisfy `earlier`), independent of the resolving-stack guard
+          // below. A hoisted local (the constructor emitted it once already,
+          // #2075/#2077 review finding 3) is reused verbatim instead of
+          // recomputing the expression a second time.
+          const siblingMemo = ctx.state.currentMemos![siblingIndex]
+          const eligible = currentIndex >= 0 && siblingIndex < currentIndex && !resolving.has(siblingMemo.name)
+          if (eligible) {
+            const hoisted = ctx.state.hoistedMemoLocals.get(siblingMemo.name)
+            goExpr = hoisted ?? computeMemoInitialValueOrNull(
+              ctx, siblingMemo, signals, propsParams, propFallbackVars,
+              new Set([...resolving, siblingMemo.name]),
+            )
+          }
+        } else {
+          const sig = signals.find(s => s.getter === name)
+          if (sig) {
+            goExpr = getSignalInitialValueAsGo(ctx, sig.initialValue, propsParams, propFallbackVars)
+          } else {
+            const p = propsParams.find(pp => pp.name === name)
+            if (p) goExpr = propRef(name)
+          }
+        }
+        if (goExpr === null) {
+          unresolved = true
+          break
+        }
+        envEntries.push(`${JSON.stringify(name)}: ${goExpr}`)
+      }
+      if (!unresolved) {
+        const itemsField = `in.${capitalizeFieldName(propName)}`
+        const envMap = `map[string]any{${envEntries.join(', ')}}`
+        return `bf.FilterEval(${itemsField}, "${escapeGoString(predJSON)}", ${JSON.stringify(paramName)}, ${envMap})`
+      }
+    }
+  }
 
   // () => getter() === 'lit' / !== 'lit' — a selection memo. Resolves to a Go
   // bool when the signal's initial value is itself a string literal.
@@ -150,8 +332,15 @@ export function memoInitialFromParsedBody(
           condGo = getSignalInitialValueAsGo(ctx, condSignal.initialValue, propsParams, propFallbackVars)
         } else {
           const condMemo = (ctx.state.currentMemos ?? []).find(m => m.name === condName)
-          if (condMemo) {
-            condGo = computeMemoInitialValueOrNull(ctx, condMemo, signals, propsParams, propFallbackVars)
+          // A condition memo already on the resolution stack (self- or
+          // mutually-referencing ternaries) falls back to null — the same
+          // zero-value default as any other unresolved shape — instead of
+          // recursing forever.
+          if (condMemo && !resolving.has(condMemo.name)) {
+            condGo = computeMemoInitialValueOrNull(
+              ctx, condMemo, signals, propsParams, propFallbackVars,
+              new Set([...resolving, condMemo.name]),
+            )
           }
         }
         if (condGo === 'true') return t
@@ -259,6 +448,15 @@ export function computeMemoInitialValueOrNull(
   signals: { getter: string; initialValue: string }[],
   propsParams: { name: string; type?: TypeInfo; defaultValue?: string }[],
   propFallbackVars: ReadonlyMap<string, PropFallbackVar> = EMPTY_PROP_FALLBACK_VARS,
+  /**
+   * Memo names currently being resolved on this call stack — guards against
+   * unbounded recursion when memos reference each other (mutually, or a
+   * self-reference). Callers that start a fresh top-level computation seed
+   * this with `memo.name`; recursive calls extend it with the sibling memo
+   * about to be entered. A candidate already in the set resolves to `null`
+   * (the shape's usual "unsupported" fallback) instead of recursing.
+   */
+  resolving: ReadonlySet<string> = new Set(),
 ): string | null {
   const computation = memo.computation
 
@@ -275,6 +473,8 @@ export function computeMemoInitialValueOrNull(
       signals,
       propsParams,
       propFallbackVars,
+      memo.name,
+      resolving,
     )
     if (fromParsed !== null) return fromParsed
   }
@@ -288,6 +488,7 @@ export function computeMemoInitialValueOrNull(
     signals,
     propsParams,
     propFallbackVars,
+    resolving,
   )
   if (cmpTernary !== null) return cmpTernary
 
@@ -329,6 +530,7 @@ export function resolveGetterValueAsGo(
   signals: { getter: string; initialValue: string }[],
   propsParams: { name: string; type?: TypeInfo; defaultValue?: string }[],
   propFallbackVars: ReadonlyMap<string, PropFallbackVar>,
+  resolving: ReadonlySet<string> = new Set(),
 ): string | null {
   const signal = signals.find(s => s.getter === name)
   if (signal) {
@@ -336,13 +538,18 @@ export function resolveGetterValueAsGo(
   }
   const memo = (ctx.state.currentMemos ?? []).find(m => m.name === name)
   if (memo) {
+    // Already on the resolution stack (self- or mutually-referencing
+    // ternary operands) — fall back to null rather than recurse forever.
+    if (resolving.has(memo.name)) return null
     const stripped = memo.computation.replace(/^\(\)\s*=>\s*/, '')
     const fb = ctx.extractPropFallback(stripped)
     if (fb && capitalizeFieldName(fb.propName) === capitalizeFieldName(memo.name)) {
       const field = `in.${capitalizeFieldName(fb.propName)}`
       return `func() interface{} { v := interface{}(${field}); if v == nil || v == "" { return ${fb.goFallback} }; return v }()`
     }
-    return computeMemoInitialValueOrNull(ctx, memo, signals, propsParams, propFallbackVars)
+    return computeMemoInitialValueOrNull(
+      ctx, memo, signals, propsParams, propFallbackVars, new Set([...resolving, memo.name]),
+    )
   }
   const param = propsParams.find(p => p.name === name)
   if (param) {
@@ -366,6 +573,7 @@ export function computeComparisonTernaryGo(
   signals: { getter: string; initialValue: string }[],
   propsParams: { name: string; type?: TypeInfo; defaultValue?: string }[],
   propFallbackVars: ReadonlyMap<string, PropFallbackVar>,
+  resolving: ReadonlySet<string> = new Set(),
 ): string | null {
   // Matches any `conditional` `parsed` — an expression-bodied ternary or, since
   // #2040, a block-bodied memo whose value `if` / early-return folded to one.
@@ -398,6 +606,7 @@ export function computeComparisonTernaryGo(
     signals,
     propsParams,
     propFallbackVars,
+    resolving,
   )
   if (condGo === null) return null
 
@@ -420,10 +629,11 @@ export function resolveComparisonOperandGo(
   signals: { getter: string; initialValue: string }[],
   propsParams: { name: string; type?: TypeInfo; defaultValue?: string }[],
   propFallbackVars: ReadonlyMap<string, PropFallbackVar>,
+  resolving: ReadonlySet<string> = new Set(),
 ): string | null {
   // getter(): a signal or memo getter call.
   if (node.kind === 'call' && node.callee.kind === 'identifier' && node.args.length === 0) {
-    return resolveGetterValueAsGo(ctx, node.callee.name, signals, propsParams, propFallbackVars)
+    return resolveGetterValueAsGo(ctx, node.callee.name, signals, propsParams, propFallbackVars, resolving)
   }
   // props.X ?? 'def' — nil/empty-tolerant field read with the default folded in.
   if (node.kind === 'logical' && node.op === '??' && node.right.kind === 'literal' && node.right.literalType === 'string') {

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

@@ -6,11 +6,25 @@
  * right SSR zero value).
  */
 
+import { asCallbackMethodCall } from '@barefootjs/jsx'
 import type { ParsedExpr, TypeInfo } from '@barefootjs/jsx'
 
 import type { GoEmitContext } from '../emit-context.ts'
 import { typeInfoToGo } from '../type/type-codegen.ts'
 
+/**
+ * True when a memo's body is a `.filter(<arrow>)` callback-method call
+ * (#2075) — a LIST-valued derived memo (the blog PostList `visible` shape:
+ * `createMemo(() => props.items.filter((p) => …))`), not a scalar. Exported
+ * so both `isBooleanMemo` (guard below) and `inferMemoType`'s field-type
+ * decision (go-template-adapter.ts) share the one recognition point.
+ */
+export function isListFilterMemo(memo: { parsed?: ParsedExpr }): boolean {
+  if (!memo.parsed) return false
+  const cb = asCallbackMethodCall(memo.parsed)
+  return cb !== null && cb.method === 'filter'
+}
+
 /**
  * Heuristic: does this memo evaluate to a boolean? True when its computation is
  * a comparison (`!==`/`===`/`!=`/`==`), a negation (`!x`), or a ternary whose
@@ -24,6 +38,11 @@ export function isBooleanMemo(
   propsParamMap: Map<string, { name: string; type: TypeInfo; defaultValue?: string }>,
 ): boolean {
   const c = memo.computation
+  // A LIST-valued `.filter(arrow)` memo (#2075) is never boolean, even though
+  // its predicate arrow body often contains a `!` negation (`!tag() || …`) —
+  // that would otherwise trip the `/=>\s*!/` heuristic below into
+  // misclassifying the whole memo. Bail before any regex runs.
+  if (isListFilterMemo(memo)) return false
   // A ternary whose two branches are string literals is a STRING memo, not
   // boolean — the `===` lives in the *condition*, so the blanket comparison
   // check below would misclassify it as bool and bake `false`. Bail first.

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

@@ -4,7 +4,11 @@
  * Free functions over a {@link GoEmitContext}. They resolve a prop/signal/const's
  * type (`TypeInfo`, a raw type string, or — as a last resort — an inferred shape
  * from a literal value) into the Go type used for its struct field. They read
- * only `state.localTypeNames`; `inferTypeFromValue` is fully pure.
+ * `state.localStructFields` / `state.localTypeAliases` (an ACTUAL Go-backed
+ * local type — a generated struct or a string-union alias) rather than the
+ * broader `state.localTypeNames` (every type definition, including a tuple
+ * alias no struct was ever emitted for — #2087); `inferTypeFromValue` is fully
+ * pure.
  */
 
 import type { TypeInfo } from '@barefootjs/jsx'
@@ -42,7 +46,19 @@ export function typeInfoToGo(
     case 'object':
       return 'map[string]interface{}'
     case 'interface':
-      if (typeInfo.raw && ctx.state.localTypeNames.has(typeInfo.raw)) {
+      // Gate on an ACTUAL backing (a generated struct — `localStructFields` —
+      // or a string-union alias — `localTypeAliases`, which emits `type X =
+      // string`), not mere presence in `localTypeNames`: the latter registers
+      // EVERY type definition unconditionally (#2087), including a tuple alias
+      // (`type Row = readonly [string, string]`) that `typeDefinitionToGo`
+      // can't turn into a struct (no object properties) and so never actually
+      // emits. Returning the bare name for one of those would reference an
+      // undeclared Go type (`[]Row`) and fail to compile — fall through to the
+      // generic-array/interface{} handling below instead, so a tuple-typed
+      // signal bakes as `[]interface{}` (each item itself an `interface{}`
+      // holding a `[]interface{}`) and the destructure `index`/`bf_slice`
+      // lowering still works via reflection regardless of the static type.
+      if (typeInfo.raw && (ctx.state.localStructFields.has(typeInfo.raw) || ctx.state.localTypeAliases.has(typeInfo.raw))) {
         return typeInfo.raw
       }
       // Resolve a raw type string pattern (e.g. `Array<Todo>`).
@@ -76,7 +92,10 @@ export function tsTypeStringToGo(ctx: GoEmitContext, tsType: string): string {
   }
   const arrayMatch = t.match(/^Array<(.+)>$/)
   if (arrayMatch) return `[]${tsTypeStringToGo(ctx, arrayMatch[1])}`
-  if (ctx.state.localTypeNames.has(t)) return t
+  // Same backing gate as `typeInfoToGo`'s 'interface' case above — an
+  // unbacked local type name (a tuple alias with no struct fields) must not
+  // be returned bare, or the generated code references an undeclared type.
+  if (ctx.state.localStructFields.has(t) || ctx.state.localTypeAliases.has(t)) return t
   return 'interface{}'
 }
 

package/src/adapter/value/parsed-literal-to-go.ts

@@ -3,20 +3,77 @@
  * for baking a signal's inline initial value into the SSR data context.
  *
  * Covers scalar literals, a unary-minus number, arrays of those, and object
- * literals baked against a concrete local struct.
+ * literals baked against a concrete local struct — including, per #2087, a
+ * struct property whose OWN value is a nested array or object literal
+ * (`{ id, cells: ['a', 'b'] }`, `{ id, user: { name: 'Ada' } }`): the struct's
+ * declared property TYPE (looked up from `ctx.state.currentTypeDefinitions`)
+ * threads through so a typed nested array bakes via the normal array branch
+ * below, and a nested INLINE object (one with no named Go struct —
+ * `typeInfoToGo`'s `'object'` case always falls back to
+ * `map[string]interface{}`) bakes as a capitalized-key Go map literal instead
+ * — the same convention `test-render.ts`'s harness-prop baking already uses
+ * for object elements, since `html/template`'s map field access is an exact
+ * case-sensitive `MapIndex`.
  *
  * Contract is **null-means-defer**: returns null for anything not reproduced
  * exactly — an object whose target type isn't a known struct, a key the struct
- * doesn't declare, a nested object/array property value, an empty array, an
- * identifier/call, or a numeric literal missing its `raw` token. The caller
- * then keeps `nil`.
+ * doesn't declare, an empty array, an identifier/call, or a numeric literal
+ * missing its `raw` token. The caller then keeps `nil`.
  */
 
-import type { ParsedExpr, TypeInfo } from '@barefootjs/jsx'
+import type { ParsedExpr, TypeDefinition, TypeInfo } from '@barefootjs/jsx'
 
 import type { GoEmitContext } from '../emit-context.ts'
+import { goFieldNameForKey } from '../lib/go-naming.ts'
 import { typeInfoToGo } from '../type/type-codegen.ts'
 
+/**
+ * Look up a struct property's declared `TypeInfo` by source key, from the
+ * user's own `TypeDefinition` (not a synthesized struct — those only arise
+ * from an UNTYPED literal, which never carries nested object/array elements
+ * because `synthesizeStructFromSignal` requires every property value to be a
+ * scalar literal). Returns undefined when the struct name isn't a user type
+ * or the key isn't declared — callers treat that as "nested type unknown"
+ * and fall back to the generic/inline lowering.
+ */
+function structPropertyType(ctx: GoEmitContext, structGoType: string, key: string): TypeInfo | undefined {
+  const td = ctx.state.currentTypeDefinitions.find((t: TypeDefinition) => t.name === structGoType)
+  return td?.properties?.find(p => p.name === key)?.type
+}
+
+/**
+ * Bake a nested INLINE object-literal property value — one whose declared
+ * type has no named Go struct (`user: { name: string }` lowers its field to
+ * `map[string]interface{}`, not a struct) — as a Go map literal with
+ * CAPITALIZED keys, recursing for further nesting. `html/template`'s dot
+ * access on a map value does an exact-string `MapIndex`, so a template
+ * action like `.User.Name` only resolves when the baked key is literally
+ * `"Name"`, not the source-cased `"name"` — mirrors the same convention
+ * `test-render.ts`'s `goArrayLiteralFromArray` uses for object elements
+ * passed as harness props.
+ *
+ * Keys are sanitized with `goFieldNameForKey` — the SAME function the
+ * accessor side (`buildSegmentAccessor` / `structFieldsFor`) uses — so a
+ * non-identifier key (`'data-x'`) bakes as `"DataX"` and dot access
+ * `.Meta.DataX` finds it. `capitalizeFieldName` alone would bake
+ * `"Data-x"`, a key no emitted accessor can ever reach (Copilot review,
+ * PR #2089).
+ */
+function bakeInlineObjectAsGoMap(ctx: GoEmitContext, expr: ParsedExpr): string | null {
+  if (expr.kind !== 'object-literal') return null
+  const entries: string[] = []
+  for (const prop of expr.properties) {
+    if (prop.shorthand) return null
+    const go =
+      prop.value.kind === 'object-literal'
+        ? bakeInlineObjectAsGoMap(ctx, prop.value)
+        : parsedLiteralToGo(ctx, prop.value)
+    if (go === null) return null
+    entries.push(`${JSON.stringify(goFieldNameForKey(prop.key))}: ${go}`)
+  }
+  return `map[string]interface{}{${entries.join(', ')}}`
+}
+
 export function parsedLiteralToGo(
   ctx: GoEmitContext,
   expr: ParsedExpr,
@@ -79,10 +136,26 @@ export function parsedLiteralToGo(
       // and defers the whole object.
       const goField = structFields.get(prop.key)
       if (!goField) return null
-      // Nested object/array property values aren't baked here (field types
-      // untracked) — defer.
-      if (prop.value.kind === 'object-literal' || prop.value.kind === 'array-literal') return null
-      const go = parsedLiteralToGo(ctx, prop.value)
+      const propType = structPropertyType(ctx, goType, prop.key)
+      let go: string | null
+      if (prop.value.kind === 'array-literal') {
+        // A nested array property (`cells: readonly string[]`, #2087):
+        // thread the struct's own declared property type through so the
+        // array branch below bakes a properly-typed slice (`[]string{…}`)
+        // instead of deferring.
+        go = parsedLiteralToGo(ctx, prop.value, propType)
+      } else if (prop.value.kind === 'object-literal') {
+        // A nested object property (`user: { name: string }`, #2087): bake
+        // against a named struct if the declared type resolves to one,
+        // else fall back to the capitalized-key inline-map convention.
+        const nestedGoType = propType ? typeInfoToGo(ctx, propType) : undefined
+        go =
+          nestedGoType && ctx.state.localStructFields.has(nestedGoType)
+            ? parsedLiteralToGo(ctx, prop.value, propType)
+            : bakeInlineObjectAsGoMap(ctx, prop.value)
+      } else {
+        go = parsedLiteralToGo(ctx, prop.value)
+      }
       if (go === null) return null
       entries.push(`${goField}: ${go}`)
     }