@barefootjs/go-template 0.15.2 → 0.17.0

package/dist/adapter/go-template-adapter.d.ts

@@ -1,32 +1,8 @@
-/**
- * BarefootJS Go html/template Adapter
- *
- * Generates Go html/template files from BarefootJS IR.
- */
-import type { ComponentIR, IRNode, IRElement, IRText, IRExpression, IRConditional, IRLoop, IRComponent, IRFragment, IRSlot, ParsedExpr, SortComparator, ReduceOp, FlatDepth, FlatMapOp, TemplatePart, IRIfStatement, IRProvider, IRAsync, TemplatePrimitiveRegistry } from '@barefootjs/jsx';
-import { BaseAdapter, type AdapterOutput, type AdapterGenerateOptions, type ParsedExprEmitter, type HigherOrderMethod, type ArrayMethod, type LiteralType, type IRNodeEmitter, type EmitIRNode } from '@barefootjs/jsx';
-/**
- * Go-template adapter's IRNode render context. Only `isRootOfClientComponent`
- * is consumed today (forwarded into `renderComponent` / `renderIfStatement`);
- * the type stays open so future render-position flags can be added without
- * widening the `IRNodeEmitter` contract.
- */
-type GoRenderCtx = {
-    isRootOfClientComponent?: boolean;
-};
-export interface GoTemplateAdapterOptions {
-    /** Go package name for generated types (default: 'components') */
-    packageName?: string;
-    /**
-     * Base path for client JS files (e.g., '/static/client/').
-     * Used to generate script registration paths.
-     */
-    clientJsBasePath?: string;
-    /**
-     * Path to barefoot.js runtime (e.g., '/static/client/barefoot.js').
-     */
-    barefootJsPath?: string;
-}
+/** BarefootJS adapter: BarefootJS IR → Go `html/template` files. */
+import type { ComponentIR, IRNode, IRElement, IRText, IRExpression, IRConditional, IRLoop, IRComponent, IRFragment, IRSlot, CompilerError, ParsedExpr, ObjectLiteralProperty, FlatDepth, TemplatePart, IRIfStatement, IRProvider, IRAsync, TemplatePrimitiveRegistry } from '@barefootjs/jsx';
+import { BaseAdapter, type AdapterOutput, type AdapterGenerateOptions, type ParsedExprEmitter, type ArrayMethod, type LiteralType, type IRNodeEmitter, type EmitIRNode } from '@barefootjs/jsx';
+import type { GoRenderCtx, GoTemplateAdapterOptions } from "./lib/types.ts";
+export type { GoTemplateAdapterOptions } from "./lib/types.ts";
 export declare class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter, IRNodeEmitter<GoRenderCtx> {
     name: string;
     extension: string;
@@ -35,247 +11,87 @@ export declare class GoTemplateAdapter extends BaseAdapter implements ParsedExpr
     private filterExprDepth;
     private filterExprUnsupported;
     /**
-     * Identifier-path callees the Go runtime can render in template
-     * scope (#1188). The relocate pass consults this map to mark
-     * matching calls as template-safe so the surrounding expression
-     * stays inlinable; the SSR template emitter (`renderParsedExpr`'s
-     * `call` branch) uses the same map to substitute the JS call with
-     * the registered Go template form.
-     *
-     * Keys are the textual callee path as written in the JSX
-     * expression. Values are emit functions that receive the already-
-     * Go-rendered argument expressions (e.g. `.Config`, `_p.Score`)
-     * and return the substituted Go template body — without the
-     * surrounding `{{ }}` action delimiters, so callers can wrap the
-     * result in `{{...}}` or compose into larger expressions like
-     * `{{if eq (bf_json .X) "..."}}`.
-     *
-     * V1 scope (#1187 R1): identifier-path callees only. Method calls
-     * on values (`(arr).join(",")`) require analyzer-resolved receiver
-     * type and are explicitly out of scope — users fall back to
-     * `/* @client *\/` for those.
+     * Identifier-path callees the Go runtime can render in template scope, keyed
+     * by the textual callee path as written in JSX. Each value emits the
+     * substituted Go body from already-Go-rendered args, WITHOUT the `{{ }}`
+     * delimiters so callers compose it (`{{if eq (bf_json .X) "..."}}`).
      *
-     * Public because the `TemplateAdapter` interface contract requires
-     * the relocate pass to read this for boolean acceptance. The arity
-     * map below is implementation detail (private) — the asymmetry is
-     * deliberate.
+     * Identifier-path callees only; method calls on values (`(arr).join(",")`)
+     * need an analyzer-resolved receiver type and are out of scope. Public
+     * because the relocate pass reads it for boolean acceptance.
      */
     templatePrimitives: TemplatePrimitiveRegistry;
     /**
-     * Expected arg count per primitive. Consulted before invoking the
-     * registered emit fn so a 0-arg `JSON.stringify()` or 2-arg
-     * `JSON.stringify(x, replacer)` doesn't silently produce invalid
-     * Go template syntax (the V1 emit fns blindly read `args[0]`).
-     *
-     * Derived from `GO_TEMPLATE_PRIMITIVES` so it can't drift from
-     * `templatePrimitives` — a wrong-arity call falls back to the
-     * standard BF101 unsupported-call diagnostic.
+     * Expected arg count per primitive, so a wrong-arity call (`JSON.stringify()`,
+     * `JSON.stringify(x, replacer)`) falls back to BF101 instead of emitting
+     * invalid Go from the emit fn's blind `args[0]` read. Derived from
+     * `GO_TEMPLATE_PRIMITIVES` so it can't drift from `templatePrimitives`.
      */
     private readonly templatePrimitiveArities;
-    private componentName;
     private options;
-    private inLoop;
+    /** Per-compile mutable state, reset at `generate()` / `generateTypes()` entry. See `CompileState` for the field-by-field docs. */
+    private readonly state;
     /**
-     * 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()`.
+     * The `GoEmitContext` handed to extracted emit modules — the seam that keeps
+     * `state` / `convert*` off the public adapter type. `state` is captured by
+     * reference (reset in place, never reassigned), so this single `emitCtx` stays
+     * valid across `generate()` calls.
      */
-    private pendingChildrenDefines;
+    private readonly emitCtx;
+    /** Diagnostics from the current compile (backed by `CompileState`); `generate()` also merges these into `ir.errors`. */
+    get errors(): CompilerError[];
+    private inLoop;
     private loopParamStack;
+    /**
+     * Per-loop: true when the body renders the bare range value (scalar-item
+     * inline-literal loop), so the `bf_tmpl` companion is fed `.BfLoopItem` (the
+     * wrapper's synthetic scalar field) instead of `.`. Innermost last.
+     */
+    private loopScalarItemStack;
     private loopVarRefCount;
     /** Stack of destructure-param binding maps (binding name → Go accessor on the
-     *  range var, e.g. `id` → `$__bf_item0.Id`, `rest` → `$__bf_item0`). Innermost last.
-     *  Lets `.map(({ id, ...rest }) => …)` resolve `id` / `rest.flag` instead of
-     *  refusing with BF104. (#1310) */
+     *  range var, e.g. `id` → `$__bf_item0.Id`, `rest` → `$__bf_item0`). Innermost
+     *  last. Lets `.map(({ id, ...rest }) => …)` resolve instead of BF104. */
     private loopBindingStack;
-    private errors;
-    /** 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;
-    private propsObjectName;
-    /**
-     * Component-scoped rest binding identifier (`function({ a, ...rest }: P)`
-     * → `'rest'`). Stashed at `generate()` entry so per-attribute
-     * emitter callbacks can classify a spread expression against it
-     * without threading the IR through each recursion (#1407
-     * follow-up).
-     */
-    private restPropsName;
-    private templateVarCounter;
-    /** Local type names resolved from typeDefinitions (populated during generateTypes) */
-    private localTypeNames;
-    /** Local type aliases mapping type name to base type (e.g., Filter → 'string') */
-    private localTypeAliases;
     /**
-     * Per-struct field map (type name → source TS key → Go field name), populated
-     * during generateTypes. The object-literal baker consults this so a baked
-     * struct literal only names fields the generated struct actually declares.
-     */
-    private localStructFields;
-    /**
-     * Synthesised array types for untyped object-array signals (signal getter →
-     * `[]SynthStruct` TypeInfo), populated during generateTypes (#1680). An
-     * untyped `createSignal([{ id: "a" }])` has no element type to bake against;
-     * we infer a struct from the literal's shape so the field can be typed and
-     * the items baked. Consulted by both the signal field-type emitter and the
-     * initial-value baker.
-     */
-    private synthStructTypes;
-    /** Full type definitions from the current IR, stashed for loop-datum field resolution (#1897). */
-    private currentTypeDefinitions;
-    /** Set during type generation when any emit references
-     *  `template.HTML(...)`; toggles the `"html/template"` import. */
-    private usesHtmlTemplate;
-    /** Component root scope element(s) — each carries `data-key` for a keyed loop
-     *  item. A plain element root is one node; an `if-statement` (early-return)
-     *  root contributes the top element of every branch. (#1297) */
-    private rootScopeNodes;
-    /** Set during type generation when any emit references
-     *  `fmt.Sprint(...)` — e.g. a `Record<staticKeys, scalar>[propKey]`
-     *  indexed-map spread value (#checkbox); toggles the `"fmt"` import. */
-    private usesFmt;
-    /**
-     * Cross-component child shapes (#checkbox), keyed by child component name.
-     * Populated out-of-band via `registerChildComponentShape` before the parent
-     * component's `generateTypes` runs, so the static-child-init codegen can
-     * route an attribute that is NOT a declared param of the child
-     * (`<CheckIcon data-slot=.../>`) into the child's rest bag
-     * (`Capitalize(restPropsName)` map field) instead of emitting an invalid
-     * hyphenated top-level field (`Data-slot:`). A child with no rest bag and
-     * an unknown attr is left as-is so the existing field path / Go compile
-     * error still surfaces.
+     * Cross-component child shapes, keyed by child component name. Populated via
+     * `registerChildComponentShape` before the parent's `generateTypes`, so the
+     * static-child-init codegen can route an attribute that is NOT a declared
+     * child param (`<CheckIcon data-slot=.../>`) into the child's rest bag instead
+     * of an invalid hyphenated field (`Data-slot:`). An unknown attr on a child
+     * with no rest bag is left as-is (existing field path / Go error surfaces).
      */
     private childComponentShapes;
-    /**
-     * Module-scope pure string-literal constants (`const X = 'literal'` at
-     * file top-level), keyed by name → resolved literal value. Populated at
-     * `generate()` entry from `ir.metadata.localConstants`. When an identifier
-     * in an expression resolves to one of these, the adapter inlines the
-     * literal value instead of emitting a struct-field reference
-     * (`{{.X}}`) — the field never exists on the Props struct, so without
-     * inlining Go's template engine fails with `can't evaluate field X`.
-     * Hono inlines it for free (it evaluates real JS); this restores parity.
-     * Only module-scope, pure string literals qualify — function-scope
-     * locals legitimately become template vars/props, and `Record<T,string>`
-     * indexed lookups / memos / signals are deliberately excluded.
-     */
-    private moduleStringConsts;
-    /**
-     * All local constants (module + function-scope) from the IR, retained for
-     * the lifetime of `generate()` so the memo-computation path can resolve
-     * `Record`-index lookups (`variantClasses[variant]`) without re-threading the
-     * full `ir` through every helper. Reset at `generate()` entry.
-     */
-    private localConstants;
-    /**
-     * `useContext(...)` consumers in the component being generated. Each becomes
-     * a struct field defaulted to the `createContext` default, which an enclosing
-     * `<Ctx.Provider value>` overwrites for descendant child slots. Reset at
-     * `generate()` / `generateTypes()` entry. (#1297)
-     */
-    private contextConsumers;
-    /**
-     * (#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;
-    /**
-     * 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 when a constructor-context lowering emits a `strings.` call (#1897), so
-     *  `strings` is added to the generated types file's import block. */
-    private needsStringsImport;
-    /** 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;
-    /** 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;
     /** Child component name → the contexts it consumes (cross-component, for provider wiring). */
     private childContextConsumers;
-    /**
-     * Set of prop NAMES whose resolved Go struct-field type is exactly
-     * `interface{}` — i.e. nillable. Populated at `generate()` entry from
-     * the SAME per-prop Go-type computation `generatePropsStruct` /
-     * `generateInputStruct` use (`propTypeOverrides` + `typeInfoToGo`), so
-     * it can't drift from the actual field types. Used by
-     * `elementAttrEmitter.emitExpression` to omit a dynamic attribute whose
-     * value is a bare reference to a nillable prop when that prop is nil
-     * (Hono-style nullish-attribute omission: an `undefined`-valued
-     * attribute is dropped rather than rendered as `attr=""`). Concrete
-     * (`string`/`int`/`bool`) fields are never in this set and always emit
-     * unconditionally, matching Hono's `value=""` / `data-count="0"`.
-     */
-    private nillablePropNames;
     constructor(options?: GoTemplateAdapterOptions);
     /**
-     * Generate template output for a component.
-     * @param ir - The component IR
-     * @param options - Generation options
+     * Prime the per-compile state both `generate()` and `generateTypes()` derive
+     * from the IR. Both must prime identically or the emitted Input/Props structs
+     * drift (`generateTypes` runs on a separately round-tripped IR).
+     * `propsObjectName` is set first because the inherited-attr scan keys off it.
      */
+    private primeCompileState;
+    /** Generate template output for a component. */
     generate(ir: ComponentIR, options?: AdapterGenerateOptions): AdapterOutput;
     /**
-     * Check if a component has client interactivity (needs client JS).
-     * A component has client interactivity if it has:
-     * - Signals (reactive state)
-     * - Effects (side effects)
-     * - Events on elements
-     */
-    private hasClientInteractivity;
-    /**
-     * Recursively check if any element in the tree has events.
-     */
-    private hasEventsInTree;
-    /**
-     * Find all child component names used in the IR tree.
-     */
-    private findChildComponentNames;
-    private collectChildComponentNames;
-    /**
-     * Push a `BF103` diagnostic for every component reference inside a
-     * loop body whose name is imported from a relative-path module
-     * (i.e. a sibling .tsx file). The Go adapter renders these as
-     * `{{template "X" .}}` calls, which Go's template engine resolves
-     * only against templates registered on the same `*template.Template`
-     * — so a user who factored a list item into `./list-item.tsx` and
-     * mapped over it gets a working build and a `template: "X" is
-     * undefined` at request time. Surfacing this at build time matches
-     * the louder-over-silent contract (#1266).
-     *
-     * Scoped to loop bodies because that's the natural Hono-style
-     * pattern the issue calls out; static (non-loop) usage of imported
-     * components is left alone so existing static-layout patterns
-     * keep working without noise.
+     * Push BF103 for every loop-body component reference whose name is imported
+     * from a relative-path (sibling) module. The Go adapter renders these as
+     * `{{template "X" .}}`, which resolves only against templates registered on
+     * the same `*template.Template` — otherwise a clean build fails at request
+     * time with `template: "X" is undefined`. Static (non-loop) usage is left
+     * alone so existing layouts keep working.
      */
     private checkImportedLoopChildComponents;
     /**
-     * Generate script registration code for the template.
-     * Scripts are registered at the beginning of the template.
-     * Uses .Scripts which is available on all Props structs.
-     * The same ScriptCollector should be shared across parent and child props.
-     * Wrapped in {{if .Scripts}} to safely handle nil Scripts.
+     * Script registration code for the template start. Reads `.Scripts` (on every
+     * Props struct) and guards the registrations with `{{if .Scripts}}` for a nil
+     * collector.
      */
     private generateScriptRegistrations;
     /**
-     * Register a child component's shape (#checkbox) so a parent's
-     * static-child-init codegen can route non-param attributes into the child's
-     * rest bag rather than emitting an invalid hyphenated top-level field. Call
-     * once per known child IR (siblings in the same source, auto-inferred
-     * `../<name>` imports) before generating the parent's types. Idempotent.
+     * Register a child component's shape (see `childComponentShapes`). Call once
+     * per known child IR before the parent's `generateTypes`. Idempotent.
      */
     registerChildComponentShape(ir: ComponentIR): void;
     /** Go field name for a `useContext` consumer (the capitalized local binding). */
@@ -284,119 +100,55 @@ export declare class GoTemplateAdapter extends BaseAdapter implements ParsedExpr
     private contextConsumerGoType;
     /** Go literal for a context-consumer's default value (the `createContext` arg). */
     private contextConsumerGoDefault;
-    /**
-     * Context-consumer fields that don't collide with an already-emitted prop /
-     * signal / memo field. The template reads them as `{{.Field}}` (the local
-     * `useContext` binding lowered to a root field); the struct must carry them.
-     */
+    /** Context-consumer fields not colliding with an already-emitted prop/signal/memo field (the struct must carry them; template reads `{{.Field}}`). */
     private nonCollidingContextConsumers;
     generateTypes(ir: ComponentIR): string | null;
-    /**
-     * Convert a TypeScript type definition to a Go type.
-     * Handles object types → Go structs, and union string literals → string alias.
-     */
+    /** Convert a TS type definition to Go: object types → structs, string-literal unions → a `string` alias. */
     private typeDefinitionToGo;
     /**
-     * Derive a struct's Go fields from the analyzer-provided structured
-     * properties — no string parsing of the definition. This is the single
-     * source of truth for which fields a generated struct has and each field's Go
-     * name/type; both the struct emitter ({@link typeDefinitionToGo}) and the
-     * object-literal baker ({@link tsLiteralToGo}) consume it, so a baked literal
-     * can never name a field the struct doesn't declare.
-     *
-     * A property whose source key isn't a valid Go identifier (`"data-id"`, a
-     * numeric key, …) can't become a struct field, so it's dropped here — and is
-     * therefore absent from the baker's field map too, which bails to nil for any
-     * literal that uses such a key.
+     * Single source of truth for a generated struct's Go fields, derived from the
+     * analyzer's structured properties (no definition-string parsing). Both the
+     * struct emitter and the object-literal baker consume it, so a baked literal
+     * can't name a field the struct lacks. A non-Go-identifier source key
+     * (`"data-id"`, a numeric key) is dropped here, so the baker bails to nil for
+     * any literal using such a key.
      */
     private structFieldsFor;
     /**
      * Synthesise a Go struct from an untyped object-array signal's inline initial
-     * value (#1680). Returns the struct name + fields, or `null` when synthesis
-     * isn't possible so the caller keeps the field `[]interface{}`/`nil`.
-     *
-     * Synthesis applies only when:
-     *   - the signal's type is an array with no usable element type (untyped),
-     *   - the initial value is a non-empty array literal of object literals,
-     *   - every element shares the same set of Go-identifier keys, and
-     *   - every value is a scalar literal whose Go type is consistent per key
-     *     (numeric keys widen int→float64 when mixed).
-     *
-     * Any deviation (heterogeneous shape, a nested object/array value, a
-     * non-literal value, a non-identifier key, or a name collision with an
-     * existing type) returns `null`.
+     * value, or `null` (caller keeps `[]interface{}`/`nil`). Requires: untyped
+     * array type; a non-empty array literal of object literals; every element
+     * sharing the same Go-identifier key set; every value a scalar literal with a
+     * per-key-consistent Go type (mixed int/float64 widens to float64). Any
+     * deviation, or a name collision with an existing type, returns `null`.
      */
     private synthesizeStructFromSignal;
     /**
-     * The Go type for a scalar JS literal used as a synthesised struct field
-     * value, or `null` for anything non-scalar (objects, arrays, identifiers,
-     * calls, interpolated templates) so the caller bails out of synthesis.
+     * Go type for a scalar-literal `ParsedExpr` field value, else `null` (caller
+     * bails out of synthesis). string/no-substitution template → `string`;
+     * numeric (optionally negated) → int/float64; boolean → `bool`.
      */
-    private scalarLiteralGoType;
-    /** `int` for an integer literal, `float64` when the literal has a fraction
-     *  or exponent. */
+    private scalarParsedGoType;
+    /** `float64` when the literal has a fraction or exponent, else `int`. */
     private numericLiteralGoType;
-    /** Reconcile two inferred Go types for the same key across elements: equal
-     *  types stay; mixed numeric (int/float64) widens to float64; otherwise null
-     *  (incompatible → bail). */
+    /** Reconcile two per-key Go types: equal stays; mixed numeric widens to float64; else null. */
     private mergeScalarGoType;
     /**
-     * Convert a raw TypeScript type string to a Go type string.
-     * Handles primitives (number, string, boolean) and basic arrays.
-     */
-    private tsTypeStringToGo;
-    /**
-     * Build a map from prop name to a better Go type inferred from signals.
-     * When a signal is initialized from a prop (e.g., createSignal(props.initial ?? 0)),
-     * the signal's type annotation may be more specific than the prop's TypeInfo.
-     */
-    private buildPropTypeOverrides;
-    /**
-     * Resolve a prop param's Go struct-field type using the SAME logic
-     * `generatePropsStruct` / `generateInputStruct` use for the field
-     * declaration: a `propTypeOverrides` entry (signal-inferred override)
-     * wins, otherwise `typeInfoToGo(param.type, param.defaultValue)`.
-     * Factored out so the nillable-field set (`collectNillablePropNames`)
-     * can't drift from the actual emitted field types.
-     */
-    private resolvePropGoType;
-    /**
-     * Build the set of prop NAMES whose resolved Go field type is exactly
-     * `interface{}` (nillable). Uses the same `propTypeOverrides` +
-     * `resolvePropGoType` pipeline as the struct generators, so a prop
-     * that ends up `interface{}` on the Props struct — and only such a
-     * prop — is treated as nillable for Hono-style attribute omission.
-     * Concrete (`string`/`int`/`bool`/`[]T`/struct) types are excluded.
-     */
-    private collectNillablePropNames;
-    /**
-     * 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).
+     * Whether the component reads the request-scoped `searchParams()` env signal
+     * (from `searchParamsLocals`, covering any local incl. aliased imports). When
+     * true the structs carry a `SearchParams bf.SearchParams` binding the handler
+     * fills per request, read as `.SearchParams.Get "key"`. Returns false when a
+     * user prop/signal/memo named `searchParams` already owns the field (the
+     * binding would resolve to their value).
      */
     private usesSearchParams;
-    /**
-     * Generate Input struct for a component
-     */
+    /** Generate the Input struct for a component. */
     private generateInputStruct;
-    /**
-     * Generate Props struct for a component
-     */
     private generatePropsStruct;
     /**
-     * (#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>`).
+     * Wrapper struct for a loop-body component with JSX children: embeds the
+     * child's Props, datum fields from the loop's item type, and slot fields for
+     * sub-components in the body (`TableCell` inside `<TableRow>…</TableRow>`).
      */
     private generateLoopBodyWrapperStruct;
     /** Extract a memo name from a loop array expression like `sortedData()` → `sortedData`. */
@@ -405,31 +157,37 @@ export declare class GoTemplateAdapter extends BaseAdapter implements ParsedExpr
     private loopBodyWrapperName;
     /** Resolve a loop item's TypeInfo to Go struct fields for the wrapper. */
     private resolveLoopDatumFields;
-    /** Collect static child instances from loop body children for the wrapper struct. */
-    private collectBodyChildInstances;
     /**
-     * Generate NewXxxProps function
+     * `'interface{}'` for a loop over an inline primitive-literal array whose body
+     * renders the bare item (`[1,2,3,4,5].map(n => …{n}…)`), else null. Such
+     * scalar-item loops have no datum fields, so the value is carried on the
+     * wrapper's synthetic `BfLoopItem`; object/field loops and non-literal sources
+     * keep the datum-field path.
      */
+    private scalarLiteralLoopGoType;
+    /** Collect static child instances from loop body children for the wrapper struct. */
+    private collectBodyChildInstances;
+    /** Generate the NewXxxProps function. */
     private generateNewPropsFunction;
-    /**
-     * Convert field name to JSON tag (camelCase)
-     */
+    private emitStaticChildInstances;
+    private emitNewPropsDocComment;
+    private emitSpreadBagInits;
+    private emitStaticBodyWrappers;
+    private emitDynamicBodyWrappers;
+    private buildLocalTypeTables;
+    private emitLocalTypeStructs;
+    private emitSynthStructs;
+    private resolveNestedLoopItemTypes;
+    private composeFileHeader;
+    private emitPropsStructHeader;
+    private emitPropsDataFields;
+    private emitPropsAuxFields;
+    /** Convert a field name to its JSON tag (camelCase). */
     private toJsonTag;
     /**
-     * Find all nested components (loops with childComponent).
-     * Returns extended info that includes whether the component comes from a dynamic (signal) array loop.
-     */
-    private findNestedComponents;
-    private collectNestedComponents;
-    /**
-     * Collect all static child component instances from the IR tree.
-     * Excludes components inside loops (which are handled by nestedComponents).
-     *
-     * Each instance is identified by:
-     * - name: Component name (e.g., "ReactiveChild")
-     * - slotId: Unique slot ID (e.g., "slot_6")
-     * - props: Component props
-     * - fieldName: Go field name (e.g., "ReactiveChildSlot6")
+     * Collect all static child component instances from the IR tree. Excludes
+     * components inside loops (handled by nestedComponents). Each instance carries
+     * its component `name`, `slotId`, `props`, and Go `fieldName`.
      */
     private collectStaticChildInstances;
     /**
@@ -437,33 +195,20 @@ export declare class GoTemplateAdapter extends BaseAdapter implements ParsedExpr
      * every node is plain text; otherwise null.
      */
     private extractTextChildren;
-    /**
-     * Render JSX children to a Go-template-ready HTML fragment when
-     * children are non-text but produce purely-static HTML (no Go
-     * template actions). Returns null when:
-     *   - children are absent or text-only (handled by extractTextChildren), or
-     *   - the rendered fragment contains any `{{...}}` action — passing
-     *     such a fragment through `template.HTML` and the parent's
-     *     `{{.Children}}` would output the actions verbatim instead of
-     *     evaluating them, which is worse than the existing
-     *     "drop children" fallback. Dynamic / component-bearing children
-     *     stay on the drop path until a re-evaluation hook lands.
-     */
     /**
      * Pull the IR nodes out of a `children={<…/>}` attribute (a `jsx-children`
-     * prop value). Empty when the component takes no such prop. (#1326 / #1335)
+     * prop value). Empty when the component takes no such prop.
      */
     private jsxChildrenPropNodes;
     private extractHtmlChildren;
     /**
      * Build a Go string-concat expression for hoisted-JSX children whose root
-     * carries `needsScope` (`children={<span/>}` — #1326 / #1335). Such roots
-     * render in the PARENT's scope, so their `bf-s` is the runtime parent
-     * `scopeID`, not a bake-time constant. We render the fragment, swap the
-     * parent-scope hydration marker for a sentinel, and splice `scopeID` back
-     * in. Returns null when the plain static `childrenHtml` path already
-     * applies, or when any other template action survives (genuinely dynamic —
-     * those stay on the drop path).
+     * carries `needsScope` (`children={<span/>}`). Such roots render in the
+     * PARENT's scope, so their `bf-s` is the runtime parent `scopeID`, not a
+     * bake-time constant. Render the fragment, swap the parent-scope hydration
+     * marker for a sentinel, and splice `scopeID` back in. Returns null when the
+     * plain static `childrenHtml` path already applies, or when any other template
+     * action survives (genuinely dynamic — those stay on the drop path).
      */
     private extractScopedHtmlChildren;
     private collectStaticChildInstancesRecursive;
@@ -474,420 +219,42 @@ export declare class GoTemplateAdapter extends BaseAdapter implements ParsedExpr
      */
     private extendProviderContext;
     /**
-     * Collect top-level (non-loop) JSX intrinsic-element spread slots
-     * from the IR (#1407). Loop-internal spreads are skipped — they
-     * emit the bag inline via the loop's iteration variable in
-     * `elementAttrEmitter.emitSpread`, so they don't need a Props
-     * struct field.
-     *
-     * Walks the IR tree, descending into elements, fragments,
-     * conditionals, providers, async, and components, but stopping at
-     * loop bodies. Each `IRElement.attrs[i].value` of kind `'spread'`
-     * that has a `slotId` becomes one `SpreadSlotInfo` entry.
-     */
-    private collectSpreadSlots;
-    /**
-     * Decide how a spread bag should be plumbed onto the Input/Props
-     * structs (#1407 follow-up). A bare-identifier spread that
-     * matches the component's `restPropsName` is open-ended (Go's
-     * static typing can't enumerate the keys), so the caller must
-     * supply the bag via an Input-side `map[string]any` field. Every
-     * other shape — signal getter, `propsObjectName`, plain
-     * propsParam, object literal — can be constructed inline in
-     * `NewXxxProps` from compile-time-known data.
-     *
-     * Reads `this.restPropsName` (stashed at `generate()` entry)
-     * rather than receiving the IR per-call — matches the existing
-     * `this.propsObjectName` / `this.componentName` storage pattern.
-     */
-    private classifySpreadBagSource;
-    private collectSpreadSlotsRecursive;
-    /**
-     * Parse a JS object-literal source text (the raw string captured
-     * for a signal's `initialValue` or a spread expression's argument)
-     * into a Go `map[string]any{...}` literal source (#1407).
-     *
-     * Supports a deliberately conservative subset so the Go output is
-     * a 1:1 translation of the JS source: string/number/boolean/null
-     * values keyed by identifier or string-literal keys. Returns null
-     * for unsupported shapes (nested objects, computed values,
-     * function calls, spread elements) — callers fall back to BF101.
-     */
-    private parseJsObjectLiteralToGoMap;
-    /**
-     * Build a Go expression for a JSX spread bag's initial value, to
-     * be placed inside `NewXxxProps`'s return literal (#1407).
-     *
-     * Supported shapes:
-     *   - Signal-getter call (e.g. `attrs()`): look up the signal,
-     *     parse its `initialValue` as a JS object literal, and emit a
-     *     Go `map[string]any{...}` literal.
-     *   - Bare identifier matching a destructured `propsParam` (e.g.
-     *     `function({ extras }: P) { <el {...extras}/> }`): emit
-     *     `in.<FieldName>` — works when the prop's Go type is a map
-     *     type the bag is assignable to.
-     *   - Bare identifier matching `propsObjectName` (SolidJS-style
-     *     `function(props: P) { <el {...props}/> }`): enumerate the
-     *     analyzer-extracted `propsParams` into an inline
-     *     `map[string]any{...}` literal so each typed Input field
-     *     surfaces as a bag key (#1407 follow-up).
-     *   - Bare identifier matching `restPropsName` (the destructured-
-     *     rest pattern `function({a, ...rest}: P) { <el {...rest}/> }`):
-     *     emit `in.<slotId>` against the `map[string]any` Input field
-     *     that `generateInputStruct` adds for `input-bag` slots. The
-     *     caller (parent component or test harness) populates the
-     *     bag with the open-ended rest values (#1407 follow-up).
-     *
-     * Returns null for unsupported shapes so the caller can raise a
-     * narrowed BF101 with the offending expression.
-     */
-    private buildSpreadInitializer;
-    /**
-     * Lower a conditional inline-object spread bag value:
-     *   `(COND ? { 'aria-describedby': describedBy } : {})`
-     * into an immediately-invoked Go func literal that conditionally
-     * builds the map (so the falsy branch OMITS the key rather than
-     * rendering it as an empty string, which `SpreadAttrs` does not
-     * filter):
-     *
-     *   func() map[string]any {
-     *     if in.DescribedBy != nil && in.DescribedBy != "" {
-     *       return map[string]any{"aria-describedby": in.DescribedBy}
-     *     }
-     *     return map[string]any{}
-     *   }()
-     *
-     * Returns:
-     *   - `undefined` when the expression is NOT a parenthesized ternary
-     *     of object literals — the caller falls through to other shapes.
-     *   - `null` when it IS that shape but a part can't be faithfully
-     *     converted (non-static key, unsupported condition, …) — the
-     *     caller raises BF101.
-     *   - the Go IIFE string when fully convertible.
-     */
-    private buildConditionalSpreadInitializer;
-    /** Strip redundant parenthesised wrappers off a TS expression. */
-    private unwrapParens;
-    /**
-     * Convert a conditional-spread condition expression to a Go bool in
-     * the `in.` context. Supports a bare prop identifier (`describedBy`)
-     * and its negation (`!describedBy`), type-aware on the prop:
-     *   string  → `in.X != ""`
-     *   boolean → `in.X`
-     *   number  → `in.X != 0`
-     *   unknown / interface{} → `in.X != nil && in.X != ""`
-     *     (faithful JS string-truthiness for an interface holding a
-     *     string — textarea's `describedBy` resolves to interface{}).
-     * Returns null for any other shape (caller → BF101).
-     */
-    private conditionToGoBool;
-    /**
-     * Convert a static object literal (`{ 'aria-describedby': describedBy }`)
-     * into a Go `map[string]any{...}` literal for a conditional spread.
-     * Only static string/identifier keys are allowed; values resolve
-     * prop-identifier references to `in.FieldName` and string literals to
-     * Go string literals. Returns null for any computed/spread/dynamic
-     * key or unsupported value (caller → BF101). Empty object → `map[string]any{}`.
-     */
-    private objectLiteralToGoSpreadMap;
-    /**
-     * Lower a spread-object VALUE of the form `IDENT[KEY]` where:
-     *   - `IDENT` resolves via `localConstants` to a MODULE-scope object
-     *     literal whose property values are all scalar (number/string)
-     *     literals under static (string-literal or identifier) keys
-     *     (a `Record<staticKeys, scalar>` map like `sizeMap`), AND
-     *   - `KEY` is a bare identifier that is a prop.
-     * Emits an inline indexed Go map:
-     *   `map[string]any{"sm": 16, ...}[fmt.Sprint(in.Size)]`
-     * (`fmt.Sprint` coerces the `interface{}`/typed prop to the map's
-     * string key space — sets `usesFmt` so the `"fmt"` import is added).
-     *
-     * Returns the Go string when convertible, else `null` (caller → BF101)
-     * for any non-scalar value, non-static key, or non-prop index so
-     * unrelated shapes don't regress. (#checkbox / icon `sizeMap[size]`.)
-     */
-    private recordIndexAccessToGoMap;
-    /**
-     * Convert JavaScript initial value to Go value for NewXxxProps function.
-     * References to props params are converted to in.FieldName format.
-     */
-    private convertInitialValue;
-    /**
-     * Convert a fully-literal JS expression string into an equivalent Go literal
-     * whose Go type matches `typeInfo` (#1672), used to bake a signal's inline
-     * initial value into the SSR data context:
-     *
-     *   `["x", "y"]`             (string[])  → `[]string{"x", "y"}`
-     *   `["x", "y"]`             (unknown[]) → `[]interface{}{"x", "y"}`
-     *   `[{ id: "a" }]`          (Item[])    → `[]Item{Item{ID: "a"}}`
-     *
-     * Returns `null` — so the caller keeps `nil` — when the expression (or any
-     * nested element) is not a pure literal (a call, identifier, template with
-     * interpolation, …) or cannot be expressed in the target Go type without a
-     * render/compile mismatch (e.g. an object element in a `[]interface{}` field,
-     * which the SSR template reaches via struct field access the map lacks).
-     */
-    private jsLiteralToGo;
-    /**
-     * Parse a JS expression string into its TS AST node (parentheses unwrapped),
-     * or `null` when it isn't a single expression. Shared by the literal baker
-     * and the struct-shape synthesiser.
-     */
-    private parseLiteralExpression;
-    /**
-     * Recursively convert a TS literal AST node to a Go literal typed as
-     * `typeInfo`, or null when the node is not a pure literal / cannot be
-     * represented in that Go type.
-     */
-    private tsLiteralToGo;
-    /**
-     * Convert TypeInfo to Go type string.
-     * If type is unknown, tries to infer from defaultValue.
-     */
-    private typeInfoToGo;
-    /**
-     * Get signal's initial value as Go code.
-     * Handles both literal values (0, true, "str") and props references (initial).
-     *
-     * (#1423) When the signal references a prop via `props.X ?? N` and
-     * the caller hoisted a fallback variable for `X`, return the hoisted
-     * variable's name so the memo inherits the signal-time fallback.
-     */
-    private getSignalInitialValueAsGo;
-    /**
-     * Resolve dynamic prop value (e.g., signal/memo getter calls) to Go initial value.
-     * Handles expressions like `count()` → signal's initial value
-     */
-    /**
-     * Convert a template literal's parsed parts into a Go expression of
-     * type `string`, evaluated in `NewXxxProps` scope (where destructured
-     * prop refs resolve via `in.FieldName`). Returns null when any part
-     * is not representable in static Go code so the caller can fall back
-     * to `resolveDynamicPropValue` (which handles the simpler shapes).
-     *
-     * Supported parts:
-     *   - `string`: emit as a Go string literal.
-     *   - `lookup`: `${MAP[KEY]}` against a `Record<T, string>` literal —
-     *     emit an IIFE that switches on the key prop and returns the
-     *     matching case (empty when no case matches). The key must be a
-     *     bare prop identifier today; other key shapes opt out.
-     *
-     * `ternary` is intentionally left unsupported — the existing
-     * element-attribute path handles it via Go template `{{if}}` syntax,
-     * and component-prop-via-ternary cases are rarer and can be added
-     * incrementally.
+     * Convert a template literal's parsed parts into a `string`-typed Go
+     * expression in `NewXxxProps` scope (destructured prop refs → `in.FieldName`),
+     * or null so the caller falls back to `resolveDynamicPropValue`. A `string`
+     * part emits a Go literal; a `lookup` (`${MAP[KEY]}` over a `Record<T,string>`,
+     * key must be a bare prop ident) emits a switch-on-key IIFE. `ternary` opts out
+     * — the element-attribute path handles it via `{{if}}`.
      */
     private templatePartsToGoCode;
     private resolveDynamicPropValue;
-    /**
-     * Compute the initial value for a memo based on its computation and signal initial values.
-     * Handles simple cases like `() => count() * 2` → `in.Initial * 2`
-     * Also handles props.xxx patterns like `() => props.value * 10` → `in.Value * 10`
-     *
-     * (#1423) When `propFallbackVars` carries a hoisted variable for the
-     * referenced prop, substitute it for `in.FieldName` so the memo
-     * inherits the signal-time `??` fallback.
-     */
-    /**
-     * (#checkbox) Compute the SSR initial value of a template-literal memo as a
-     * Go `string` expression. The memo computation looks like
-     * `() => `${a} ${b} ${props.className ?? ''} grid place-content-center``.
-     *
-     * Each quasi (literal text span) becomes a Go string literal; each
-     * interpolation is resolved:
-     *   - an identifier naming a module string const → its inlined literal
-     *     (covers both pure-string and `[...].join(' ')` consts);
-     *   - `props.<name> ?? '<fallback>'` or bare `props.<name>` → `in.<Field>`
-     *     when `<name>` is a known prop param (typed `string`); the `?? ''`
-     *     fallback maps to Go's zero value for an unset string field, matching
-     *     the Hono reference's empty-string result.
-     *
-     * Returns the `"a" + in.Field + " grid..."` concatenation, or null when the
-     * computation isn't a single template literal or any interpolation isn't
-     * representable (so the caller keeps its existing pattern matching).
-     */
-    private computeTemplateLiteralMemoInitialValue;
-    /**
-     * (#checkbox) Resolve one `${expr}` interpolation of a template-literal memo
-     * to a Go string expression, or null when unsupported. See
-     * `computeTemplateLiteralMemoInitialValue` for the supported shapes.
-     */
-    private resolveTemplateInterpolation;
-    /**
-     * Parse a memo-local `const X = …` initializer into a `Record`-index key
-     * binding: `props.Y ?? 'lit'` → `{ propName: 'Y', defaultLiteral: 'lit' }`,
-     * or bare `props.Y` → `{ propName: 'Y' }`. Returns null for any other shape
-     * (a literal const, a call, etc.) so it simply isn't registered as a key.
-     */
-    private parseLocalKeyBinding;
-    /**
-     * Lower a `recordConst[key]` interpolation to an inline indexed Go map,
-     * emitting `map[string]string{…}[fmt.Sprint(in.Field)]` (or `map[string]any`
-     * for mixed values). `key` is a bare prop or a memo-local const bound to
-     * `props.X ?? 'default'` (resolved via `localKeyBindings`); a `'default'`
-     * fallback also maps `""` to that entry, so an unset prop (Go zero value `""`)
-     * renders the default — matching Hono's `props.X ?? 'default'`. Returns null
-     * for any non-record / non-resolvable key so the caller falls through.
-     */
-    private recordIndexInterpolationToGo;
-    /**
-     * If `node` is a `<propsObjectName>.<name>` access, return `<name>`, else
-     * null. Used to recognize props-object reads inside memo interpolations.
-     */
-    private propsAccessName;
-    private computeMemoInitialValue;
-    /**
-     * 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;
-    /**
-     * (#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 resolveBlockBodyMemoModuleConst;
-    /**
-     * (#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 computeObjectMemoInitialValue;
-    /**
-     * 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;
-    /**
-     * 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;
-    /**
-     * 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;
-    /**
-     * 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;
-    /**
-     * Infer the Go type for a memo based on its computation and dependencies.
-     */
+    /** Infer the Go type for a memo from its computation and dependencies. */
     private inferMemoType;
     /**
-     * (#checkbox) Heuristic: does this memo evaluate to a boolean? True when its
-     * computation is a comparison (`!==`/`===`/`!=`/`==`), a negation (`!x`), or
-     * a ternary whose branches are all boolean signals/props. Used to pick `bool`
-     * (zero value `false`) over the int `0` default for the SSR initial value.
-     */
-    private isBooleanMemo;
-    /**
-     * Infer Go type from a JavaScript value literal.
-     */
-    private inferTypeFromValue;
-    /**
-     * (#1423) Hoisted-variable record for a prop with a signal-time
-     * `??` fallback. The same record is referenced from the prop field
-     * loop, the signal field loop, and the memo computation path.
-     */
-    private static EMPTY_PROP_FALLBACK_VARS;
-    /**
-     * (#1423) Walk signals to collect prop fallbacks. Skips props that
-     * already have a destructure-side default (`{ X = N }`) or signals
-     * whose fallback resolves to the type's Go zero value (no-op).
+     * Walk signals to collect prop fallbacks. Skips props that already have a
+     * destructure-side default (`{ X = N }`) or signals whose fallback resolves to
+     * the type's Go zero value (no-op).
      */
     private collectPropFallbackVars;
     /**
-     * (#1423) Parse a signal-time initial value of the form
-     * `props.X ?? <literal>` into the source prop name and the Go-formatted
-     * fallback. Returns null when:
-     *   - the expression isn't a `??` against a property access on
-     *     `propsObjectName`
-     *   - the fallback isn't a simple literal `goPropDefault` can translate
+     * Parse a signal-time initial value of the form `props.X ?? <literal>` into
+     * the source prop name and the Go-formatted fallback. Returns null when the
+     * expression isn't a `??` against a property access on `propsObjectName`, or
+     * the fallback isn't a simple literal `goPropDefault` can translate.
      *
-     * The Go-adapter equivalent of the same parse already done by the
-     * static evaluator in `ssr-defaults.ts` — duplicated here because we
-     * need the original prop reference (not just the resolved value)
-     * to honour caller-supplied non-zero inputs.
+     * Keeps the original prop reference (not just the resolved value) so
+     * caller-supplied non-zero inputs are honoured.
      */
     private extractPropFallback;
     /**
-     * Extract prop name from a signal's initialValue that uses props.xxx pattern.
-     * e.g., "props.initial ?? 0" → "initial", "props.checked" → "checked"
+     * Extract the prop name from a signal's `props.xxx`-pattern initialValue,
+     * e.g. `"props.initial ?? 0"` → `"initial"`, `"props.checked"` → `"checked"`.
      */
     private extractPropNameFromInitialValue;
-    /**
-     * A source key that can become a Go struct field — i.e. a valid Go
-     * identifier. TS object keys that aren't (e.g. `"data-id"`, numeric keys)
-     * can't be exported struct fields, so they're excluded from struct generation
-     * and from the baker's field map.
-     */
-    private static GO_IDENTIFIER;
-    /** Go common initialisms that should be fully uppercased (https://go.dev/wiki/CodeReviewComments#initialisms) */
-    static GO_INITIALISMS: Set<string>;
-    /**
-     * (#1423) Go reserved keywords. When we hoist a local var named after
-     * a JSX prop, the prop name could collide with one of these — append
-     * `_` until the name is free.
-     */
-    private static GO_KEYWORDS;
-    private capitalizeFieldName;
-    /**
-     * Convert a JavaScript literal value to Go literal syntax.
-     */
-    /**
-     * Translate a JSX param default (e.g. `'default'`, `0`, `false`) into
-     * the corresponding Go literal. Returns null when the default is
-     * absent or non-trivial (objects, arrow functions, etc.) — those
-     * fall back to letting Go's zero value win.
-     */
-    private goPropDefault;
-    /**
-     * Wrap an `in.X` reference in a Go expression that substitutes
-     * `fallback` when the input is the zero value for its type. We pick
-     * the comparison based on the fallback literal's shape.
-     *
-     * Asymmetry on bool defaults is intentional and worth flagging:
-     *   - For a `true` default, the generated expression is
-     *     `(in.X || true)` — which is **always `true`**. Go has no
-     *     unset-vs-explicit-false distinction at the struct-field level,
-     *     so any caller wanting to thread `false` through has to set it
-     *     after `NewXxxProps` rather than via the input struct.
-     *   - For a `false` default, the Go zero value already matches, so
-     *     the helper is a no-op (returns `ref` unchanged).
-     * Numeric `0` defaults are similarly indistinguishable from "unset"
-     * and pass through as the zero value; non-zero numeric defaults
-     * substitute, matching the JSX behavior of `(initial = 5) => ...`.
-     */
-    private applyGoFallback;
-    private goLiteral;
     /**
      * Public entry point for node rendering. Delegates to the shared
-     * `IRNodeEmitter` dispatcher (#1290 step 1); per-kind logic lives in
-     * the `IRNodeEmitter` methods below.
+     * `IRNodeEmitter` dispatcher; per-kind logic lives in the `IRNodeEmitter`
+     * methods below.
      */
     renderNode(node: IRNode, ctx?: GoRenderCtx): string;
     emitElement(node: IRElement, _ctx: GoRenderCtx, _emit: EmitIRNode<GoRenderCtx>): string;
@@ -904,57 +271,38 @@ export declare class GoTemplateAdapter extends BaseAdapter implements ParsedExpr
     renderElement(element: IRElement): string;
     renderExpression(expr: IRExpression): string;
     /**
-     * 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.
+     * Whether a lowered Go string already carries its own `{{...}}` actions and so
+     * must NOT be re-wrapped (`{{ {{...}} }}` is a parse error). Single source of
+     * the wrap-or-not decision across the expression / template-literal / attr
+     * 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.
+     * Structural, deliberately NOT a `{{` substring scan (a Go string literal may
+     * contain `{{`). Exactly two shapes are fragments: an action block, which the
+     * emitter never prefixes with literal text so it always starts with `{{`; and
+     * a template literal, the only form interleaving author text with actions,
+     * keyed by its parsed `kind`. The "no non-template-literal fragment starts
+     * with literal text" invariant is enforced by the template-fragment tests.
      */
     private isTemplateFragment;
     /**
-     * Render a client-only conditional as comment markers.
-     * Used when @client directive is applied to an unsupported conditional.
-     * The condition is evaluated on the client side via insert().
+     * Render a client-only conditional as comment markers (used when @client is
+     * applied to an unsupported conditional). The client evaluates the condition
+     * via insert().
      */
     private renderClientOnlyConditional;
     /**
-     * Render a ParsedExpr to Go template syntax via the shared
-     * dispatcher (#1250 phase 1). The per-kind logic lives in the
-     * `ParsedExprEmitter` methods below; this method is a thin wrapper
-     * so existing call sites keep working.
+     * Render a ParsedExpr to Go template syntax via the shared dispatcher. The
+     * per-kind logic lives in the `ParsedExprEmitter` methods below; this is a
+     * thin wrapper so existing call sites keep working.
      */
     private renderParsedExpr;
     identifier(name: string): string;
     /**
-     * (#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.
+     * 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;
     /**
@@ -978,15 +326,15 @@ export declare class GoTemplateAdapter extends BaseAdapter implements ParsedExpr
      * that lives on the component's top-level data struct. Inside a `{{range}}`
      * the dot is rebound to the iteration element, so root data must be reached
      * through Go template's `$` (the top-level argument to Execute), which never
-     * rebinds. Outside any loop the root *is* the dot, so we emit `.Field` (#1677).
+     * rebinds. Outside any loop the root *is* the dot, so we emit `.Field`.
      */
     private rootFieldRef;
     /**
-     * (#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.
+     * 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;
     /**
@@ -999,21 +347,14 @@ export declare class GoTemplateAdapter extends BaseAdapter implements ParsedExpr
      * pure compile-time string can be safely inlined byte-for-byte.
      */
     private collectModuleStringConsts;
-    /**
-     * (#checkbox) Statically evaluate `[<string literals>].join(<sep?>)`.
-     * Returns the joined string, or null when the shape doesn't match (non-call,
-     * non-`.join`, non-array receiver, any non-string-literal element, or a
-     * non-string-literal separator). Comments/whitespace between elements are
-     * irrelevant — the TS parser already discarded them.
-     */
     /**
      * Resolve an identifier to its inlined Go string literal when it names a
      * module pure-string const. Returns the Go template literal form
-     * (`"<escaped>"`) so callers can drop it straight into a `{{...}}` action,
-     * or `null` when the name is not such a const (the caller then falls back
-     * to its normal field-ref lowering). The value is escaped for a Go
-     * double-quoted string literal — Go's `html/template` then applies the
-     * same contextual auto-escaping it applies to any literal, matching Hono.
+     * (`"<escaped>"`) so callers can drop it straight into a `{{...}}` action, or
+     * `null` when the name is not such a const (the caller then falls back to its
+     * normal field-ref lowering). The value is escaped for a Go double-quoted
+     * string literal; `html/template` then applies its usual contextual
+     * auto-escaping.
      */
     private resolveModuleStringConst;
     /**
@@ -1033,37 +374,66 @@ export declare class GoTemplateAdapter extends BaseAdapter implements ParsedExpr
     logical(op: '&&' | '||' | '??', left: ParsedExpr, right: ParsedExpr, emit: (e: ParsedExpr) => string): string;
     conditional(test: ParsedExpr, consequent: ParsedExpr, alternate: ParsedExpr, emit: (e: ParsedExpr) => string): string;
     templateLiteral(parts: TemplatePart[], emit: (e: ParsedExpr) => string): string;
-    arrowFn(param: string, _body: ParsedExpr, _emit: (e: ParsedExpr) => string): string;
+    arrow(params: string[], _body: ParsedExpr, _emit: (e: ParsedExpr) => string): string;
+    regex(raw: string): string;
     arrayLiteral(elements: ParsedExpr[], emit: (e: ParsedExpr) => string): string;
-    higherOrder(method: HigherOrderMethod, object: ParsedExpr, param: string, predicate: ParsedExpr, emit: (e: ParsedExpr) => string): string;
+    objectLiteral(_properties: ObjectLiteralProperty[], raw: string, _emit: (e: ParsedExpr) => string): string;
+    /** Set of predicate (boolean-callback) higher-order methods. */
+    private static readonly PREDICATE_METHODS;
+    /**
+     * Recover the (removed) `higher-order` destructured shape from a generic
+     * `call` that is a recognised callback method whose method is a *predicate*
+     * one. Returns null for sort/reduce/flatMap or any non-callback call. Used by
+     * the `member`-arm short-circuits (`obj.filter(...).length`,
+     * `obj.find(...).prop`) that need the structured fallbacks.
+     */
+    private higherOrderShapeOf;
+    /**
+     * Push BF101 for a callback method whose shape has no Go template form.
+     *
+     * `selfContained` callbacks (`reduce` / `flatMap` off the eval-lowerable
+     * catalogue — a `.reduce` with no init, a tuple `.flatMap` with a non-leaf
+     * element) carry the self-contained "no SSR" remedy and must NOT get the
+     * generic Options block appended (mirrors `isSupported`'s `selfContained`
+     * flag for `UNSUPPORTED_METHODS`). Predicate callbacks that exhaust their
+     * template-block fallbacks keep the generic Options remediation.
+     */
+    private pushCallbackBF101;
+    callbackMethod(method: string, object: ParsedExpr, arrow: Extract<ParsedExpr, {
+        kind: 'arrow';
+    }>, restArgs: ParsedExpr[], emit: (e: ParsedExpr) => string): string;
     arrayMethod(method: ArrayMethod, object: ParsedExpr, args: ParsedExpr[], emit: (e: ParsedExpr) => string): string;
-    sortMethod(method: 'sort' | 'toSorted', object: ParsedExpr, comparator: SortComparator, emit: (e: ParsedExpr) => string): string;
-    reduceMethod(method: 'reduce' | 'reduceRight', object: ParsedExpr, reduceOp: ReduceOp, emit: (e: ParsedExpr) => string): string;
     flatMethod(object: ParsedExpr, depth: FlatDepth, emit: (e: ParsedExpr) => string): string;
-    flatMapMethod(object: ParsedExpr, op: FlatMapOp, emit: (e: ParsedExpr) => string): string;
     unsupported(raw: string, _reason: string): string;
     /**
      * Extract field name and negation from a simple predicate.
-     * t => t.done → { field: "Done", negated: false }
-     * t => !t.done → { field: "Done", negated: true }
+     *   `t => t.done`  → { field: "Done", negated: false }
+     *   `t => !t.done` → { field: "Done", negated: true }
      */
     private extractFieldPredicate;
     /**
-     * Extract field name and value from an equality predicate.
-     * Extends extractFieldPredicate to also handle equality comparisons.
-     *
-     * t.done → { field: "Done", value: "true" }
-     * !t.done → { field: "Done", value: "false" }
-     * u.id === selectedId() → { field: "Id", value: <rendered expr> }
-     * selectedId() === u.id → same (supports both operand orders)
+     * Extract field name and value from an equality predicate (extends
+     * extractFieldPredicate to also handle equality comparisons).
+     *   `t.done`                → { field: "Done", value: "true" }
+     *   `!t.done`               → { field: "Done", value: "false" }
+     *   `u.id === selectedId()` → { field: "Id", value: <rendered expr> }
+     *   `selectedId() === u.id` → same (both operand orders supported)
      */
     private extractEqualityPredicate;
     /**
-     * Render a higher-order expression (filter, every, some, find, findIndex) to Go template.
-     * Returns null if the expression is not supported.
-     *
-     * @param expr - The higher-order expression
-     * @param renderArray - Function to render the array expression (allows recursion via different methods)
+     * Emit a higher-order method through the runtime evaluator (#2018 P2):
+     * `bf_filter_eval` / `bf_every_eval` / `bf_some_eval` / `bf_find_eval` /
+     * `bf_find_index_eval`, carrying the serialized predicate body + captured
+     * env. Returns null when the predicate is outside the evaluator surface
+     * (caller falls back to the structured helper / template block). The find /
+     * findLast (and findIndex / findLastIndex) pair share a helper, differing
+     * only by the `forward` bool argument.
+     */
+    private renderHigherOrderEval;
+    /**
+     * Render a higher-order expression (filter, every, some, find, findIndex) to
+     * Go template, or null when the shape isn't supported. `renderArray` is passed
+     * in so the array can recurse through different lowering methods.
      */
     private renderHigherOrderExpr;
     /**
@@ -1077,39 +447,30 @@ export declare class GoTemplateAdapter extends BaseAdapter implements ParsedExpr
      */
     private renderFindTemplateBlock;
     /**
-     * Render every()/some() with complex predicates using {{range}}{{if}} with variable reassignment.
-     * Falls back from bf_every/bf_some when extractFieldPredicate returns null.
-     * Reuses renderFilterExpr for condition rendering.
+     * Render every()/some() with complex predicates as a `{{range}}{{if}}` with
+     * variable reassignment — the fallback from bf_every/bf_some when
+     * extractFieldPredicate returns null.
      *
-     * every: start true, set false on first failure, break early
-     * some: start false, set true on first match, break early
-     *
-     * @param expr - The higher-order every/some expression
-     * @param renderArray - Function to render the array expression
+     *   every: start true, set false on first failure, break early
+     *   some:  start false, set true on first match, break early
      */
     private renderEverySomeTemplateBlock;
     /**
-     * Negate a Go template condition.
-     * Wraps in `not (...)` when the condition is a Go function call (eq, ne, gt, etc.),
-     * otherwise uses `not condition`.
+     * Negate a Go template condition: `not (...)` when it's a Go function call
+     * (eq, ne, gt, …), else `not condition`.
      */
     private negateGoCondition;
     /**
-     * Render .length on a filter higher-order expression.
-     * e.g., todos().filter(t => !t.done).length → len (bf_filter .Todos "Done" false)
-     *
-     * @param filterExpr - The filter higher-order expression
-     * @param renderArray - Function to render the array expression
+     * Render `.length` on a filter higher-order expression, e.g.
+     * `todos().filter(t => !t.done).length` → `len (bf_filter .Todos "Done" false)`.
      */
     private renderFilterLengthExpr;
     /**
-     * Render a predicate expression for use in Go template {{if}} conditions.
-     * Substitutes the loop parameter (e.g., 't' in 't.done') with dot notation.
+     * Render a predicate for use in Go template `{{if}}` conditions, substituting
+     * the loop parameter (e.g. `t` in `t.done`) with dot notation.
      */
     private renderPredicateCondition;
-    /**
-     * Check if expression needs parentheses when used in and/or.
-     */
+    /** Whether an expression needs parentheses when used in and/or. */
     private needsParens;
     /**
      * Split a rendered template block into preamble + final expression.
@@ -1120,169 +481,50 @@ export declare class GoTemplateAdapter extends BaseAdapter implements ParsedExpr
      */
     private splitPreamble;
     /**
-     * Render block body filter into a single Go template condition.
-     *
-     * Example block body:
-     * ```
-     * filter(t => {
-     *   const f = filter()
-     *   if (f === 'active') return !t.done
-     *   if (f === 'completed') return t.done
-     *   return true
-     * })
-     * ```
-     *
-     * Becomes:
-     * ```
-     * or (and (eq $.Filter "active") (not .Done))
-     *    (and (eq $.Filter "completed") .Done)
-     *    (and (ne $.Filter "active") (ne $.Filter "completed"))
-     * ```
-     */
-    private renderBlockBodyCondition;
-    /**
-     * Recursively collect all return paths through the statements.
-     * Returns an array of ReturnPath objects.
-     */
-    private collectReturnPaths;
-    /**
-     * Build a condition for a single return path.
-     */
-    private buildSinglePathCondition;
-    /**
-     * Build an OR condition from multiple return paths.
-     */
-    private buildOrCondition;
-    /**
-     * Render multiple conditions combined with AND.
-     */
-    private renderConditionsAnd;
-    /**
-     * Unified method for rendering filter predicate expressions.
-     * Used for both expression body (t => !t.done) and block body filters.
-     *
-     * @param expr - The parsed expression to render
-     * @param param - The loop parameter name (e.g., 't' in filter(t => ...))
-     * @param localVarMap - Optional map of local variables to signal names (for block body)
+     * Render a filter predicate expression (`t => !t.done`, or a block body
+     * normalized to one — #2040). `localVarMap` is a vestigial empty default kept
+     * on the recursion; block-body locals are now inlined upstream, so no caller
+     * populates it.
      */
     private renderFilterExpr;
     private renderFilterExprNode;
     /**
-     * Check if a ParsedExpr will render as a Go template function call.
-     * Used to determine if parentheses are needed around the expression.
+     * Whether a ParsedExpr renders as a Go template function call (so it needs
+     * parentheses around it).
      */
     private isGoFunctionCall;
     /**
-     * Render a branch of a conditional expression.
-     * String literals render as bare text (no quotes).
-     * Nested conditionals render as complete {{if}}...{{end}} blocks.
+     * Render a branch of a conditional expression. String literals render as bare
+     * text (no quotes); nested conditionals render as complete `{{if}}…{{end}}`
+     * blocks; everything else is wrapped in `{{...}}`.
      */
     private renderConditionalBranch;
     /**
-     * Check if a ParsedExpr renders to a Go template function call that needs parentheses.
-     * In Go templates, function calls like `len .X` or `bf_add .A .B` need parentheses
-     * when used as arguments to comparison operators (eq, gt, lt, etc.).
+     * Whether a ParsedExpr renders to a Go template function call (`len .X`,
+     * `bf_add .A .B`) that needs parentheses when used as an argument to a
+     * comparison operator (eq, gt, lt, …).
      */
     private needsParensInGoTemplate;
-    /**
-     * Convert a JS expression to Go template syntax.
-     */
+    /** Convert a JS expression to Go template syntax. */
     private convertExpressionToGo;
     /**
-     * (#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;
-    /**
-     * 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;
-    /**
-     * 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;
-    /**
-     * 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;
-    /**
-     * (#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;
-    /**
-     * 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;
-    /**
-     * Match `<builderVar>.set('literalKey', <value>)` — as a statement or an
-     * if-then — returning the key text and value node, else null.
-     */
-    private matchUrlSet;
-    /**
-     * 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;
-    /**
-     * 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;
-    /**
-     * 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.
+     * 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']`). 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 lives in `parseRecordIndexAccess`
+     * (shared with Mojo); this helper covers the literal-key case parse rejects.
      */
     private resolveStaticRecordLiteralIndex;
-    /**
-     * Create a source location for error reporting.
-     */
+    /** Create a source location for error reporting. */
     private makeLoc;
     private renderIfStatement;
     renderConditional(cond: IRConditional): string;
     /**
-     * Convert a JS condition to Go template condition syntax.
-     * Returns { condition, preamble } where preamble contains template blocks
-     * that must be emitted before the {{if}} (e.g., every/some range blocks).
+     * Convert a JS condition to Go template condition syntax. `preamble` holds
+     * template blocks that must be emitted before the `{{if}}` (e.g. every/some
+     * range blocks).
      */
     private convertConditionToGo;
     private renderConditionExpr;
@@ -1290,36 +532,33 @@ export declare class GoTemplateAdapter extends BaseAdapter implements ParsedExpr
      * Map each destructure binding to its Go accessor on the range var: a named
      * binding → `$<rangeVar>.<Field>`, an object-rest binding → the bare
      * `$<rangeVar>` so the member emitter renders `rest.flag` → `$<rangeVar>.Flag`.
-     * (#1310)
      */
     private buildDestructureBindingMap;
     renderLoop(loop: IRLoop): string;
     /**
      * Per-item `<!--bf-loop-i-->` / `<!--bf-loop-i:KEY-->` start marker emitted
-     * inside a `{{range}}` body. Multi-root Fragment items (#1212) get the bare
-     * anchor; whole-item conditional items (#1665) get the key-bearing anchor so
-     * the client's `mapArrayAnchored` can hydrate items that render no element.
+     * inside a `{{range}}` body. Multi-root Fragment items get the bare anchor;
+     * whole-item conditional items get the key-bearing anchor so the client's
+     * `mapArrayAnchored` can hydrate items that render no element.
      */
     private loopItemMarker;
-    /**
-     * Find the first component child in a list of nodes
-     */
+    /** Find the first component child in a list of nodes. */
     private findChildComponent;
     /**
-     * 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.
+     * 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`. Returns null for childless or
+     * statically-bakeable children, which keep the constructor-baked `Children`
+     * value.
      */
     private queueDynamicChildrenDefine;
     /**
-     * (#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
+     * 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.
@@ -1329,28 +568,23 @@ export declare class GoTemplateAdapter extends BaseAdapter implements ParsedExpr
         isRootOfClientComponent?: boolean;
     }): string;
     /**
-     * Render a Portal component by adding its children to PortalCollector.
-     * Portal content is rendered at </body> instead of inline.
-     *
-     * For static content: uses simple string literal with Add()
-     * For dynamic content: uses bfPortalHTML() to parse and execute template string
+     * Render a Portal component by adding its children to PortalCollector. Portal
+     * content is rendered at </body> instead of inline: static content via a plain
+     * string literal, dynamic content via `bfPortalHTML()` (parses and executes
+     * the template string with the provided data).
      */
     private renderPortalComponent;
     private renderFragment;
     private renderSlot;
     renderAsync(node: IRAsync): string;
-    private escapeGoString;
     /**
-     * AttrValue lowering for intrinsic-element attributes (Go templates).
-     * Per-kind logic that used to live in a `switch (v.kind)` inside
-     * `renderAttributes`; routed through the shared dispatcher so a new
-     * AttrValue kind becomes a TS compile error here (#1290 step 2).
+     * AttrValue lowering for intrinsic-element attributes. Routed through the
+     * shared dispatcher so a new AttrValue kind becomes a TS compile error here.
      *
-     * Components have no equivalent AttrValueEmitter on this adapter:
-     * Go templates pass component-instance props as Go struct fields
-     * (`collectStaticChildInstances` builds them), not as string-emitted
-     * markup, so that path does not share a contract with the
-     * intrinsic-attribute one.
+     * Components have no equivalent AttrValueEmitter: Go templates pass
+     * component-instance props as Go struct fields (built by
+     * `collectStaticChildInstances`), not as string-emitted markup, so that path
+     * doesn't share a contract with the intrinsic-attribute one.
      */
     private readonly elementAttrEmitter;
     /**
@@ -1359,36 +593,24 @@ export declare class GoTemplateAdapter extends BaseAdapter implements ParsedExpr
      * `{ backgroundColor: color, padding: '8px' }` →
      * `background-color:{{.Color}};padding:8px`. Returns null when the object
      * shape is unsupported or any value expression can't be lowered (the caller
-     * then falls through to the generic BF101 path). (#1322)
+     * then falls through to the generic BF101 path).
      */
     private tryLowerStyleObject;
     private renderAttributes;
     /**
-     * Replace `${EXPR}` JS-template-literal interpolations in a static
-     * string part with Go template actions (`{{<expr-as-go>}}`), and
-     * HTML-escape the surrounding literal text so embedded characters
-     * don't break the attribute quoting we render into.
-     *
-     * UnoCSS arbitrary-value classes like `[class*="size-"]:size-4`
-     * legitimately contain `"`, which would otherwise terminate the
-     * `class="..."` attribute early and produce invalid HTML / a
-     * `html/template` error at execution time.
-     *
-     * The interpolation parser is brace-depth aware: nested `{...}`
-     * inside an expression (object literals, nested template literals,
-     * etc.) are skipped past correctly so the closing brace of the
-     * outer `${...}` is found. An unterminated `${` falls back to
-     * literal text — better to output something than swallow it.
+     * Replace `${EXPR}` interpolations with Go actions (`{{<expr-as-go>}}`) and
+     * HTML-escape the surrounding literal text — UnoCSS arbitrary values
+     * (`[class*="size-"]:size-4`) contain `"` that would otherwise close the
+     * `class="..."` attribute. Brace-depth aware (nested `{...}` skipped to find
+     * the outer `}`); an unterminated `${` falls back to literal text.
      */
     private substituteJsInterpolations;
     /**
-     * HTML-attribute-safe escaping for double-quoted attribute values.
-     * `&`/`"`/`<` are non-negotiable — without them the surrounding
-     * `class="..."` quoting breaks (a real bug we hit with UnoCSS's
-     * `[class*="size-"]`). `>`/`'` are belt-and-suspenders: HTML5
-     * permits both inside double-quoted attrs, but Go's `html/template`
-     * lexer is contextual and we'd rather not bet on its edge cases
-     * matching ours forever.
+     * HTML-attribute-safe escaping for double-quoted attribute values. `&`/`"`/`<`
+     * are non-negotiable — without them the surrounding `class="..."` quoting
+     * breaks (e.g. UnoCSS's `[class*="size-"]`). `>`/`'` are belt-and-suspenders:
+     * HTML5 permits both inside double-quoted attrs, but Go's `html/template`
+     * lexer is contextual, so escape them too.
      */
     private escapeAttrText;
     private renderTemplateLiteralParts;
@@ -1398,5 +620,4 @@ export declare class GoTemplateAdapter extends BaseAdapter implements ParsedExpr
     private wrapWithCondMarker;
 }
 export declare const goTemplateAdapter: GoTemplateAdapter;
-export {};
 //# sourceMappingURL=go-template-adapter.d.ts.map