@barefootjs/jsx 0.17.1 → 0.18.0

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

@@ -136,12 +136,14 @@ describe('Unsupported Expression Error (BF021)', () => {
 })
 
 describe('Unsupported Sort Comparator (BF021)', () => {
-  test('emits BF021 for function-reference comparator — outside accepted catalogue', () => {
+  test('function-reference comparator resolves through scope — no BF021 (#2090)', () => {
     // #1448 Tier B follow-up widened the catalogue to include
     // multi-key (`a.x - b.x || a.y - b.y`), relational ternary, and
-    // single-`return` block bodies. Function-reference comparators
-    // (`arr.sort(cmp)` where `cmp` is a named function) are still out
-    // of scope — they need scope resolution and refuse here.
+    // single-`return` block bodies. #2090 closes the remaining gap:
+    // a bare identifier callback (`arr.sort(cmp)`) is now resolved
+    // through the analyzer's scope machinery (one hop, same-file
+    // only) to the const-bound arrow, then fed through the same
+    // catalogue as an inline comparator.
     const source = `
       'use client'
       import { createSignal } from '@barefootjs/client'
@@ -152,7 +154,73 @@ describe('Unsupported Sort Comparator (BF021)', () => {
         return (
           <ul>
             {items().sort(cmp).map(t => (
-              <li>{t.name}</li>
+              <li key={t.name}>{t.name}</li>
+            ))}
+          </ul>
+        )
+      }
+    `
+
+    const { ir, errors } = compileToIR(source)
+    const bf021 = errors.filter(e => e.code === ErrorCodes.UNSUPPORTED_JSX_PATTERN)
+
+    expect(bf021).toHaveLength(0)
+    expect(ir).not.toBeNull()
+    if (ir!.type === 'element') {
+      const loop = ir!.children.find(c => c.type === 'loop')
+      expect(loop).toBeDefined()
+      if (loop?.type === 'loop') {
+        expect(loop.sortComparator).toBeDefined()
+        expect(loop.sortComparator!.raw).toBe('a.priority - b.priority')
+      }
+    }
+  })
+
+  test('function-declaration comparator reference resolves — no BF021 (#2090)', () => {
+    const source = `
+      'use client'
+      import { createSignal } from '@barefootjs/client'
+
+      function cmp(a, b) { return a.priority - b.priority }
+
+      export function TodoList() {
+        const [items, setItems] = createSignal<any[]>([])
+        return (
+          <ul>
+            {items().toSorted(cmp).map(t => (
+              <li key={t.name}>{t.name}</li>
+            ))}
+          </ul>
+        )
+      }
+    `
+
+    const { ir, errors } = compileToIR(source)
+    const bf021 = errors.filter(e => e.code === ErrorCodes.UNSUPPORTED_JSX_PATTERN)
+
+    expect(bf021).toHaveLength(0)
+    expect(ir).not.toBeNull()
+    if (ir!.type === 'element') {
+      const loop = ir!.children.find(c => c.type === 'loop')
+      if (loop?.type === 'loop') {
+        expect(loop.sortComparator).toBeDefined()
+        expect(loop.sortComparator!.raw).toBe('a.priority - b.priority')
+      }
+    }
+  })
+
+  test('identifier resolving to a non-function const emits BF021 (#2090)', () => {
+    const source = `
+      'use client'
+      import { createSignal } from '@barefootjs/client'
+
+      export function TodoList() {
+        const [items, setItems] = createSignal<any[]>([])
+        const cmp = 5
+        return (
+          <ul>
+            {items().sort(cmp).map(t => (
+              <li key={t.name}>{t.name}</li>
             ))}
           </ul>
         )
@@ -163,16 +231,135 @@ describe('Unsupported Sort Comparator (BF021)', () => {
     const bf021 = errors.filter(e => e.code === ErrorCodes.UNSUPPORTED_JSX_PATTERN)
 
     expect(bf021).toHaveLength(1)
+    expect(bf021[0].message).toContain('could not be resolved')
   })
 
-  test('@client suppresses BF021 for unsupported sort comparator', () => {
+  test('cross-kind shadowing (component const over module function) emits BF021, not the shadowed function (#2090)', () => {
+    // A name bound both as a const and as a `function` declaration can
+    // only happen across scopes, and FunctionInfo does not carry lexical
+    // scope (component-body functions are hoisted for client emission).
+    // Resolution refuses the ambiguity rather than guessing — pre-fix
+    // this wrongly compiled against the shadowed module function
+    // (Copilot review on #2091).
     const source = `
       'use client'
       import { createSignal } from '@barefootjs/client'
 
+      function cmp(a, b) { return a.priority - b.priority }
+
+      export function TodoList() {
+        const [items, setItems] = createSignal<any[]>([])
+        const cmp = 5
+        return (
+          <ul>
+            {items().sort(cmp).map(t => (
+              <li key={t.name}>{t.name}</li>
+            ))}
+          </ul>
+        )
+      }
+    `
+
+    const { errors } = compileToIR(source)
+    const bf021 = errors.filter(e => e.code === ErrorCodes.UNSUPPORTED_JSX_PATTERN)
+
+    expect(bf021).toHaveLength(1)
+    expect(bf021[0].message).toContain('could not be resolved')
+  })
+
+  test('cross-kind shadowing (component function over module const) also refuses with BF021 (#2090)', () => {
+    // The safe half of the same ambiguity: JS would use the component
+    // function here, but resolution cannot prove which binding the call
+    // site sees, so it refuses loudly instead of risking the WRONG
+    // (opposite-direction) comparator.
+    const source = `
+      'use client'
+      import { createSignal } from '@barefootjs/client'
+
+      const byPrice = (a, b) => a.price - b.price
+
+      export function ProductList() {
+        const [products, setProducts] = createSignal<any[]>([])
+        function byPrice(a, b) { return b.price - a.price }
+        return (
+          <ul>
+            {products().sort(byPrice).map(p => (
+              <li key={p.name}>{p.name}</li>
+            ))}
+          </ul>
+        )
+      }
+    `
+
+    const { errors } = compileToIR(source)
+    const bf021 = errors.filter(e => e.code === ErrorCodes.UNSUPPORTED_JSX_PATTERN)
+
+    expect(bf021).toHaveLength(1)
+    expect(bf021[0].message).toContain('could not be resolved')
+  })
+
+  test('unresolved (imported) identifier comparator emits BF021 (#2090)', () => {
+    const source = `
+      'use client'
+      import { createSignal } from '@barefootjs/client'
+      import { cmp } from './cmp'
+
+      export function TodoList() {
+        const [items, setItems] = createSignal<any[]>([])
+        return (
+          <ul>
+            {items().sort(cmp).map(t => (
+              <li key={t.name}>{t.name}</li>
+            ))}
+          </ul>
+        )
+      }
+    `
+
+    const { errors } = compileToIR(source)
+    const bf021 = errors.filter(e => e.code === ErrorCodes.UNSUPPORTED_JSX_PATTERN)
+
+    expect(bf021).toHaveLength(1)
+    expect(bf021[0].message).toContain('could not be resolved')
+  })
+
+  test('resolved-but-off-catalogue comparator body emits BF021 naming the comparator (#2090)', () => {
+    // `a.deep.x - b.deep.x` has operand depth > 1 — `classifySortOperand`
+    // only accepts the param itself or a single-level field access, so this
+    // stays refused even once the identifier resolves to the arrow.
+    const source = `
+      'use client'
+      import { createSignal } from '@barefootjs/client'
+
+      export function TodoList() {
+        const [items, setItems] = createSignal<any[]>([])
+        const cmp = (a, b) => a.deep.x - b.deep.x
+        return (
+          <ul>
+            {items().sort(cmp).map(t => (
+              <li key={t.name}>{t.name}</li>
+            ))}
+          </ul>
+        )
+      }
+    `
+
+    const { errors } = compileToIR(source)
+    const bf021 = errors.filter(e => e.code === ErrorCodes.UNSUPPORTED_JSX_PATTERN)
+
+    expect(bf021).toHaveLength(1)
+    expect(bf021[0].message).toContain("'cmp'")
+    expect(bf021[0].message).toContain('not a supported shape')
+  })
+
+  test('@client suppresses BF021 for an unresolved sort comparator identifier', () => {
+    const source = `
+      'use client'
+      import { createSignal } from '@barefootjs/client'
+      import { cmp } from './cmp'
+
       export function TodoList() {
         const [items, setItems] = createSignal<any[]>([])
-        const cmp = (a, b) => a.priority - b.priority
         return (
           <ul>
             {/* @client */ items().sort(cmp).map(t => (

package/src/adapters/interface.ts

@@ -96,9 +96,23 @@ export type TemplatePrimitiveEmit = (args: string[]) => string
  * Keys are the textual callee path as it appears in the JSX expression
  * (`JSON.stringify`, `Math.floor`, `String`).
  *
- * V1 scope: identifier-path callees only. Method calls on values whose type
- * the analyzer must resolve (`props.name.toUpperCase()`) are out of scope —
- * see #1187 R1. Users can fall back to `/* @client *\/` for those.
+ * V1 scope (#1187): identifier-path callees only, and only names the adapter
+ * knows about AHEAD OF TIME — this map is fixed at adapter-construction
+ * time, so it can never contain a name from a component's own (unknown in
+ * advance) imports. Method calls on values whose type the analyzer must
+ * resolve (`props.name.toUpperCase()`) are ALSO out of scope — see #1187 R1.
+ * Users can fall back to `/* @client *\/` for either limitation.
+ *
+ * V2 (#2069) does not widen this map — it adds a separate, orthogonal
+ * acceptance path instead: `RelocateEnv.loweringMatchers`, bound once per
+ * component from the global `LoweringPlugin` registry
+ * (`prepareLoweringMatchers`, `packages/jsx/src/lowering-registry.ts`). A
+ * plugin's `prepare(metadata)` resolves the component's ACTUAL import list,
+ * so it can recognise a call this string-keyed map structurally never could
+ * (a bespoke user import, unknown until compile time). `templatePrimitives`
+ * remains the right home for well-known JS builtins (`JSON.stringify`,
+ * `Math.floor`) that every component might reasonably use, with no import
+ * to key a plugin against.
  */
 export type TemplatePrimitiveRegistry = Record<string, TemplatePrimitiveEmit>
 
@@ -110,7 +124,9 @@ export type TemplatePrimitiveRegistry = Record<string, TemplatePrimitiveEmit>
  *
  * Adapters whose template runtime can't execute arbitrary JS (Go, Perl,
  * other server-side template languages) should leave this undefined and
- * rely on the explicit `templatePrimitives` map alone.
+ * rely on the explicit `templatePrimitives` map alone (plus, since #2069,
+ * whatever `LoweringPlugin`s are registered — see `TemplatePrimitiveRegistry`
+ * above).
  */
 export type TemplateCallAcceptor = (calleeName: string) => boolean
 

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

@@ -177,9 +177,22 @@ export interface ParsedExprEmitter {
   // a structured `FlatDepth` (the validated literal / `'infinity'`) rather
   // than a `ParsedExpr[]` args list. Non-callback, so it is NOT routed
   // through `callbackMethod`.
+  //
+  // `depth` is `FlatDepth` for the literal path (unchanged: adapters keep
+  // their existing `bf_flat`-family emit exactly as before) or
+  // `{ expr: ParsedExpr }` for a DYNAMIC depth (#2094) — an adapter renders
+  // `expr` with the `emit` callback and passes the result to a SEPARATE
+  // runtime helper that coerces it at render time (JS `ToIntegerOrInfinity`;
+  // see the `depthExpr` doc on `ParsedExpr`'s `array-method`/`flat` variant
+  // for why this must NOT be the same helper as the literal path — the
+  // literal path's `-1` sentinel means "flatten fully", but a genuinely
+  // dynamic `-1` means the opposite per JS). Every adapter emits its
+  // `flat_dynamic`-family helper for the dynamic form, and every runtime
+  // implements the coercion; parity is pinned by the `flat_dynamic`
+  // golden helper vectors.
   flatMethod(
     object: ParsedExpr,
-    depth: FlatDepth,
+    depth: FlatDepth | { expr: ParsedExpr },
     emit: (e: ParsedExpr) => string,
   ): string
   unsupported(raw: string, reason: string): string
@@ -232,7 +245,11 @@ export function emitParsedExpr(expr: ParsedExpr, emitter: ParsedExprEmitter): st
       return emitter.objectLiteral(expr.properties, expr.raw, emit)
     case 'array-method':
       if (expr.method === 'flat') {
-        return emitter.flatMethod(expr.object, expr.flatDepth, emit)
+        return emitter.flatMethod(
+          expr.object,
+          expr.depthExpr ? { expr: expr.depthExpr } : expr.flatDepth,
+          emit,
+        )
       }
       return emitter.arrayMethod(expr.method, expr.object, expr.args, emit)
     case 'unsupported':

package/src/analyzer-context.ts

@@ -268,6 +268,26 @@ export function createAnalyzerContext(
     checker: null,
     componentBodyBlock: null,
     getJS(node: ts.Node): string {
+      // A node whose owning source file differs from this component's
+      // `sourceFile` comes from a synthetic re-parse — e.g. #2090's
+      // resolved sort-comparator functions, or #2092's desugared
+      // tagged-template-literal callee — rather than a live position in
+      // this file. `reconstructWithoutTypes` slices `sourceFile.text` by
+      // the node's start/end, so feeding it a foreign node's positions
+      // would silently slice the WRONG bytes (not throw). These synthetic
+      // subtrees are already built from plain re-parsed source text with
+      // no straggling TS type syntax to strip, so the node's own text is
+      // correct as-is — mirrors the `astText()` workaround already used
+      // for synthetic const/function re-parses elsewhere in the compiler.
+      let ownSourceFile: ts.SourceFile | undefined
+      try {
+        ownSourceFile = node.getSourceFile()
+      } catch {
+        ownSourceFile = undefined
+      }
+      if (ownSourceFile && ownSourceFile !== sourceFile) {
+        return node.getText(ownSourceFile)
+      }
       return reconstructWithoutTypes(node, sourceFile, this.typeExcludeRanges)
     },
   }

package/src/analyzer.ts

@@ -3011,6 +3011,12 @@ function extractProps(param: ts.ParameterDeclaration, ctx: AnalyzerContext): voi
       hasIgnoreDirective: ignored,
     }
 
+    // Resolve each destructured binding's declared type from the param's type
+    // annotation, so `{ value }: Props` keeps the same per-prop TypeInfo as the
+    // `props: Props` path instead of degrading to `unknown` (which typed
+    // adapters emit as `interface{}` + an unchecked assertion). See issue #2150.
+    const memberTypes = param.type ? collectMemberTypes(param.type, ctx) : null
+
     for (const element of param.name.elements) {
       if (ts.isBindingElement(element) && ts.isIdentifier(element.name)) {
         const localName = element.name.text
@@ -3022,10 +3028,19 @@ function extractProps(param: ts.ParameterDeclaration, ctx: AnalyzerContext): voi
           continue
         }
 
+        // Aliased bindings (`{ value: v }`) take their type from the source
+        // property name, not the local alias.
+        const sourcePropName =
+          element.propertyName && ts.isIdentifier(element.propertyName)
+            ? element.propertyName.text
+            : localName
+        const resolvedType: TypeInfo =
+          memberTypes?.get(sourcePropName) ?? { kind: 'unknown', raw: 'unknown' }
+
         const defaultContainsArrow = element.initializer ? nodeContainsArrow(element.initializer) : false
         ctx.propsParams.push({
           name: localName,
-          type: { kind: 'unknown', raw: 'unknown' },
+          type: resolvedType,
           optional: !!element.initializer,
           defaultValue,
           defaultContainsArrow: defaultContainsArrow || undefined,
@@ -3108,6 +3123,64 @@ function collectKeysFromMembers(
   return keys
 }
 
+/**
+ * Build a property-name -> resolved TypeInfo map from a props type annotation,
+ * for destructured params (`{ value }: Props`) so they carry the same per-prop
+ * types the props-object path (`props: Props`) already resolves. Returns null
+ * for external/unresolvable types.
+ *
+ * Scope (deliberately narrow — targets the panic in issue #2150):
+ * - Only REQUIRED members are resolved. Optional members (`value?: T`) are left
+ *   out so they keep degrading to `unknown` -> `interface{}`: typed adapters
+ *   rely on that nillable field to omit an unset optional attribute
+ *   (`{{if ne .X nil}}` in Go), which a concrete zero value could not express.
+ * - Only PRIMITIVE members (string/number/boolean) are resolved. 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.
+ */
+function collectMemberTypes(
+  typeNode: ts.TypeNode,
+  ctx: AnalyzerContext
+): Map<string, TypeInfo> | null {
+  const isResolvablePrimitive = (info: TypeInfo): boolean =>
+    info.kind === 'primitive' &&
+    (info.primitive === 'string' || info.primitive === 'number' || info.primitive === 'boolean')
+
+  const fromMembers = (members: ts.NodeArray<ts.TypeElement>): Map<string, TypeInfo> => {
+    const map = new Map<string, TypeInfo>()
+    for (const member of members) {
+      if (ts.isPropertySignature(member) && member.name && member.type && !member.questionToken) {
+        const info = typeNodeToTypeInfo(member.type, ctx.sourceFile)
+        if (info && isResolvablePrimitive(info)) {
+          map.set(member.name.getText(ctx.sourceFile), info)
+        }
+      }
+    }
+    return map
+  }
+
+  if (ts.isTypeLiteralNode(typeNode)) {
+    return fromMembers(typeNode.members)
+  }
+
+  if (ts.isTypeReferenceNode(typeNode)) {
+    const typeName = typeNode.typeName.getText(ctx.sourceFile)
+    const typeDecl = findTypeDeclaration(typeName, ctx.sourceFile)
+    if (!typeDecl) return null
+    if (ts.isInterfaceDeclaration(typeDecl)) {
+      return fromMembers(typeDecl.members)
+    }
+    if (ts.isTypeAliasDeclaration(typeDecl) && ts.isTypeLiteralNode(typeDecl.type)) {
+      return fromMembers(typeDecl.type.members)
+    }
+  }
+
+  return null
+}
+
 /**
  * Extract props parameters from a type annotation.
  * Supports type literals and type references to local interfaces.

package/src/augment-inherited-props.ts

@@ -32,6 +32,25 @@ export interface ContextConsumer {
    * absent / not a literal (the consumer then defaults to the empty value).
    */
   defaultValue: string | number | boolean | null
+  /**
+   * Set to `'object'` when the `createContext(<default>)` argument is an
+   * OBJECT LITERAL (`createContext<{ config: X }>({ config: {} })`) — a shape
+   * `defaultValue` alone can't distinguish from "no default at all" (both
+   * collapse to `null`). Adapters with a live SSR context stack (twig, jinja,
+   * erb, minijinja, xslate, mojolicious) never read this: their consumer seed
+   * (`bf.use_context(name, default)`) only matters when NO enclosing Provider
+   * ran, and every existing fixture exercising an object-shaped default keeps
+   * its consumer nested inside a Provider that supplies a live value at
+   * render time — see each adapter's `memo/seed.ts` (or equivalent). Go has no
+   * such runtime stack: it bakes the Provider's value into the descendant's
+   * constructor call at COMPILE time (`extendProviderContext` /
+   * `emitStaticChildInstances`, go-template-adapter.ts), so an object-shaped
+   * default needs its own Go type (`map[string]interface{}`, not the scalar
+   * `string` fallback `contextConsumerGoType` used to pick for every
+   * non-literal default) — `defaultKind` is what lets it tell "object" apart
+   * from "no default" (#2087).
+   */
+  defaultKind?: 'object'
 }
 
 /**
@@ -44,9 +63,15 @@ export function collectContextConsumers(metadata: IRMetadata): ContextConsumer[]
   const constants = metadata.localConstants ?? []
   // Map each createContext const name → its default-arg literal value.
   const contextDefaults = new Map<string, string | number | boolean | null>()
+  // Map each createContext const name → 'object' when its default is an
+  // object-literal (a shape `contextDefaults` alone can't distinguish from
+  // "no default" — both parse to `null`). Only Go consults this (see
+  // `ContextConsumer.defaultKind`'s docstring).
+  const contextDefaultKinds = new Map<string, 'object'>()
   for (const c of constants) {
     if (c.systemConstructKind !== 'createContext' || c.value === undefined) continue
     contextDefaults.set(c.name, parseCreateContextDefault(c.value))
+    if (isObjectLiteralCreateContextDefault(c.value)) contextDefaultKinds.set(c.name, 'object')
   }
   if (contextDefaults.size === 0) return []
 
@@ -59,6 +84,7 @@ export function collectContextConsumers(metadata: IRMetadata): ContextConsumer[]
       localName: c.name,
       contextName: ctxName,
       defaultValue: contextDefaults.get(ctxName) ?? null,
+      defaultKind: contextDefaultKinds.get(ctxName),
     })
   }
   return consumers
@@ -87,6 +113,14 @@ function parseCreateContextDefault(source: string): string | number | boolean |
   return null
 }
 
+/** True when `createContext(<arg>)`'s argument is an object-literal (`{ config: {} }`). */
+function isObjectLiteralCreateContextDefault(source: string): boolean {
+  const expr = parseSingleExpression(source)
+  if (!expr || !ts.isCallExpression(expr)) return false
+  if (expr.arguments.length === 0) return false
+  return ts.isObjectLiteralExpression(expr.arguments[0])
+}
+
 function parseSingleExpression(source: string): ts.Expression | null {
   const sf = ts.createSourceFile('__ctx.ts', `(${source})`, ts.ScriptTarget.Latest, false)
   const stmt = sf.statements[0]
@@ -139,14 +173,65 @@ export function augmentInheritedPropAccesses(ir: ComponentIR): void {
   const booleanAttrProps = new Set<string>()
   const accessed = new Set<string>()
   const accessRe = new RegExp(`(?:^|[^\\w$.])${propsObj}\\.([A-Za-z_$][\\w$]*)`, 'g')
-  const scan = (s: string | undefined): void => {
+  const scan = (s: string | undefined, also?: Set<string>): void => {
     if (!s) return
-    for (const m of s.matchAll(accessRe)) accessed.add(m[1])
+    for (const m of s.matchAll(accessRe)) {
+      accessed.add(m[1])
+      also?.add(m[1])
+    }
+  }
+
+  // Coalesce-literal type pins: a read of the form `props.X ?? <literal>`
+  // (or `|| <literal>`) fixes X's type to the literal's. The Go adapter
+  // seeds a prop-derived signal/memo constructor from the synthetic field
+  // (`Count: in.Initial` where `Count int` came from evaluating
+  // `props.initial ?? 0`), so classifying `initial` with the string
+  // default produces a Go type mismatch the compiler rejects.
+  const coalesceLiteralTypes = new Map<string, 'number' | 'boolean' | 'string'>()
+  const pinCoalesceLiterals = (s: string | undefined): void => {
+    if (!s || !s.includes(propsObj)) return
+    const sf = ts.createSourceFile('__aug.ts', `(${s})`, ts.ScriptTarget.Latest, false)
+    const visit = (n: ts.Node): void => {
+      if (
+        ts.isBinaryExpression(n) &&
+        (n.operatorToken.kind === ts.SyntaxKind.QuestionQuestionToken ||
+          n.operatorToken.kind === ts.SyntaxKind.BarBarToken)
+      ) {
+        let left: ts.Expression = n.left
+        while (ts.isParenthesizedExpression(left)) left = left.expression
+        if (
+          ts.isPropertyAccessExpression(left) &&
+          ts.isIdentifier(left.expression) &&
+          left.expression.text === propsObj
+        ) {
+          const name = left.name.text
+          let right: ts.Expression = n.right
+          while (ts.isParenthesizedExpression(right)) right = right.expression
+          if (ts.isPrefixUnaryExpression(right)) right = right.operand
+          const kind = ts.isNumericLiteral(right)
+            ? 'number'
+            : right.kind === ts.SyntaxKind.TrueKeyword || right.kind === ts.SyntaxKind.FalseKeyword
+              ? 'boolean'
+              : ts.isStringLiteralLike(right)
+                ? 'string'
+                : null
+          if (kind && !coalesceLiteralTypes.has(name)) coalesceLiteralTypes.set(name, kind)
+        }
+      }
+      ts.forEachChild(n, visit)
+    }
+    visit(sf)
   }
 
   // Memos, signals, init statements, effects: any `props.X` read.
-  for (const memo of ir.metadata.memos) scan(memo.computation)
-  for (const signal of ir.metadata.signals) scan(signal.initialValue)
+  for (const memo of ir.metadata.memos) {
+    scan(memo.computation)
+    pinCoalesceLiterals(memo.computation)
+  }
+  for (const signal of ir.metadata.signals) {
+    scan(signal.initialValue)
+    pinCoalesceLiterals(signal.initialValue)
+  }
   for (const stmt of ir.metadata.initStatements ?? []) scan(stmt.body)
   for (const eff of ir.metadata.effects ?? []) scan((eff as { body?: string }).body)
 
@@ -157,12 +242,58 @@ export function augmentInheritedPropAccesses(ir: ComponentIR): void {
   for (const c of ir.metadata.localConstants ?? []) {
     if (c.isModule) continue
     scan(c.value)
+    pinCoalesceLiterals(c.value)
   }
 
   // Template attribute exprs — also note bare-ref / boolean usage.
   const walk = (node: IRNode | undefined): void => {
     if (!node) return
+    // Non-attribute expression carriers (#2126 follow-up): a `props.X`
+    // read can reach the template as a bare scalar through a dynamic
+    // text child (`<p>{props.label}</p>`), a conditional / if-statement
+    // condition (`{props.show && …}`), or a loop's array expression
+    // (`(props.items ?? []).map(…)`). With a typed props object those
+    // names are already in `propsParams`; with an untyped `props`
+    // parameter these reads were invisible to this pass, so the emitted
+    // template referenced a var the props type / ssrDefaults never
+    // declared (a strict-mode 500 on Perl-family adapters, a missing
+    // struct field on Go). Text reads keep the default `string`
+    // classification; condition / loop-array reads land in the nillable
+    // bucket (`unknown` → omittable/interface-typed) since their values
+    // are only ever truth-tested or iterated.
+    const carrier = node as unknown as { type?: string; expr?: string; condition?: string; array?: string }
+    if (carrier.type === 'expression') {
+      scan(carrier.expr)
+      pinCoalesceLiterals(carrier.expr)
+    }
+    scan(carrier.condition, bareRefProps)
+    pinCoalesceLiterals(carrier.condition)
+    scan(carrier.array, bareRefProps)
     const el = node as unknown as IRElement
+    // Component nodes carry the same AttrValue shapes under `props`
+    // (`<Child value={props.foo} />` reads `$foo` at child-props
+    // construction time in the SSR template) — but they are NOT HTML
+    // attributes: boolean-attr inference by name doesn't apply, and the
+    // value's type belongs to the child's contract, not to how this
+    // component renders it. Classify these reads as nillable (`unknown`)
+    // unless a `?? <literal>` pins a concrete type.
+    for (const prop of (node as unknown as { props?: IRElement['attrs'] }).props ?? []) {
+      const v = prop.value as { kind?: string; expr?: string; parts?: Array<{ type: string } & Record<string, string>> }
+      if (v?.parts) {
+        for (const part of v.parts) {
+          if (part.type === 'string') scan(part.value)
+          else if (part.type === 'ternary') {
+            scan(part.condition)
+            scan(part.whenTrue)
+            scan(part.whenFalse)
+          } else if (part.type === 'lookup') scan(part.key)
+        }
+      }
+      if (v?.kind === 'expression' && typeof v.expr === 'string') {
+        scan(v.expr, bareRefProps)
+        pinCoalesceLiterals(v.expr)
+      }
+    }
     for (const attr of el.attrs ?? []) {
       const v = attr.value as {
         kind?: string
@@ -231,14 +362,13 @@ export function augmentInheritedPropAccesses(ir: ComponentIR): void {
     if (existing.has(name)) continue
     let raw: string
     if (booleanAttrProps.has(name)) raw = 'boolean'
+    else if (coalesceLiteralTypes.has(name)) raw = coalesceLiteralTypes.get(name)!
     else if (bareRefProps.has(name)) raw = 'unknown' // → interface{} (nillable, omittable)
     else raw = 'string' // read in a memo / string context (e.g. className)
     const type: TypeInfo =
-      raw === 'boolean'
-        ? { kind: 'primitive', raw: 'boolean', primitive: 'boolean' }
-        : raw === 'string'
-          ? { kind: 'primitive', raw: 'string', primitive: 'string' }
-          : { kind: 'unknown', raw: 'unknown' }
+      raw === 'unknown'
+        ? { kind: 'unknown', raw: 'unknown' }
+        : { kind: 'primitive', raw, primitive: raw as 'string' | 'number' | 'boolean' }
     ir.metadata.propsParams.push({ name, type, optional: true })
     existing.add(name)
   }

package/src/compiler.ts

@@ -276,6 +276,7 @@ function compileMultipleComponents(
         path: dir + output.componentName + adapter.extension,
         content: output.rawTemplate,
         type: 'markedTemplate',
+        componentName: output.componentName,
       })
       // SSR defaults, paired with the per-component template file via
       // the matching basename (the build pipeline pairs them in
@@ -287,6 +288,7 @@ function compileMultipleComponents(
           path: dir + output.componentName + '.ssr-defaults.json',
           content: JSON.stringify(ssrDefaults),
           type: 'ssrDefaults',
+          componentName: output.componentName,
         })
       }
     }
@@ -672,6 +674,7 @@ export function compileJSX(
     path: filePath.replace(/\.tsx?$/, adapter.extension),
     content,
     type: 'markedTemplate',
+    componentName: componentIR.metadata.componentName,
   })
 
   // SSR defaults — JSON-encoded seed values for the template's
@@ -686,6 +689,7 @@ export function compileJSX(
         path: filePath.replace(/\.tsx?$/, '.ssr-defaults.json'),
         content: JSON.stringify(ssrDefaults),
         type: 'ssrDefaults',
+        componentName: componentIR.metadata.componentName,
       })
     }
   }