@barefootjs/jsx 0.31.1 → 0.31.2

package/src/__tests__/ssr-defaults.test.ts

@@ -13,7 +13,8 @@
 //     computations that derive from those signals (`count() * 2`).
 
 import { describe, test, expect } from 'bun:test'
-import { extractSsrDefaults } from '../ssr-defaults'
+import { extractSsrDefaults, deriveStashFromDefaults } from '../ssr-defaults'
+import type { SsrDefault } from '../ssr-defaults'
 import { analyzeComponent } from '../analyzer'
 import { buildMetadata } from '../compiler'
 
@@ -253,3 +254,125 @@ describe('extractSsrDefaults', () => {
     expect(defaults?.classes).toEqual({ value: 'a b c d  tail' })
   })
 })
+
+// TS twin of the Ruby/Python/PHP/Perl/Rust `derive*FromDefaults` runtime
+// ports (#2524 SSR half). Matches `derive_vars_from_defaults`'s edge cases
+// exactly — see that Ruby method's docstring
+// (packages/adapter-erb/lib/barefoot_js.rb:337-360) for the reference
+// semantics this mirrors.
+describe('deriveStashFromDefaults', () => {
+  test('aliased prop: resolves the CALLER-facing propName, not the local key', () => {
+    // `{ n: count }` — extractSsrDefaults keys the entry by the LOCAL
+    // binding (`count`) with `propName: 'n'`. The caller supplies `n`.
+    const defaults: Record<string, SsrDefault> = {
+      count: { propName: 'n', value: null },
+    }
+    expect(deriveStashFromDefaults(defaults, { n: 7 })).toEqual({ count: 7 })
+  })
+
+  test('un-aliased prop: propName equals the local key, resolves the same way', () => {
+    const defaults: Record<string, SsrDefault> = {
+      n: { propName: 'n', value: null },
+    }
+    expect(deriveStashFromDefaults(defaults, { n: 7 })).toEqual({ n: 7 })
+  })
+
+  test('caller omits the prop: falls back to the static default value', () => {
+    const defaults: Record<string, SsrDefault> = {
+      count: { propName: 'n', value: 3 },
+    }
+    expect(deriveStashFromDefaults(defaults, {})).toEqual({ count: 3 })
+  })
+
+  test('caller supplies null / undefined for the propName: falls back to the static value', () => {
+    // Mirrors every runtime port's "present AND defined" check — an
+    // explicit null/undefined caller value does not count as an override.
+    const defaults: Record<string, SsrDefault> = {
+      count: { propName: 'n', value: 3 },
+    }
+    expect(deriveStashFromDefaults(defaults, { n: null })).toEqual({ count: 3 })
+    expect(deriveStashFromDefaults(defaults, { n: undefined })).toEqual({ count: 3 })
+  })
+
+  test('caller supplies a falsy-but-defined propName value: the caller value wins', () => {
+    // `0` / `''` / `false` are legitimate override values, not "absent".
+    const defaults: Record<string, SsrDefault> = {
+      count: { propName: 'n', value: 99 },
+    }
+    expect(deriveStashFromDefaults(defaults, { n: 0 })).toEqual({ count: 0 })
+  })
+
+  test('propName-less entry (signal / memo local): always uses the static value', () => {
+    // A caller cannot override an internal signal/memo by construction —
+    // even a same-named caller prop must not leak in.
+    const defaults: Record<string, SsrDefault> = {
+      doubled: { value: 10 },
+    }
+    expect(deriveStashFromDefaults(defaults, { doubled: 999 })).toEqual({ doubled: 10 })
+  })
+
+  test('isRestProps entry: prefers the caller-assembled rest bag under its OWN key', () => {
+    const defaults: Record<string, SsrDefault> = {
+      rest: { isRestProps: true, value: {} },
+    }
+    expect(deriveStashFromDefaults(defaults, { rest: { href: '/x' } })).toEqual({
+      rest: { href: '/x' },
+    })
+  })
+
+  test('isRestProps entry: falls back to the static value (normally {}) when the caller supplied none', () => {
+    const defaults: Record<string, SsrDefault> = {
+      rest: { isRestProps: true, value: {} },
+    }
+    expect(deriveStashFromDefaults(defaults, {})).toEqual({ rest: {} })
+  })
+
+  test('isRestProps entry: an explicit `undefined` caller value still counts as supplied', () => {
+    // Unlike the ordinary propName branch (nullish check), the isRestProps
+    // branch tests presence via `in` — the rest bag is a caller-assembled
+    // aggregate, not a single scalar with a meaningful "absent" state, so
+    // an explicit `undefined` still wins over the static fallback instead
+    // of falling through to it.
+    const defaults: Record<string, SsrDefault> = {
+      rest: { isRestProps: true, value: { fallback: true } },
+    }
+    const result = deriveStashFromDefaults(defaults, { rest: undefined })
+    expect('rest' in result).toBe(true)
+    expect(result.rest).toBeUndefined()
+  })
+
+  test('a bare (non-object) entry passes through as-is', () => {
+    // Defensive parity with every runtime port's `ref($d) eq 'HASH'` /
+    // `isinstance(d, dict)` guard — never emitted by `extractSsrDefaults`
+    // itself, but a caller may hand this a manifest round-tripped through a
+    // generic JSON domain.
+    const defaults = { flag: true } as unknown as Record<string, SsrDefault>
+    expect(deriveStashFromDefaults(defaults, {})).toEqual({ flag: true })
+  })
+
+  test('a literal null entry hits the same non-object passthrough guard', () => {
+    // `d === null` is checked ALONGSIDE `typeof d !== 'object'` (not just
+    // the latter) — `typeof null === 'object'` in JS, so without the
+    // explicit `d === null` check a null entry would wrongly fall into the
+    // object-shaped branches below and throw reading `d.isRestProps`.
+    const defaults = { flag: null } as unknown as Record<string, SsrDefault>
+    expect(deriveStashFromDefaults(defaults, {})).toEqual({ flag: null })
+  })
+
+  test('mixed defaults map resolves every entry kind independently', () => {
+    const defaults: Record<string, SsrDefault> = {
+      count: { propName: 'n', value: null },
+      text: { propName: 'text', value: null },
+      doubled: { value: 0 },
+      rest: { isRestProps: true, value: {} },
+    }
+    expect(
+      deriveStashFromDefaults(defaults, { n: 7, rest: { extra: 'x' } }),
+    ).toEqual({
+      count: 7,
+      text: null,
+      doubled: 0,
+      rest: { extra: 'x' },
+    })
+  })
+})

package/src/__tests__/staged-ir/08-relocate-unit.test.ts

@@ -20,6 +20,7 @@ function envWith(
     propsForLift: new Set(
       bindings.filter(([, k]) => k === 'prop').map(([n]) => n),
     ),
+    propSourceNames: options?.propSourceNames ?? new Map(),
     propsObjectName: options?.propsObjectName ?? 'props',
     allowFallback: options?.allowFallback ?? true,
   }

package/src/__tests__/staged-ir/11-template-primitive-registry.test.ts

@@ -35,6 +35,7 @@ function envWith(
     propsForLift: new Set(
       bindings.filter(([, k]) => k === 'prop').map(([n]) => n),
     ),
+    propSourceNames: options?.propSourceNames ?? new Map(),
     propsObjectName: options?.propsObjectName ?? 'props',
     allowFallback: options?.allowFallback ?? true,
     templatePrimitives: options?.templatePrimitives,

package/src/adapters/interface.ts

@@ -28,6 +28,17 @@ export interface TemplateSections {
    * component in a source file.
    */
   moduleConstants?: string
+  /**
+   * When true, the `moduleConstants` section already carries the module's
+   * EXPORTED value declarations (consts/functions, `export` keyword
+   * included) interleaved in source order — so the compiler must NOT
+   * re-emit them via `generateModuleExports` (only `export { … }`
+   * specifier blocks remain its job). JSX adapters set this; keeping the
+   * exported and non-exported declarations in one source-ordered section
+   * is what prevents a non-exported const that reads an exported one from
+   * being emitted above it (a module-load TDZ crash — #2570's input-otp).
+   */
+  moduleConstantsIncludeExports?: boolean
 }
 
 export interface AdapterOutput {

package/src/adapters/jsx-adapter.ts

@@ -6,15 +6,19 @@
  */
 
 import type {
+  AttrValue,
   ComponentIR,
   IRNode,
+  IRTemplatePart,
   ImportSpecifier,
 } from '../types.ts'
+import { templatePartsToJsExpr } from '../template-parts.ts'
 import { BF_SCOPE, BF_SLOT, BF_COND } from '@barefootjs/shared'
 import { BaseAdapter } from './interface.ts'
 import type { CallbackBodyAcceptor } from './interface.ts'
 import { ENV_SIGNAL_CLIENT_FACTORY } from './env-signal.ts'
 import { formatParamWithType, findReachableNames } from '../module-exports.ts'
+import { extractFreeIdentifiersFromText } from '../ir-to-client-js/csr-substitute.ts'
 
 export interface JsxAdapterConfig {
   /** Use typed versions (typedInitialValue, etc.) for type-safe .tsx output */
@@ -144,11 +148,15 @@ export abstract class JsxAdapter extends BaseAdapter {
       const initialValue = rawInitialValue.trim().startsWith('{') ? `(${rawInitialValue})` : rawInitialValue
 
       // When preserveTypes and typedInitialValue is absent but signal.type has a meaningful
-      // type from a generic parameter, add a type assertion to prevent TS inference issues
+      // type from a generic parameter, add a type assertion to prevent TS inference issues.
+      // A bare `object` raw is the analyzer's coarse KIND, not a real type — asserting
+      // `as object` only destroys the initializer's inferred literal type (a
+      // `{ x: 0, y: 0 }` signal getter stops matching `() => { x: number; y: number }`).
       const needsTypeAssertion = preserveTypes
         && !signal.typedInitialValue
         && signal.type.kind !== 'unknown'
         && signal.type.kind !== 'primitive'
+        && signal.type.raw !== 'object'
       if (needsTypeAssertion) {
         lines.push(`  const ${signal.getter} = () => ${initialValue} as ${signal.type.raw}`)
       } else {
@@ -173,12 +181,24 @@ export abstract class JsxAdapter extends BaseAdapter {
       lines.push(`  const ${memo.name} = ${computation}`)
     }
 
-    // Include local constants — skip unreachable ones (only used in event handlers)
+    // Include local constants — skip unreachable ones (only used in event
+    // handlers). Genuinely module-scope constants are NOT localised here:
+    // they're emitted at module scope by `generateModuleScopeDeclarations`
+    // so module-scope types that reference them (via `typeof`) keep
+    // resolving, matching the client bundle's `emitModuleLevelDeclarations`
+    // (#2570). `moduleScopeDeclarationNames` — not the raw `isModule` flag
+    // — decides the split; see its docstring.
+    const moduleScopeNames = this.moduleScopeDeclarationNames(ir)
     for (const constant of ir.metadata.localConstants) {
       if (constant.isExported) continue
+      if (moduleScopeNames.has(constant.name)) continue
       const keyword = constant.declarationKind ?? 'const'
       if (!constant.value) {
-        lines.push(`  ${keyword} ${constant.name}`)
+        // No initializer (e.g. `let emblaApi: EmblaCarouselType | undefined`)
+        // — carry the declared type annotation through so `.tsx` output
+        // doesn't fall back to implicit `any` (TS7034/TS7005, #2573).
+        const typeAnnotation = preserveTypes && constant.type ? `: ${constant.type.raw}` : ''
+        lines.push(`  ${keyword} ${constant.name}${typeAnnotation}`)
         continue
       }
       const value = constant.value.trim()
@@ -196,8 +216,11 @@ export abstract class JsxAdapter extends BaseAdapter {
       lines.push(`  ${keyword} ${constant.name} = ${constValue}`)
     }
 
-    // Include local functions — skip unreachable ones (only used in event handlers)
+    // Include local functions — skip unreachable ones (only used in event
+    // handlers). Genuinely module-scope functions stay at module scope,
+    // same as constants above.
     for (const func of localFunctions) {
+      if (moduleScopeNames.has(func.name)) continue
       if (!reachable.has(func.name)) continue
       // Prefer the source-verbatim signature when types are preserved so
       // type-predicate annotations (`element is { tag: unknown; … }`) and
@@ -219,6 +242,207 @@ export abstract class JsxAdapter extends BaseAdapter {
     return lines.join('\n')
   }
 
+  // ===========================================================================
+  // Module-Scope Declarations
+  // ===========================================================================
+
+  /**
+   * Names that genuinely live at module scope in the emitted template.
+   *
+   * The analyzer's `isModule` flag is NOT a lexical-scope oracle: the
+   * module walker recurses into component bodies, so a component-body
+   * helper (calendar's `renderMonthGrid`, xyflow's edge handlers) can
+   * carry `isModule: true` while closing over component state. Hoisting
+   * such a helper breaks every reference (TS2304/TS2552 — and worse,
+   * wrong runtime scope). So candidates are demoted by a forward-
+   * reachability fixpoint, mirroring the client bundle's
+   * `computeDeclarationScopes` (`ir-to-client-js/compute-scope.ts`): a
+   * candidate that references component scope — a signal getter/setter, a
+   * memo, a prop, a body const/function, or an already-demoted candidate
+   * — is component-scoped, transitively. References are REAL identifier
+   * nodes from a TS AST walk (`extractFreeIdentifiersFromText`), not text
+   * matches — a component-scope name occurring inside a candidate's
+   * string literal (`[data-state="open"]` vs a body const `open`) is not
+   * a reference and must not demote it.
+   *
+   * EXPORTED candidates are never demoted: `export` is only legal at
+   * module top level, so an exported declaration is lexically module-
+   * scoped by construction — and a spurious demotion would make it
+   * vanish entirely (the body loop skips exported declarations and
+   * `generateModuleExports` is told to skip value declarations).
+   *
+   * Memoized per IR: `generateModuleScopeDeclarations` (module emission)
+   * and `generateSignalInitializers` (body emission) must agree on the
+   * split or a declaration is emitted twice or not at all.
+   */
+  private readonly moduleScopeNamesCache = new WeakMap<ComponentIR, Set<string>>()
+
+  protected moduleScopeDeclarationNames(ir: ComponentIR): Set<string> {
+    const cached = this.moduleScopeNamesCache.get(ir)
+    if (cached) return cached
+
+    const componentScope = new Set<string>()
+    for (const sig of ir.metadata.signals) {
+      if (sig.isModule) continue
+      componentScope.add(sig.getter)
+      if (sig.setter) componentScope.add(sig.setter)
+    }
+    for (const memo of ir.metadata.memos) {
+      if (!memo.isModule) componentScope.add(memo.name)
+    }
+    for (const p of ir.metadata.propsParams) componentScope.add(p.name)
+    if (ir.metadata.propsObjectName) componentScope.add(ir.metadata.propsObjectName)
+    if (ir.metadata.restPropsName) componentScope.add(ir.metadata.restPropsName)
+    for (const c of ir.metadata.localConstants) {
+      if (!c.isModule) componentScope.add(c.name)
+    }
+    for (const f of ir.metadata.localFunctions) {
+      if (!f.isModule) componentScope.add(f.name)
+    }
+
+    // Exported declarations join the emit set unconditionally (see the
+    // docstring); only non-exported candidates enter the demotion
+    // fixpoint, each carrying its REAL free-identifier set.
+    const exported = new Set<string>()
+    const candidates = new Map<string, ReadonlySet<string>>()
+    for (const c of ir.metadata.localConstants) {
+      if (!c.isModule) continue
+      // JSX-valued consts are inlined at their usage sites at IR level
+      // (#547/#569) — same skip as the client's `classifyConstant`.
+      if (c.isJsx || c.isJsxFunction) continue
+      if (c.isExported) {
+        exported.add(c.name)
+        continue
+      }
+      // The analyzer precomputes the value's free identifiers; fall back
+      // to the same AST walk for values it didn't cover.
+      candidates.set(c.name, c.freeIdentifiers ?? extractFreeIdentifiersFromText(c.value ?? ''))
+    }
+    for (const f of ir.metadata.localFunctions) {
+      if (!f.isModule) continue
+      // JSX-returning helpers (single- and multi-return) are inlined at
+      // their call sites (#569/#932); emitting them too would resurrect
+      // them as dead module-scope declarations — and the multi-return
+      // bodies carry raw source JSX that must not reach the template
+      // verbatim. Same skips as the client's `computeDeclarationScopes`.
+      if (f.isJsxFunction || f.isMultiReturnJsxHelper) continue
+      if (f.isExported) {
+        exported.add(f.name)
+        continue
+      }
+      // Wrap as an ARROW so the extractor's parameter shadowing applies
+      // (it tracks arrow params only) — param references then don't count
+      // as free, matching the client fixpoint's `refs.delete(p.name)`.
+      const params = f.typedParams !== undefined
+        ? f.typedParams
+        : f.params.map(formatParamWithType).join(', ')
+      candidates.set(f.name, extractFreeIdentifiersFromText(`(${params}) => ${f.body}`))
+    }
+
+    const referencesAny = (refs: ReadonlySet<string>, names: ReadonlySet<string>): boolean => {
+      for (const ref of refs) {
+        if (names.has(ref)) return true
+      }
+      return false
+    }
+    let changed = true
+    while (changed) {
+      changed = false
+      for (const [name, refs] of candidates) {
+        if (referencesAny(refs, componentScope)) {
+          candidates.delete(name)
+          componentScope.add(name)
+          changed = true
+        }
+      }
+    }
+
+    const result = new Set([...exported, ...candidates.keys()])
+    this.moduleScopeNamesCache.set(ir, result)
+    return result
+  }
+
+  /**
+   * Module-scope type, constant, and function declarations for the
+   * emitted template, kept at MODULE scope in SOURCE ORDER — the emitted
+   * module preserves the source module's shape, as the client bundle
+   * already does (`emitModuleLevelDeclarations` in `ir-to-client-js`).
+   * Root cure for the #2570 family: type declarations are re-emitted
+   * verbatim at module scope, so any value they reference through
+   * `typeof` (a type alias's `keyof typeof strokePaths`, a props
+   * annotation's `keyof typeof modes`) must be declared there too.
+   * Localising those values into each component body — the previous
+   * shape — failed the query with TS2304, and an unresolved
+   * `keyof typeof` degrades to `keyof any`, silently widening the type
+   * to `string | number | symbol` and taking every downstream check
+   * with it.
+   *
+   * EXPORTED module declarations are emitted here too (with their
+   * `export` keyword), interleaved with the non-exported ones in source
+   * order — not split off to `generateModuleExports`' section, which is
+   * emitted after this one and so would put an exported const AFTER a
+   * non-exported const that reads it (input-otp's `patternPresets`
+   * reading `REGEXP_ONLY_DIGITS`): a module-load TDZ crash, not just
+   * TS2448. The compiler skips value declarations in
+   * `generateModuleExports` when `moduleConstantsIncludeExports` is set
+   * on the sections.
+   *
+   * Emission is deliberately UNFILTERED by per-component reachability: an
+   * unused module declaration in the emitted template is harmless and
+   * matches the source module. In a multi-component file each component's
+   * adapter output carries its own block (the analyzer collects the module
+   * declarations lexically preceding the component, so blocks can be
+   * unequal prefixes); the compiler merges them with top-level-STATEMENT
+   * dedup, so shared declarations land exactly once in source order.
+   *
+   * `new WeakMap()` bindings stay client-only, and exported
+   * `createContext()` bindings stay unemitted, exactly as before.
+   */
+  protected generateModuleScopeDeclarations(ir: ComponentIR): string {
+    const { preserveTypes } = this.jsxConfig
+    const moduleNames = this.moduleScopeDeclarationNames(ir)
+    const entries: Array<{ line: number, text: string }> = []
+
+    for (const t of ir.metadata.typeDefinitions) {
+      entries.push({ line: t.loc.start.line, text: t.definition })
+    }
+
+    for (const c of ir.metadata.localConstants) {
+      if (!c.isModule || !moduleNames.has(c.name)) continue
+      const keyword = c.declarationKind ?? 'const'
+      const exportKw = c.isExported ? 'export ' : ''
+      if (!c.value) {
+        entries.push({ line: c.loc.start.line, text: `${exportKw}${keyword} ${c.name}` })
+        continue
+      }
+      const trimmed = c.value.trim()
+      if (/^new WeakMap\b/.test(trimmed)) continue
+      if (c.isExported && /^createContext\b/.test(trimmed)) continue
+      const value = preserveTypes ? (c.typedValue ?? c.value) : c.value
+      entries.push({ line: c.loc.start.line, text: `${exportKw}${keyword} ${c.name} = ${value}` })
+    }
+
+    for (const f of ir.metadata.localFunctions) {
+      if (!f.isModule || !moduleNames.has(f.name)) continue
+      const params = preserveTypes && f.typedParams !== undefined
+        ? f.typedParams
+        : f.params.map(formatParamWithType).join(', ')
+      const returnAnnotation = preserveTypes && f.typedReturnType
+        ? `: ${f.typedReturnType}`
+        : ''
+      const body = preserveTypes ? (f.typedBody ?? f.body) : f.body
+      const asyncKw = f.isAsync ? 'async ' : ''
+      const exportKw = f.isExported ? 'export ' : ''
+      entries.push({
+        line: f.loc.start.line,
+        text: `${exportKw}${asyncKw}function ${f.name}(${params})${returnAnnotation} ${body}`,
+      })
+    }
+
+    entries.sort((a, b) => a.line - b.line)
+    return entries.map(e => e.text).join('\n')
+  }
+
   // ===========================================================================
   // Raw Node Rendering
   // ===========================================================================
@@ -233,6 +457,44 @@ export abstract class JsxAdapter extends BaseAdapter {
     return this.renderNode(node)
   }
 
+  // ===========================================================================
+  // Template Part Rendering
+  // ===========================================================================
+
+  /**
+   * Render a structured `template` variant's parts as JS template-literal
+   * source for this adapter's .tsx output, carrying the `preserveTypes`
+   * index annotation on inlined `lookup` records (#2565 — see
+   * `lookupPartToJsExpr`).
+   */
+  protected renderTemplatePartsAsJs(parts: readonly IRTemplatePart[]): string {
+    return templatePartsToJsExpr(parts, { typed: this.jsxConfig.preserveTypes })
+  }
+
+  /**
+   * The JS source for an `expression` attribute / component-prop value.
+   *
+   * A component-prop `template` is collapsed into an `expression` at IR
+   * construction time (component props are runtime values, not HTML
+   * attribute bodies), which drops it out of `renderTemplatePartsAsJs`'s
+   * reach — the same inlined-record index, minus the type annotation
+   * (#2565). The collapse keeps its `parts`, so re-render from those when
+   * `expr` is still EXACTLY the neutral collapse. Any later rewrite of
+   * `expr` (a presence peel, a prop-ref rewrite) fails the identity check
+   * and wins, so this can only ever add the annotation, never undo a
+   * downstream edit.
+   */
+  protected expressionValueToJs(value: Extract<AttrValue, { kind: 'expression' }>): string {
+    if (
+      this.jsxConfig.preserveTypes &&
+      value.parts &&
+      value.expr === templatePartsToJsExpr(value.parts)
+    ) {
+      return this.renderTemplatePartsAsJs(value.parts)
+    }
+    return value.expr
+  }
+
   // ===========================================================================
   // Hydration Markers
   // ===========================================================================

package/src/adapters/test-adapter.ts

@@ -5,6 +5,7 @@
  * Generates simple JSX output without framework-specific features.
  */
 
+import ts from 'typescript'
 import type {
   ComponentIR,
   IRNode,
@@ -20,6 +21,7 @@ import type {
 import type { AdapterOutput, TemplateSections } from './interface.ts'
 import { type JsxAdapterConfig, JsxAdapter } from './jsx-adapter.ts'
 import { rewriteImportsForTemplate } from './template-imports.ts'
+import { propsDestructureBinding } from '../props-binding.ts'
 
 export class TestAdapter extends JsxAdapter {
   name = 'test'
@@ -31,6 +33,7 @@ export class TestAdapter extends JsxAdapter {
     this.componentName = ir.metadata.componentName
 
     const imports = this.generateImports(ir)
+    const moduleConstants = this.generateModuleScopeDeclarations(ir)
     const types = this.generateTypes(ir)
     const component = this.generateComponent(ir)
 
@@ -43,10 +46,12 @@ export class TestAdapter extends JsxAdapter {
       types: types || '',
       component,
       defaultExport,
+      moduleConstants,
+      moduleConstantsIncludeExports: true,
     }
 
     // Assemble template for backward compat
-    const template = [imports, types, component].filter(Boolean).join('\n\n') + defaultExport
+    const template = [imports, moduleConstants, types, component].filter(Boolean).join('\n\n') + defaultExport
 
     return {
       template,
@@ -84,9 +89,9 @@ export class TestAdapter extends JsxAdapter {
   generateTypes(ir: ComponentIR): string | null {
     const lines: string[] = []
 
-    for (const typeDef of ir.metadata.typeDefinitions) {
-      lines.push(typeDef.definition)
-    }
+    // Source type declarations are emitted once at module scope by
+    // `generateModuleScopeDeclarations` (#2570) — only the synthesized
+    // hydration alias is per-component.
 
     // Only generate PropsWithHydration when destructured-props pattern uses it
     const propsTypeName = ir.metadata.propsType?.raw
@@ -122,8 +127,10 @@ export class TestAdapter extends JsxAdapter {
     const bodyRefText = [jsxBody, signalInits, scopeIdLine].join('\n')
     const bfScopeAlias = /\b__bfScope\b/.test(bodyRefText) ? '__bfScope' : '__bfScope: _bfScope'
 
+    // `key: local` rename-aware bindings, shared with the Hono SSR
+    // destructure — one renderer, zero drift (`propsDestructureBinding`).
     const propsParams = ir.metadata.propsParams
-      .map((p: ParamInfo) => (p.defaultValue ? `${p.name} = ${p.defaultValue}` : p.name))
+      .map((p: ParamInfo) => propsDestructureBinding(p))
       .join(', ')
 
     const restPropsName = ir.metadata.restPropsName
@@ -325,11 +332,7 @@ export class TestAdapter extends JsxAdapter {
     // Simple stringifier for `template`-kind values; tests only need a
     // recognisable JSX shape, not byte-exact reproduction.
     const v = value as { kind: 'template'; parts: import('../types.ts').IRTemplatePart[] }
-    return '`' + v.parts.map(p => {
-      if (p.type === 'string') return p.value
-      if (p.type === 'ternary') return `\${${p.condition} ? '${p.whenTrue}' : '${p.whenFalse}'}`
-      return `\${(${JSON.stringify(p.cases)})[${p.key}]}`
-    }).join('') + '`'
+    return this.renderTemplatePartsAsJs(v.parts)
   }
 
   private renderComponentProps(comp: IRComponent): string {