@barefootjs/go-template 0.14.0 → 0.15.0

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

@@ -64,8 +64,11 @@ import {
   collectContextConsumers,
   isLowerableObjectRestDestructure,
   type ContextConsumer,
+  collectModuleStringConsts as collectModuleStringConstsShared,
+  searchParamsLocalNames
 } from '@barefootjs/jsx'
 import { findInterpolationEnd } from '@barefootjs/jsx/scanner'
+import { BF_REGION } from '@barefootjs/shared'
 
 /**
  * Go-template adapter's IRNode render context. Only `isRootOfClientComponent`
@@ -88,6 +91,18 @@ interface NestedComponentInfo extends IRLoopChildComponent {
    *  name (`item`), so the loop-child init can stamp `data-key` per item. */
   loopKey?: string
   loopParam?: string
+  /** The loop body component's JSX children (e.g. the 4 `<TableCell>` nodes
+   *  inside `<TableRow>` in data-table's `.map(payment => <TableRow>…</TableRow>)`).
+   *  Non-empty when the loop body component has children that need a companion
+   *  define rendered via `bf_with_children` + `bf_tmpl`. (#1897) */
+  bodyChildren?: IRNode[]
+  /** The loop's array expression for baking (e.g. `sortedData()`) */
+  loopArray?: string
+  /** The enclosing loop's `markerId` (e.g. `l0`) for unique naming */
+  loopMarkerId?: string
+  /** The loop item's TS type (`Payment` from `sortedData().map(payment => …)`),
+   *  resolved to Go struct fields for the wrapper struct's datum fields. */
+  loopItemType?: TypeInfo | null
 }
 
 interface StaticChildInstance {
@@ -182,6 +197,19 @@ interface PropFallbackVar {
   zeroLiteral: string
 }
 
+/**
+ * Scope for `lowerCtorExpr` — lowering a JS expression to Go in the
+ * `NewXxxProps` constructor context (#1897 PostList derived state).
+ */
+interface CtorLowerEnv {
+  /** Local names bound to `searchParams()` (`const sp = searchParams()`). */
+  searchParamsVars: Set<string>
+  /** Helper-param name → its already-lowered Go argument, for inlining. */
+  params: Map<string, string>
+  /** Component-scope const names currently being inlined (cycle guard). */
+  consts?: Set<string>
+}
+
 export interface GoTemplateAdapterOptions {
   /** Go package name for generated types (default: 'components') */
   packageName?: string
@@ -388,13 +416,49 @@ function buildUnsupportedSuggestion(support: SupportResult): string {
   return `${support.reason}\n\n${GO_REMEDIATION_OPTIONS}`
 }
 
+/**
+ * Parenthesize a compound Go template argument (`or .Checked false`) so a
+ * primitive call reads it as ONE argument — unwrapped, the parser splits
+ * it into three and `bf_string` fails with "want 1 got 3" (#1896,
+ * DropdownMenuCheckboxItem's `String(props.checked ?? false)`).
+ */
+function wrapGoArg(arg: string): string {
+  if (!/\s/.test(arg)) return arg
+  if (arg.startsWith('(') && arg.endsWith(')')) return arg
+  return `(${arg})`
+}
+
+/**
+ * Make an equality comparison string-tolerant when exactly one side is a
+ * Go string literal (#1896): JS `sorted === 'asc'` is loosely false for
+ * `sorted = false`, but Go's template `eq` ERRORS on bool-vs-string
+ * (`incompatible types for comparison` — DataTableColumnHeader's
+ * `'asc' | 'desc' | false` union prop). Routing the non-literal side
+ * through `bf_string` preserves JS comparison semantics for every
+ * concrete type while keeping same-kind comparisons untouched.
+ */
+function stringTolerantEqOperands(l: string, r: string): [string, string] {
+  const isStrLit = (x: string) => /^"(?:[^"\\]|\\.)*"$/.test(x)
+  if (isStrLit(l) === isStrLit(r)) return [l, r]
+  // Keep `wrapGoArg`'s parentheses: a compound operand must reach
+  // `bf_string` as ONE argument — `(bf_string (or .Placement "top"))`,
+  // not `(bf_string or .Placement "top")` (which the template parser
+  // reads as three arguments and fails at runtime).
+  const wrap = (x: string) => (isStrLit(x) ? x : `(bf_string ${wrapGoArg(x)})`)
+  return [wrap(l), wrap(r)]
+}
+
 const GO_TEMPLATE_PRIMITIVES: Record<string, PrimitiveSpec> = {
-  'JSON.stringify': { arity: 1, emit: (args) => `bf_json ${args[0]}` },
-  'String':         { arity: 1, emit: (args) => `bf_string ${args[0]}` },
-  'Number':         { arity: 1, emit: (args) => `bf_number ${args[0]}` },
-  'Math.floor':     { arity: 1, emit: (args) => `bf_floor ${args[0]}` },
-  'Math.ceil':      { arity: 1, emit: (args) => `bf_ceil ${args[0]}` },
-  'Math.round':     { arity: 1, emit: (args) => `bf_round ${args[0]}` },
+  'JSON.stringify': { arity: 1, emit: (args) => `bf_json ${wrapGoArg(args[0])}` },
+  'String':         { arity: 1, emit: (args) => `bf_string ${wrapGoArg(args[0])}` },
+  'Number':         { arity: 1, emit: (args) => `bf_number ${wrapGoArg(args[0])}` },
+  'Math.floor':     { arity: 1, emit: (args) => `bf_floor ${wrapGoArg(args[0])}` },
+  'Math.ceil':      { arity: 1, emit: (args) => `bf_ceil ${wrapGoArg(args[0])}` },
+  'Math.round':     { arity: 1, emit: (args) => `bf_round ${wrapGoArg(args[0])}` },
+  // Two-arg forms only; an N-arg `Math.min(a, b, c)` falls through to the
+  // standard BF101 unsupported-call diagnostic via the arity gate.
+  'Math.min':       { arity: 2, emit: (args) => `bf_min ${wrapGoArg(args[0])} ${wrapGoArg(args[1])}` },
+  'Math.max':       { arity: 2, emit: (args) => `bf_max ${wrapGoArg(args[0])} ${wrapGoArg(args[1])}` },
 }
 
 export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter, IRNodeEmitter<GoRenderCtx> {
@@ -467,6 +531,17 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
   private componentName: string = ''
   private options: Required<GoTemplateAdapterOptions>
   private inLoop: boolean = false
+  /**
+   * Companion `{{define "<Component>__children_<slot>"}}` blocks queued
+   * while rendering the template body (#1896): JSX children passed to an
+   * imported child component that contain template actions (nested
+   * components, dynamic text) can't be baked to a static `Children`
+   * string — they render through a per-call-site define executed via
+   * `bf_tmpl` with the PARENT's data, and the result is injected into
+   * the child props with `bf_with_children`. Flushed after the main
+   * define in `generate()`.
+   */
+  private pendingChildrenDefines: Array<{ name: string; content: string }> = []
   private loopParamStack: string[] = []
   private loopVarRefCount: Map<string, number> = new Map()
   /** Stack of destructure-param binding maps (binding name → Go accessor on the
@@ -475,6 +550,10 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
    *  refusing with BF104. (#1310) */
   private loopBindingStack: Array<Map<string, string>> = []
   private errors: CompilerError[] = []
+  /** The current IR's memos, stashed like `localConstants` so nested memo
+   *  resolution (a ternary memo whose condition is another memo, #1896)
+   *  can recurse without threading the list through every signature. */
+  private currentMemos: Array<{ name: string; computation: string; deps: string[] }> = []
   private propsObjectName: string | null = null
   /**
    * Component-scoped rest binding identifier (`function({ a, ...rest }: P)`
@@ -504,6 +583,8 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
    * initial-value baker.
    */
   private synthStructTypes: Map<string, TypeInfo> = new Map()
+  /** Full type definitions from the current IR, stashed for loop-datum field resolution (#1897). */
+  private currentTypeDefinitions: TypeDefinition[] = []
 
   /** Set during type generation when any emit references
    *  `template.HTML(...)`; toggles the `"html/template"` import. */
@@ -562,6 +643,36 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
    */
   private contextConsumers: ContextConsumer[] = []
 
+  /**
+   * (#1922) Local binding names the request-scoped `searchParams()` env signal
+   * is imported under (handles `import { searchParams as sp }`). A zero-arg call
+   * on one of these names lowers to the canonical `.SearchParams` field
+   * regardless of the JS alias. Set at `generate()` / `generateTypes()` entry.
+   */
+  private searchParamsLocals: Set<string> = new Set()
+
+  /**
+   * Names of component-scope arrow-const helpers (`const sortClass = …`),
+   * eligible for call-site inlining (#1897). Precomputed per component so the
+   * inliner can skip the AST parse for the common non-helper expression.
+   */
+  private localHelperNames: Set<string> = new Set()
+
+  /** Set when a constructor-context lowering emits a `strings.` call (#1897), so
+   *  `strings` is added to the generated types file's import block. */
+  private needsStringsImport = false
+
+  /** Component-scope derived consts referenced by the template during rendering
+   *  (e.g. `root` → `.Root`). `generateTypes` emits a computed field for each
+   *  that's resolvable and non-colliding (#1897). */
+  private referencedDerivedConsts: Set<string> = new Set()
+
+  /** Array-memo name → the handler-filled loop slice field its `.map()` feeds
+   *  (e.g. `visible` → `PostListItems`). Lets `<memo>().length` lower to
+   *  `len .<Slice>` instead of `len .<Memo>` (a nil/unset memo field) — the
+   *  slice IS the rendered (filtered) items, so its length is the count (#1897). */
+  private memoBackedLoopSlice: Map<string, string> = new Map()
+
   /** Child component name → the contexts it consumes (cross-component, for provider wiring). */
   private childContextConsumers: Map<string, ContextConsumer[]> = new Map()
 
@@ -597,12 +708,20 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
   generate(ir: ComponentIR, options?: AdapterGenerateOptions): AdapterOutput {
     this.componentName = ir.metadata.componentName
     this.errors = []
+    this.referencedDerivedConsts = new Set()
     this.templateVarCounter = 0
+    this.pendingChildrenDefines = []
     this.propsObjectName = ir.metadata.propsObjectName
     this.restPropsName = ir.metadata.restPropsName ?? null
     this.moduleStringConsts = this.collectModuleStringConsts(ir.metadata.localConstants)
     this.localConstants = ir.metadata.localConstants ?? []
+    this.localHelperNames = new Set(
+      this.localConstants.filter(c => !c.isModule && c.containsArrow).map(c => c.name),
+    )
+    this.currentMemos = ir.metadata.memos ?? []
+    this.currentTypeDefinitions = ir.metadata.typeDefinitions ?? []
     this.contextConsumers = collectContextConsumers(ir.metadata)
+    this.searchParamsLocals = searchParamsLocalNames(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
@@ -639,6 +758,15 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     const isIfStatement = ir.root.type === 'if-statement'
 
     this.rootScopeNodes = collectRootScopeNodes(ir.root)
+    // Map each array memo that backs a loop (`<memo>().map(...)`) to that loop's
+    // handler-filled slice field, so `<memo>().length` can lower to the slice's
+    // length (#1897 PostList status count). Built before rendering — the
+    // `.length` reference can appear before the loop in source order.
+    this.memoBackedLoopSlice = new Map()
+    for (const nested of this.findNestedComponents(ir.root)) {
+      const memoName = this.extractMemoNameFromLoopArray(nested.loopArray)
+      if (memoName) this.memoBackedLoopSlice.set(memoName, `${nested.name}s`)
+    }
     const templateBody = isIfStatement
       ? this.renderIfStatement(ir.root as IRIfStatement, { isRootOfClientComponent: hasInteractivity })
       : this.renderNode(ir.root, { isRootOfClientComponent: hasInteractivity && isRootComponent })
@@ -648,7 +776,13 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
       ? ''
       : this.generateScriptRegistrations(ir, options?.scriptBaseName)
 
-    const template = `{{define "${this.componentName}"}}\n${scriptRegistrations}${templateBody}\n{{end}}\n`
+    let template = `{{define "${this.componentName}"}}\n${scriptRegistrations}${templateBody}\n{{end}}\n`
+    // Flush the companion children defines (#1896) — they execute with
+    // the parent's data via `bf_tmpl`, so they belong to this
+    // component's template output.
+    for (const d of this.pendingChildrenDefines) {
+      template += `{{define "${d.name}"}}${d.content}{{end}}\n`
+    }
     const types = this.generateTypes(ir)
 
     // Merge collected errors into IR errors
@@ -958,13 +1092,28 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     // 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
+    // Mirror `generate()` for the rest binding too (#1896):
+    // `classifySpreadBagSource` decides whether a `{...props}` slot is an
+    // Input-side bag by comparing against `this.restPropsName`. Without
+    // this line the stash holds whichever component `generate()` ran
+    // LAST — in a multi-component file (`tabs/index.tsx`) that is a
+    // different component, so the Input struct dropped its `Props`
+    // bag field while `NewXxxProps` (which reads the per-IR metadata)
+    // still emitted `Spread_N: in.Props` — `in.Props undefined`.
+    this.restPropsName = ir.metadata.restPropsName ?? null
     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.localHelperNames = new Set(
+      this.localConstants.filter(c => !c.isModule && c.containsArrow).map(c => c.name),
+    )
+    this.currentMemos = ir.metadata.memos ?? []
+    this.currentTypeDefinitions = ir.metadata.typeDefinitions ?? []
     this.contextConsumers = collectContextConsumers(ir.metadata)
+    this.searchParamsLocals = searchParamsLocalNames(ir.metadata)
     const lines: string[] = []
 
     const componentName = ir.metadata.componentName
@@ -1029,6 +1178,52 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     // Find nested components (loops with childComponent)
     const nestedComponents = this.findNestedComponents(ir.root)
 
+    // (#1897) When a loop's `itemType` is null, resolve the element type
+    // from the source array so wrapper structs get correct datum fields.
+    // Two cases:
+    //   1. Memo-derived: `sortedData()` → resolve through the memo's SSR
+    //      path to the module const it returns (block-body memo baking).
+    //   2. Direct module const: `payments` → look up the constant directly.
+    for (const nested of nestedComponents) {
+      if (nested.loopItemType || !nested.loopArray) continue
+
+      // Case 1: memo-derived loop array (`sortedData()`)
+      const memoName = this.extractMemoNameFromLoopArray(nested.loopArray)
+      if (memoName) {
+        const memo = ir.metadata.memos.find(m => m.name === memoName)
+        if (memo) {
+          const blockReturn = this.resolveBlockBodyMemoModuleConst(
+            memo.computation, ir.metadata.signals,
+          )
+          if (blockReturn) {
+            const constant = (ir.metadata.localConstants ?? []).find(
+              c => c.name === blockReturn.constName && c.origin?.scope === 'module',
+            )
+            if (constant?.type?.elementType) {
+              nested.loopItemType = constant.type.elementType
+            }
+          }
+        }
+        continue
+      }
+
+      // Case 2: direct module-const array reference (`payments`)
+      const directConst = (ir.metadata.localConstants ?? []).find(
+        c => c.name === nested.loopArray && c.origin?.scope === 'module',
+      )
+      if (directConst?.type?.elementType) {
+        nested.loopItemType = directConst.type.elementType
+      }
+    }
+
+    // (#1897) Generate wrapper structs for loop body components with JSX children.
+    // The wrapper embeds the child component's Props and adds datum fields from
+    // the loop's item type + static child instances from the body children.
+    for (const nested of nestedComponents) {
+      if (!nested.bodyChildren || nested.bodyChildren.length === 0) continue
+      this.generateLoopBodyWrapperStruct(lines, componentName, nested)
+    }
+
     // Build prop type overrides from signal types
     const propTypeOverrides = this.buildPropTypeOverrides(ir)
 
@@ -1045,10 +1240,11 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     this.generateInputStruct(lines, ir, componentName, nestedComponents, propTypeOverrides, spreadSlots)
 
     // Generate Props struct for main component
+    this.needsStringsImport = false
     this.generatePropsStruct(lines, ir, componentName, nestedComponents, propTypeOverrides, spreadSlots)
 
     // Generate NewXxxProps function
-    this.generateNewPropsFunction(lines, ir, componentName, nestedComponents, spreadSlots)
+    this.generateNewPropsFunction(lines, ir, componentName, nestedComponents, spreadSlots, propTypeOverrides)
 
     // Imports come at the top, but `usesHtmlTemplate` is only known
     // after the body has been generated. Compose package + imports +
@@ -1062,6 +1258,7 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     if (this.usesFmt) header.push('\t"fmt"')
     if (this.usesHtmlTemplate) header.push('\t"html/template"')
     header.push('\t"math/rand"')
+    if (this.needsStringsImport) header.push('\t"strings"')
     header.push('')
     header.push('\tbf "github.com/barefootjs/runtime/bf"')
     header.push(')')
@@ -1319,6 +1516,39 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     return nillable
   }
 
+  /**
+   * Whether the component reads the request-scoped `searchParams()`
+   * environment signal (router v0.5, #1922). Detected from `searchParamsLocals`
+   * — the binding names the shared `searchParamsLocalNames` helper found at
+   * `generate()` / `generateTypes()` entry, covering any local name (including
+   * an aliased `import { searchParams as sp }`). When non-empty the generated
+   * structs carry a `SearchParams bf.SearchParams` binding the route handler
+   * fills per request and the template reads via `.SearchParams.Get "key"`.
+   *
+   * Guarded against a name collision with a user prop / signal / memo also
+   * called `searchParams`: that author owns the `SearchParams` field, so the
+   * env-signal field is dropped (the reference would resolve to their value).
+   */
+  private usesSearchParams(ir: ComponentIR): boolean {
+    if (this.searchParamsLocals.size === 0) return false
+    // Every other source that contributes a Props/Input struct field: a
+    // collision on `SearchParams` would redeclare the field and break the Go
+    // compile. Covers props, signals, memos, `useContext` consumers, and the
+    // `{...rest}` bag — the same field-producing sets the struct emitters draw
+    // from. When the author already owns `SearchParams`, drop the env-signal
+    // field (their binding lowers to the same `.SearchParams` reference).
+    const taken = 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)),
+      ...this.contextConsumers.map(c => this.contextFieldName(c)),
+    ])
+    if (ir.metadata.restPropsName) {
+      taken.add(this.capitalizeFieldName(ir.metadata.restPropsName))
+    }
+    return !taken.has('SearchParams')
+  }
+
   /**
    * Generate Input struct for a component
    */
@@ -1339,6 +1569,14 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     lines.push('\tBfParent string // Optional: parent scope id')
     lines.push('\tBfMount string // Optional: slot id in parent')
 
+    // (#1922) Request-scoped `searchParams()` binding. The route handler
+    // builds it from the request URL (`bf.NewSearchParams(r.URL.RawQuery)`);
+    // the zero value is an empty query, so an omitted field resolves every
+    // `.Get` to "" — the author's `?? default` then renders.
+    if (this.usesSearchParams(ir)) {
+      lines.push('\tSearchParams bf.SearchParams // Optional: request query for searchParams()')
+    }
+
     // Static + prop-derived nested components appear in Input;
     // signal-backed dynamic ones are template-only
     const inputNested = nestedComponents.filter(n => !n.isDynamic || n.isPropDerived)
@@ -1423,6 +1661,13 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     // Add Scripts field for dynamic script collection
     lines.push('\tScripts *bf.ScriptCollector `json:"-"`')
 
+    // (#1922) Request-scoped `searchParams()` SSR value. Read by the
+    // template as `.SearchParams.Get "key"`. Not serialised for hydration
+    // (`json:"-"`) — the client re-reads `window.location.search` itself.
+    if (this.usesSearchParams(ir)) {
+      lines.push('\tSearchParams bf.SearchParams `json:"-"`')
+    }
+
     // Collect nested component array field names to skip from propsParams
     const nestedArrayFields = new Set(nestedComponents.map(n => `${n.name}s`))
 
@@ -1492,15 +1737,35 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
       lines.push(`\t${fieldName} ${goType} \`json:"${jsonTag}"\``)
     }
 
-    // Add memos to Props (they are computed values needed for SSR)
+    // Add memos to Props (they are computed values needed for SSR).
+    // Skip a memo whose name collides with an already-emitted prop field
+    // (#1896): `const className = createMemo(() => props.className ?? '')`
+    // — common in site/ui (AccordionContent, PaginationLink) — would
+    // otherwise redeclare `ClassName`. Both readers (the memo usage and
+    // the inherited `props.className` access) lower to the same `.Field`,
+    // so the prop field carries the value; the memo's `?? fallback` is
+    // folded into the prop's initializer in `generateNewPropsFunction`.
     for (const memo of ir.metadata.memos) {
       const fieldName = this.capitalizeFieldName(memo.name)
+      if (propFieldNames.has(fieldName)) continue
       const jsonTag = this.toJsonTag(memo.name)
       // Memos that depend on number signals are usually numbers
       const goType = this.inferMemoType(memo, ir.metadata.signals, propsParamMap)
       lines.push(`\t${fieldName} ${goType} \`json:"${jsonTag}"\``)
     }
 
+    // (#1897 PostList) Computed fields for component-scope derived string consts
+    // the template references (e.g. `root = base || '/'`). Not serialised — the
+    // route handler doesn't supply them; `NewXxxProps` computes them.
+    const takenForDerivedConsts = 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 f of this.computeDerivedConstFields(takenForDerivedConsts)) {
+      lines.push(`\t${f.name} string \`json:"-"\``)
+    }
+
     // `useContext` consumer fields (skip names already taken by a prop /
     // signal / memo field).
     const takenProps = new Set<string>([
@@ -1515,14 +1780,18 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
 
     // Add array fields for nested components (for template rendering)
     for (const nested of nestedComponents) {
+      // (#1897) Loop body with JSX children → use the wrapper struct type
+      const elemType = nested.bodyChildren?.length
+        ? this.loopBodyWrapperName(componentName, nested)
+        : `${nested.name}Props`
       if (nested.isDynamic && !nested.isPropDerived) {
         // Dynamic signal array loops: template-only, not in JSON
-        lines.push(`\t${nested.name}s []${nested.name}Props \`json:"-"\``)
+        lines.push(`\t${nested.name}s []${elemType} \`json:"-"\``)
       } else {
         // Static arrays and prop-derived dynamic arrays: include in JSON
         // so the client can hydrate via mapArray or forEach
         const jsonTag = this.toJsonTag(`${nested.name.charAt(0).toLowerCase()}${nested.name.slice(1)}s`)
-        lines.push(`\t${nested.name}s []${nested.name}Props \`json:"${jsonTag}"\``)
+        lines.push(`\t${nested.name}s []${elemType} \`json:"${jsonTag}"\``)
       }
     }
 
@@ -1549,6 +1818,90 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     lines.push('')
   }
 
+  /**
+   * (#1897) Generate a wrapper struct for loop body components with JSX children.
+   * The wrapper embeds the child component's Props, adds datum fields from the
+   * loop's item type, and adds static child instance fields for sub-components
+   * within the loop body children (e.g. the `TableCell` instances inside
+   * `<TableRow>…</TableRow>`).
+   */
+  private generateLoopBodyWrapperStruct(
+    lines: string[],
+    parentComponentName: string,
+    nested: NestedComponentInfo,
+  ): void {
+    const wrapperName = this.loopBodyWrapperName(parentComponentName, nested)
+
+    // Resolve datum fields from the loop's item type
+    const datumFields = this.resolveLoopDatumFields(nested.loopItemType)
+
+    // Collect static child instances from the body children
+    const bodyChildInstances = this.collectBodyChildInstances(nested.bodyChildren!)
+
+    lines.push(`// ${wrapperName} wraps ${nested.name}Props with per-row loop datum`)
+    lines.push(`// fields and child component slots for the loop body children. (#1897)`)
+    lines.push(`type ${wrapperName} struct {`)
+    lines.push(`\t${nested.name}Props`)
+    for (const f of datumFields) {
+      lines.push(`\t${f.goName} ${f.goType} \`json:"-"\``)
+    }
+    for (const child of bodyChildInstances) {
+      lines.push(`\t${child.fieldName} ${child.name}Props \`json:"-"\``)
+    }
+    lines.push('}')
+    lines.push('')
+  }
+
+  /** Extract a memo name from a loop array expression like `sortedData()` → `sortedData`. */
+  private extractMemoNameFromLoopArray(loopArray: string | undefined): string | null {
+    if (!loopArray) return null
+    const match = loopArray.match(/^(\w+)\(\)$/)
+    return match ? match[1] : null
+  }
+
+  /** Stable name for the wrapper struct: `<Parent><Child>L<Marker>Ctx` */
+  private loopBodyWrapperName(parentName: string, nested: NestedComponentInfo): string {
+    return `${parentName}${nested.name}L${nested.loopMarkerId ?? '0'}Ctx`
+  }
+
+  /** Resolve a loop item's TypeInfo to Go struct fields for the wrapper. */
+  private resolveLoopDatumFields(
+    itemType: TypeInfo | null | undefined,
+  ): Array<{ tsName: string; goName: string; goType: string }> {
+    if (!itemType) return []
+    const typeName = itemType.raw?.replace(/\[\]$/, '') ?? itemType.raw
+    if (!typeName) return []
+    for (const td of this.currentTypeDefinitions) {
+      if (td.name === typeName) {
+        const fields: Array<{ tsName: string; goName: string; goType: string }> = []
+        for (const prop of td.properties ?? []) {
+          if (!GoTemplateAdapter.GO_IDENTIFIER.test(prop.name)) continue
+          fields.push({
+            tsName: prop.name,
+            goName: this.capitalizeFieldName(prop.name),
+            goType: this.typeInfoToGo(prop.type),
+          })
+        }
+        if (fields.length > 0) return fields
+        break
+      }
+    }
+    const structFields = this.localStructFields.get(typeName)
+    if (structFields) {
+      return Array.from(structFields, ([tsName, goName]) => ({ tsName, goName, goType: 'interface{}' }))
+    }
+    return []
+  }
+
+  /** Collect static child instances from loop body children for the wrapper struct. */
+  private collectBodyChildInstances(bodyChildren: IRNode[]): StaticChildInstance[] {
+    const result: StaticChildInstance[] = []
+    for (const child of bodyChildren) {
+      this.collectStaticChildInstancesRecursive(child, result, false, new Map())
+    }
+    return result
+  }
+
   /**
    * Generate NewXxxProps function
    */
@@ -1557,7 +1910,8 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     ir: ComponentIR,
     componentName: string,
     nestedComponents: NestedComponentInfo[],
-    spreadSlots: SpreadSlotInfo[]
+    spreadSlots: SpreadSlotInfo[],
+    propTypeOverrides: Map<string, string>,
   ): void {
     const inputTypeName = `${componentName}Input`
     const propsTypeName = `${componentName}Props`
@@ -1569,7 +1923,14 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     // field, the SSR template iterates over it, but
     // `NewTodoAppProps(TodoAppInput{Initial: ...})` returns it empty
     // and the page renders a blank list (#1442 echo TodoApp repro).
-    const signalDynamicNested = nestedComponents.filter(n => n.isDynamic && !n.isPropDerived)
+    // (#1897) Split dynamic nested: components with body children get auto-populated
+    // from baked memo data; components without stay handler-populated.
+    const dynamicWithBody = nestedComponents.filter(
+      n => n.isDynamic && !n.isPropDerived && n.bodyChildren && n.bodyChildren.length > 0,
+    )
+    const signalDynamicNested = nestedComponents.filter(
+      n => n.isDynamic && !n.isPropDerived && !(n.bodyChildren && n.bodyChildren.length > 0),
+    )
     lines.push(`// New${componentName}Props creates ${propsTypeName} from ${inputTypeName}.`)
     for (const nested of signalDynamicNested) {
       const arrayField = `${nested.name}s`
@@ -1598,27 +1959,103 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     // Signal-backed dynamic arrays are set manually by the handler.
     const staticNested = nestedComponents.filter(n => !n.isDynamic || n.isPropDerived)
 
-    // Handle nested components
-    if (staticNested.length > 0) {
-      for (const nested of staticNested) {
-        const varName = `${nested.name.charAt(0).toLowerCase()}${nested.name.slice(1)}s`
-        lines.push(`\t${varName} := make([]${nested.name}Props, len(in.${nested.name}s))`)
-        lines.push(`\tfor i, item := range in.${nested.name}s {`)
-        lines.push(`\t\t${varName}[i] = New${nested.name}Props(item)`)
-        // (#1249) Stamp slot identity on each child item so bf-h / bf-m
-        // mark it as a slot-attached child of this scope.
-        lines.push(`\t\t${varName}[i].BfParent = scopeID`)
-        lines.push(`\t\t${varName}[i].BfMount = "${nested.slotId}"`)
-        // (#1297) Stamp the keyed-loop `data-key` per item from the loop's
-        // `key` expression (`item.label` → `item.Label`), matching Hono.
-        const keyField = loopKeyToGoFieldPath(nested.loopKey, nested.loopParam)
-        if (keyField) {
-          lines.push(`\t\t${varName}[i].BfDataKey = fmt.Sprint(${keyField})`)
-          this.usesFmt = true
+    // Track which wrapper vars have been emitted so the return struct can
+    // conditionally include them (both static-with-body and dynamic-with-body
+    // paths may emit wrappers).
+    const emittedWrapperVars = new Set<string>()
+
+    // (#1897) Split static nested into those with and without body children.
+    // Static loops with body children backed by module consts bake the data
+    // directly (like the dynamic-with-body path) because Input items don't
+    // carry the datum fields the wrapper struct needs.
+    const staticWithBody = staticNested.filter(
+      n => n.bodyChildren && n.bodyChildren.length > 0,
+    )
+    const staticWithoutBody = staticNested.filter(
+      n => !n.bodyChildren || n.bodyChildren.length === 0,
+    )
+
+    // Handle static nested components WITHOUT body children (original path)
+    for (const nested of staticWithoutBody) {
+      const varName = `${nested.name.charAt(0).toLowerCase()}${nested.name.slice(1)}s`
+      lines.push(`\t${varName} := make([]${nested.name}Props, len(in.${nested.name}s))`)
+      lines.push(`\tfor i, item := range in.${nested.name}s {`)
+      lines.push(`\t\t${varName}[i] = New${nested.name}Props(item)`)
+      lines.push(`\t\t${varName}[i].BfParent = scopeID`)
+      lines.push(`\t\t${varName}[i].BfMount = "${nested.slotId}"`)
+      const keyField = loopKeyToGoFieldPath(nested.loopKey, nested.loopParam)
+      if (keyField) {
+        lines.push(`\t\t${varName}[i].BfDataKey = fmt.Sprint(${keyField})`)
+        this.usesFmt = true
+      }
+      lines.push('\t}')
+      lines.push('')
+    }
+
+    // (#1897) Handle static nested components WITH body children.
+    // Bake the module-const array into the constructor so wrapper structs
+    // get their datum fields directly from the data, not from Input items
+    // (Input items only carry child-component params, not loop datum fields).
+    for (const nested of staticWithBody) {
+      const loopArray = nested.loopArray
+      const moduleConst = loopArray
+        ? (ir.metadata.localConstants ?? []).find(
+            c => c.name === loopArray && c.origin?.scope === 'module' && c.value && c.type,
+          )
+        : null
+      const bakedValue = moduleConst?.type
+        ? this.convertInitialValue(moduleConst.value!, moduleConst.type, ir.metadata.propsParams)
+        : null
+      if (!bakedValue || bakedValue === 'nil' || bakedValue === '0') continue
+
+      const varName = `${nested.name.charAt(0).toLowerCase()}${nested.name.slice(1)}s`
+      const wrapperType = this.loopBodyWrapperName(componentName, nested)
+      const datumFields = this.resolveLoopDatumFields(nested.loopItemType)
+      const bodyChildInstances = this.collectBodyChildInstances(nested.bodyChildren!)
+
+      for (const child of bodyChildInstances) {
+        const childVar = `child_${child.fieldName}`
+        lines.push(`\t${childVar} := New${child.name}Props(${child.name}Input{`)
+        lines.push(`\t\tScopeID: scopeID + "_${child.slotId}",`)
+        lines.push(`\t\tBfParent: scopeID,`)
+        lines.push(`\t\tBfMount: "${child.slotId}",`)
+        for (const prop of child.props) {
+          if (prop.value.kind === 'literal') {
+            lines.push(`\t\t${this.capitalizeFieldName(prop.name)}: ${this.goLiteral(prop.value.value)},`)
+          } else if (prop.value.kind === 'boolean-shorthand' || prop.value.kind === 'boolean-attr') {
+            lines.push(`\t\t${this.capitalizeFieldName(prop.name)}: true,`)
+          }
         }
-        lines.push('\t}')
-        lines.push('')
-      }
+        lines.push(`\t})`)
+      }
+      if (bodyChildInstances.length > 0) lines.push('')
+
+      const dataVar = `${varName}Data`
+      lines.push(`\t${dataVar} := ${bakedValue}`)
+      lines.push(`\t${varName} := make([]${wrapperType}, len(${dataVar}))`)
+      lines.push(`\tfor i, item := range ${dataVar} {`)
+      lines.push(`\t\t${varName}[i] = ${wrapperType}{`)
+      lines.push(`\t\t\t${nested.name}Props: New${nested.name}Props(${nested.name}Input{`)
+      lines.push(`\t\t\t\tBfParent: scopeID,`)
+      lines.push(`\t\t\t\tBfMount: "${nested.slotId}",`)
+      lines.push(`\t\t\t}),`)
+      for (const f of datumFields) {
+        lines.push(`\t\t\t${f.goName}: item.${f.goName},`)
+      }
+      for (const child of bodyChildInstances) {
+        lines.push(`\t\t\t${child.fieldName}: child_${child.fieldName},`)
+      }
+      lines.push(`\t\t}`)
+      lines.push(`\t\t${varName}[i].BfParent = scopeID`)
+      lines.push(`\t\t${varName}[i].BfMount = "${nested.slotId}"`)
+      const keyField = loopKeyToGoFieldPath(nested.loopKey, nested.loopParam)
+      if (keyField) {
+        lines.push(`\t\t${varName}[i].BfDataKey = fmt.Sprint(${keyField})`)
+        this.usesFmt = true
+      }
+      lines.push('\t}')
+      lines.push('')
+      emittedWrapperVars.add(varName)
     }
 
     // (#1423) Collect signal-time prop fallbacks: when a signal is
@@ -1638,12 +2075,80 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     }
     if (propFallbackVars.size > 0) lines.push('')
 
+    // (#1897) Build wrapper items for dynamic loop body components whose array
+    // bakes to a module-const via a memo. Creates the wrapper slice with
+    // embedded child Props + datum fields + static sub-component instances.
+    const propsParamMap = new Map(ir.metadata.propsParams.map(p => [p.name, p]))
+    for (const nested of dynamicWithBody) {
+      const memoName = this.extractMemoNameFromLoopArray(nested.loopArray)
+      if (!memoName) continue
+      const memo = ir.metadata.memos.find(m => m.name === memoName)
+      if (!memo) continue
+
+      const goType = this.inferMemoType(memo, ir.metadata.signals, propsParamMap)
+      const bakedValue = this.computeMemoInitialValue(
+        memo, ir.metadata.signals, ir.metadata.propsParams, propFallbackVars, goType,
+      )
+      if (bakedValue === 'nil' || bakedValue === '0') continue
+
+      const wrapperType = this.loopBodyWrapperName(componentName, nested)
+      const varName = `${nested.name.charAt(0).toLowerCase()}${nested.name.slice(1)}s`
+      const datumFields = this.resolveLoopDatumFields(nested.loopItemType)
+      const bodyChildInstances = this.collectBodyChildInstances(nested.bodyChildren!)
+
+      // Create child sub-component instances once (identical scope IDs across rows)
+      for (const child of bodyChildInstances) {
+        const childVar = `child_${child.fieldName}`
+        lines.push(`\t${childVar} := New${child.name}Props(${child.name}Input{`)
+        lines.push(`\t\tScopeID: scopeID + "_${child.slotId}",`)
+        lines.push(`\t\tBfParent: scopeID,`)
+        lines.push(`\t\tBfMount: "${child.slotId}",`)
+        for (const prop of child.props) {
+          if (prop.value.kind === 'literal') {
+            lines.push(`\t\t${this.capitalizeFieldName(prop.name)}: ${this.goLiteral(prop.value.value)},`)
+          } else if (prop.value.kind === 'boolean-shorthand' || prop.value.kind === 'boolean-attr') {
+            lines.push(`\t\t${this.capitalizeFieldName(prop.name)}: true,`)
+          }
+        }
+        lines.push(`\t})`)
+      }
+      if (bodyChildInstances.length > 0) lines.push('')
+
+      lines.push(`\tbakedData := ${bakedValue}`)
+      lines.push(`\t${varName} := make([]${wrapperType}, len(bakedData))`)
+      lines.push(`\tfor i, item := range bakedData {`)
+      lines.push(`\t\t${varName}[i] = ${wrapperType}{`)
+      lines.push(`\t\t\t${nested.name}Props: New${nested.name}Props(${nested.name}Input{`)
+      lines.push(`\t\t\t\tBfParent: scopeID,`)
+      lines.push(`\t\t\t\tBfMount: "${nested.slotId}",`)
+      lines.push(`\t\t\t}),`)
+      for (const f of datumFields) {
+        lines.push(`\t\t\t${f.goName}: item.${f.goName},`)
+      }
+      for (const child of bodyChildInstances) {
+        lines.push(`\t\t\t${child.fieldName}: child_${child.fieldName},`)
+      }
+      lines.push(`\t\t}`)
+      const keyField = loopKeyToGoFieldPath(nested.loopKey, nested.loopParam)
+      if (keyField) {
+        lines.push(`\t\t${varName}[i].BfDataKey = fmt.Sprint(${keyField})`)
+        this.usesFmt = true
+      }
+      lines.push(`\t}`)
+      lines.push('')
+      emittedWrapperVars.add(varName)
+    }
+
     lines.push(`\treturn ${propsTypeName}{`)
     lines.push('\t\tScopeID: scopeID,')
     // (#1249) Forward host context for when *this* component is itself a
     // slot-attached child of an outer page/component.
     lines.push('\t\tBfParent: in.BfParent,')
     lines.push('\t\tBfMount: in.BfMount,')
+    // (#1922) Forward the request-scoped searchParams() binding unchanged.
+    if (this.usesSearchParams(ir)) {
+      lines.push('\t\tSearchParams: in.SearchParams,')
+    }
 
     // Collect nested component array field names
     const nestedArrayFields = new Set(nestedComponents.map(n => `${n.name}s`))
@@ -1654,6 +2159,31 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     // doesn't silently shadow the JSX-side default. The same logic
     // applies for signal-side fallbacks (`createSignal(props.X ?? N)`)
     // via the hoisted variable from `propFallbackVars` (#1423).
+    // (#1896) A memo that shadows a prop of the same name
+    // (`const className = createMemo(() => props.className ?? '')`)
+    // shares the prop's struct field (see `generatePropsStruct`). Fold
+    // the memo's `?? fallback` into the prop's own initializer so the
+    // SSR value matches the memo semantics when the caller omits it.
+    const memoFallbacks = new Map<string, { goFallback: string; goType: string }>()
+    for (const memo of ir.metadata.memos) {
+      const stripped = memo.computation.replace(/^\(\)\s*=>\s*/, '')
+      const m = this.extractPropFallback(stripped)
+      if (!m) continue
+      if (this.capitalizeFieldName(m.propName) !== this.capitalizeFieldName(memo.name)) continue
+      // `applyGoFallback` emits a string-typed zero-value check; folding
+      // onto a prop whose Input field resolved to `interface{}` (e.g. a
+      // string-literal-union type the resolver can't narrow —
+      // PaginationLink's `size`) would not compile. Such props keep the
+      // plain `in.<Field>` assignment.
+      const param = ir.metadata.propsParams.find(
+        p => this.capitalizeFieldName(p.name) === this.capitalizeFieldName(memo.name),
+      )
+      if (!param) continue
+      const goType = this.resolvePropGoType(param, propTypeOverrides)
+      if (goType !== 'string' && goType !== 'interface{}') continue
+      memoFallbacks.set(this.capitalizeFieldName(memo.name), { goFallback: m.goFallback, goType })
+    }
+
     const propFieldNames = new Set<string>()
     for (const param of ir.metadata.propsParams) {
       const fieldName = this.capitalizeFieldName(param.name)
@@ -1662,9 +2192,19 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
       if (hoisted) {
         lines.push(`\t\t${fieldName}: ${hoisted.varName},`)
       } else {
-        const fallback = this.goPropDefault(param.defaultValue)
-        if (fallback !== null) {
-          lines.push(`\t\t${fieldName}: ${this.applyGoFallback(`in.${fieldName}`, fallback)},`)
+        const paramDefault = this.goPropDefault(param.defaultValue)
+        const memoFold = memoFallbacks.get(fieldName)
+        if (paramDefault !== null) {
+          lines.push(`\t\t${fieldName}: ${this.applyGoFallback(`in.${fieldName}`, paramDefault)},`)
+        } else if (memoFold !== undefined && memoFold.goType === 'string') {
+          lines.push(`\t\t${fieldName}: ${this.applyGoFallback(`in.${fieldName}`, memoFold.goFallback)},`)
+        } else if (memoFold !== undefined) {
+          // interface{} field (#1896, PaginationLink's `size ?? 'icon'`):
+          // applyGoFallback's string zero-check doesn't compile here, so
+          // emit a nil/empty-tolerant wrapper instead.
+          lines.push(
+            `\t\t${fieldName}: func() interface{} { v := interface{}(in.${fieldName}); if v == nil || v == "" { return ${memoFold.goFallback} }; return v }(),`,
+          )
         } else {
           lines.push(`\t\t${fieldName}: in.${fieldName},`)
         }
@@ -1692,16 +2232,24 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
       }
     }
 
-    // Add nested component arrays (static only; dynamic ones are set by the handler)
-    for (const nested of staticNested) {
+    // Add nested component arrays (static without body always emitted;
+    // static with body + dynamic with body use emittedWrapperVars guard)
+    for (const nested of staticWithoutBody) {
+      const varName = `${nested.name.charAt(0).toLowerCase()}${nested.name.slice(1)}s`
+      lines.push(`\t\t${nested.name}s: ${varName},`)
+    }
+    for (const nested of [...staticWithBody, ...dynamicWithBody]) {
       const varName = `${nested.name.charAt(0).toLowerCase()}${nested.name.slice(1)}s`
+      if (!emittedWrapperVars.has(varName)) continue
       lines.push(`\t\t${nested.name}s: ${varName},`)
     }
 
-    // Add memo initial values (computed from signal initial values)
+    // Add memo initial values (computed from signal initial values).
+    // Prop-shadowing memos were folded into the prop field above (#1896).
     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)
+      if (propFieldNames.has(fieldName)) continue
       // (#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`.
@@ -1710,6 +2258,17 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
       lines.push(`\t\t${fieldName}: ${memoValue},`)
     }
 
+    // (#1897 PostList) Initialise computed derived-const fields
+    // (e.g. `Root: func() string { … }()`), matching `generatePropsStruct`.
+    const takenDerivedInit = 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 f of this.computeDerivedConstFields(takenDerivedInit)) {
+      lines.push(`\t\t${f.name}: ${f.init},`)
+    }
+
     // `useContext` consumer fields: default to the `createContext` default
     // when the caller (a provider) didn't set them.
     const takenInit = new Set<string>([
@@ -1768,6 +2327,12 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
           restBagEntries.push(`${JSON.stringify(jsxName)}: ${goValue}`)
           return
         }
+        // A hyphenated attribute (`aria-label`) can't be a Go struct
+        // field, and with no rest bag on the child there is nowhere to
+        // route it — the child has no `{...props}` spread, so the Hono
+        // reference drops it on the child's root too. Skip rather than
+        // emit invalid Go (#1896, data-table's selection sibling).
+        if (jsxName.includes('-')) return
         lines.push(`\t\t\t${this.capitalizeFieldName(jsxName)}: ${goValue},`)
       }
       // Add prop values
@@ -1907,12 +2472,17 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
       if (loop.childComponent) {
         // Check for duplicates
         if (!result.some(c => c.name === loop.childComponent!.name)) {
+          const hasBodyChildren = loop.childComponent.children.length > 0
           result.push({
             ...loop.childComponent,
             isDynamic: !loop.isStaticArray,
             isPropDerived: !!loop.isPropDerivedArray,
             loopKey: loop.key ?? undefined,
             loopParam: loop.param ?? undefined,
+            bodyChildren: hasBodyChildren ? loop.childComponent.children : undefined,
+            loopArray: loop.array,
+            loopMarkerId: loop.markerId,
+            loopItemType: loop.itemType,
           })
         }
       }
@@ -1935,6 +2505,22 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
       if (cond.whenFalse) {
         this.collectNestedComponents(cond.whenFalse, result)
       }
+    } else if (node.type === 'if-statement') {
+      const stmt = node as IRIfStatement
+      this.collectNestedComponents(stmt.consequent, result)
+      if (stmt.alternate) {
+        this.collectNestedComponents(stmt.alternate, result)
+      }
+    } else if (node.type === 'component') {
+      // (#1896) JSX children passed to an imported component render via
+      // a companion define with the PARENT's data, so a keyed loop
+      // nested inside them (DataTablePreviewDemo's `sortedData().map(…)`
+      // inside `<TableBody>`) needs its `<Name>s` slice on THIS
+      // component's props like any other nested loop.
+      const comp = node as IRComponent
+      for (const child of comp.children) {
+        this.collectNestedComponents(child, result)
+      }
     }
   }
 
@@ -2070,6 +2656,16 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
           childrenScopedHtmlExpr: this.extractScopedHtmlChildren(effectiveChildren),
           contextBindings: providerCtx.size > 0 ? providerCtx : undefined,
         })
+        // (#1896) Action-bearing JSX children render through a companion
+        // define with the PARENT's data (see `queueDynamicChildrenDefine`),
+        // so component instances nested inside them need their own
+        // `<Name>SlotN` fields + constructor inits on THIS component's
+        // props. Statically-baked children never contain components
+        // (any nested component renders a `{{template}}` action, which
+        // the bake extractors reject), so recursing is a no-op for them.
+        for (const child of effectiveChildren) {
+          this.collectStaticChildInstancesRecursive(child, result, inLoop, providerCtx)
+        }
       }
       // Recurse into Portal's children to find nested components
       if (comp.name === 'Portal' && comp.children) {
@@ -2099,6 +2695,16 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
       if (cond.whenFalse) {
         this.collectStaticChildInstancesRecursive(cond.whenFalse, result, inLoop, providerCtx)
       }
+    } else if (node.type === 'if-statement') {
+      // (#1896) An early-return if-statement root (AccordionTrigger's
+      // asChild split) keeps its subtrees in consequent/alternate — the
+      // non-asChild branch's ChevronDownIcon needs its slot field like
+      // any other static child.
+      const stmt = node as IRIfStatement
+      this.collectStaticChildInstancesRecursive(stmt.consequent, result, inLoop, providerCtx)
+      if (stmt.alternate) {
+        this.collectStaticChildInstancesRecursive(stmt.alternate, result, inLoop, providerCtx)
+      }
     } else if (node.type === 'provider') {
       // SSR context propagation: record the provider's value against its
       // context name and extend the active binding map for descendants. A
@@ -2974,8 +3580,12 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
         }
         const lines: string[] = []
         lines.push('func() string {')
-        lines.push(`\t\t\tk, _ := in.${fieldName}.(string)`)
-        lines.push('\t\t\tswitch k {')
+        // `fmt.Sprint` is type-tolerant: the key field is `interface{}`
+        // when the analyzer typed the prop, but a `string` when the
+        // shared inherited-prop augmentation synthesised it (#1896) — a
+        // `.(string)` assertion compiles for the former only.
+        this.usesFmt = true
+        lines.push(`\t\t\tswitch fmt.Sprint(in.${fieldName}) {`)
         for (const [k, v] of caseEntries) {
           lines.push(`\t\t\tcase ${JSON.stringify(k)}: return ${JSON.stringify(v)}`)
         }
@@ -2999,6 +3609,31 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     memos: { name: string; computation: string; deps: string[] }[],
     propsParams: { name: string }[]
   ): string | null {
+    // `getter() === 'lit'` / `!==` as a child-instance prop value
+    // (#1896 — accordion's `open={openItem() === 'item-1'}`): resolves
+    // to a Go bool when the signal's initial value is a string literal.
+    const cmpMatch = expr.match(
+      /^(\w+)\(\)\s*([!=]==?)\s*(?:'([^']*)'|(-?\d+(?:\.\d+)?))\s*$/,
+    )
+    if (cmpMatch) {
+      const [, depName, op, strLit, numLit] = cmpMatch
+      const signal = signals.find(sg => sg.getter === depName)
+      const init = signal?.initialValue.trim()
+      const initMatch = init !== undefined
+        ? /^(?:'([^'\\]*)'|(-?\d+(?:\.\d+)?))$/.exec(init)
+        : null
+      if (initMatch) {
+        const initVal = initMatch[1] ?? initMatch[2]
+        const litVal = strLit ?? numLit
+        // Same-kind comparison only (string vs string, number vs number).
+        const sameKind = (initMatch[1] !== undefined) === (strLit !== undefined)
+        if (sameKind) {
+          const equal = initVal === litVal
+          return String(op.startsWith('!') ? !equal : equal)
+        }
+      }
+    }
+
     // Match signal/memo getter calls like count(), doubled()
     const getterMatch = expr.match(/^([a-zA-Z_][a-zA-Z0-9_]*)\(\)$/)
     if (getterMatch) {
@@ -3010,10 +3645,12 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
         return this.convertInitialValue(signal.initialValue, signal.type, propsParams)
       }
 
-      // Check if it's a memo
+      // Check if it's a memo. Use the pattern-matching core: when no
+      // pattern applies, return null so the caller OMITS the field and
+      // Go's typed zero value applies (#1896).
       const memo = memos.find(m => m.name === getterName)
       if (memo) {
-        return this.computeMemoInitialValue(memo, signals, propsParams)
+        return this.computeMemoInitialValueOrNull(memo, signals, propsParams)
       }
     }
 
@@ -3256,6 +3893,47 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     // `string`, else the historical `0`).
     goType?: string,
   ): string {
+    const resolved = this.computeMemoInitialValueOrNull(
+      memo, signals, propsParams, propFallbackVars,
+    )
+    if (resolved !== null) return resolved
+    // Default: zero value for the memo's Go type (#checkbox). A boolean memo
+    // (`isChecked`) renders `false`, a string memo `""`; reference types
+    // (map / slice / interface / pointer) take `nil` — `0` is not
+    // assignable to them and broke the struct literal for a
+    // block-bodied string-building memo whose type inferred to
+    // `map[string]any` (#1896, select-demo's `summary`). Other types
+    // keep the historical int `0`.
+    if (goType === 'bool') return 'false'
+    if (goType === 'string') return '""'
+    if (
+      goType !== undefined &&
+      (goType.startsWith('map[') ||
+        goType.startsWith('[]') ||
+        goType.startsWith('*') ||
+        goType.includes('interface{}') ||
+        goType === 'any')
+    ) {
+      return 'nil'
+    }
+    return '0'
+  }
+
+  /**
+   * Pattern-matching core of `computeMemoInitialValue`: returns the
+   * memo's SSR initial value as a Go expression, or `null` when no
+   * pattern applies. Callers that have a typed field to fill use the
+   * zero-value-defaulting wrapper above; callers that can simply OMIT
+   * the field (a child-instance prop init — Go's zero values then apply
+   * with the right type for free) use this directly (#1896,
+   * data-table's `Checked: 0` into a bool field).
+   */
+  private computeMemoInitialValueOrNull(
+    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,
+  ): string | null {
     const computation = memo.computation
     // Helper to pick the hoisted var (if any) or fall back to `in.X`.
     const propRef = (propName: string): string => {
@@ -3274,6 +3952,71 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     const tmplMemo = this.computeTemplateLiteralMemoInitialValue(computation, propsParams)
     if (tmplMemo !== null) return tmplMemo
 
+    // Pattern: () => getter() === 'lit' / !== 'lit' — a selection memo
+    // (#1896, tabs' `isAccountSelected = createMemo(() => activeTab() ===
+    // 'account')`). Resolves to a Go bool when the signal's initial value
+    // is itself a string literal.
+    const eqMatch = computation.match(
+      /^\(\)\s*=>\s*(\w+)\(\)\s*([!=]==?)\s*'([^']*)'\s*$/,
+    )
+    if (eqMatch) {
+      const [, depName, op, lit] = eqMatch
+      const signal = signals.find(sg => sg.getter === depName)
+      const initLit = signal ? /^'([^'\\]*)'$/.exec(signal.initialValue.trim()) : null
+      if (initLit) {
+        const equal = initLit[1] === lit
+        return String(op.startsWith('!') ? !equal : equal)
+      }
+    }
+
+    // Pattern: () => props.X ?? false — a boolean passthrough memo
+    // (#1896, SelectItem's `isDisabled`). Go's bool zero value IS the
+    // `?? false` fallback, so the raw input field carries the memo
+    // semantics exactly.
+    const boolPassthrough = computation.match(
+      /^\(\)\s*=>\s*props\.(\w+)\s*\?\?\s*false\s*$/,
+    )
+    if (boolPassthrough) {
+      return propRef(boolPassthrough[1])
+    }
+
+    // Pattern: () => cond() ? A : B where each branch is a module string
+    // const or a string literal, and `cond` is a signal/memo this
+    // resolver can already evaluate (#1896, SelectItem's
+    // `stateClasses`). Emits a Go conditional so the SSR value tracks
+    // the caller's input rather than a baked branch.
+    const ternMatch = computation.match(
+      /^\(\)\s*=>\s*(\w+)\(\)\s*\?\s*([\w$]+|'[^']*')\s*:\s*([\w$]+|'[^']*')\s*$/,
+    )
+    if (ternMatch) {
+      const [, condName, whenTrue, whenFalse] = ternMatch
+      const resolveBranch = (b: string): string | null => {
+        const lit = /^'([^']*)'$/.exec(b)
+        if (lit) return JSON.stringify(lit[1])
+        const constVal = this.moduleStringConsts.get(b)
+        return constVal !== undefined ? JSON.stringify(constVal) : null
+      }
+      const t = resolveBranch(whenTrue)
+      const f = resolveBranch(whenFalse)
+      if (t !== null && f !== null) {
+        let condGo: string | null = null
+        const condSignal = signals.find(sg => sg.getter === condName)
+        if (condSignal) {
+          condGo = this.getSignalInitialValueAsGo(condSignal.initialValue, propsParams, propFallbackVars)
+        } else {
+          const condMemo = (this.currentMemos ?? []).find(m => m.name === condName)
+          if (condMemo) {
+            condGo = this.computeMemoInitialValueOrNull(condMemo, signals, propsParams, propFallbackVars)
+          }
+        }
+        if (condGo === 'true') return t
+        if (condGo === 'false') return f
+        if (condGo !== null) {
+          return `func() string { if ${condGo} { return ${t} }; return ${f} }()`
+        }
+      }
+    }
+
     // Pattern: () => dep() * N or () => dep() + N etc.
     const arithmeticMatch = computation.match(/\(\)\s*=>\s*(\w+)\(\)\s*([*+\-/])\s*(\d+)/)
     if (arithmeticMatch) {
@@ -3352,55 +4095,486 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
       }
     }
 
-    // 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'
+    // (#1897) Pattern: block-body memo that early-returns a module-const array
+    // when a guard signal is falsy — `() => { const k = getter(); if (!k)
+    // return MODULE_ARRAY; return /* @client */ ... }`. When the signal starts
+    // null, the SSR value is the module-const array. The constant's literal
+    // value (not the identifier) is passed to the baker so `jsLiteralToGo`
+    // can reduce it to a Go slice.
+    const blockReturn = this.resolveBlockBodyMemoModuleConst(computation, signals)
+    if (blockReturn !== null && blockReturn.constValue && blockReturn.constType) {
+      return this.convertInitialValue(
+        blockReturn.constValue,
+        blockReturn.constType,
+        propsParams,
+      )
+    }
+
+    // (#1897 PostList) Pattern: an object-returning block-body memo derived from
+    // `searchParams()` — `() => { const sp = searchParams(); return { sort:
+    // asSortKey(sp.get('sort')), tag: sp.get('tag') ?? '' } }`. Compute a Go
+    // `map[string]interface{}` whose values are lowered from the request query,
+    // so `.Params.Sort` / `.Params.Tag` resolve at execute time instead of
+    // reading a nil map. Returns null for any unsupported shape (→ nil fallback,
+    // no regression).
+    const objMemo = this.computeObjectMemoInitialValue(computation)
+    if (objMemo !== null) return objMemo
+
+    return null
   }
 
   /**
-   * Whether a memo is an arrow whose result is a template literal — either a
-   * concise body (`() => \`…\``) or a block body whose `return` is one.
+   * (#1897) Recognises a block-body memo whose SSR path returns a module-const
+   * array when the guard signal starts falsy:
+   *   `() => { const k = getter(); if (!k) return MODULE_CONST; … }`
+   * Returns the constant's name and inferred type, or null.
    */
-  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
+  private resolveBlockBodyMemoModuleConst(
+    computation: string,
+    signals: { getter: string; initialValue: string }[],
+  ): { constName: string; constValue: string | undefined; constType: TypeInfo | undefined } | null {
+    try {
+      const sf = ts.createSourceFile(
+        '__memo.ts',
+        `const __x = (${computation});`,
+        ts.ScriptTarget.Latest,
+        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
+      const body = init.body
+      if (!ts.isBlock(body)) return null
+
+      // Walk the block's statements collecting:
+      //   const <varName> = <signalGetter>()   →  varToSignal map
+      //   if (!<varName>) return <moduleConst>  →  match varName back to signal
+      const varToSignal = new Map<string, string>()
+      let guardSignalGetter: string | null = null
+      let returnedConst: string | null = null
+
+      for (const s of body.statements) {
+        if (ts.isVariableStatement(s)) {
+          for (const decl of s.declarationList.declarations) {
+            if (
+              ts.isIdentifier(decl.name) &&
+              decl.initializer &&
+              ts.isCallExpression(decl.initializer) &&
+              ts.isIdentifier(decl.initializer.expression)
+            ) {
+              const callee = decl.initializer.expression.text
+              if (signals.some(sg => sg.getter === callee)) {
+                varToSignal.set(decl.name.text, callee)
+              }
+            }
+          }
+        }
+        if (
+          ts.isIfStatement(s) &&
+          ts.isPrefixUnaryExpression(s.expression) &&
+          s.expression.operator === ts.SyntaxKind.ExclamationToken &&
+          ts.isIdentifier(s.expression.operand)
+        ) {
+          const guardVar = s.expression.operand.text
+          const signalGetter = varToSignal.get(guardVar)
+          if (!signalGetter) continue
+          const thenBlock = ts.isBlock(s.thenStatement)
+            ? s.thenStatement.statements
+            : [s.thenStatement]
+          for (const rs of thenBlock) {
+            if (
+              ts.isReturnStatement(rs) &&
+              rs.expression &&
+              ts.isIdentifier(rs.expression)
+            ) {
+              guardSignalGetter = signalGetter
+              returnedConst = rs.expression.text
+            }
+          }
+        }
+        if (guardSignalGetter && returnedConst) break
+      }
+
+      if (!guardSignalGetter || !returnedConst) return null
+
+      // The guard signal must start falsy (null, '', 0, false)
+      const guardSignal = signals.find(sg => sg.getter === guardSignalGetter)
+      if (!guardSignal) return null
+      const iv = guardSignal.initialValue.trim()
+      if (iv !== 'null' && iv !== "''" && iv !== '""' && iv !== '0' && iv !== 'false') {
+        return null
+      }
+
+      // The returned identifier must be a module-scope constant
+      const constant = this.localConstants.find(
+        c => c.name === returnedConst && c.origin?.scope === 'module',
+      )
+      if (!constant) return null
+
+      return {
+        constName: constant.name,
+        constValue: constant.value,
+        constType: constant.type ?? undefined,
       }
+    } catch {
+      return null
     }
-    return ts.isTemplateExpression(body) || ts.isNoSubstitutionTemplateLiteral(body)
   }
 
   /**
-   * Infer the Go type for a memo based on its computation and dependencies.
+   * (#1897 PostList) Compute the SSR value of an object-returning block-body
+   * memo derived from `searchParams()`:
+   *   () => { const sp = searchParams(); return { sort: asSortKey(sp.get('sort')),
+   *                                               tag: sp.get('tag') ?? '' } }
+   * Emits a Go `map[string]interface{}{ "Sort": …, "Tag": … }` whose values are
+   * lowered from the request query (see `lowerCtorExpr`). Keys are capitalized to
+   * match the template's `.Params.<Field>` map access. Returns null for any shape
+   * the lowerer can't represent, so the caller falls back to a nil map.
    */
-  private inferMemoType(
-    memo: { name: string; computation: string; type: TypeInfo; deps: string[] },
-    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'
-
+  private computeObjectMemoInitialValue(computation: string): string | null {
+    const arrow = this.parseLiteralExpression(computation)
+    if (!arrow || !ts.isArrowFunction(arrow) || !ts.isBlock(arrow.body)) return null
+
+    // Accept only a strict shape: zero or more `const`/`let` declarations
+    // followed by exactly one `return { … }` as the LAST statement. Any other
+    // statement kind — `if`, an early/extra `return`, a loop, a bare call —
+    // means the block has control flow this resolver can't reason about, so we
+    // bail to the nil fallback rather than silently lowering one of several
+    // returns (#1941 review). Along the way, collect `const <v> = searchParams()`
+    // bindings (the env for `<v>.get('k')`).
+    const searchParamsVars = new Set<string>()
+    let retObj: ts.ObjectLiteralExpression | null = null
+    const statements = arrow.body.statements
+    for (let i = 0; i < statements.length; i++) {
+      const s = statements[i]
+      if (ts.isVariableStatement(s)) {
+        for (const d of s.declarationList.declarations) {
+          if (
+            ts.isIdentifier(d.name) &&
+            d.initializer &&
+            ts.isCallExpression(d.initializer) &&
+            ts.isIdentifier(d.initializer.expression) &&
+            d.initializer.arguments.length === 0 &&
+            this.searchParamsLocals.has(d.initializer.expression.text)
+          ) {
+            searchParamsVars.add(d.name.text)
+          }
+        }
+        continue
+      }
+      if (ts.isReturnStatement(s)) {
+        // The return must be the last statement (so it's the only one) and
+        // return an object literal.
+        if (i !== statements.length - 1 || !s.expression) return null
+        let e: ts.Expression = s.expression
+        while (ts.isParenthesizedExpression(e)) e = e.expression
+        if (!ts.isObjectLiteralExpression(e)) return null
+        retObj = e
+        continue
+      }
+      // Any other statement kind → control flow we don't model → bail.
+      return null
+    }
+    if (!retObj || retObj.properties.length === 0) return null
+
+    const env: CtorLowerEnv = { searchParamsVars, params: new Map() }
+    const entries: string[] = []
+    for (const prop of retObj.properties) {
+      if (!ts.isPropertyAssignment(prop)) return null
+      const key =
+        ts.isIdentifier(prop.name) || ts.isStringLiteral(prop.name) ? prop.name.text : null
+      if (!key) return null
+      const go = this.lowerCtorExpr(prop.initializer, env)
+      if (go === null) return null
+      entries.push(`"${this.capitalizeFieldName(key)}": ${go}`)
+    }
+    return `map[string]interface{}{\n\t\t${entries.join(',\n\t\t')},\n\t}`
+  }
+
+  /**
+   * Lower a JS expression to a Go expression in the `NewXxxProps` constructor
+   * context. This is Go *code*, not template syntax — so a search-param read
+   * becomes `in.SearchParams.Get("k")` (method call), not the template's
+   * `.SearchParams.Get "k"`. Supports the narrow surface derived-state memos
+   * need: string/number literals, `<sp>.get('k')`, `<arr>.includes(<x>)`,
+   * module arrow-helper inlining, `<expr> ?? <fallback>`, and string ternaries.
+   * Returns null for anything else so the caller can fall back safely.
+   */
+  private lowerCtorExpr(node: ts.Expression, env: CtorLowerEnv): string | null {
+    while (ts.isParenthesizedExpression(node)) node = node.expression
+
+    if (ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node)) {
+      return JSON.stringify(node.text)
+    }
+    if (ts.isNumericLiteral(node)) return node.text
+
+    // Identifier: a substituted helper param, a module string const, or a
+    // component-scope derived const inlined recursively (e.g. `root` → its
+    // `base || '/'` value).
+    if (ts.isIdentifier(node)) {
+      const sub = env.params.get(node.text)
+      if (sub !== undefined) return sub
+      const c = this.localConstants.find(lc => lc.name === node.text)
+      if (c?.value !== undefined) {
+        if (c.isModule) {
+          const lit = this.parseLiteralExpression(c.value)
+          if (lit && (ts.isStringLiteral(lit) || ts.isNoSubstitutionTemplateLiteral(lit))) {
+            return JSON.stringify(lit.text)
+          }
+          return null
+        }
+        // Component-scope const: inline its computed value, guarding cycles.
+        if (env.consts?.has(node.text)) return null
+        const inner = this.parseLiteralExpression(c.value)
+        if (!inner) return null
+        return this.lowerCtorExpr(inner, {
+          ...env,
+          consts: new Set([...(env.consts ?? []), node.text]),
+        })
+      }
+      return null
+    }
+
+    // `props.<X>` → the constructor input field `in.<X>`.
+    if (
+      ts.isPropertyAccessExpression(node) &&
+      ts.isIdentifier(node.expression) &&
+      node.expression.text === this.propsObjectName
+    ) {
+      return `in.${this.capitalizeFieldName(node.name.text)}`
+    }
+
+    if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression)) {
+      const method = node.expression.name.text
+      const recv = node.expression.expression
+      // `<sp>.get('k')` where <sp> is bound to searchParams().
+      if (
+        method === 'get' &&
+        ts.isIdentifier(recv) &&
+        env.searchParamsVars.has(recv.text) &&
+        node.arguments.length === 1 &&
+        ts.isStringLiteral(node.arguments[0])
+      ) {
+        return `in.SearchParams.Get(${JSON.stringify(node.arguments[0].text)})`
+      }
+      // `<arr>.includes(<x>)` → bf.Includes(<[]string{…}>, <x>) (bool).
+      if (method === 'includes' && node.arguments.length === 1) {
+        const arr = this.lowerCtorStringArray(recv)
+        const elem = this.lowerCtorExpr(node.arguments[0], env)
+        if (arr !== null && elem !== null) return `bf.Includes(${arr}, ${elem})`
+        return null
+      }
+      // `<s>.replace(/\/+$/, '')` — strip trailing slashes → strings.TrimRight.
+      // Only this exact trailing-slash regex is recognized (a general regex
+      // replace would need Go's regexp; out of scope).
+      if (
+        method === 'replace' &&
+        node.arguments.length === 2 &&
+        node.arguments[0].kind === ts.SyntaxKind.RegularExpressionLiteral &&
+        (node.arguments[0] as ts.Node).getText() === '/\\/+$/' &&
+        (ts.isStringLiteral(node.arguments[1]) ||
+          ts.isNoSubstitutionTemplateLiteral(node.arguments[1])) &&
+        node.arguments[1].text === ''
+      ) {
+        const recvGo = this.lowerCtorExpr(recv, env)
+        if (recvGo === null) return null
+        this.needsStringsImport = true
+        return `strings.TrimRight(${recvGo}, "/")`
+      }
+      return null
+    }
+
+    // `helper(<args>)` where helper is a module arrow const → inline its body.
+    if (ts.isCallExpression(node) && ts.isIdentifier(node.expression)) {
+      const fnConst = this.localConstants.find(
+        lc => lc.name === (node.expression as ts.Identifier).text && lc.isModule,
+      )
+      if (fnConst?.value) {
+        const fn = this.parseLiteralExpression(fnConst.value)
+        if (
+          fn &&
+          ts.isArrowFunction(fn) &&
+          !ts.isBlock(fn.body) &&
+          fn.parameters.length === node.arguments.length
+        ) {
+          const params = new Map(env.params)
+          for (let i = 0; i < fn.parameters.length; i++) {
+            const p = fn.parameters[i]
+            if (!ts.isIdentifier(p.name)) return null
+            const argGo = this.lowerCtorExpr(node.arguments[i], env)
+            if (argGo === null) return null
+            params.set(p.name.text, argGo)
+          }
+          return this.lowerCtorExpr(fn.body, { searchParamsVars: env.searchParamsVars, params })
+        }
+      }
+      return null
+    }
+
+    // `<expr> ?? <fallback>`
+    if (
+      ts.isBinaryExpression(node) &&
+      node.operatorToken.kind === ts.SyntaxKind.QuestionQuestionToken
+    ) {
+      const left = this.lowerCtorExpr(node.left, env)
+      if (left === null) return null
+      let r: ts.Expression = node.right
+      while (ts.isParenthesizedExpression(r)) r = r.expression
+      // `?? ''` is a no-op: SearchParams.Get already returns "" for a missing key.
+      if ((ts.isStringLiteral(r) || ts.isNoSubstitutionTemplateLiteral(r)) && r.text === '') {
+        return left
+      }
+      const right = this.lowerCtorExpr(node.right, env)
+      if (right === null) return null
+      return `func() string { v := ${left}; if v != "" { return v }; return ${right} }()`
+    }
+
+    // `<expr> || <fallback>` (string `||` — falsy = empty, like `?? ''` but the
+    // left can itself be empty): `base || '/'`.
+    if (
+      ts.isBinaryExpression(node) &&
+      node.operatorToken.kind === ts.SyntaxKind.BarBarToken
+    ) {
+      const left = this.lowerCtorExpr(node.left, env)
+      const right = this.lowerCtorExpr(node.right, env)
+      if (left === null || right === null) return null
+      return `func() string { v := ${left}; if v != "" { return v }; return ${right} }()`
+    }
+
+    // `<cond> ? <t> : <f>` (string result)
+    if (ts.isConditionalExpression(node)) {
+      // The condition must be lowered as a *boolean* (`lowerCtorCond`), not a
+      // value: a string-valued JS condition like `sp.get('tag') ? a : b` is
+      // truthy in JS, but `if "<string>"` does not compile in Go — such shapes
+      // return null so the memo falls back to nil rather than emitting invalid
+      // code (#1941 review).
+      const cond = this.lowerCtorCond(node.condition, env)
+      const t = this.lowerCtorExpr(node.whenTrue, env)
+      const f = this.lowerCtorExpr(node.whenFalse, env)
+      if (cond !== null && t !== null && f !== null) {
+        return `func() string { if ${cond} { return ${t} }; return ${f} }()`
+      }
+      return null
+    }
+
+    return null
+  }
+
+  /**
+   * Lower a JS expression used as a *boolean* condition to a Go bool expression,
+   * or null when it is not provably boolean. Distinct from `lowerCtorExpr`,
+   * which lowers value expressions: a string-valued condition (`sp.get('tag')`)
+   * is truthy in JS but `if "<string>"` does not compile in Go, so anything not
+   * known to yield a Go bool must fall back to null (#1941 review).
+   */
+  private lowerCtorCond(node: ts.Expression, env: CtorLowerEnv): string | null {
+    while (ts.isParenthesizedExpression(node)) node = node.expression
+
+    if (node.kind === ts.SyntaxKind.TrueKeyword) return 'true'
+    if (node.kind === ts.SyntaxKind.FalseKeyword) return 'false'
+
+    // `!<cond>`
+    if (
+      ts.isPrefixUnaryExpression(node) &&
+      node.operator === ts.SyntaxKind.ExclamationToken
+    ) {
+      const inner = this.lowerCtorCond(node.operand, env)
+      return inner === null ? null : `!(${inner})`
+    }
+
+    // `<a> && <b>` / `<a> || <b>` — both operands must themselves be boolean.
+    if (ts.isBinaryExpression(node)) {
+      const op =
+        node.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken
+          ? '&&'
+          : node.operatorToken.kind === ts.SyntaxKind.BarBarToken
+            ? '||'
+            : null
+      if (op) {
+        const l = this.lowerCtorCond(node.left, env)
+        const r = this.lowerCtorCond(node.right, env)
+        return l !== null && r !== null ? `(${l} ${op} ${r})` : null
+      }
+    }
+
+    // `<arr>.includes(<x>)` is the one value-shape `lowerCtorExpr` lowers to a
+    // Go bool (`bf.Includes(...)`); reuse it for that case only.
+    if (
+      ts.isCallExpression(node) &&
+      ts.isPropertyAccessExpression(node.expression) &&
+      node.expression.name.text === 'includes'
+    ) {
+      return this.lowerCtorExpr(node, env)
+    }
+
+    return null
+  }
+
+  /**
+   * Resolve a string-array expression (a `['a','b']` literal, or a module const
+   * bound to one) to a Go `[]string{…}` literal, or null when it isn't a pure
+   * string-array. Used by `lowerCtorExpr` for `<arr>.includes(<x>)`.
+   */
+  private lowerCtorStringArray(node: ts.Expression): string | null {
+    let arr: ts.Expression | null = node
+    if (ts.isIdentifier(node)) {
+      const c = this.localConstants.find(lc => lc.name === node.text && lc.isModule)
+      if (!c?.value) return null
+      arr = this.parseLiteralExpression(c.value)
+    }
+    if (!arr || !ts.isArrayLiteralExpression(arr)) return null
+    const elems: string[] = []
+    for (const el of arr.elements) {
+      if (ts.isStringLiteral(el) || ts.isNoSubstitutionTemplateLiteral(el)) {
+        elems.push(JSON.stringify(el.text))
+      } else return null
+    }
+    return `[]string{${elems.join(', ')}}`
+  }
+
+  /**
+   * 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.
+   */
+  private inferMemoType(
+    memo: { name: string; computation: string; type: TypeInfo; deps: string[] },
+    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('-')) {
@@ -3438,6 +4612,13 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
       return 'bool'
     }
 
+    // (#1897) Block-body memo returning a module-const array: use the
+    // constant's array type instead of the memo's generic `object`.
+    const blockReturn = this.resolveBlockBodyMemoModuleConst(memo.computation, signals)
+    if (blockReturn?.constType?.kind === 'array') {
+      return this.typeInfoToGo(blockReturn.constType)
+    }
+
     // Default to the memo's declared type
     return this.typeInfoToGo(memo.type)
   }
@@ -3816,6 +4997,12 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     if (element.slotId) {
       hydrationAttrs += ` ${this.renderSlotMarker(element.slotId)}`
     }
+    // Page-lifecycle boundary lowered from `<Region>` (spec/router.md). The id
+    // is a deterministic static string (`<file scope>:<index>`), so it emits as
+    // a plain literal attribute — no Go-template interpolation.
+    if (element.regionId) {
+      hydrationAttrs += ` ${BF_REGION}="${element.regionId}"`
+    }
 
     const voidElements = [
       'area', 'base', 'br', 'col', 'embed', 'hr', 'img', 'input',
@@ -3839,12 +5026,32 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
       return ''
     }
 
-    const goExpr = this.convertExpressionToGo(expr.expr)
-
-    // If the expression already contains Go template blocks (e.g., {{with ...}}),
-    // don't wrap it again in {{...}} to avoid double-wrapping.
+    // Let `convertExpressionToGo` report the `ParsedExpr` it already builds (if
+    // it gets that far) so the wrap decision below reuses that single parse —
+    // no extra `ts.createSourceFile`, and no parse at all for expressions it
+    // resolves via early returns (`null`/`undefined`, inlined consts) on the
+    // `bf build` hot path.
+    const classify: { parsed?: ParsedExpr } = {}
+    const goExpr = this.convertExpressionToGo(expr.expr, classify)
+
+    // If the lowered expression is already template text, don't wrap it again
+    // in {{...}} (double-wrapping). Two distinct shapes reach here:
+    //   - whole-expression blocks that START with `{{` (a `{{with ...}}` /
+    //     `{{if ...}}` chain from a nested ternary), and
+    //   - template literals, which lower via `templateLiteral()` to a MIX of
+    //     literal text and actions (` · #${tag}` → ` · #{{.Tag}}`). Those don't
+    //     start with `{{`, so a plain `startsWith` test let them fall through to
+    //     the wrap below and produced `{{ · #{{.Tag}}}}` — invalid
+    //     `html/template` syntax that panics at parse time (#1933, blog PostList
+    //     status line).
+    //
+    // `isTemplateFragment` makes this decision structurally (a `{{`-leading
+    // action block or a template-literal kind), not by substring-matching `{{`:
+    // a bare string literal that merely CONTAINS `{{` (JSX `{"{{"}` → Go expr
+    // `"{{"`) is neither — it must still be wrapped so html/template evaluates
+    // and escapes the string instead of emitting the raw quotes (#1937 review).
     // Use comment markers instead of <span> to avoid changing DOM structure.
-    if (goExpr.startsWith('{{')) {
+    if (this.isTemplateFragment(goExpr, classify.parsed?.kind)) {
       if (expr.slotId) {
         return `{{bfTextStart "${expr.slotId}"}}${goExpr}{{bfTextEnd}}`
       }
@@ -3860,6 +5067,41 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     return `{{${goExpr}}}`
   }
 
+  /**
+   * Decide whether a lowered Go string is ALREADY a self-contained template
+   * fragment — i.e. it carries its own `{{...}}` actions and so must NOT be
+   * re-wrapped in another `{{...}}` (doing so yields `{{ {{...}} }}`, which
+   * `html/template` rejects at parse time). Single source of truth for the
+   * wrap-or-not decision across `renderExpression`, `templateLiteral`, and the
+   * static-string / attribute interpolation paths.
+   *
+   * The decision is STRUCTURAL, deliberately NOT a `{{` substring scan: literal
+   * text and Go string literals are ambiguous to scan — `5" ${x}` lowers to
+   * `5" {{.X}}` while JS `{"{{"}` lowers to the Go literal `"{{"`; both mix
+   * quotes and braces, so no scan can tell them apart. Two — and only two —
+   * structural shapes are fragments:
+   *
+   *   1. A pure action block (`{{if}}` / `{{with}}` / `{{range}}` from a ternary,
+   *      a `find().prop`, a `filter().length`, …). The emitter prepends NO
+   *      literal text to these, so they ALWAYS start with `{{`; a leading `{{`
+   *      is therefore an unambiguous structural marker for this whole class.
+   *   2. A template literal — the ONLY source form that interleaves author
+   *      literal text with `{{...}}` actions (` · #${tag}` → ` · #{{.Tag}}`), so
+   *      it may begin with literal text and is detected by its parsed `kind`.
+   *
+   * Everything else is a bare pipeline (`.Foo`, `len .X`, `bf_arr …`) — even one
+   * whose value contains `{{` inside a Go string literal — and MUST be wrapped.
+   *
+   * Invariant (enforced by the `template-fragment invariant` tests): no
+   * non-template-literal fragment ever begins with literal text, so case 1's
+   * `startsWith('{{')` is complete. If a future emitter prepends literal text to
+   * an action block those tests fail — fix it by giving that shape a parsed kind
+   * this helper can key off, exactly as template literals are handled here.
+   */
+  private isTemplateFragment(go: string, kind?: ParsedExpr['kind']): boolean {
+    return go.startsWith('{{') || kind === 'template-literal'
+  }
+
   /**
    * Render a client-only conditional as comment markers.
    * Used when @client directive is applied to an unsupported conditional.
@@ -3888,6 +5130,11 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
   // ===========================================================================
 
   identifier(name: string): string {
+    // `undefined` / `null` inside a larger expression tree (a ternary
+    // branch like `props.isActive ? 'page' : undefined`, #1896
+    // pagination) renders as the empty string — the top-level
+    // `convertExpressionToGo` short-circuit doesn't see nested ones.
+    if (name === 'undefined' || name === 'null') return '""'
     // Module pure-string const (e.g. `const baseClasses = '...'` used in a
     // className template literal): inline the literal value rather than
     // emit `{{.BaseClasses}}` against a Props field that never exists.
@@ -3901,6 +5148,11 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     }
     const inlined = this.resolveModuleStringConst(name)
     if (inlined !== null) return inlined
+    // Module numeric const (e.g. `const TRACK = 8` used in a width expression):
+    // inline the literal value rather than emit `{{.TRACK}}` against a Props
+    // field that never exists. Mirrors the string-const inlining above.
+    const inlinedNum = this.resolveModuleNumericConst(name)
+    if (inlinedNum !== null) return inlinedNum
     const currentLoopParam = this.loopParamStack[this.loopParamStack.length - 1]
     if (currentLoopParam && name === currentLoopParam) return '.'
     // An *outer* loop's value variable (we're in a nested loop) is in scope as
@@ -3908,7 +5160,101 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     // the inner dot no longer refers to it, and it's not a root field. (#1677)
     if (this.isOuterLoopParam(name)) return `$${name}`
     if (this.loopVarRefCount.has(name)) return `$${name}`
-    return this.rootFieldRef(name)
+    // (#1897) A bare reference to a component-scope derived const (e.g. `root`)
+    // lowers to `.Root`; note it so `generateTypes` emits a computed field.
+    if (this.localConstants.some(c => c.name === name && !c.isModule && !c.containsArrow)) {
+      this.referencedDerivedConsts.add(name)
+    }
+    // Env-signal binding (incl. an alias) → canonical `.SearchParams` (#1922).
+    return this.searchParamsFieldRef(name) ?? this.rootFieldRef(name)
+  }
+
+  /**
+   * (#1897 PostList) Compute the Go struct fields for component-scope derived
+   * string consts referenced by the template (e.g. `root = base || '/'`). Each
+   * is lowered to a constructor-context Go expression via `lowerCtorExpr`, with
+   * its dependency consts inlined. Skips names that collide with an existing
+   * field (`takenFieldNames`) or that the lowerer can't represent.
+   */
+  private computeDerivedConstFields(
+    takenFieldNames: ReadonlySet<string>,
+  ): { name: string; init: string }[] {
+    const fields: { name: string; init: string }[] = []
+    for (const name of this.referencedDerivedConsts) {
+      const fieldName = this.capitalizeFieldName(name)
+      if (takenFieldNames.has(fieldName)) continue
+      const c = this.localConstants.find(lc => lc.name === name && !lc.isModule && lc.value)
+      if (!c?.value) continue
+      const expr = this.parseLiteralExpression(c.value)
+      if (!expr) continue
+      // The field is typed `string`; only emit when the value is provably a Go
+      // string, so a numeric/other const referenced in the template can't be
+      // assigned into a string field (#1945 review).
+      if (!this.isStringExpr(expr, new Set())) continue
+      const init = this.lowerCtorExpr(expr, {
+        searchParamsVars: new Set(),
+        params: new Map(),
+        consts: new Set([name]),
+      })
+      if (init === null) continue
+      fields.push({ name: fieldName, init })
+    }
+    return fields
+  }
+
+  /**
+   * Conservative check that a JS expression is *definitely* string-valued —
+   * used to gate derived-const field emission (the field is typed `string`).
+   * Recognizes string/template literals, string-returning methods (`.replace`,
+   * `.trim`, … and `searchParams().get`), `+` / `||` / `??` where a branch is
+   * string-valued, and a component-const reference to such a value. Anything
+   * unproven (numbers, `props.X`, calls it doesn't know) returns false.
+   */
+  private isStringExpr(node: ts.Expression, seen: Set<string>): boolean {
+    while (ts.isParenthesizedExpression(node)) node = node.expression
+    if (
+      ts.isStringLiteral(node) ||
+      ts.isNoSubstitutionTemplateLiteral(node) ||
+      ts.isTemplateExpression(node)
+    ) {
+      return true
+    }
+    if (ts.isBinaryExpression(node)) {
+      const op = node.operatorToken.kind
+      // `+`: a string on *either* side forces string concatenation.
+      if (op === ts.SyntaxKind.PlusToken) {
+        return this.isStringExpr(node.left, seen) || this.isStringExpr(node.right, seen)
+      }
+      // `||` / `??` evaluate to *one* operand, so the result is only provably a
+      // string when *both* sides are (`props.count ?? ''` is not — it can be the
+      // number) (#1945 review).
+      if (op === ts.SyntaxKind.BarBarToken || op === ts.SyntaxKind.QuestionQuestionToken) {
+        return this.isStringExpr(node.left, seen) && this.isStringExpr(node.right, seen)
+      }
+      return false
+    }
+    if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression)) {
+      const m = node.expression.name.text
+      const STRING_METHODS = new Set([
+        'replace', 'trim', 'trimStart', 'trimEnd', 'toLowerCase', 'toUpperCase',
+        'slice', 'substring', 'substr', 'padStart', 'padEnd', 'concat', 'repeat', 'get',
+      ])
+      return STRING_METHODS.has(m)
+    }
+    if (ts.isConditionalExpression(node)) {
+      return (
+        this.isStringExpr(node.whenTrue, seen) && this.isStringExpr(node.whenFalse, seen)
+      )
+    }
+    if (ts.isIdentifier(node)) {
+      if (seen.has(node.text)) return false
+      const c = this.localConstants.find(lc => lc.name === node.text && !lc.isModule && lc.value)
+      if (c?.value) {
+        const inner = this.parseLiteralExpression(c.value)
+        if (inner) return this.isStringExpr(inner, new Set([...seen, node.text]))
+      }
+    }
+    return false
   }
 
   /**
@@ -3937,6 +5283,17 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     return `${prefix}${this.capitalizeFieldName(name)}`
   }
 
+  /**
+   * (#1922) When `name` is a local binding of the `searchParams()` env signal,
+   * resolve it to the canonical `.SearchParams` field — not `.<Capitalized
+   * name>` — so an aliased `import { searchParams as sp }` (`sp()`) reaches the
+   * same struct field the generator emits. Returns null for any other name so
+   * callers fall back to their normal field-ref lowering.
+   */
+  private searchParamsFieldRef(name: string): string | null {
+    return this.searchParamsLocals.has(name) ? this.rootFieldRef('searchParams') : null
+  }
+
   /**
    * Build the module pure-string-const map from the IR's localConstants.
    * A const qualifies only when it is module-scope (`isModule`) and its
@@ -3947,49 +5304,13 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
    * pure compile-time string can be safely inlined byte-for-byte.
    */
   private collectModuleStringConsts(constants: IRMetadata['localConstants']): Map<string, string> {
-    const map = new Map<string, string>()
-    for (const c of constants ?? []) {
-      if (!c.isModule) continue
-      if (c.value === undefined) continue
-      const literal = this.parsePureStringLiteral(c.value)
-      if (literal !== null) map.set(c.name, literal)
-    }
-    return map
+    // Single source of truth shared with the Mojo / Xslate adapters
+    // (fixed-point resolution incl. composed template-literal consts and
+    // `[...].join(sep)` — #1896 / #1897).
+    return collectModuleStringConstsShared(constants)
   }
 
-  /**
-   * Parse a const initializer's source text. Returns the unescaped string
-   * value when the whole initializer is a single string literal (or a
-   * no-substitution template literal), else `null`. Uses the TS parser so
-   * escapes/quotes are resolved exactly as JS would, matching the value
-   * the Hono reference inlines at runtime.
-   */
-  private parsePureStringLiteral(source: string): string | null {
-    const sf = ts.createSourceFile(
-      '__const.ts',
-      `const __x = (${source});`,
-      ts.ScriptTarget.Latest,
-      /*setParentNodes*/ false,
-    )
-    const stmt = sf.statements[0]
-    if (!stmt || !ts.isVariableStatement(stmt)) return null
-    const decl = stmt.declarationList.declarations[0]
-    let init = decl?.initializer
-    while (init && ts.isParenthesizedExpression(init)) init = init.expression
-    if (!init) return null
-    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?>)`.
@@ -3998,31 +5319,6 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
    * 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
@@ -4043,6 +5339,31 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     return `"${this.escapeGoString(value)}"`
   }
 
+  /**
+   * Inline a module-level numeric const (`const TRACK = 8`) as its literal
+   * value. Only a plain numeric initializer qualifies — anything computed or
+   * non-numeric falls through to the normal field/ident resolution. Scoped to
+   * module consts (like the string variant) and guarded against loop vars so a
+   * range variable that shadows a const name still wins.
+   */
+  private resolveModuleNumericConst(name: string): string | null {
+    if (this.loopParamStack.length > 0 && this.loopParamStack[this.loopParamStack.length - 1] === name) {
+      return null
+    }
+    if (this.loopVarRefCount.has(name)) return null
+    if (this.isOuterLoopParam(name)) return null
+    const c = this.localConstants.find(
+      (k) => k.name === name && k.isModule && !k.containsArrow,
+    )
+    if (!c || c.value === undefined) return null
+    // `value` is reconstructed from source text, so a valid TS literal may carry
+    // numeric separators (`100_000`). Strip them between digits, then accept a
+    // plain decimal / float; Go template numeric literals don't allow `_`, so
+    // the stripped form is what gets emitted.
+    const v = c.value.trim().replace(/(?<=\d)_(?=\d)/g, '')
+    return /^-?\d+(\.\d+)?$/.test(v) ? v : null
+  }
+
   literal(value: string | number | boolean | null, literalType: LiteralType): string {
     if (literalType === 'string') return `"${value}"`
     if (literalType === 'null') return 'nil'
@@ -4050,9 +5371,11 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
   }
 
   call(callee: ParsedExpr, args: ParsedExpr[], emit: (e: ParsedExpr) => string): string {
-    // Signal call: count() -> .Count (or $.Count inside a loop, #1677)
+    // Signal call: count() -> .Count (or $.Count inside a loop, #1677).
+    // An env-signal binding (`searchParams()`, or an aliased `sp()`) resolves to
+    // the canonical `.SearchParams` field regardless of the JS name (#1922).
     if (callee.kind === 'identifier' && args.length === 0) {
-      return this.rootFieldRef(callee.name)
+      return this.searchParamsFieldRef(callee.name) ?? this.rootFieldRef(callee.name)
     }
     // Array methods (`.join` and any others added to ArrayMethod, #1443)
     // are lifted into the `array-method` IR kind at parse time, so
@@ -4104,6 +5427,24 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
       if (result) return result
     }
 
+    // `<memo>().length` where the memo's `.map()` feeds a handler-filled loop
+    // slice → `len .<Slice>` (#1897 PostList: `visible().length` →
+    // `len .PostListItems`). The slice holds the rendered (filtered) items, so
+    // its length is the count — unlike the memo's own field, which is unset.
+    if (
+      property === 'length' &&
+      object.kind === 'call' &&
+      object.callee.kind === 'identifier' &&
+      object.args.length === 0
+    ) {
+      const slice = this.memoBackedLoopSlice.get(object.callee.name)
+      if (slice) {
+        // Root field, so reach it through `$.` inside a loop (#1677).
+        const prefix = this.loopParamStack.length > 0 ? '$.' : '.'
+        return `len ${prefix}${slice}`
+      }
+    }
+
     // find().property / findLast().property → {{with bf_find ...}}{{.Property}}{{end}}
     if (object.kind === 'higher-order' && (object.method === 'find' || object.method === 'findLast')) {
       const findResult = this.renderHigherOrderExpr(object, emit)
@@ -4122,6 +5463,18 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
       return this.rootFieldRef(property)
     }
 
+    // Static property access on a module object-literal const
+    // (`variantClasses.ghost` in a class template literal, #1896
+    // pagination) resolves at compile time — same lookup as the
+    // bracket-index form in `resolveStaticRecordLiteralIndex`, reached
+    // here when the access is nested inside a larger ParsedExpr tree.
+    if (object.kind === 'identifier') {
+      const staticValue = this.resolveStaticRecordLiteralIndex(
+        `${object.name}.${property}`,
+      )
+      if (staticValue !== null) return staticValue
+    }
+
     // Inside a loop, the loop param variable refers to the current item
     // (dot). e.g. `msg.role` inside `{{range $_, $msg := .Messages}}` → `.Role`
     const currentLoopParam = this.loopParamStack[this.loopParamStack.length - 1]
@@ -4134,34 +5487,56 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     return `${obj}.${this.capitalizeFieldName(property)}`
   }
 
+  indexAccess(object: ParsedExpr, index: ParsedExpr, emit: (e: ParsedExpr) => string): string {
+    // Go's `index` builtin: `index $arr $i`. Both operands render
+    // through the same emitter so a loop-variable / arithmetic index
+    // lowers correctly. A multi-token operand (`bf_add $i 1`) must be
+    // parenthesised or Go parses it as extra `index` arguments. #1897
+    // (`selected()[index]`). (data-table's broader keyed-loop SSR stays
+    // tracked under #1896.)
+    return `index ${wrapIfMultiToken(emit(object))} ${wrapIfMultiToken(emit(index))}`
+  }
+
   binary(op: string, left: ParsedExpr, right: ParsedExpr, emit: (e: ParsedExpr) => string): string {
     const l = emit(left)
     const r = emit(right)
+    // Every Go form below is a prefix function call (`bf_mul a b`, `gt a b`,
+    // `eq a b`), so a COMPOUND operand must be parenthesised or the template
+    // parser folds its tokens into the call's argument list — e.g. nested
+    // arithmetic `(elapsed / TRACK) * 100` would emit `bf_mul bf_div .Elapsed
+    // .TRACK 100`, handing `bf_mul` four args. `wrapIfMultiToken` is a no-op
+    // for single tokens and quoted literals, so simple operands are untouched.
+    const wl = wrapIfMultiToken(l)
+    const wr = wrapIfMultiToken(r)
     switch (op) {
       case '===':
-      case '==':
-        return `eq ${l} ${r}`
+      case '==': {
+        const [el, er] = stringTolerantEqOperands(l, r)
+        return `eq ${wrapIfMultiToken(el)} ${wrapIfMultiToken(er)}`
+      }
       case '!==':
-      case '!=':
-        return `ne ${l} ${r}`
+      case '!=': {
+        const [el, er] = stringTolerantEqOperands(l, r)
+        return `ne ${wrapIfMultiToken(el)} ${wrapIfMultiToken(er)}`
+      }
       case '>':
-        return `gt ${l} ${r}`
+        return `gt ${wl} ${wr}`
       case '<':
-        return `lt ${l} ${r}`
+        return `lt ${wl} ${wr}`
       case '>=':
-        return `ge ${l} ${r}`
+        return `ge ${wl} ${wr}`
       case '<=':
-        return `le ${l} ${r}`
+        return `le ${wl} ${wr}`
       case '+':
-        return `bf_add ${l} ${r}`
+        return `bf_add ${wl} ${wr}`
       case '-':
-        return `bf_sub ${l} ${r}`
+        return `bf_sub ${wl} ${wr}`
       case '*':
-        return `bf_mul ${l} ${r}`
+        return `bf_mul ${wl} ${wr}`
       case '/':
-        return `bf_div ${l} ${r}`
+        return `bf_div ${wl} ${wr}`
       case '%':
-        return `bf_mod ${l} ${r}`
+        return `bf_mod ${wl} ${wr}`
       default:
         return `${l} ${op} ${r}`
     }
@@ -4180,10 +5555,18 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     right: ParsedExpr,
     emit: (e: ParsedExpr) => string,
   ): string {
-    const l = emit(left)
-    const r = emit(right)
-    const wrapLeft = this.needsParens(left) ? `(${l})` : l
-    const wrapRight = this.needsParens(right) ? `(${r})` : r
+    // Go's `and`/`or` are prefix builtins, so every operand that renders to
+    // more than one token (a method/function call like `.SearchParams.Get
+    // "sort"`, an arithmetic `bf_add a b`, a comparison `eq a b`, a nested
+    // `not …` / `or …`) must be parenthesised or it degrades into extra
+    // sibling args of the enclosing `and`/`or`. `wrapIfMultiToken` is the
+    // file-wide idiom for exactly this (every other prefix-helper emitter
+    // composes operands through it); a bare field ref / quoted literal stays
+    // uncluttered. This is what makes `searchParams().get(k) ?? d` lower to
+    // `or (.SearchParams.Get "sort") "none"` instead of the broken
+    // `or .SearchParams.Get "sort" "none"` (#1922).
+    const wrapLeft = wrapIfMultiToken(emit(left))
+    const wrapRight = wrapIfMultiToken(emit(right))
     if (op === '&&') return `and ${wrapLeft} ${wrapRight}`
     return `or ${wrapLeft} ${wrapRight}`
   }
@@ -4212,7 +5595,13 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
       if (part.type === 'string') {
         result += part.value
       } else {
-        result += `{{${emit(part.expr)}}}`
+        // A nested ternary emits a complete `{{if …}}…{{end}}` action
+        // chain (see `conditional` above) — wrapping it again produces
+        // `{{{{if …}}` and a template parse error (#1896, the tooltip
+        // open/closed class ternary with module-const branches). Same
+        // `isTemplateFragment` guard as `renderExpression`.
+        const e = emit(part.expr)
+        result += this.isTemplateFragment(e, part.expr.kind) ? e : `{{${e}}}`
       }
     }
     return result
@@ -4398,6 +5787,13 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
         const recv = emit(object)
         return `bf_trim ${wrapIfMultiToken(recv)}`
       }
+      case 'toFixed': {
+        // `.toFixed(digits?)` → `bf_to_fixed` (`fmt.Sprintf("%.*f", …)`).
+        // Default 0 digits when the argument is omitted. #1897.
+        const recv = emit(object)
+        const digits = args.length >= 1 ? emit(args[0]) : '0'
+        return `bf_to_fixed ${wrapIfMultiToken(recv)} ${wrapIfMultiToken(digits)}`
+      }
       case 'split': {
         // `.split()` / `.split(sep)` / `.split(sep, limit)` — string →
         // `[]any`. No separator → the whole string as a single element
@@ -5258,7 +6654,7 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
   /**
    * Convert a JS expression to Go template syntax.
    */
-  private convertExpressionToGo(jsExpr: string): string {
+  private convertExpressionToGo(jsExpr: string, out?: { parsed?: ParsedExpr }): string {
     const trimmed = jsExpr.trim()
 
     // Handle null/undefined specially
@@ -5266,6 +6662,59 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
       return '""'
     }
 
+    // `IDENT['key']` over a module object-literal const with a STRING
+    // LITERAL key is a fully static lookup — resolve it at compile time
+    // (#1896). The generic member lowering below would otherwise
+    // capitalize the bracket access into a field reference and emit an
+    // invalid hyphenated path (`strokePaths['chevron-down']` →
+    // `.StrokePaths.Chevron-down`, a template parse error).
+    const staticIndexed = this.resolveStaticRecordLiteralIndex(trimmed)
+    if (staticIndexed !== null) {
+      return staticIndexed
+    }
+
+    // A bare identifier bound to a literal const inlines at compile time
+    // (#1896 — pagination's `Page {currentPage()} of {totalPages}`:
+    // `totalPages` is a function-scope `const totalPages = 5`, not a
+    // prop, so the generic lowering would reference a nonexistent
+    // `.TotalPages` field). Only pure numeric / single-quoted-string
+    // initializers qualify; anything else may be runtime-dependent.
+    if (/^[A-Za-z_$][\w$]*$/.test(trimmed)) {
+      const litConst = (this.localConstants ?? []).find(c => c.name === trimmed)
+      if (litConst?.value !== undefined) {
+        const v = litConst.value.trim()
+        if (/^-?\d+(\.\d+)?$/.test(v)) return v
+        const strLit = /^'([^'\\]*)'$/.exec(v) ?? /^"([^"\\]*)"$/.exec(v)
+        if (strLit) return JSON.stringify(strLit[1])
+      }
+    }
+
+    // (#1897 PostList) A local URL-builder helper (`hrefFor`, or `sortHref` /
+    // `tagHref` delegating to it) lowers to a `bf_query` action — there is no Go
+    // method backing a `.SortHref "date"` call. Tried before the generic inliner
+    // because these helpers are block-bodied / delegate, which the inliner skips.
+    const urlBuilt = this.lowerUrlBuilderHelperCall(trimmed)
+    if (urlBuilt !== null) return urlBuilt
+
+    // Inline a call to a local, expression-bodied helper arrow
+    // (`sortClass(k)` / `tagClass(t)`) by substituting its params with the call
+    // args and lowering the resulting expression. There is no Go method backing
+    // a `.SortClass "date"` call, so the call site must carry the computation
+    // (`{{if eq .Params.Sort "date"}}sort on{{else}}sort{{end}}`). Only self-
+    // contained helpers are inlined; one that delegates to another local helper
+    // (e.g. `sortHref` → `hrefFor`) is left for a later capability.
+    const inlined = this.inlineLocalHelperCall(trimmed)
+    if (inlined !== null) {
+      return this.convertExpressionToGo(inlined, out)
+    }
+
+    // Parse only here — *after* the early returns above, which resolve
+    // `null`/`undefined`, static record indexes, and inlined literal consts
+    // without a parse. The result is reported to the caller via `out` below
+    // (after the support gate) so `renderExpression` can classify the
+    // expression (template literal vs. not) off this single `parseExpression`,
+    // with no extra `ts.createSourceFile` on the `bf build` hot path and no
+    // parse at all for the early-return shapes.
     const parsed = parseExpression(trimmed)
     const support = isSupported(parsed)
 
@@ -5280,13 +6729,429 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
           message: buildUnsupportedSuggestion(support),
         },
       })
-      // Return empty string - Go template comments must be separate actions
+      // Return empty string - Go template comments must be separate actions.
+      // Deliberately leave `out.parsed` unset here: the sentinel `""` must take
+      // the normal wrap path in `renderExpression` (→ `{{""}}`), not the
+      // template-literal "already template text" path — otherwise an
+      // unsupported interpolation (`template-literal` kind) would emit `""`
+      // outside an action and render literal quotes into the HTML (#1937 review).
       return `""`
     }
 
+    // Report the supported parse to the caller (template-literal classification
+    // for `renderExpression`) only after the support gate, so the wrap-skip path
+    // can never trigger on the error sentinel above.
+    if (out) out.parsed = parsed
+
     return this.renderParsedExpr(parsed)
   }
 
+  /**
+   * (#1897 PostList) If `jsExpr` is a call to a local, expression-bodied helper
+   * arrow const (`sortClass(k)` / `tagClass(t)`), return its body with the call
+   * args substituted for the params (re-emitted to source), so the caller can
+   * lower the inlined expression. Returns null when `jsExpr` is not such a call,
+   * or when the helper delegates to another local helper (e.g. `sortHref` →
+   * `hrefFor`) — those need their own lowering capability and must not be
+   * half-inlined here. Substitution is AST-based (no string matching) so it is
+   * shadowing- and member-name-safe.
+   */
+  private inlineLocalHelperCall(jsExpr: string): string | null {
+    if (this.localHelperNames.size === 0) return null
+    // Fast path: skip the AST parse unless the expression begins with a known
+    // helper name applied as a call (`<helper>(`). The leading-identifier match
+    // is an unambiguous prefix — the real shape check is the AST parse below.
+    const head = /^\s*([A-Za-z_$][\w$]*)\s*\(/.exec(jsExpr)
+    if (!head || !this.localHelperNames.has(head[1])) return null
+
+    const call = this.parseLiteralExpression(jsExpr)
+    if (!call || !ts.isCallExpression(call) || !ts.isIdentifier(call.expression)) return null
+    // A spread arg (`f(...xs)`) can't map to positional params by text splice.
+    if (call.arguments.some(a => ts.isSpreadElement(a))) return null
+    const fnConst = this.localConstants.find(
+      c => c.name === (call.expression as ts.Identifier).text && !c.isModule && c.value,
+    )
+    if (!fnConst?.value) return null
+    const fn = this.parseLiteralExpression(fnConst.value)
+    if (!fn || !ts.isArrowFunction(fn) || ts.isBlock(fn.body)) return null
+    if (fn.parameters.length !== call.arguments.length) return null
+    // Don't half-inline a helper that calls another local helper.
+    if (this.bodyCallsLocalHelper(fn.body)) return null
+
+    const subs = new Map<string, string>()
+    for (let i = 0; i < fn.parameters.length; i++) {
+      const p = fn.parameters[i]
+      if (!ts.isIdentifier(p.name)) return null
+      // Parenthesize the arg so its own precedence survives the splice into the
+      // body (e.g. `x === <param>` with arg `a || b` must not become
+      // `x === a || b`).
+      subs.set(p.name.text, `(${call.arguments[i].getText()})`)
+    }
+    // The splicer is scope-blind, so reject bodies where a textual identifier
+    // replacement could be wrong: nested function scopes (shadowing / param
+    // positions) and object shorthand keys that are params.
+    if (!this.isSpliceSafeHelperBody(fn.body, new Set(subs.keys()))) return null
+    return this.substituteHelperParams(fn.body, subs)
+  }
+
+  /**
+   * Guard for `substituteHelperParams`: the span splicer replaces identifiers by
+   * name without scope tracking, so it is only safe on bodies free of
+   * constructs where a param name could appear in a position the splice can't
+   * handle — a nested function scope (shadowing or its own parameters), or an
+   * object shorthand key (`{ k }`, which can't be rewritten to `{ (arg) }`).
+   */
+  private isSpliceSafeHelperBody(body: ts.Node, paramNames: ReadonlySet<string>): boolean {
+    let safe = true
+    const visit = (n: ts.Node): void => {
+      if (!safe) return
+      if (
+        ts.isArrowFunction(n) ||
+        ts.isFunctionExpression(n) ||
+        ts.isFunctionDeclaration(n)
+      ) {
+        safe = false
+        return
+      }
+      if (ts.isShorthandPropertyAssignment(n) && paramNames.has(n.name.text)) {
+        safe = false
+        return
+      }
+      ts.forEachChild(n, visit)
+    }
+    visit(body)
+    return safe
+  }
+
+  /**
+   * True when `body` contains a call to a *local* (component-scope) arrow helper
+   * const — the signal that inlining `body` here would only push the problem to
+   * another un-lowered helper (e.g. `sortHref`'s body calls `hrefFor`).
+   */
+  private bodyCallsLocalHelper(body: ts.Node): boolean {
+    let found = false
+    const visit = (n: ts.Node): void => {
+      if (found) return
+      if (ts.isCallExpression(n) && ts.isIdentifier(n.expression)) {
+        const name = n.expression.text
+        if (
+          this.localConstants.some(c => c.name === name && !c.isModule && c.containsArrow)
+        ) {
+          found = true
+          return
+        }
+      }
+      ts.forEachChild(n, visit)
+    }
+    visit(body)
+    return found
+  }
+
+  /**
+   * Re-emit `body` to source with each identifier named in `subs` replaced by
+   * the substitution's source text. Implemented as span splicing over `body`'s
+   * own source (single source file — args are passed as text, not cross-file
+   * AST nodes, which would corrupt a printer keyed to `body`'s source). The walk
+   * skips non-value identifier positions — the property NAME in `a.b` and a
+   * plain object-literal key in `{ k: … }` — so a param sharing a name with a
+   * member or key is left untouched. (`isSpliceSafeHelperBody` has already
+   * rejected nested functions and `{ k }` shorthand keys.)
+   */
+  private substituteHelperParams(
+    body: ts.Expression,
+    subs: ReadonlyMap<string, string>,
+  ): string {
+    const sf = body.getSourceFile()
+    const base = body.getStart(sf)
+    // Collect replacement spans (relative to the body's start), right-to-left.
+    const repls: { start: number; end: number; text: string }[] = []
+    const visit = (node: ts.Node): void => {
+      if (ts.isPropertyAccessExpression(node)) {
+        visit(node.expression) // skip `.name`
+        return
+      }
+      if (ts.isPropertyAssignment(node)) {
+        // A plain identifier/string key isn't a value position; only a computed
+        // key (`[expr]`) is. Visit the initializer (and computed key) only.
+        if (ts.isComputedPropertyName(node.name)) visit(node.name)
+        visit(node.initializer)
+        return
+      }
+      if (ts.isIdentifier(node)) {
+        const sub = subs.get(node.text)
+        if (sub !== undefined) {
+          repls.push({ start: node.getStart(sf) - base, end: node.getEnd() - base, text: sub })
+          return
+        }
+      }
+      ts.forEachChild(node, visit)
+    }
+    visit(body)
+
+    let text = body.getText(sf)
+    for (const r of repls.sort((a, b) => b.start - a.start)) {
+      text = text.slice(0, r.start) + r.text + text.slice(r.end)
+    }
+    return text
+  }
+
+  /**
+   * (#1897 PostList) Lower a call to a local URL-builder helper to a `bf_query`
+   * template expression. Handles two shapes:
+   *   - the builder itself — `(sort, tag) => { const u = new URLSearchParams();
+   *     if (sort !== 'date') u.set('sort', sort); if (tag) u.set('tag', tag);
+   *     return u.toString() ? \`${root}?${u}\` : root }` — substitute the call
+   *     args for params and emit `bf_query <base> (<guard>) "key" <value> …`;
+   *   - a pass-through delegate — `(k) => hrefFor(k, params().tag)` — substitute
+   *     and recurse on the delegated call.
+   * Returns null for anything else (→ existing lowering / method-call fallback).
+   */
+  private lowerUrlBuilderHelperCall(jsExpr: string): string | null {
+    if (this.localHelperNames.size === 0) return null
+    const head = /^\s*([A-Za-z_$][\w$]*)\s*\(/.exec(jsExpr)
+    if (!head || !this.localHelperNames.has(head[1])) return null
+
+    const call = this.parseLiteralExpression(jsExpr)
+    if (!call || !ts.isCallExpression(call) || !ts.isIdentifier(call.expression)) return null
+    if (call.arguments.some(a => ts.isSpreadElement(a))) return null
+    const fnConst = this.localConstants.find(
+      c => c.name === (call.expression as ts.Identifier).text && !c.isModule && c.value,
+    )
+    if (!fnConst?.value) return null
+    const fn = this.parseLiteralExpression(fnConst.value)
+    if (!fn || !ts.isArrowFunction(fn) || fn.parameters.length !== call.arguments.length) return null
+
+    const subs = new Map<string, string>()
+    for (let i = 0; i < fn.parameters.length; i++) {
+      const p = fn.parameters[i]
+      if (!ts.isIdentifier(p.name)) return null
+      subs.set(p.name.text, `(${call.arguments[i].getText()})`)
+    }
+
+    // Shape 1: the helper is itself a URLSearchParams builder.
+    const shape = this.extractUrlBuilder(fn)
+    if (shape) return this.emitUrlBuilder(shape, subs)
+
+    // Shape 2: a pass-through delegate to another local URL-builder helper.
+    if (!ts.isBlock(fn.body)) {
+      let body: ts.Expression = fn.body
+      while (ts.isParenthesizedExpression(body)) body = body.expression
+      if (
+        ts.isCallExpression(body) &&
+        ts.isIdentifier(body.expression) &&
+        this.localHelperNames.has(body.expression.text)
+      ) {
+        return this.lowerUrlBuilderHelperCall(this.substituteHelperParams(body, subs))
+      }
+    }
+    return null
+  }
+
+  /**
+   * Extract the `bf_query` shape from a `(…) => { const u = new URLSearchParams();
+   * [if (G)] u.set(K, V); …; return <s> ? … : <base> }` helper, or null when the
+   * block doesn't match that exact builder idiom.
+   */
+  private extractUrlBuilder(
+    arrow: ts.ArrowFunction,
+  ): { base: ts.Expression; sets: { guard: ts.Expression | null; key: string; value: ts.Expression }[] } | null {
+    if (!ts.isBlock(arrow.body)) return null
+    let builderVar: string | null = null
+    let base: ts.Expression | null = null
+    const sets: { guard: ts.Expression | null; key: string; value: ts.Expression }[] = []
+
+    for (const s of arrow.body.statements) {
+      if (ts.isVariableStatement(s)) {
+        for (const d of s.declarationList.declarations) {
+          if (
+            ts.isIdentifier(d.name) &&
+            d.initializer &&
+            ts.isNewExpression(d.initializer) &&
+            ts.isIdentifier(d.initializer.expression) &&
+            d.initializer.expression.text === 'URLSearchParams' &&
+            (d.initializer.arguments?.length ?? 0) === 0
+          ) {
+            builderVar = d.name.text
+          }
+          // Other locals (`const s = u.toString()`) are inert — ignored.
+        }
+        continue
+      }
+      // `if (G) u.set(K, V)` (no else).
+      if (ts.isIfStatement(s) && !s.elseStatement && builderVar) {
+        const set = this.matchUrlSet(s.thenStatement, builderVar)
+        if (!set) return null
+        sets.push({ guard: s.expression, key: set.key, value: set.value })
+        continue
+      }
+      // Unguarded `u.set(K, V)`.
+      if (ts.isExpressionStatement(s) && builderVar) {
+        const set = this.matchUrlSet(s, builderVar)
+        if (set) {
+          sets.push({ guard: null, key: set.key, value: set.value })
+          continue
+        }
+        return null
+      }
+      // `return <s> ? `${base}?…` : <base>` — the builder's return must be the
+      // conditional that picks between the with-query and bare-base URL; its
+      // `whenFalse` (no-query) branch is the base. Any other return shape isn't
+      // this idiom (#1945 review) — bail to the method-call fallback.
+      if (ts.isReturnStatement(s) && s.expression) {
+        let e: ts.Expression = s.expression
+        while (ts.isParenthesizedExpression(e)) e = e.expression
+        if (!ts.isConditionalExpression(e)) return null
+        base = e.whenFalse
+        continue
+      }
+      return null
+    }
+    if (!builderVar || !base || sets.length === 0) return null
+    return { base, sets }
+  }
+
+  /**
+   * Match `<builderVar>.set('literalKey', <value>)` — as a statement or an
+   * if-then — returning the key text and value node, else null.
+   */
+  private matchUrlSet(
+    node: ts.Node,
+    builderVar: string,
+  ): { key: string; value: ts.Expression } | null {
+    const stmt = ts.isBlock(node) ? (node.statements.length === 1 ? node.statements[0] : null) : node
+    if (!stmt || !ts.isExpressionStatement(stmt)) return null
+    const call = stmt.expression
+    if (
+      ts.isCallExpression(call) &&
+      ts.isPropertyAccessExpression(call.expression) &&
+      ts.isIdentifier(call.expression.expression) &&
+      call.expression.expression.text === builderVar &&
+      call.expression.name.text === 'set' &&
+      call.arguments.length === 2 &&
+      ts.isStringLiteral(call.arguments[0])
+    ) {
+      return { key: call.arguments[0].text, value: call.arguments[1] }
+    }
+    return null
+  }
+
+  /**
+   * Emit `bf_query <base> (<guard>) "key" <value> …` from an extracted builder
+   * shape, lowering each part (with the call args substituted for params) via
+   * the normal expression / condition lowering. Unguarded sets use `true`.
+   */
+  private emitUrlBuilder(
+    shape: { base: ts.Expression; sets: { guard: ts.Expression | null; key: string; value: ts.Expression }[] },
+    subs: ReadonlyMap<string, string>,
+  ): string | null {
+    const lowerExpr = (n: ts.Expression): string =>
+      this.convertExpressionToGo(this.substituteHelperParams(n, subs))
+    const baseGo = wrapIfMultiToken(lowerExpr(shape.base))
+    const parts: string[] = [baseGo]
+    for (const set of shape.sets) {
+      const guardGo = set.guard ? this.lowerUrlGuard(set.guard, subs) : 'true'
+      parts.push(`(${guardGo})`)
+      parts.push(JSON.stringify(set.key))
+      parts.push(wrapIfMultiToken(lowerExpr(set.value)))
+    }
+    return `bf_query ${parts.join(' ')}`
+  }
+
+  /**
+   * Lower a `u.set()` guard to a Go *bool* for `bf_query`'s `include` argument.
+   * A comparison / logical / negation / bool-literal already yields a bool
+   * (`convertConditionToGo`); a bare value (`if (tag)`) is JS string-truthiness,
+   * lowered to `ne <value> ""`. The arg must be a real bool — `bf_query` type-
+   * asserts it, so Go-template truthiness (`{{if x}}`) is not enough.
+   */
+  private lowerUrlGuard(guard: ts.Expression, subs: ReadonlyMap<string, string>): string {
+    let g = guard
+    while (ts.isParenthesizedExpression(g)) g = g.expression
+    // Comparisons, `!x`, and bool literals lower to a Go bool via the condition
+    // lowering. `&&` / `||` do NOT qualify: Go's `and`/`or` return one of their
+    // operands (a string for a truthiness guard like `tag && other`), not a
+    // bool — so they take the truthiness-wrap path below, yielding
+    // `ne (and …) ""`, an actual bool (#1945 review).
+    const isBoolShape =
+      (ts.isBinaryExpression(g) &&
+        [
+          ts.SyntaxKind.EqualsEqualsToken,
+          ts.SyntaxKind.EqualsEqualsEqualsToken,
+          ts.SyntaxKind.ExclamationEqualsToken,
+          ts.SyntaxKind.ExclamationEqualsEqualsToken,
+          ts.SyntaxKind.LessThanToken,
+          ts.SyntaxKind.GreaterThanToken,
+          ts.SyntaxKind.LessThanEqualsToken,
+          ts.SyntaxKind.GreaterThanEqualsToken,
+        ].includes(g.operatorToken.kind)) ||
+      (ts.isPrefixUnaryExpression(g) && g.operator === ts.SyntaxKind.ExclamationToken) ||
+      g.kind === ts.SyntaxKind.TrueKeyword ||
+      g.kind === ts.SyntaxKind.FalseKeyword
+    if (isBoolShape) {
+      return this.convertConditionToGo(this.substituteHelperParams(guard, subs)).condition
+    }
+    const valueGo = wrapIfMultiToken(
+      this.convertExpressionToGo(this.substituteHelperParams(guard, subs)),
+    )
+    return `ne ${valueGo} ""`
+  }
+
+  /**
+   * Resolve `IDENT['key']` / `IDENT["key"]` where `IDENT` is a
+   * module-scope object-literal const and the key is a string literal —
+   * a compile-time-static lookup (the icon registry's
+   * `strokePaths['chevron-down']`, #1896). Returns the looked-up value
+   * as a Go literal (quoted string / bare number) usable inside a
+   * template action, or `null` for any other shape so the caller falls
+   * through to the generic lowering. The prop-keyed variant of the same
+   * pattern lives in `parseRecordIndexAccess` (shared with Mojo); this
+   * helper covers the literal-key case that parse rejects.
+   */
+  private resolveStaticRecordLiteralIndex(jsExpr: string): string | null {
+    const m =
+      /^([A-Za-z_$][\w$]*)\[\s*(?:'([^']*)'|"([^"]*)")\s*\]$/.exec(jsExpr) ??
+      // Property-access form of the same static lookup
+      // (`variantClasses.ghost`, #1896 pagination) — only when the base
+      // resolves to a module object-literal const below, so ordinary
+      // props/locals never match.
+      /^([A-Za-z_$][\w$]*)\.([A-Za-z_$][\w$]*)$/.exec(jsExpr)
+    if (!m) return null
+    const key = m[2] ?? m[3]
+    const constInfo = (this.localConstants ?? []).find(
+      c => c.name === m[1] && c.isModule,
+    )
+    if (constInfo?.value === undefined) return null
+    const sf = ts.createSourceFile(
+      '__rec.ts',
+      `(${constInfo.value})`,
+      ts.ScriptTarget.Latest,
+      /* setParentNodes */ true,
+    )
+    if (sf.statements.length !== 1) return null
+    const stmt = sf.statements[0]
+    if (!ts.isExpressionStatement(stmt)) return null
+    let parsed: ts.Expression = stmt.expression
+    while (ts.isParenthesizedExpression(parsed)) parsed = parsed.expression
+    if (!ts.isObjectLiteralExpression(parsed)) return null
+    for (const prop of parsed.properties) {
+      if (!ts.isPropertyAssignment(prop)) continue
+      const name = prop.name
+      const propKey =
+        ts.isIdentifier(name) || ts.isStringLiteral(name) || ts.isNoSubstitutionTemplateLiteral(name)
+          ? name.text
+          : null
+      if (propKey !== key) continue
+      let v: ts.Expression = prop.initializer
+      while (ts.isParenthesizedExpression(v)) v = v.expression
+      if (ts.isNumericLiteral(v)) return v.text
+      if (ts.isStringLiteral(v) || ts.isNoSubstitutionTemplateLiteral(v)) {
+        return JSON.stringify(v.text)
+      }
+      return null
+    }
+    return null
+  }
+
   /**
    * Create a source location for error reporting.
    */
@@ -5525,6 +7390,18 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
         return { preamble: obj.preamble, expr: `${obj.expr}.${this.capitalizeFieldName(expr.property)}` }
       }
 
+      case 'index-access': {
+        // Go's `index` builtin: `index $arr $i`. A multi-token operand
+        // (`bf_add $i 1`) must be parenthesised or Go parses it as extra
+        // `index` arguments. #1897.
+        const obj = this.renderConditionExpr(expr.object)
+        const idx = this.renderConditionExpr(expr.index)
+        return {
+          preamble: obj.preamble + idx.preamble,
+          expr: `index ${wrapIfMultiToken(obj.expr)} ${wrapIfMultiToken(idx.expr)}`,
+        }
+      }
+
       case 'binary': {
         const leftNeedsParens = this.needsParensInGoTemplate(expr.left)
         const leftResult = this.renderConditionExpr(expr.left)
@@ -5539,11 +7416,15 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
         let result: string
         switch (expr.op) {
           case '===':
-          case '==':
-            result = `eq ${left} ${right}`; break
+          case '==': {
+            const [el, er] = stringTolerantEqOperands(left, right)
+            result = `eq ${el} ${er}`; break
+          }
           case '!==':
-          case '!=':
-            result = `ne ${left} ${right}`; break
+          case '!=': {
+            const [el, er] = stringTolerantEqOperands(left, right)
+            result = `ne ${el} ${er}`; break
+          }
           case '>':
             result = `gt ${left} ${right}`; break
           case '<':
@@ -5831,6 +7712,61 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     return null
   }
 
+  /**
+   * When `comp`'s JSX children contain template actions (nested
+   * components, dynamic text) — i.e. none of the static bake paths in
+   * `collectStaticChildInstances` apply — render them into a companion
+   * define and return its name; `renderComponent` then routes the child
+   * call through `bf_with_children` + `bf_tmpl` (#1896). Returns null
+   * for childless or statically-bakeable children, which keep the
+   * constructor-baked `Children` value.
+   */
+  private queueDynamicChildrenDefine(comp: IRComponent): string | null {
+    const effectiveChildren = comp.children.length > 0
+      ? comp.children
+      : this.jsxChildrenPropNodes(comp.props)
+    if (effectiveChildren.length === 0) return null
+    if (this.extractTextChildren(effectiveChildren) !== null) return null
+    if (this.extractHtmlChildren(effectiveChildren) !== null) return null
+    if (this.extractScopedHtmlChildren(effectiveChildren) !== null) return null
+    const name = `${this.componentName}__children_${comp.slotId}`
+    if (!this.pendingChildrenDefines.some(d => d.name === name)) {
+      this.pendingChildrenDefines.push({
+        name,
+        content: this.renderChildren(effectiveChildren),
+      })
+    }
+    return name
+  }
+
+  /**
+   * (#1897) Queue a companion define for a loop body component's JSX children.
+   * Like `queueDynamicChildrenDefine` but temporarily exits the `inLoop`
+   * context so nested component calls render with the normal `.NameSlotN`
+   * field-access pattern (the fields live on the wrapper struct that the
+   * companion define receives as its data context). The loop param stack
+   * stays intact so datum-field references (`payment.id` → `.Id`) still
+   * resolve.
+   */
+  private queueLoopBodyChildrenDefine(comp: IRComponent): string | null {
+    const effectiveChildren = comp.children.length > 0
+      ? comp.children
+      : this.jsxChildrenPropNodes(comp.props)
+    if (effectiveChildren.length === 0) return null
+    if (this.extractTextChildren(effectiveChildren) !== null) return null
+    if (this.extractHtmlChildren(effectiveChildren) !== null) return null
+    if (this.extractScopedHtmlChildren(effectiveChildren) !== null) return null
+    const name = `${this.componentName}__loop_children_${comp.slotId}`
+    if (!this.pendingChildrenDefines.some(d => d.name === name)) {
+      const wasInLoop = this.inLoop
+      this.inLoop = false
+      const content = this.renderChildren(effectiveChildren)
+      this.inLoop = wasInLoop
+      this.pendingChildrenDefines.push({ name, content })
+    }
+    return name
+  }
+
   renderComponent(comp: IRComponent, ctx?: { isRootOfClientComponent?: boolean }): string {
     // Handle Portal component specially - collect content for body end
     if (comp.name === 'Portal') {
@@ -5852,12 +7788,25 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     // In Go templates, components are rendered using {{template "name" data}}
     let templateCall: string
     if (this.inLoop) {
-      // Loop children: dot becomes loop item (already has correct props)
-      templateCall = `{{template "${comp.name}" .}}`
+      // (#1897) Loop body component with JSX children: render children through
+      // a companion define so `bf_with_children` injects them at template
+      // execution time. Temporarily exit loop context so nested component
+      // calls (e.g. TableCell inside TableRow) use the normal non-loop
+      // rendering path (`.TableCellSlotN` fields on the wrapper struct),
+      // while the loop param stack stays intact so datum references resolve.
+      const loopBodyDefine = this.queueLoopBodyChildrenDefine(comp)
+      if (loopBodyDefine) {
+        templateCall = `{{template "${comp.name}" (bf_with_children . (bf_tmpl "${loopBodyDefine}" .))}}`
+      } else {
+        templateCall = `{{template "${comp.name}" .}}`
+      }
     } else if (comp.slotId) {
       // Static children with slotId: use unique field name based on slotId
       const suffix = slotIdToFieldSuffix(comp.slotId)
-      templateCall = `{{template "${comp.name}" .${comp.name}${suffix}}}`
+      const childrenDefine = this.queueDynamicChildrenDefine(comp)
+      templateCall = childrenDefine
+        ? `{{template "${comp.name}" (bf_with_children .${comp.name}${suffix} (bf_tmpl "${childrenDefine}" .))}}`
+        : `{{template "${comp.name}" .${comp.name}${suffix}}}`
     } else {
       // Static children without slotId: fallback to .ComponentName
       templateCall = `{{template "${comp.name}" .${comp.name}}}`
@@ -5948,10 +7897,40 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
       }
       if (isBooleanAttr(name) || value.presenceOrUndefined) {
         const { condition: goCond, preamble } = this.convertConditionToGo(value.expr)
-        return `${preamble}{{if ${goCond}}}${name}{{end}}`
+        // ARIA attributes are string-valued ("true"/"false"), not HTML5
+        // presence booleans — Hono renders the truthy presence form as
+        // `aria-x="true"` (#1896, SelectItem's
+        // `aria-disabled={isDisabled() || undefined}`).
+        const body = name.startsWith('aria-') ? `${name}="true"` : name
+        return `${preamble}{{if ${goCond}}}${body}{{end}}`
       }
       const parsed = parseExpression(value.expr.trim())
-      if (parsed.kind === 'conditional' || parsed.kind === 'template-literal') {
+      if (parsed.kind === 'conditional') {
+        // A ternary whose falsy branch is `undefined` / `null` OMITS the
+        // attribute entirely on Hono (`aria-current={props.isActive ?
+        // 'page' : undefined}`, #1896 pagination) — wrap the whole
+        // attribute in the condition instead of rendering `attr=""`.
+        const undef = (e: ParsedExpr): boolean =>
+          (e.kind === 'identifier' && (e.name === 'undefined' || e.name === 'null')) ||
+          (e.kind === 'literal' && (e.value === null || e.value === undefined))
+        const test = parsed.test
+        if (undef(parsed.alternate) && !undef(parsed.consequent)) {
+          const { condition: goCond, preamble } = this.convertConditionToGo(
+            // Re-render the test from its source span via the parsed tree. If it
+            // lowered to a self-contained action block, re-parse the whole
+            // ternary source; otherwise slice off the test portion.
+            this.isTemplateFragment(this.renderParsedExpr(test), test.kind)
+              ? value.expr
+              : value.expr.slice(0, value.expr.indexOf('?')).trim(),
+          )
+          const valueExpr = this.renderParsedExpr(parsed.consequent)
+          const body = `${name}="{{${valueExpr}}}"`
+          return `${preamble}{{if ${goCond}}}${body}{{end}}`
+        }
+        // Inline Go template syntax with embedded `{{...}}` actions.
+        return `${name}="${this.renderParsedExpr(parsed)}"`
+      }
+      if (parsed.kind === 'template-literal') {
         // Inline Go template syntax with embedded `{{...}}` actions.
         return `${name}="${this.renderParsedExpr(parsed)}"`
       }
@@ -5977,7 +7956,14 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
         const field = `.${this.capitalizeFieldName(propName)}`
         return `{{if ne ${field} nil}}${name}="{{${this.convertExpressionToGo(value.expr)}}}"{{end}}`
       }
-      return `${name}="{{${this.convertExpressionToGo(value.expr)}}}"`
+      // Lower once; if the result is already a self-contained action block (e.g.
+      // an inlined `sortClass(k)` → `{{if …}}…{{end}}`, #1897), embed it as-is
+      // rather than double-wrapping it in another `{{…}}`.
+      const exprOut: { parsed?: ParsedExpr } = {}
+      const go = this.convertExpressionToGo(value.expr, exprOut)
+      return this.isTemplateFragment(go, exprOut.parsed?.kind)
+        ? `${name}="${go}"`
+        : `${name}="{{${go}}}"`
     },
     emitBooleanAttr: (_value, name) => name,
     // Spread attributes (`<div {...attrs()} />`) lower through the
@@ -6127,7 +8113,33 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
       }
       const inner = s.slice(open + 2, close).trim()
       if (inner) {
-        out += `{{${this.convertExpressionToGo(inner)}}}`
+        // Thread the parsed kind out of `convertExpressionToGo` (reusing its
+        // single parse) so a nested template literal here is handled too.
+        const cls: { parsed?: ParsedExpr } = {}
+        const goExpr = this.convertExpressionToGo(inner, cls)
+        const parsed = cls.parsed
+        if (parsed?.kind === 'template-literal') {
+          // Attribute context: a template literal lowers to literal text
+          // interleaved with `{{...}}` actions. That literal text sits OUTSIDE
+          // any action, so — unlike the `{{...}}` actions, which Go escapes for
+          // the attribute context at render time — it bypasses escaping. A `"`,
+          // `<`, or `&` in a UnoCSS arbitrary value (`content-["x"]`) would then
+          // break the surrounding `class="..."`. Escape each string part with
+          // `escapeAttrText`, keeping interpolations as fragment-aware actions
+          // (#1937 review). Mirrors the `templateLiteral` emitter, plus escaping.
+          for (const part of parsed.parts) {
+            if (part.type === 'string') {
+              out += this.escapeAttrText(part.value)
+            } else {
+              const e = this.renderParsedExpr(part.expr)
+              out += this.isTemplateFragment(e, part.expr.kind) ? e : `{{${e}}}`
+            }
+          }
+        } else {
+          // Same `isTemplateFragment` guard as `renderExpression` (#1896): a
+          // ternary lowers to a complete `{{if}}` action chain — don't re-wrap.
+          out += this.isTemplateFragment(goExpr, parsed?.kind) ? goExpr : `{{${goExpr}}}`
+        }
       } else {
         out += s.slice(open, close + 1)
       }
@@ -6174,7 +8186,12 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
         // case matches; consumers shouldn't rely on a default fallback
         // here (the JSX-side `variant = 'default'` default already
         // shows up via the per-prop fallback in `NewXxxProps`).
-        const keyExpr = this.convertExpressionToGo(part.key)
+        const rawKeyExpr = this.convertExpressionToGo(part.key)
+        // A compound key (`props.placement ?? 'top'` → `or .Placement
+        // "top"`) must be parenthesized inside `eq` — unwrapped, Go's
+        // template parser reads `eq or .Placement "top" "left"` as four
+        // arguments with a zero-arg `or` (#1896, tooltip placement).
+        const keyExpr = /\s/.test(rawKeyExpr) ? `(${rawKeyExpr})` : rawKeyExpr
         const caseEntries = Object.entries(part.cases)
         if (caseEntries.length === 0) continue
         const branches = caseEntries.map(([k, v], i) => {