@barefootjs/go-template 0.7.0 → 0.9.0

package/src/adapter/go-template-adapter.ts

@@ -58,6 +58,10 @@ import {
   emitParsedExpr,
   emitIRNode,
   emitAttrValue,
+  augmentInheritedPropAccesses,
+  parseRecordIndexAccess,
+  collectContextConsumers,
+  type ContextConsumer,
 } from '@barefootjs/jsx'
 import { findInterpolationEnd } from '@barefootjs/jsx/scanner'
 
@@ -100,6 +104,24 @@ interface StaticChildInstance {
    *  through the parent's `{{.Children}}` read; those cases stay on
    *  the existing drop path. */
   childrenHtml: string | null
+  /**
+   * Context values from enclosing `<Ctx.Provider value>` ancestors
+   * (`createContext` identifier → Go value literal), wired into this child
+   * slot's input against its own context-consumer fields. Empty/undefined when
+   * the child isn't under any provider. (#1297)
+   */
+  contextBindings?: ReadonlyMap<string, string>
+}
+
+/**
+ * Cross-component shape of a child component the parent renders (#checkbox).
+ * `paramNames` are the child's declared `propsParams`; `restBagField` is the
+ * Go field name of the child's open-ended rest bag (`Capitalize(restPropsName)`),
+ * or null when the child has no `...props` rest spread.
+ */
+interface ChildComponentShape {
+  paramNames: Set<string>
+  restBagField: string | null
 }
 
 /**
@@ -419,6 +441,24 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
    *  `template.HTML(...)`; toggles the `"html/template"` import. */
   private usesHtmlTemplate: boolean = false
 
+  /** Set during type generation when any emit references
+   *  `fmt.Sprint(...)` — e.g. a `Record<staticKeys, scalar>[propKey]`
+   *  indexed-map spread value (#checkbox); toggles the `"fmt"` import. */
+  private usesFmt: boolean = false
+
+  /**
+   * Cross-component child shapes (#checkbox), keyed by child component name.
+   * Populated out-of-band via `registerChildComponentShape` before the parent
+   * component's `generateTypes` runs, so the static-child-init codegen can
+   * route an attribute that is NOT a declared param of the child
+   * (`<CheckIcon data-slot=.../>`) into the child's rest bag
+   * (`Capitalize(restPropsName)` map field) instead of emitting an invalid
+   * hyphenated top-level field (`Data-slot:`). A child with no rest bag and
+   * an unknown attr is left as-is so the existing field path / Go compile
+   * error still surfaces.
+   */
+  private childComponentShapes: Map<string, ChildComponentShape> = new Map()
+
   /**
    * Module-scope pure string-literal constants (`const X = 'literal'` at
    * file top-level), keyed by name → resolved literal value. Populated at
@@ -434,6 +474,40 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
    */
   private moduleStringConsts: Map<string, string> = new Map()
 
+  /**
+   * All local constants (module + function-scope) from the IR, retained for
+   * the lifetime of `generate()` so the memo-computation path can resolve
+   * `Record`-index lookups (`variantClasses[variant]`) without re-threading the
+   * full `ir` through every helper. Reset at `generate()` entry.
+   */
+  private localConstants: IRMetadata['localConstants'] = []
+
+  /**
+   * `useContext(...)` consumers in the component being generated. Each becomes
+   * a struct field defaulted to the `createContext` default, which an enclosing
+   * `<Ctx.Provider value>` overwrites for descendant child slots. Reset at
+   * `generate()` / `generateTypes()` entry. (#1297)
+   */
+  private contextConsumers: ContextConsumer[] = []
+
+  /** Child component name → the contexts it consumes (cross-component, for provider wiring). */
+  private childContextConsumers: Map<string, ContextConsumer[]> = new Map()
+
+  /**
+   * Set of prop NAMES whose resolved Go struct-field type is exactly
+   * `interface{}` — i.e. nillable. Populated at `generate()` entry from
+   * the SAME per-prop Go-type computation `generatePropsStruct` /
+   * `generateInputStruct` use (`propTypeOverrides` + `typeInfoToGo`), so
+   * it can't drift from the actual field types. Used by
+   * `elementAttrEmitter.emitExpression` to omit a dynamic attribute whose
+   * value is a bare reference to a nillable prop when that prop is nil
+   * (Hono-style nullish-attribute omission: an `undefined`-valued
+   * attribute is dropped rather than rendered as `attr=""`). Concrete
+   * (`string`/`int`/`bool`) fields are never in this set and always emit
+   * unconditionally, matching Hono's `value=""` / `data-count="0"`.
+   */
+  private nillablePropNames: Set<string> = new Set()
+
   constructor(options: GoTemplateAdapterOptions = {}) {
     super()
     this.options = {
@@ -455,6 +529,14 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     this.propsObjectName = ir.metadata.propsObjectName
     this.restPropsName = ir.metadata.restPropsName ?? null
     this.moduleStringConsts = this.collectModuleStringConsts(ir.metadata.localConstants)
+    this.localConstants = ir.metadata.localConstants ?? []
+    this.contextConsumers = collectContextConsumers(ir.metadata)
+    // (#checkbox) Enumerate inherited-attribute accesses (props-object pattern)
+    // before computing the nillable set / rendering, so the synthetic params
+    // participate in attribute omission and field binding uniformly. Shared
+    // with the Mojo adapter (single source of truth in `@barefootjs/jsx`).
+    augmentInheritedPropAccesses(ir)
+    this.nillablePropNames = this.collectNillablePropNames(ir)
 
     // Surface loop-body usages of components imported from sibling
     // .tsx files. The adapter emits `{{template "X" .}}` for these,
@@ -746,8 +828,70 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     return `{{if .Scripts}}${registrations.join('')}{{end}}\n`
   }
 
+  /**
+   * Register a child component's shape (#checkbox) so a parent's
+   * static-child-init codegen can route non-param attributes into the child's
+   * rest bag rather than emitting an invalid hyphenated top-level field. Call
+   * once per known child IR (siblings in the same source, auto-inferred
+   * `../<name>` imports) before generating the parent's types. Idempotent.
+   */
+  registerChildComponentShape(ir: ComponentIR): void {
+    const name = ir.metadata.componentName
+    if (!name) return
+    const paramNames = new Set((ir.metadata.propsParams ?? []).map(p => p.name))
+    const restPropsName = ir.metadata.restPropsName ?? null
+    const restBagField = restPropsName ? this.capitalizeFieldName(restPropsName) : null
+    this.childComponentShapes.set(name, { paramNames, restBagField })
+    // Record the contexts this child consumes so a parent wrapping it in
+    // `<Ctx.Provider value>` can set the matching field on the child's slot input.
+    this.childContextConsumers.set(name, collectContextConsumers(ir.metadata))
+  }
+
+  /** Go field name for a `useContext` consumer (the capitalized local binding). */
+  private contextFieldName(c: ContextConsumer): string {
+    return this.capitalizeFieldName(c.localName)
+  }
+
+  /** Go type for a context-consumer field, from its `createContext` default's type. */
+  private contextConsumerGoType(c: ContextConsumer): string {
+    if (typeof c.defaultValue === 'number') return 'int'
+    if (typeof c.defaultValue === 'boolean') return 'bool'
+    return 'string'
+  }
+
+  /** Go literal for a context-consumer's default value (the `createContext` arg). */
+  private contextConsumerGoDefault(c: ContextConsumer): string {
+    if (typeof c.defaultValue === 'number') return String(c.defaultValue)
+    if (typeof c.defaultValue === 'boolean') return String(c.defaultValue)
+    if (typeof c.defaultValue === 'string') return `"${this.escapeGoString(c.defaultValue)}"`
+    return '""'
+  }
+
+  /**
+   * Context-consumer fields that don't collide with an already-emitted prop /
+   * signal / memo field. The template reads them as `{{.Field}}` (the local
+   * `useContext` binding lowered to a root field); the struct must carry them.
+   */
+  private nonCollidingContextConsumers(taken: ReadonlySet<string>): ContextConsumer[] {
+    return this.contextConsumers.filter(c => !taken.has(this.contextFieldName(c)))
+  }
+
   generateTypes(ir: ComponentIR): string | null {
     this.usesHtmlTemplate = false
+    this.usesFmt = false
+    // (#checkbox) Mirror `generate()`: enumerate inherited-attribute accesses
+    // so the Input/Props structs expose `ClassName`/`ID`/`Disabled` fields the
+    // template + caller bind against. `generateTypes` runs on a separately
+    // round-tripped IR, so this must be applied here too; the method is
+    // idempotent. `propsObjectName` is needed by the scan.
+    this.propsObjectName = ir.metadata.propsObjectName
+    augmentInheritedPropAccesses(ir)
+    // Mirror `generate()`: the `NewXxxProps` initializer computes memo SSR
+    // values, which inline module string consts and resolve `Record`-index
+    // lookups — both need the const tables populated on this standalone entry.
+    this.moduleStringConsts = this.collectModuleStringConsts(ir.metadata.localConstants)
+    this.localConstants = ir.metadata.localConstants ?? []
+    this.contextConsumers = collectContextConsumers(ir.metadata)
     const lines: string[] = []
 
     const componentName = ir.metadata.componentName
@@ -840,6 +984,9 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     header.push(`package ${this.options.packageName}`)
     header.push('')
     header.push('import (')
+    // Go's import block is conventionally sorted; emit in lexical order
+    // (`fmt` < `html/template` < `math/rand`).
+    if (this.usesFmt) header.push('\t"fmt"')
     if (this.usesHtmlTemplate) header.push('\t"html/template"')
     header.push('\t"math/rand"')
     header.push('')
@@ -1065,6 +1212,40 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     return overrides
   }
 
+  /**
+   * Resolve a prop param's Go struct-field type using the SAME logic
+   * `generatePropsStruct` / `generateInputStruct` use for the field
+   * declaration: a `propTypeOverrides` entry (signal-inferred override)
+   * wins, otherwise `typeInfoToGo(param.type, param.defaultValue)`.
+   * Factored out so the nillable-field set (`collectNillablePropNames`)
+   * can't drift from the actual emitted field types.
+   */
+  private resolvePropGoType(
+    param: IRMetadata['propsParams'][number],
+    propTypeOverrides: Map<string, string>,
+  ): string {
+    return propTypeOverrides.get(param.name) ?? this.typeInfoToGo(param.type, param.defaultValue)
+  }
+
+  /**
+   * Build the set of prop NAMES whose resolved Go field type is exactly
+   * `interface{}` (nillable). Uses the same `propTypeOverrides` +
+   * `resolvePropGoType` pipeline as the struct generators, so a prop
+   * that ends up `interface{}` on the Props struct — and only such a
+   * prop — is treated as nillable for Hono-style attribute omission.
+   * Concrete (`string`/`int`/`bool`/`[]T`/struct) types are excluded.
+   */
+  private collectNillablePropNames(ir: ComponentIR): Set<string> {
+    const propTypeOverrides = this.buildPropTypeOverrides(ir)
+    const nillable = new Set<string>()
+    for (const param of ir.metadata.propsParams) {
+      if (this.resolvePropGoType(param, propTypeOverrides) === 'interface{}') {
+        nillable.add(param.name)
+      }
+    }
+    return nillable
+  }
+
   /**
    * Generate Input struct for a component
    */
@@ -1096,7 +1277,7 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     for (const param of ir.metadata.propsParams) {
       const fieldName = this.capitalizeFieldName(param.name)
       if (nestedArrayFields.has(fieldName)) continue
-      const goType = propTypeOverrides.get(param.name) ?? this.typeInfoToGo(param.type, param.defaultValue)
+      const goType = this.resolvePropGoType(param, propTypeOverrides)
       lines.push(`\t${fieldName} ${goType}`)
     }
 
@@ -1105,6 +1286,13 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
       lines.push(`\t${nested.name}s []${nested.name}Input`)
     }
 
+    // `useContext` consumer fields — settable by an enclosing provider on the
+    // parent's side; default applied in NewXxxProps.
+    const takenInput = new Set(ir.metadata.propsParams.map(p => this.capitalizeFieldName(p.name)))
+    for (const c of this.nonCollidingContextConsumers(takenInput)) {
+      lines.push(`\t${this.contextFieldName(c)} ${this.contextConsumerGoType(c)}`)
+    }
+
     // (#1407 follow-up) Input-side bag field for restPropsName spreads.
     // The destructured-rest pattern
     // (`function({a, ...rest}: P) { <el {...rest}/> }`) surfaces
@@ -1169,7 +1357,7 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
       const fieldName = this.capitalizeFieldName(param.name)
       // Skip if this field will be replaced by a typed array for nested components
       if (nestedArrayFields.has(fieldName)) continue
-      const goType = propTypeOverrides.get(param.name) ?? this.typeInfoToGo(param.type, param.defaultValue)
+      const goType = this.resolvePropGoType(param, propTypeOverrides)
       const jsonTag = this.toJsonTag(param.name)
       lines.push(`\t${fieldName} ${goType} \`json:"${jsonTag}"\``)
       propFieldNames.add(fieldName)
@@ -1237,6 +1425,18 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
       lines.push(`\t${fieldName} ${goType} \`json:"${jsonTag}"\``)
     }
 
+    // `useContext` consumer fields (skip names already taken by a prop /
+    // signal / memo field).
+    const takenProps = new Set<string>([
+      ...ir.metadata.propsParams.map(p => this.capitalizeFieldName(p.name)),
+      ...ir.metadata.signals.map(s => this.capitalizeFieldName(s.getter)),
+      ...ir.metadata.memos.map(m => this.capitalizeFieldName(m.name)),
+    ])
+    for (const c of this.nonCollidingContextConsumers(takenProps)) {
+      const jsonTag = this.toJsonTag(c.localName)
+      lines.push(`\t${this.contextFieldName(c)} ${this.contextConsumerGoType(c)} \`json:"${jsonTag}"\``)
+    }
+
     // Add array fields for nested components (for template rendering)
     for (const nested of nestedComponents) {
       if (nested.isDynamic && !nested.isPropDerived) {
@@ -1416,12 +1616,34 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     }
 
     // Add memo initial values (computed from signal initial values)
+    const memoPropsParamMap = new Map(ir.metadata.propsParams.map(p => [p.name, p]))
     for (const memo of ir.metadata.memos) {
       const fieldName = this.capitalizeFieldName(memo.name)
-      const memoValue = this.computeMemoInitialValue(memo, ir.metadata.signals, ir.metadata.propsParams, propFallbackVars)
+      // (#checkbox) Pass the memo's inferred Go type so an unresolved
+      // computation falls back to that type's zero value (`false` for a
+      // boolean memo like `isChecked`), not the int `0`.
+      const goType = this.inferMemoType(memo, ir.metadata.signals, memoPropsParamMap)
+      const memoValue = this.computeMemoInitialValue(memo, ir.metadata.signals, ir.metadata.propsParams, propFallbackVars, goType)
       lines.push(`\t\t${fieldName}: ${memoValue},`)
     }
 
+    // `useContext` consumer fields: default to the `createContext` default
+    // when the caller (a provider) didn't set them.
+    const takenInit = new Set<string>([
+      ...ir.metadata.propsParams.map(p => this.capitalizeFieldName(p.name)),
+      ...ir.metadata.signals.map(s => this.capitalizeFieldName(s.getter)),
+      ...ir.metadata.memos.map(m => this.capitalizeFieldName(m.name)),
+    ])
+    for (const c of this.nonCollidingContextConsumers(takenInit)) {
+      const field = this.contextFieldName(c)
+      const def = this.contextConsumerGoDefault(c)
+      const defaulted =
+        c.defaultValue === null || def === '""' || def === '0' || def === 'false'
+          ? `in.${field}`
+          : this.applyGoFallback(`in.${field}`, def)
+      lines.push(`\t\t${field}: ${defaulted},`)
+    }
+
     // Add static child component instances
     const staticChildren = this.collectStaticChildInstances(ir.root)
     for (const child of staticChildren) {
@@ -1431,15 +1653,49 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
       // own NewProps (BfParent/BfMount fields).
       lines.push(`\t\t\tBfParent: scopeID,`)
       lines.push(`\t\t\tBfMount: "${child.slotId}",`)
+      // SSR context propagation: if this child is wrapped in a `<Ctx.Provider
+      // value>` it consumes, set its context-consumer field to the provider
+      // value (else the child's own NewProps applies the `createContext`
+      // default). (#1297)
+      if (child.contextBindings) {
+        for (const consumer of this.childContextConsumers.get(child.name) ?? []) {
+          const goVal = child.contextBindings.get(consumer.contextName)
+          if (goVal !== undefined) {
+            lines.push(`\t\t\t${this.contextFieldName(consumer)}: ${goVal},`)
+          }
+        }
+      }
+      // (#checkbox) Cross-component shape lookup: an attribute that is NOT a
+      // declared param of the child but the child has a `...props` rest bag
+      // (`<CheckIcon data-slot=.../>`, where CheckIcon's params are
+      // `size`/`className` and the rest binding is `props`) must be routed
+      // into the child's rest-bag map field — emitting `Data-slot:` as a
+      // top-level Go field is a syntax error (hyphen). `restBagEntries`
+      // collects `"jsx-attr-name": goValue` pairs for that map.
+      const childShape = this.childComponentShapes.get(child.name)
+      const restBagEntries: string[] = []
+      // Emit a child input field, OR collect it as a rest-bag entry when the
+      // attr isn't a declared child param and a rest bag exists.
+      const emitChildField = (jsxName: string, goValue: string): void => {
+        if (
+          childShape &&
+          childShape.restBagField &&
+          !childShape.paramNames.has(jsxName)
+        ) {
+          restBagEntries.push(`${JSON.stringify(jsxName)}: ${goValue}`)
+          return
+        }
+        lines.push(`\t\t\t${this.capitalizeFieldName(jsxName)}: ${goValue},`)
+      }
       // Add prop values
       for (const prop of child.props) {
         switch (prop.value.kind) {
           case 'literal':
-            lines.push(`\t\t\t${this.capitalizeFieldName(prop.name)}: ${this.goLiteral(prop.value.value)},`)
+            emitChildField(prop.name, this.goLiteral(prop.value.value))
             break
           case 'boolean-shorthand':
           case 'boolean-attr':
-            lines.push(`\t\t\t${this.capitalizeFieldName(prop.name)}: true,`)
+            emitChildField(prop.name, 'true')
             break
           case 'expression':
           case 'spread':
@@ -1458,7 +1714,7 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
               const goExpr = this.templatePartsToGoCode(parts, ir.metadata.propsParams)
               if (goExpr !== null) {
                 // Parts path succeeded — emit and move on.
-                lines.push(`\t\t\t${this.capitalizeFieldName(prop.name)}: ${goExpr},`)
+                emitChildField(prop.name, goExpr)
                 break
               }
               // Parts exist but templatePartsToGoCode opted out (unsupported
@@ -1476,7 +1732,7 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
               ir.metadata.propsParams
             )
             if (resolvedValue !== null) {
-              lines.push(`\t\t\t${this.capitalizeFieldName(prop.name)}: ${resolvedValue},`)
+              emitChildField(prop.name, resolvedValue)
             }
             break
           }
@@ -1485,6 +1741,14 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
             break
         }
       }
+      // (#checkbox) Emit the collected rest-bag entries as the child's
+      // open-ended bag field (`Props: map[string]any{...}`), matching how the
+      // child's `NewXxxProps` maps `in.Props` onto its `Spread_<N>` field.
+      if (childShape?.restBagField && restBagEntries.length > 0) {
+        lines.push(
+          `\t\t\t${childShape.restBagField}: map[string]any{${restBagEntries.join(', ')}},`,
+        )
+      }
       // Pass through JSX children as the child slot's `Children` input.
       // Two paths:
       //   1. Plain text (`<Button>+1</Button>`) → quote with JSON.stringify
@@ -1596,7 +1860,7 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
    */
   private collectStaticChildInstances(node: IRNode): Array<StaticChildInstance> {
     const result: StaticChildInstance[] = []
-    this.collectStaticChildInstancesRecursive(node, result, false)
+    this.collectStaticChildInstancesRecursive(node, result, false, new Map())
     return result
   }
 
@@ -1637,7 +1901,8 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
   private collectStaticChildInstancesRecursive(
     node: IRNode,
     result: StaticChildInstance[],
-    inLoop: boolean
+    inLoop: boolean,
+    providerCtx: ReadonlyMap<string, string>,
   ): void {
     if (node.type === 'component') {
       const comp = node as IRComponent
@@ -1647,7 +1912,7 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
       // child components nested inside still get their slot fields.
       if (comp.dynamicTag) {
         for (const child of comp.children) {
-          this.collectStaticChildInstancesRecursive(child, result, inLoop)
+          this.collectStaticChildInstancesRecursive(child, result, inLoop, providerCtx)
         }
         return
       }
@@ -1662,57 +1927,79 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
           fieldName: `${comp.name}${suffix}`,
           childrenText: this.extractTextChildren(comp.children),
           childrenHtml: this.extractHtmlChildren(comp.children),
+          contextBindings: providerCtx.size > 0 ? providerCtx : undefined,
         })
       }
       // Recurse into Portal's children to find nested components
       if (comp.name === 'Portal' && comp.children) {
         for (const child of comp.children) {
-          this.collectStaticChildInstancesRecursive(child, result, inLoop)
+          this.collectStaticChildInstancesRecursive(child, result, inLoop, providerCtx)
         }
       }
     } else if (node.type === 'loop') {
       const loop = node as IRLoop
       // Mark children as inside loop
       for (const child of loop.children) {
-        this.collectStaticChildInstancesRecursive(child, result, true)
+        this.collectStaticChildInstancesRecursive(child, result, true, providerCtx)
       }
     } else if (node.type === 'element') {
       const element = node as IRElement
       for (const child of element.children) {
-        this.collectStaticChildInstancesRecursive(child, result, inLoop)
+        this.collectStaticChildInstancesRecursive(child, result, inLoop, providerCtx)
       }
     } else if (node.type === 'fragment') {
       const fragment = node as IRFragment
       for (const child of fragment.children) {
-        this.collectStaticChildInstancesRecursive(child, result, inLoop)
+        this.collectStaticChildInstancesRecursive(child, result, inLoop, providerCtx)
       }
     } else if (node.type === 'conditional') {
       const cond = node as IRConditional
-      this.collectStaticChildInstancesRecursive(cond.whenTrue, result, inLoop)
+      this.collectStaticChildInstancesRecursive(cond.whenTrue, result, inLoop, providerCtx)
       if (cond.whenFalse) {
-        this.collectStaticChildInstancesRecursive(cond.whenFalse, result, inLoop)
+        this.collectStaticChildInstancesRecursive(cond.whenFalse, result, inLoop, providerCtx)
       }
     } else if (node.type === 'provider') {
-      // Provider is a transparent wrapper at the SSR layer — context
-      // propagation is purely a client-runtime concern. Recurse into
-      // its children so any static <Child/> nested under <Ctx.Provider>
-      // still gets a slot field generated on the parent's props type.
+      // SSR context propagation: record the provider's value against its
+      // context name and extend the active binding map for descendants. A
+      // literal value lowers to a Go literal; a non-literal is left unbound
+      // (the consumer keeps its default). (#1297)
       const p = node as IRProvider
+      const childCtx = this.extendProviderContext(providerCtx, p)
       for (const child of p.children) {
-        this.collectStaticChildInstancesRecursive(child, result, inLoop)
+        this.collectStaticChildInstancesRecursive(child, result, inLoop, childCtx)
       }
     } else if (node.type === 'async') {
       // Async fallback + children render server-side via the OOS
       // protocol; static child components inside them still need slot
       // fields on the parent struct.
       const a = node as IRAsync
-      this.collectStaticChildInstancesRecursive(a.fallback, result, inLoop)
+      this.collectStaticChildInstancesRecursive(a.fallback, result, inLoop, providerCtx)
       for (const child of a.children) {
-        this.collectStaticChildInstancesRecursive(child, result, inLoop)
+        this.collectStaticChildInstancesRecursive(child, result, inLoop, providerCtx)
       }
     }
   }
 
+  /**
+   * Extend the active provider-context map with one `<Ctx.Provider value>`. A
+   * string/number/boolean literal value is lowered to a Go literal; any other
+   * shape is skipped (the descendant consumer keeps its `createContext` default).
+   */
+  private extendProviderContext(
+    current: ReadonlyMap<string, string>,
+    p: IRProvider,
+  ): ReadonlyMap<string, string> {
+    const v = p.valueProp?.value as { kind?: string; value?: unknown } | undefined
+    if (!v || v.kind !== 'literal') return current
+    let goLit: string | null = null
+    if (typeof v.value === 'string') goLit = `"${this.escapeGoString(v.value)}"`
+    else if (typeof v.value === 'number' || typeof v.value === 'boolean') goLit = String(v.value)
+    if (goLit === null) return current
+    const next = new Map(current)
+    next.set(p.contextName, goLit)
+    return next
+  }
+
   /**
    * Collect top-level (non-loop) JSX intrinsic-element spread slots
    * from the IR (#1407). Loop-internal spreads are skipped — they
@@ -1922,6 +2209,15 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     ir: ComponentIR,
   ): string | null {
     const trimmed = spreadExpr.trim()
+    // Conditional inline-object spread:
+    //   `{...(COND ? { 'k': v } : {})}` (either branch possibly `{}`).
+    // Lower to an immediately-invoked func literal that conditionally
+    // builds the bag, so the falsy branch yields an empty map (the key
+    // is OMITTED rather than rendered as `k=""` — `SpreadAttrs` does
+    // NOT filter empty strings). Returns null for any shape it can't
+    // faithfully convert so the caller falls back to BF101 (#textarea).
+    const conditional = this.buildConditionalSpreadInitializer(trimmed, ir)
+    if (conditional !== undefined) return conditional
     // Signal-getter call: `attrs()` — pluck the signal's initialValue
     // and translate the JS object literal to a Go map literal.
     const callMatch = /^([a-zA-Z_][a-zA-Z0-9_]*)\s*\(\s*\)$/.exec(trimmed)
@@ -1970,10 +2266,219 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
       if (ir.metadata.restPropsName === trimmed) {
         return `in.${this.capitalizeFieldName(trimmed)}`
       }
+      // 4. Function-scope local const holding a conditional inline-object
+      //    spread: `const sizeAttrs = size ? {…} : {}` then `{...sizeAttrs}`
+      //    (#checkbox / icon). Resolve the identifier to its initializer
+      //    text and route through the conditional-spread lowering. Only
+      //    function-scope (`!isModule`) consts qualify — a module const is
+      //    a different shape, and the resolved initializer must itself be a
+      //    conditional-of-object-literals (else `buildConditionalSpreadInitializer`
+      //    returns undefined and we fall through to BF101). Guard against a
+      //    const that resolves to another bare identifier (loop / non-literal).
+      const localConst = (ir.metadata.localConstants ?? []).find(
+        c => c.name === trimmed && !c.isModule,
+      )
+      if (localConst?.value !== undefined) {
+        const initTrimmed = localConst.value.trim()
+        // Reject a const resolving to a bare identifier to avoid an
+        // unbounded resolution loop / non-literal forwarding.
+        if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(initTrimmed)) {
+          const resolved = this.buildConditionalSpreadInitializer(initTrimmed, ir)
+          // `undefined` → not a conditional-spread shape; fall through to
+          // BF101. `null` → that shape but unconvertible; also BF101.
+          if (resolved) return resolved
+          if (resolved === null) return null
+        }
+      }
     }
     return null
   }
 
+  /**
+   * Lower a conditional inline-object spread bag value:
+   *   `(COND ? { 'aria-describedby': describedBy } : {})`
+   * into an immediately-invoked Go func literal that conditionally
+   * builds the map (so the falsy branch OMITS the key rather than
+   * rendering it as an empty string, which `SpreadAttrs` does not
+   * filter):
+   *
+   *   func() map[string]any {
+   *     if in.DescribedBy != nil && in.DescribedBy != "" {
+   *       return map[string]any{"aria-describedby": in.DescribedBy}
+   *     }
+   *     return map[string]any{}
+   *   }()
+   *
+   * Returns:
+   *   - `undefined` when the expression is NOT a parenthesized ternary
+   *     of object literals — the caller falls through to other shapes.
+   *   - `null` when it IS that shape but a part can't be faithfully
+   *     converted (non-static key, unsupported condition, …) — the
+   *     caller raises BF101.
+   *   - the Go IIFE string when fully convertible.
+   */
+  private buildConditionalSpreadInitializer(
+    spreadExpr: string,
+    ir: ComponentIR,
+  ): string | null | undefined {
+    const expr = this.parseLiteralExpression(spreadExpr)
+    if (!expr || !ts.isConditionalExpression(expr)) return undefined
+    const whenTrue = this.unwrapParens(expr.whenTrue)
+    const whenFalse = this.unwrapParens(expr.whenFalse)
+    if (!ts.isObjectLiteralExpression(whenTrue) || !ts.isObjectLiteralExpression(whenFalse)) {
+      return undefined
+    }
+    // Condition → Go bool against `in.`, type-aware on the prop.
+    const goCond = this.conditionToGoBool(expr.condition, ir)
+    if (goCond === null) return null
+    const trueMap = this.objectLiteralToGoSpreadMap(whenTrue, ir)
+    const falseMap = this.objectLiteralToGoSpreadMap(whenFalse, ir)
+    if (trueMap === null || falseMap === null) return null
+    return (
+      `func() map[string]any {\n` +
+      `\t\tif ${goCond} {\n` +
+      `\t\t\treturn ${trueMap}\n` +
+      `\t\t}\n` +
+      `\t\treturn ${falseMap}\n` +
+      `\t}()`
+    )
+  }
+
+  /** Strip redundant parenthesised wrappers off a TS expression. */
+  private unwrapParens(node: ts.Expression): ts.Expression {
+    let e = node
+    while (ts.isParenthesizedExpression(e)) e = e.expression
+    return e
+  }
+
+  /**
+   * Convert a conditional-spread condition expression to a Go bool in
+   * the `in.` context. Supports a bare prop identifier (`describedBy`)
+   * and its negation (`!describedBy`), type-aware on the prop:
+   *   string  → `in.X != ""`
+   *   boolean → `in.X`
+   *   number  → `in.X != 0`
+   *   unknown / interface{} → `in.X != nil && in.X != ""`
+   *     (faithful JS string-truthiness for an interface holding a
+   *     string — textarea's `describedBy` resolves to interface{}).
+   * Returns null for any other shape (caller → BF101).
+   */
+  private conditionToGoBool(
+    condition: ts.Expression,
+    ir: ComponentIR,
+  ): string | null {
+    let node = this.unwrapParens(condition)
+    let negate = false
+    if (ts.isPrefixUnaryExpression(node) && node.operator === ts.SyntaxKind.ExclamationToken) {
+      negate = true
+      node = this.unwrapParens(node.operand)
+    }
+    if (!ts.isIdentifier(node)) return null
+    const param = ir.metadata.propsParams.find(p => p.name === node.text)
+    if (!param) return null
+    const field = `in.${this.capitalizeFieldName(param.name)}`
+    const prim = param.type.kind === 'primitive' ? param.type.primitive : undefined
+    let truthy: string
+    if (prim === 'boolean') {
+      truthy = field
+    } else if (prim === 'number') {
+      truthy = `${field} != 0`
+    } else if (prim === 'string') {
+      truthy = `${field} != ""`
+    } else {
+      // unknown / interface{}: the runtime value may be a string, number,
+      // bool, etc., so a string-biased `!= ""` test would diverge from JS
+      // truthiness (e.g. an `interface{}` holding `0` or `false` is falsy in
+      // JS but `!= ""` reads true). Route through `bf.Truthy`, the exported
+      // `Boolean(x)` equivalent, for a faithful check (Copilot review #1752).
+      truthy = `bf.Truthy(${field})`
+    }
+    if (!negate) return truthy
+    // Negation: wrap so `!` applies to the whole truthiness test.
+    if (prim === 'boolean') return `!${field}`
+    if (prim === 'number') return `${field} == 0`
+    if (prim === 'string') return `${field} == ""`
+    return `!bf.Truthy(${field})`
+  }
+
+  /**
+   * Convert a static object literal (`{ 'aria-describedby': describedBy }`)
+   * into a Go `map[string]any{...}` literal for a conditional spread.
+   * Only static string/identifier keys are allowed; values resolve
+   * prop-identifier references to `in.FieldName` and string literals to
+   * Go string literals. Returns null for any computed/spread/dynamic
+   * key or unsupported value (caller → BF101). Empty object → `map[string]any{}`.
+   */
+  private objectLiteralToGoSpreadMap(
+    obj: ts.ObjectLiteralExpression,
+    ir: ComponentIR,
+  ): string | null {
+    const entries: string[] = []
+    for (const prop of obj.properties) {
+      if (!ts.isPropertyAssignment(prop)) return null
+      let key: string
+      if (ts.isIdentifier(prop.name)) {
+        key = prop.name.text
+      } else if (ts.isStringLiteral(prop.name) || ts.isNoSubstitutionTemplateLiteral(prop.name)) {
+        key = prop.name.text
+      } else {
+        return null
+      }
+      const val = this.unwrapParens(prop.initializer)
+      let goVal: string
+      if (ts.isStringLiteral(val) || ts.isNoSubstitutionTemplateLiteral(val)) {
+        goVal = JSON.stringify(val.text)
+      } else if (ts.isIdentifier(val)) {
+        const param = ir.metadata.propsParams.find(p => p.name === val.text)
+        if (!param) return null
+        goVal = `in.${this.capitalizeFieldName(param.name)}`
+      } else {
+        const indexed = this.recordIndexAccessToGoMap(val, ir)
+        if (indexed === null) return null
+        goVal = indexed
+      }
+      entries.push(`${JSON.stringify(key)}: ${goVal}`)
+    }
+    return `map[string]any{${entries.join(', ')}}`
+  }
+
+  /**
+   * Lower a spread-object VALUE of the form `IDENT[KEY]` where:
+   *   - `IDENT` resolves via `localConstants` to a MODULE-scope object
+   *     literal whose property values are all scalar (number/string)
+   *     literals under static (string-literal or identifier) keys
+   *     (a `Record<staticKeys, scalar>` map like `sizeMap`), AND
+   *   - `KEY` is a bare identifier that is a prop.
+   * Emits an inline indexed Go map:
+   *   `map[string]any{"sm": 16, ...}[fmt.Sprint(in.Size)]`
+   * (`fmt.Sprint` coerces the `interface{}`/typed prop to the map's
+   * string key space — sets `usesFmt` so the `"fmt"` import is added).
+   *
+   * Returns the Go string when convertible, else `null` (caller → BF101)
+   * for any non-scalar value, non-static key, or non-prop index so
+   * unrelated shapes don't regress. (#checkbox / icon `sizeMap[size]`.)
+   */
+  private recordIndexAccessToGoMap(
+    val: ts.Expression,
+    ir: ComponentIR,
+  ): string | null {
+    // Shared structural parse (single source of truth in `@barefootjs/jsx`);
+    // this wrapper only does the Go-specific emit from the structured result.
+    const parsed = parseRecordIndexAccess(
+      val,
+      ir.metadata.localConstants ?? [],
+      ir.metadata.propsParams,
+    )
+    if (!parsed) return null
+    const entries = parsed.entries.map(e => {
+      const mapVal = e.value.kind === 'number' ? e.value.text : JSON.stringify(e.value.text)
+      return `${JSON.stringify(e.key)}: ${mapVal}`
+    })
+    this.usesFmt = true
+    const field = `in.${this.capitalizeFieldName(parsed.indexPropName)}`
+    return `map[string]any{${entries.join(', ')}}[fmt.Sprint(${field})]`
+  }
+
   /**
    * Convert JavaScript initial value to Go value for NewXxxProps function.
    * References to props params are converted to in.FieldName format.
@@ -2383,11 +2888,232 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
    * referenced prop, substitute it for `in.FieldName` so the memo
    * inherits the signal-time `??` fallback.
    */
+  /**
+   * (#checkbox) Compute the SSR initial value of a template-literal memo as a
+   * Go `string` expression. The memo computation looks like
+   * `() => `${a} ${b} ${props.className ?? ''} grid place-content-center``.
+   *
+   * Each quasi (literal text span) becomes a Go string literal; each
+   * interpolation is resolved:
+   *   - an identifier naming a module string const → its inlined literal
+   *     (covers both pure-string and `[...].join(' ')` consts);
+   *   - `props.<name> ?? '<fallback>'` or bare `props.<name>` → `in.<Field>`
+   *     when `<name>` is a known prop param (typed `string`); the `?? ''`
+   *     fallback maps to Go's zero value for an unset string field, matching
+   *     the Hono reference's empty-string result.
+   *
+   * Returns the `"a" + in.Field + " grid..."` concatenation, or null when the
+   * computation isn't a single template literal or any interpolation isn't
+   * representable (so the caller keeps its existing pattern matching).
+   */
+  private computeTemplateLiteralMemoInitialValue(
+    computation: string,
+    propsParams: { name: string; type?: TypeInfo; defaultValue?: string }[],
+  ): string | null {
+    const sf = ts.createSourceFile(
+      '__memo.ts',
+      `const __x = (${computation});`,
+      ts.ScriptTarget.Latest,
+      /*setParentNodes*/ false,
+    )
+    const stmt = sf.statements[0]
+    if (!stmt || !ts.isVariableStatement(stmt)) return null
+    let init = stmt.declarationList.declarations[0]?.initializer
+    while (init && ts.isParenthesizedExpression(init)) init = init.expression
+    if (!init || !ts.isArrowFunction(init)) return null
+    let body = init.body as ts.Node
+    while (ts.isParenthesizedExpression(body as ts.Expression)) {
+      body = (body as ts.ParenthesizedExpression).expression
+    }
+
+    // Block-bodied arrow (the Toggle `classes` memo): collect leading
+    // `const X = props.Y ?? 'lit'` key bindings, then resolve against the
+    // single returned template literal. The bindings let `variantClasses[variant]`
+    // resolve `variant` to prop `variant` with its `'default'` fallback key.
+    const localKeyBindings = new Map<string, { propName: string; defaultLiteral?: string }>()
+    if (ts.isBlock(body)) {
+      let returned: ts.Node | null = null
+      for (const s of body.statements) {
+        if (ts.isVariableStatement(s)) {
+          for (const d of s.declarationList.declarations) {
+            if (!ts.isIdentifier(d.name) || !d.initializer) continue
+            const binding = this.parseLocalKeyBinding(d.initializer)
+            if (binding) localKeyBindings.set(d.name.text, binding)
+          }
+        } else if (ts.isReturnStatement(s) && s.expression) {
+          returned = s.expression
+        } else if (ts.isExpressionStatement(s) || ts.isEmptyStatement(s)) {
+          // ignore
+        } else {
+          return null // unsupported statement shape — bail to existing patterns
+        }
+      }
+      if (!returned) return null
+      body = returned
+      while (ts.isParenthesizedExpression(body as ts.Expression)) {
+        body = (body as ts.ParenthesizedExpression).expression
+      }
+    }
+
+    if (!ts.isTemplateExpression(body) && !ts.isNoSubstitutionTemplateLiteral(body)) {
+      return null
+    }
+    const propNames = new Set(propsParams.map(p => p.name))
+    const escGo = (s: string) => `"${this.escapeGoString(s)}"`
+    const segments: string[] = []
+
+    if (ts.isNoSubstitutionTemplateLiteral(body)) {
+      return escGo(body.text)
+    }
+    // head + each span
+    if (body.head.text) segments.push(escGo(body.head.text))
+    for (const span of body.templateSpans) {
+      const resolved = this.resolveTemplateInterpolation(span.expression, propNames, localKeyBindings)
+      if (resolved === null) return null
+      segments.push(resolved)
+      if (span.literal.text) segments.push(escGo(span.literal.text))
+    }
+    if (segments.length === 0) return '""'
+    return segments.join(' + ')
+  }
+
+  /**
+   * (#checkbox) Resolve one `${expr}` interpolation of a template-literal memo
+   * to a Go string expression, or null when unsupported. See
+   * `computeTemplateLiteralMemoInitialValue` for the supported shapes.
+   */
+  private resolveTemplateInterpolation(
+    expr: ts.Expression,
+    propNames: Set<string>,
+    localKeyBindings: ReadonlyMap<string, { propName: string; defaultLiteral?: string }> = new Map(),
+  ): string | null {
+    let node: ts.Expression = expr
+    while (ts.isParenthesizedExpression(node)) node = node.expression
+
+    // Identifier → module string const inline.
+    if (ts.isIdentifier(node)) {
+      const inlined = this.resolveModuleStringConst(node.text)
+      if (inlined !== null) return inlined
+      return null
+    }
+
+    // `recordConst[key]` → inline indexed Go map (the Toggle `classes` memo's
+    // `variantClasses[variant]` / `sizeClasses[size]`).
+    if (ts.isElementAccessExpression(node)) {
+      const indexed = this.recordIndexInterpolationToGo(node, propNames, localKeyBindings)
+      if (indexed !== null) return indexed
+      return null
+    }
+
+    // `props.X ?? '...'` — string-typed prop with an empty-string fallback.
+    if (
+      ts.isBinaryExpression(node) &&
+      node.operatorToken.kind === ts.SyntaxKind.QuestionQuestionToken
+    ) {
+      const right = node.right
+      const isEmptyStr =
+        (ts.isStringLiteral(right) || ts.isNoSubstitutionTemplateLiteral(right)) &&
+        right.text === ''
+      const propName = this.propsAccessName(node.left)
+      if (propName && propNames.has(propName) && isEmptyStr) {
+        // Unset string field is "" in Go — same as `?? ''`.
+        return `in.${this.capitalizeFieldName(propName)}`
+      }
+      return null
+    }
+
+    // Bare `props.X` (string-typed prop).
+    const propName = this.propsAccessName(node)
+    if (propName && propNames.has(propName)) {
+      return `in.${this.capitalizeFieldName(propName)}`
+    }
+    return null
+  }
+
+  /**
+   * Parse a memo-local `const X = …` initializer into a `Record`-index key
+   * binding: `props.Y ?? 'lit'` → `{ propName: 'Y', defaultLiteral: 'lit' }`,
+   * or bare `props.Y` → `{ propName: 'Y' }`. Returns null for any other shape
+   * (a literal const, a call, etc.) so it simply isn't registered as a key.
+   */
+  private parseLocalKeyBinding(
+    init: ts.Expression,
+  ): { propName: string; defaultLiteral?: string } | null {
+    let node: ts.Expression = init
+    while (ts.isParenthesizedExpression(node)) node = node.expression
+    if (
+      ts.isBinaryExpression(node) &&
+      node.operatorToken.kind === ts.SyntaxKind.QuestionQuestionToken
+    ) {
+      const propName = this.propsAccessName(node.left)
+      const right = node.right
+      if (
+        propName &&
+        (ts.isStringLiteral(right) || ts.isNoSubstitutionTemplateLiteral(right))
+      ) {
+        return { propName, defaultLiteral: right.text }
+      }
+      return null
+    }
+    const propName = this.propsAccessName(node)
+    if (propName) return { propName }
+    return null
+  }
+
+  /**
+   * Lower a `recordConst[key]` interpolation to an inline indexed Go map,
+   * emitting `map[string]string{…}[fmt.Sprint(in.Field)]` (or `map[string]any`
+   * for mixed values). `key` is a bare prop or a memo-local const bound to
+   * `props.X ?? 'default'` (resolved via `localKeyBindings`); a `'default'`
+   * fallback also maps `""` to that entry, so an unset prop (Go zero value `""`)
+   * renders the default — matching Hono's `props.X ?? 'default'`. Returns null
+   * for any non-record / non-resolvable key so the caller falls through.
+   */
+  private recordIndexInterpolationToGo(
+    node: ts.ElementAccessExpression,
+    propNames: Set<string>,
+    localKeyBindings: ReadonlyMap<string, { propName: string; defaultLiteral?: string }>,
+  ): string | null {
+    const parsed = parseRecordIndexAccess(
+      node,
+      this.localConstants ?? [],
+      [...propNames].map(name => ({ name })),
+      name => localKeyBindings.get(name) ?? null,
+    )
+    if (!parsed) return null
+    const goVal = (v: { kind: 'number' | 'string'; text: string }) =>
+      v.kind === 'number' ? v.text : JSON.stringify(v.text)
+    const entries = parsed.entries.map(e => `${JSON.stringify(e.key)}: ${goVal(e.value)}`)
+    if (parsed.defaultKey !== undefined) {
+      const def = parsed.entries.find(e => e.key === parsed.defaultKey)
+      if (def) entries.unshift(`"": ${goVal(def.value)}`)
+    }
+    const allString = parsed.entries.every(e => e.value.kind === 'string')
+    const mapType = allString ? 'map[string]string' : 'map[string]any'
+    this.usesFmt = true
+    return `${mapType}{${entries.join(', ')}}[fmt.Sprint(in.${this.capitalizeFieldName(parsed.indexPropName)})]`
+  }
+
+  /**
+   * If `node` is a `<propsObjectName>.<name>` access, return `<name>`, else
+   * null. Used to recognize props-object reads inside memo interpolations.
+   */
+  private propsAccessName(node: ts.Expression): string | null {
+    if (!ts.isPropertyAccessExpression(node)) return null
+    if (!ts.isIdentifier(node.expression)) return null
+    if (!this.propsObjectName || node.expression.text !== this.propsObjectName) return null
+    return node.name.text
+  }
+
   private computeMemoInitialValue(
     memo: { name: string; computation: string; deps: string[] },
     signals: { getter: string; initialValue: string }[],
     propsParams: { name: string; type?: TypeInfo; defaultValue?: string }[],
     propFallbackVars: ReadonlyMap<string, PropFallbackVar> = GoTemplateAdapter.EMPTY_PROP_FALLBACK_VARS,
+    // (#checkbox) Go type of the memo field; used to pick the zero-value
+    // fallback for an unresolved computation (`false` for `bool`, `""` for
+    // `string`, else the historical `0`).
+    goType?: string,
   ): string {
     const computation = memo.computation
     // Helper to pick the hoisted var (if any) or fall back to `in.X`.
@@ -2397,6 +3123,16 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
       return `in.${this.capitalizeFieldName(propName)}`
     }
 
+    // (#checkbox) Pattern: () => `...${expr}...` — a template-literal memo
+    // (the classes memo: `${baseClasses} ${focusClasses} ... ${props.className
+    // ?? ''} grid place-content-center`). Build a Go string concatenation that
+    // inlines module string consts (incl. `[...].join(' ')` consts resolved by
+    // `resolveModuleStringConst`) and resolves `props.X ?? ''` / bare `props.X`
+    // to the corresponding `in.Field`. Returns null when any interpolation
+    // isn't representable, so the existing patterns below still apply.
+    const tmplMemo = this.computeTemplateLiteralMemoInitialValue(computation, propsParams)
+    if (tmplMemo !== null) return tmplMemo
+
     // Pattern: () => dep() * N or () => dep() + N etc.
     const arithmeticMatch = computation.match(/\(\)\s*=>\s*(\w+)\(\)\s*([*+\-/])\s*(\d+)/)
     if (arithmeticMatch) {
@@ -2475,10 +3211,42 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
       }
     }
 
-    // Default: return 0 for unknown computations
+    // Default: zero value for the memo's Go type (#checkbox). A boolean memo
+    // (`isChecked`) renders `false`, a string memo `""`; otherwise the
+    // historical int `0`.
+    if (goType === 'bool') return 'false'
+    if (goType === 'string') return '""'
     return '0'
   }
 
+  /**
+   * Whether a memo is an arrow whose result is a template literal — either a
+   * concise body (`() => \`…\``) or a block body whose `return` is one.
+   */
+  private isTemplateLiteralMemo(computation: string): boolean {
+    const sf = ts.createSourceFile(
+      '__memo.ts', `const __x = (${computation});`, ts.ScriptTarget.Latest, /*setParentNodes*/ false,
+    )
+    const stmt = sf.statements[0]
+    if (!stmt || !ts.isVariableStatement(stmt)) return false
+    let init = stmt.declarationList.declarations[0]?.initializer
+    while (init && ts.isParenthesizedExpression(init)) init = init.expression
+    if (!init || !ts.isArrowFunction(init)) return false
+    let body = init.body as ts.Node
+    while (ts.isParenthesizedExpression(body as ts.Expression)) {
+      body = (body as ts.ParenthesizedExpression).expression
+    }
+    if (ts.isBlock(body)) {
+      const ret = body.statements.find(ts.isReturnStatement)
+      if (!ret || !ret.expression) return false
+      body = ret.expression
+      while (ts.isParenthesizedExpression(body as ts.Expression)) {
+        body = (body as ts.ParenthesizedExpression).expression
+      }
+    }
+    return ts.isTemplateExpression(body) || ts.isNoSubstitutionTemplateLiteral(body)
+  }
+
   /**
    * Infer the Go type for a memo based on its computation and dependencies.
    */
@@ -2487,6 +3255,11 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     signals: { getter: string; initialValue: string; type: TypeInfo }[],
     propsParamMap: Map<string, { name: string; type: TypeInfo; defaultValue?: string }>
   ): string {
+    // A template-literal memo always produces a string. Decide this first so a
+    // class-string `/` (e.g. `ring-ring/50`) doesn't trip the arithmetic
+    // heuristic below into `int`.
+    if (this.isTemplateLiteralMemo(memo.computation)) return 'string'
+
     // Check if computation involves multiplication (*) - likely number
     if (memo.computation.includes('*') || memo.computation.includes('/') ||
         memo.computation.includes('+') || memo.computation.includes('-')) {
@@ -2514,10 +3287,58 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
       }
     }
 
+    // (#checkbox) Boolean memo: a comparison/negation/ternary whose dependency
+    // signals are all boolean (`isChecked = isControlled() ? controlledChecked()
+    // : internalChecked()`). Inferring `bool` makes the field render `false`
+    // (not the int `0`) for `aria-checked={isChecked()}`, matching Hono's SSR
+    // initial value. Only fires when the declared memo type is unknown so an
+    // explicitly-typed memo still wins.
+    if (this.typeInfoToGo(memo.type) === 'interface{}' && this.isBooleanMemo(memo, signals, propsParamMap)) {
+      return 'bool'
+    }
+
     // Default to the memo's declared type
     return this.typeInfoToGo(memo.type)
   }
 
+  /**
+   * (#checkbox) Heuristic: does this memo evaluate to a boolean? True when its
+   * computation is a comparison (`!==`/`===`/`!=`/`==`), a negation (`!x`), or
+   * a ternary whose branches are all boolean signals/props. Used to pick `bool`
+   * (zero value `false`) over the int `0` default for the SSR initial value.
+   */
+  private isBooleanMemo(
+    memo: { computation: string; deps: string[] },
+    signals: { getter: string; initialValue: string; type: TypeInfo }[],
+    propsParamMap: Map<string, { name: string; type: TypeInfo; defaultValue?: string }>,
+  ): boolean {
+    const c = memo.computation
+    if (/(!==|===|!=(?!=)|==(?!=))/.test(c)) return true
+    if (/=>\s*!/.test(c)) return true
+    // Ternary `() => cond() ? a() : b()` — boolean when both branches are
+    // boolean-resolving getters (signals whose value is boolean, or boolean
+    // props).
+    const isBoolGetter = (name: string): boolean => {
+      const sig = signals.find(s => s.getter === name)
+      if (sig) {
+        if (this.typeInfoToGo(sig.type) === 'bool') return true
+        // Signal initialised from `props.X ?? false` / a boolean prop.
+        if (/\?\?\s*(true|false)\b/.test(sig.initialValue)) return true
+        const propName = this.extractPropNameFromInitialValue(sig.initialValue) ?? sig.initialValue
+        const prop = propsParamMap.get(propName)
+        if (prop && this.typeInfoToGo(prop.type, prop.defaultValue) === 'bool') return true
+        return false
+      }
+      const prop = propsParamMap.get(name)
+      return !!prop && this.typeInfoToGo(prop.type, prop.defaultValue) === 'bool'
+    }
+    const ternary = c.match(/=>\s*\w+\(\)\s*\?\s*(\w+)\(\)\s*:\s*(\w+)\(\)/)
+    if (ternary) {
+      return isBoolGetter(ternary[1]) && isBoolGetter(ternary[2])
+    }
+    return false
+  }
+
   /**
    * Infer Go type from a JavaScript value literal.
    */
@@ -3002,9 +3823,49 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     if (ts.isStringLiteral(init) || ts.isNoSubstitutionTemplateLiteral(init)) {
       return init.text
     }
+    // (#checkbox) `[...string literals].join(SEP)` — a const that flattens an
+    // array of pure string literals to a single string at module load (e.g.
+    // Checkbox's `stateClasses = [...].join(' ')`). Evaluate it statically so
+    // the const inlines byte-for-byte like the Hono reference. Only fires when
+    // every array element is a string/no-substitution-template literal and the
+    // separator is a string-literal argument (or omitted → default `,`).
+    const joined = this.evalStringArrayJoin(init)
+    if (joined !== null) return joined
     return null
   }
 
+  /**
+   * (#checkbox) Statically evaluate `[<string literals>].join(<sep?>)`.
+   * Returns the joined string, or null when the shape doesn't match (non-call,
+   * non-`.join`, non-array receiver, any non-string-literal element, or a
+   * non-string-literal separator). Comments/whitespace between elements are
+   * irrelevant — the TS parser already discarded them.
+   */
+  private evalStringArrayJoin(node: ts.Expression): string | null {
+    if (!ts.isCallExpression(node)) return null
+    const callee = node.expression
+    if (!ts.isPropertyAccessExpression(callee)) return null
+    if (callee.name.text !== 'join') return null
+    let recv: ts.Expression = callee.expression
+    while (ts.isParenthesizedExpression(recv)) recv = recv.expression
+    if (!ts.isArrayLiteralExpression(recv)) return null
+    const parts: string[] = []
+    for (const el of recv.elements) {
+      if (ts.isStringLiteral(el) || ts.isNoSubstitutionTemplateLiteral(el)) {
+        parts.push(el.text)
+      } else {
+        return null
+      }
+    }
+    let sep = ','
+    if (node.arguments.length >= 1) {
+      const arg = node.arguments[0]
+      if (ts.isStringLiteral(arg) || ts.isNoSubstitutionTemplateLiteral(arg)) sep = arg.text
+      else return null
+    }
+    return parts.join(sep)
+  }
+
   /**
    * Resolve an identifier to its inlined Go string literal when it names a
    * module pure-string const. Returns the Go template literal form
@@ -4886,6 +5747,28 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
         // Inline Go template syntax with embedded `{{...}}` actions.
         return `${name}="${this.renderParsedExpr(parsed)}"`
       }
+      // Hono-style nullish-attribute omission (#textarea rows): when the
+      // attribute value is a BARE reference to a nillable (`interface{}`)
+      // prop field, guard emission on `ne .X nil` so an unset optional
+      // prop drops the attribute entirely instead of rendering `attr=""`.
+      // Hono omits `undefined`/`null`-valued attributes; this restores
+      // parity. Scope is deliberately narrow — bare identifiers only — so
+      // member exprs, calls, ternaries, template literals, and
+      // concrete-typed props (which are never nil) are unaffected and
+      // still emit `attr=""` / `attr="0"` exactly as Hono does.
+      const bareId = value.expr.trim()
+      // Normalize a props-object access (`props.id`) to its bare prop name
+      // (`id`) so the nillable set — which is keyed by bare prop name —
+      // matches the SolidJS-style props-object pattern too, not just
+      // destructured params (#checkbox `id={props.id}`).
+      const propName =
+        this.propsObjectName && bareId.startsWith(`${this.propsObjectName}.`)
+          ? bareId.slice(this.propsObjectName.length + 1)
+          : bareId
+      if (/^[A-Za-z_$][\w$]*$/.test(propName) && this.nillablePropNames.has(propName)) {
+        const field = `.${this.capitalizeFieldName(propName)}`
+        return `{{if ne ${field} nil}}${name}="{{${this.convertExpressionToGo(value.expr)}}}"{{end}}`
+      }
       return `${name}="{{${this.convertExpressionToGo(value.expr)}}}"`
     },
     emitBooleanAttr: (_value, name) => name,