@barefootjs/jsx 0.7.0 → 0.9.0

package/src/__tests__/augment-inherited-props.test.ts

@@ -0,0 +1,97 @@
+import { describe, test, expect } from 'bun:test'
+
+import { augmentInheritedPropAccesses } from '../augment-inherited-props'
+import type { ComponentIR, IRMetadata, ParamInfo } from '../index'
+
+/**
+ * Build a minimal `ComponentIR` exercising the SolidJS props-object pattern.
+ * Only the fields `augmentInheritedPropAccesses` reads are populated; the rest
+ * are cast through `as` so the test stays focused on the scanned inputs.
+ */
+function makeIR(opts: {
+  propsObjectName: string | null
+  propsParams: ParamInfo[]
+  memos?: Array<{ computation: string }>
+  effects?: Array<{ body: string }>
+  initStatements?: Array<{ body: string }>
+  root?: unknown
+}): ComponentIR {
+  const metadata = {
+    componentName: 'Checkbox',
+    propsObjectName: opts.propsObjectName,
+    propsParams: opts.propsParams,
+    memos: opts.memos ?? [],
+    signals: [],
+    effects: opts.effects ?? [],
+    initStatements: opts.initStatements ?? [],
+  } as unknown as IRMetadata
+
+  return {
+    root: (opts.root ?? { type: 'element', tag: 'div', attrs: [], children: [] }) as never,
+    metadata,
+    errors: [],
+  } as unknown as ComponentIR
+}
+
+describe('augmentInheritedPropAccesses', () => {
+  test('adds inherited accessed props from memos, effects, and template attrs', () => {
+    const ir = makeIR({
+      propsObjectName: 'props',
+      propsParams: [{ name: 'checked', type: { kind: 'primitive', raw: 'boolean', primitive: 'boolean' }, optional: false }],
+      // className read in a classes memo → string
+      memos: [{ computation: '`base ${props.className}`' }],
+      // size read only in an effect → string (default classification)
+      effects: [{ body: 'console.log(props.size)' }],
+      root: {
+        type: 'element',
+        tag: 'button',
+        attrs: [
+          // bare-reference attribute → nillable (unknown)
+          { name: 'id', value: { kind: 'expression', expr: 'props.id' } },
+          // boolean attribute → boolean
+          { name: 'disabled', value: { kind: 'expression', expr: 'props.disabled ?? false' } },
+        ],
+        children: [],
+      },
+    })
+
+    augmentInheritedPropAccesses(ir)
+
+    const byName = new Map(ir.metadata.propsParams.map(p => [p.name, p]))
+    // Pre-existing param untouched.
+    expect(byName.get('checked')?.type.kind).toBe('primitive')
+
+    // className → string (memo / string context)
+    expect(byName.get('className')?.type).toMatchObject({ kind: 'primitive', primitive: 'string' })
+    // size → string, accessed ONLY in an effect (the intentional Mojo-unification path)
+    expect(byName.get('size')?.type).toMatchObject({ kind: 'primitive', primitive: 'string' })
+    // id → unknown (bare-reference, nillable/omittable)
+    expect(byName.get('id')?.type).toMatchObject({ kind: 'unknown' })
+    // disabled → boolean (boolean HTML attribute, even with `?? false`)
+    expect(byName.get('disabled')?.type).toMatchObject({ kind: 'primitive', primitive: 'boolean' })
+
+    // Synthetic params are marked optional.
+    for (const name of ['className', 'size', 'id', 'disabled']) {
+      expect(byName.get(name)?.optional).toBe(true)
+    }
+  })
+
+  test('is idempotent — re-running adds nothing', () => {
+    const ir = makeIR({
+      propsObjectName: 'props',
+      propsParams: [],
+      memos: [{ computation: 'props.className' }],
+    })
+    augmentInheritedPropAccesses(ir)
+    const afterFirst = ir.metadata.propsParams.length
+    augmentInheritedPropAccesses(ir)
+    expect(ir.metadata.propsParams.length).toBe(afterFirst)
+    expect(afterFirst).toBe(1)
+  })
+
+  test('no-op when there is no props-object pattern', () => {
+    const ir = makeIR({ propsObjectName: null, propsParams: [], memos: [{ computation: 'props.className' }] })
+    augmentInheritedPropAccesses(ir)
+    expect(ir.metadata.propsParams.length).toBe(0)
+  })
+})

package/src/__tests__/merge-template-imports.test.ts

@@ -0,0 +1,68 @@
+import { describe, test, expect } from 'bun:test'
+import { mergeTemplateImports } from '../compiler'
+
+describe('mergeTemplateImports', () => {
+  test('merges same-source named imports with disjoint + overlapping symbols', () => {
+    const out = mergeTemplateImports([
+      "import { bfText, bfTextEnd } from '@barefootjs/hono/utils'",
+      "import { bfComment } from '@barefootjs/hono/utils'",
+      "import { bfComment, bfText, bfTextEnd } from '@barefootjs/hono/utils'",
+    ])
+    // Single statement, no redeclared binding (Deno rejects duplicates).
+    expect(out).toBe("import { bfText, bfTextEnd, bfComment } from '@barefootjs/hono/utils'")
+    expect((out.match(/from '@barefootjs\/hono\/utils'/g) ?? []).length).toBe(1)
+  })
+
+  // The merge must not depend on the emitter's exact spacing: a named import
+  // that slipped past the matcher would fall through to by-line dedup and
+  // re-introduce the duplicate `bfComment` binding Deno rejects. Mixed
+  // spacing (compact, padded, double-spaced `from`, trailing `;`) must still
+  // collapse to one statement.
+  test('folds same-source imports regardless of whitespace / trailing semicolon', () => {
+    const out = mergeTemplateImports([
+      "import {bfText,bfTextEnd} from '@barefootjs/hono/utils'",
+      "import {  bfComment  }  from  \"@barefootjs/hono/utils\";",
+      "import { bfComment, bfText } from '@barefootjs/hono/utils'",
+    ])
+    expect(out).toBe("import { bfText, bfTextEnd, bfComment } from '@barefootjs/hono/utils'")
+    expect((out.match(/from '@barefootjs\/hono\/utils'/g) ?? []).length).toBe(1)
+  })
+
+  // `import type` must stay separate from the value import even with compact
+  // spacing — the value matcher must not swallow a type-only line.
+  test('keeps type vs value separate under compact spacing', () => {
+    const out = mergeTemplateImports([
+      "import {Foo} from 'x'",
+      "import type {Bar} from 'x'",
+    ])
+    expect(out).toBe("import { Foo } from 'x'\nimport type { Bar } from 'x'")
+  })
+
+  test('single-component input is unchanged (order preserved)', () => {
+    const lines = [
+      "import { bfComment, bfText, bfTextEnd } from '@barefootjs/hono/utils'",
+      "import { createSignal } from '@barefootjs/hono/client-shim'",
+      "import { Button } from '@/components/ui/button'",
+    ]
+    expect(mergeTemplateImports(lines)).toBe(lines.join('\n'))
+  })
+
+  test('keeps value and type imports from the same source separate', () => {
+    const out = mergeTemplateImports([
+      "import { Foo } from 'x'",
+      "import type { Bar } from 'x'",
+      "import { Baz } from 'x'",
+    ])
+    expect(out).toBe("import { Foo, Baz } from 'x'\nimport type { Bar } from 'x'")
+  })
+
+  test('passes through and dedupes side-effect / default imports by line', () => {
+    const out = mergeTemplateImports([
+      "import './a.css'",
+      "import Foo from 'foo'",
+      "import './a.css'",
+      "import { x } from 'm'",
+    ])
+    expect(out).toBe("import './a.css'\nimport Foo from 'foo'\nimport { x } from 'm'")
+  })
+})

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

@@ -115,4 +115,28 @@ describe('extractSsrDefaults', () => {
     expect(defaults?.count).toEqual({ value: 3 })
     expect(defaults?.squared).toEqual({ value: 9 })
   })
+
+  // (#checkbox) A className memo interpolating module string consts — incl. a
+  // `[...].join(' ')` const — plus `props.className ?? ''` resolves to a
+  // concrete string so the SSR `class="..."` renders the full token list
+  // (Checkbox's `classes` memo). Without seeding module consts / evaluating
+  // `.join`, the memo collapsed to `null` and the class attribute rendered
+  // empty.
+  test('module-const + join template-literal className memo resolves to a string', () => {
+    const metadata = metadataFor(`
+      'use client'
+      import { createMemo } from '@barefootjs/client'
+      const base = 'a b'
+      const states = ['c', 'd'].join(' ')
+      function Box(props: { tone?: string }) {
+        const classes = createMemo(() => \`\${base} \${states} \${props.className ?? ''} tail\`)
+        return <button class={classes()}>x</button>
+      }
+    `)
+
+    const defaults = extractSsrDefaults(metadata)
+    // props.className is undefined → `?? ''` → '' → 'a b c d  tail' (the double
+    // space mirrors Hono's empty-className interpolation).
+    expect(defaults?.classes).toEqual({ value: 'a b c d  tail' })
+  })
 })

package/src/augment-inherited-props.ts

@@ -0,0 +1,366 @@
+/**
+ * Shared adapter helpers for the SolidJS props-object pattern (#checkbox).
+ *
+ * These two functions are the SINGLE SOURCE OF TRUTH for logic that the
+ * Go-template and Mojolicious template adapters previously carried as
+ * near-identical private copies. They live in `@barefootjs/jsx` (the IR
+ * layer) so the two adapters can share one implementation; they are
+ * deliberately NOT wired into the core IR-construction pipeline — only the
+ * Go and Mojo adapters call them, so every other IR consumer (Hono, the
+ * client codegen, etc.) is unaffected.
+ */
+
+import ts from 'typescript'
+
+import type { ComponentIR, IRMetadata, IRNode, IRElement, TypeInfo } from './types'
+import { isBooleanAttr } from './html-constants'
+
+/**
+ * A `const x = useContext(SomeContext)` consumer in a component body. SSR
+ * template adapters have no JS runtime context stack, so a consumer's value is
+ * threaded in at the data-construction layer: the adapter exposes a field/stash
+ * var defaulted to the context default, which an enclosing `<Ctx.Provider
+ * value>` overwrites for descendant child slots.
+ */
+export interface ContextConsumer {
+  /** The local const bound to the `useContext` call (e.g. `theme`). */
+  localName: string
+  /** The `createContext` identifier read (e.g. `ThemeContext`). */
+  contextName: string
+  /**
+   * The `createContext(<default>)` argument as a JS literal, or `null` when
+   * absent / not a literal (the consumer then defaults to the empty value).
+   */
+  defaultValue: string | number | boolean | null
+}
+
+/**
+ * Collect every `const x = useContext(Ctx)` consumer in a component, resolving
+ * each `Ctx` to its `createContext(<default>)` default via the component's
+ * module-scope `createContext` constants. Returns `[]` when the component
+ * consumes no context. Single source of truth for the SSR-context adapters.
+ */
+export function collectContextConsumers(metadata: IRMetadata): ContextConsumer[] {
+  const constants = metadata.localConstants ?? []
+  // Map each createContext const name → its default-arg literal value.
+  const contextDefaults = new Map<string, string | number | boolean | null>()
+  for (const c of constants) {
+    if (c.systemConstructKind !== 'createContext' || c.value === undefined) continue
+    contextDefaults.set(c.name, parseCreateContextDefault(c.value))
+  }
+  if (contextDefaults.size === 0) return []
+
+  const consumers: ContextConsumer[] = []
+  for (const c of constants) {
+    if (c.value === undefined) continue
+    const ctxName = parseUseContextArg(c.value)
+    if (ctxName === null || !contextDefaults.has(ctxName)) continue
+    consumers.push({
+      localName: c.name,
+      contextName: ctxName,
+      defaultValue: contextDefaults.get(ctxName) ?? null,
+    })
+  }
+  return consumers
+}
+
+/** Parse `useContext(Ident)` → `Ident`, else `null`. */
+function parseUseContextArg(source: string): string | null {
+  const expr = parseSingleExpression(source)
+  if (!expr || !ts.isCallExpression(expr)) return null
+  if (!ts.isIdentifier(expr.expression) || expr.expression.text !== 'useContext') return null
+  if (expr.arguments.length !== 1) return null
+  const arg = expr.arguments[0]
+  return ts.isIdentifier(arg) ? arg.text : null
+}
+
+/** Parse `createContext(<literal>)` → the default value, else `null`. */
+function parseCreateContextDefault(source: string): string | number | boolean | null {
+  const expr = parseSingleExpression(source)
+  if (!expr || !ts.isCallExpression(expr)) return null
+  if (expr.arguments.length === 0) return null
+  const arg = expr.arguments[0]
+  if (ts.isStringLiteral(arg) || ts.isNoSubstitutionTemplateLiteral(arg)) return arg.text
+  if (ts.isNumericLiteral(arg)) return Number(arg.text)
+  if (arg.kind === ts.SyntaxKind.TrueKeyword) return true
+  if (arg.kind === ts.SyntaxKind.FalseKeyword) return false
+  return null
+}
+
+function parseSingleExpression(source: string): ts.Expression | null {
+  const sf = ts.createSourceFile('__ctx.ts', `(${source})`, ts.ScriptTarget.Latest, false)
+  const stmt = sf.statements[0]
+  if (!stmt || !ts.isExpressionStatement(stmt)) return null
+  let e: ts.Expression = stmt.expression
+  while (ts.isParenthesizedExpression(e)) e = e.expression
+  return e
+}
+
+/**
+ * (#checkbox) Enumerate inherited-attribute accesses for the SolidJS
+ * props-object pattern.
+ *
+ * `function Checkbox(props: CheckboxProps)` only lists `CheckboxProps`'s own
+ * members in `propsParams`; the inherited `ButtonHTMLAttributes` members the
+ * component actually reads (`props.className` in the classes memo, `props.id`,
+ * `props.disabled` on the root element) are never enumerated, so the generated
+ * Input/Props structs (Go) or stash vars (Mojo) have no field to bind a
+ * caller's `className: ''` / `id` / `disabled` to. This scans the component's
+ * expressions for `props.<name>` accesses (where `props` is the resolved
+ * `propsObjectName`) and appends any not-already-a-param as a synthetic prop
+ * param, with a type inferred from how the access is used:
+ *   - a boolean attribute (`disabled={props.disabled ?? false}`) → `boolean`;
+ *   - a pure bare-reference attribute (`id={props.id}`) → `unknown`
+ *     (nillable, so the attribute is omitted when unset — Hono parity);
+ *   - otherwise (`className`, read in a string memo) → `string`.
+ *
+ * Scans memos, signals, init statements, effects, and template attribute
+ * expressions. (The Mojo adapter previously omitted `effects` from its scan;
+ * unifying on the Go behaviour of also scanning `effects` is intentional — the
+ * function only ever ADDS a param, and it changes no fixture output.)
+ *
+ * Idempotent: re-running (e.g. once in `generate`, again in `generateTypes` on
+ * a round-tripped IR) is a no-op once the params are present. Mutates
+ * `ir.metadata.propsParams` in place so every downstream emitter sees one
+ * consistent param list.
+ *
+ * The single source of truth for BOTH the Go and Mojo adapters — change here,
+ * not in an adapter copy.
+ */
+export function augmentInheritedPropAccesses(ir: ComponentIR): void {
+  const propsObj = ir.metadata.propsObjectName
+  if (!propsObj) return // only the props-object pattern is affected
+
+  const existing = new Set(ir.metadata.propsParams.map(p => p.name))
+
+  // Collect bare-reference attribute exprs (`attr={props.id}`) and boolean
+  // attributes from the template so we can classify accessed props by use.
+  const bareRefProps = new Set<string>()
+  const booleanAttrProps = new Set<string>()
+  const accessed = new Set<string>()
+  const accessRe = new RegExp(`(?:^|[^\\w$.])${propsObj}\\.([A-Za-z_$][\\w$]*)`, 'g')
+  const scan = (s: string | undefined): void => {
+    if (!s) return
+    for (const m of s.matchAll(accessRe)) accessed.add(m[1])
+  }
+
+  // Memos, signals, init statements, effects: any `props.X` read.
+  for (const memo of ir.metadata.memos) scan(memo.computation)
+  for (const signal of ir.metadata.signals) scan(signal.initialValue)
+  for (const stmt of ir.metadata.initStatements ?? []) scan(stmt.body)
+  for (const eff of ir.metadata.effects ?? []) scan((eff as { body?: string }).body)
+
+  // Function-scope plain-const initializers (the Switch pattern): a
+  // `const trackClasses = \`… ${props.className ?? ''}\`` holds the only
+  // `props.X` read. Skip module consts — they can't reference function-scoped
+  // `props`. Reads land in string context, so the default `string` type holds.
+  for (const c of ir.metadata.localConstants ?? []) {
+    if (c.isModule) continue
+    scan(c.value)
+  }
+
+  // Template attribute exprs — also note bare-ref / boolean usage.
+  const walk = (node: IRNode | undefined): void => {
+    if (!node) return
+    const el = node as unknown as IRElement
+    for (const attr of el.attrs ?? []) {
+      const v = attr.value as { kind?: string; expr?: string; presenceOrUndefined?: boolean }
+      if (v?.kind === 'expression' && typeof v.expr === 'string') {
+        scan(v.expr)
+        const expr = v.expr.trim()
+        const prefix = `${propsObj}.`
+        // A boolean HTML attribute (`disabled={props.disabled ?? false}`)
+        // marks the referenced prop as boolean even when wrapped in a
+        // `?? false` default — extract the prop name from the expr.
+        if (isBooleanAttr(attr.name) || v.presenceOrUndefined) {
+          const m = expr.match(new RegExp(`^${propsObj}\\.([A-Za-z_$][\\w$]*)`))
+          if (m) booleanAttrProps.add(m[1])
+        } else if (expr.startsWith(prefix)) {
+          const rest = expr.slice(prefix.length)
+          // A pure bare-reference attribute (`id={props.id}`) → nillable.
+          if (/^[A-Za-z_$][\w$]*$/.test(rest)) bareRefProps.add(rest)
+        }
+      }
+    }
+    for (const child of (el.children ?? []) as unknown[]) {
+      const c = child as { element?: IRNode }
+      walk((c.element ?? child) as IRNode)
+    }
+  }
+  walk(ir.root)
+
+  for (const name of accessed) {
+    if (existing.has(name)) continue
+    let raw: string
+    if (booleanAttrProps.has(name)) raw = 'boolean'
+    else if (bareRefProps.has(name)) raw = 'unknown' // → interface{} (nillable, omittable)
+    else raw = 'string' // read in a memo / string context (e.g. className)
+    const type: TypeInfo =
+      raw === 'boolean'
+        ? { kind: 'primitive', raw: 'boolean', primitive: 'boolean' }
+        : raw === 'string'
+          ? { kind: 'primitive', raw: 'string', primitive: 'string' }
+          : { kind: 'unknown', raw: 'unknown' }
+    ir.metadata.propsParams.push({ name, type, optional: true })
+    existing.add(name)
+  }
+}
+
+/**
+ * Statically evaluate `[<string literals>].join(<sep?>)` (e.g. a module-scope
+ * `const stateClasses = ['…', …].join(' ')`) to its joined string, so SSR
+ * adapters inline the flattened literal byte-for-byte like the Hono reference
+ * instead of referencing a binding that doesn't exist server-side. Default
+ * separator `,` matches JS `Array.prototype.join`. Returns `null` for any
+ * other shape (non-`.join` call, non-array receiver, non-string-literal element
+ * or separator). Shared by the Mojo + Xslate adapters; Go keeps a private copy.
+ */
+export function evalStringArrayJoin(source: string): string | null {
+  const sf = ts.createSourceFile(
+    '__join.ts', `const __x = (${source});`, ts.ScriptTarget.Latest, /*setParentNodes*/ false,
+  )
+  const stmt = sf.statements[0]
+  if (!stmt || !ts.isVariableStatement(stmt)) return null
+  let node = stmt.declarationList.declarations[0]?.initializer
+  while (node && ts.isParenthesizedExpression(node)) node = node.expression
+  if (!node || !ts.isCallExpression(node)) return null
+  const callee = node.expression
+  if (!ts.isPropertyAccessExpression(callee)) return null
+  if (callee.name.text !== 'join') return null
+  let recv: ts.Expression = callee.expression
+  while (ts.isParenthesizedExpression(recv)) recv = recv.expression
+  if (!ts.isArrayLiteralExpression(recv)) return null
+  const parts: string[] = []
+  for (const el of recv.elements) {
+    if (ts.isStringLiteral(el) || ts.isNoSubstitutionTemplateLiteral(el)) {
+      parts.push(el.text)
+    } else {
+      return null
+    }
+  }
+  let sep = ','
+  if (node.arguments.length >= 1) {
+    const arg = node.arguments[0]
+    if (ts.isStringLiteral(arg) || ts.isNoSubstitutionTemplateLiteral(arg)) sep = arg.text
+    else return null
+  }
+  return parts.join(sep)
+}
+
+/** A minimal `{ name }` shape — both adapters pass their own param/const lists. */
+interface NamedConst {
+  name: string
+  value?: string
+  isModule?: boolean
+}
+
+/** A parsed `Record<staticKeys, scalar>[propKey]` map entry. */
+export interface RecordIndexEntry {
+  key: string
+  value: { kind: 'number' | 'string'; text: string }
+}
+
+/** The structured result of a `Record<staticKeys, scalar>[propKey]` access. */
+export interface RecordIndexAccess {
+  /** The bare prop identifier used as the index key (`size` in `sizeMap[size]`). */
+  indexPropName: string
+  /** The map's entries in source order — each a static key + scalar literal value. */
+  entries: RecordIndexEntry[]
+  /**
+   * When the index key is a local const with a `props.X ?? '<lit>'` default
+   * (the Toggle `classes` memo's `const variant = props.variant ?? 'default'`),
+   * the `<lit>` fallback key — so a caller can render the default entry's value
+   * when the prop is unset. Absent when the key is a bare prop with no default.
+   */
+  defaultKey?: string
+}
+
+/**
+ * Structural parse of a spread-object VALUE of the form `IDENT[KEY]` where:
+ *   - `IDENT` resolves via `localConstants` to a MODULE-scope (`isModule`)
+ *     object literal whose every property has a static (string-literal or
+ *     identifier) key and a scalar (number or string) literal value
+ *     (a `Record<staticKeys, scalar>` map like `sizeMap`), AND
+ *   - `KEY` is a bare identifier that is a prop (`propsParams`).
+ *
+ * Returns the structured `{ indexPropName, entries }` when convertible, else
+ * `null` for any unsupported shape (non-element-access, non-identifier
+ * object/index, non-prop index, non-module const, non-object-literal const,
+ * computed/spread/dynamic key, or non-scalar value) so the caller falls back
+ * to its normal lowering / BF101.
+ *
+ * The single source of truth for BOTH adapters' `recordIndexAccessTo*` emitters
+ * — only the final language-specific emit differs (Go inline `map[string]any{…}
+ * [fmt.Sprint(in.Field)]`; Mojo `{ … }->{$key}`). (#checkbox / icon `sizeMap[size]`.)
+ */
+export function parseRecordIndexAccess(
+  val: ts.Expression,
+  localConstants: readonly NamedConst[],
+  propsParams: ReadonlyArray<{ name: string }>,
+  /**
+   * Resolves an index key that isn't a bare prop (a memo-local const like
+   * `const variant = props.variant ?? 'default'`) to its underlying prop + an
+   * optional default-key literal; returns `null` to reject. Keeps the parse
+   * generic — the caller owns the block-scoped binding map.
+   */
+  resolveKey?: (name: string) => { propName: string; defaultLiteral?: string } | null,
+): RecordIndexAccess | null {
+  if (!ts.isElementAccessExpression(val)) return null
+  const obj = val.expression
+  const arg = val.argumentExpression
+  if (!ts.isIdentifier(obj) || !ts.isIdentifier(arg)) return null
+  // KEY resolution. A caller-supplied local key wins first — the Toggle memo's
+  // `const variant = props.variant ?? 'default'` shadows the same-named
+  // `variant` prop, and only the local binding carries the `'default'` fallback.
+  // Otherwise the key must be a bare prop (`sizeMap[size]`).
+  let indexPropName: string
+  let defaultKey: string | undefined
+  const resolved = resolveKey?.(arg.text)
+  if (resolved) {
+    indexPropName = resolved.propName
+    defaultKey = resolved.defaultLiteral
+  } else if (propsParams.some(p => p.name === arg.text)) {
+    indexPropName = arg.text
+  } else {
+    return null
+  }
+  // IDENT must resolve to a module-scope object-literal const.
+  const constInfo = localConstants.find(c => c.name === obj.text && c.isModule)
+  if (constInfo?.value === undefined) return null
+
+  const sf = ts.createSourceFile(
+    '__rec.ts', `(${constInfo.value})`, ts.ScriptTarget.Latest, /* setParentNodes */ true,
+  )
+  if (sf.statements.length !== 1) return null
+  const stmt = sf.statements[0]
+  if (!ts.isExpressionStatement(stmt)) return null
+  let parsed: ts.Expression = stmt.expression
+  while (ts.isParenthesizedExpression(parsed)) parsed = parsed.expression
+  if (!ts.isObjectLiteralExpression(parsed)) return null
+
+  const entries: RecordIndexEntry[] = []
+  for (const prop of parsed.properties) {
+    if (!ts.isPropertyAssignment(prop)) return null
+    let key: string
+    if (ts.isIdentifier(prop.name)) {
+      key = prop.name.text
+    } else if (
+      ts.isStringLiteral(prop.name) ||
+      ts.isNoSubstitutionTemplateLiteral(prop.name)
+    ) {
+      key = prop.name.text
+    } else {
+      return null
+    }
+    let v: ts.Expression = prop.initializer
+    while (ts.isParenthesizedExpression(v)) v = v.expression
+    if (ts.isNumericLiteral(v)) {
+      entries.push({ key, value: { kind: 'number', text: v.text } })
+    } else if (ts.isStringLiteral(v) || ts.isNoSubstitutionTemplateLiteral(v)) {
+      entries.push({ key, value: { kind: 'string', text: v.text } })
+    } else {
+      return null
+    }
+  }
+  return { indexPropName, entries, defaultKey }
+}

package/src/compiler.ts

@@ -31,6 +31,70 @@ export interface CompileOptionsWithAdapter extends CompileOptions {
   adapter: TemplateAdapter
 }
 
+/**
+ * Merge the import lines of a multi-component template file into a single,
+ * conflict-free block.
+ *
+ * Named value/type imports from the same source are folded into their first
+ * occurrence (preserving line order and first-seen symbol order); every
+ * other import form (side-effect, default, namespace) is kept in place and
+ * de-duplicated by exact line. This ensures a symbol is never imported
+ * twice across sibling components — a redeclaration that Bun tolerates but
+ * stricter ESM parsers (the Deno runtime that renders SSR templates) reject.
+ *
+ * For a single-component file the output is identical to the input order;
+ * only repeated sibling imports collapse.
+ *
+ * Matching is whitespace-insensitive (`import {a,b} from 'x'` and
+ * `import {  a , b  }  from  "x"` fold the same): the merge must not silently
+ * depend on the emitter's exact spacing. A named import that failed to match
+ * would fall through to the by-line branch below and re-introduce the very
+ * duplicate-binding SyntaxError this function exists to prevent, so the
+ * patterns tolerate any spacing the generated lines might carry.
+ */
+export function mergeTemplateImports(lines: string[]): string {
+  const result: string[] = []
+  const valueIdx = new Map<string, number>()
+  const valueNames = new Map<string, Set<string>>()
+  const typeIdx = new Map<string, number>()
+  const typeNames = new Map<string, Set<string>>()
+  const seenOther = new Set<string>()
+
+  const fold = (
+    src: string,
+    rawNames: string,
+    idx: Map<string, number>,
+    names: Map<string, Set<string>>,
+    render: (src: string, names: Set<string>) => string,
+  ) => {
+    if (!idx.has(src)) {
+      idx.set(src, result.length)
+      names.set(src, new Set())
+      result.push('')
+    }
+    const set = names.get(src)!
+    for (const n of rawNames.split(',').map(s => s.trim()).filter(Boolean)) set.add(n)
+    result[idx.get(src)!] = render(src, set)
+  }
+
+  for (const raw of lines) {
+    const line = raw.trim()
+    if (!line) continue
+    const typeMatch = line.match(/^import\s+type\s*\{([^}]+)\}\s*from\s*['"]([^'"]+)['"]\s*;?$/)
+    const valueMatch = line.match(/^import\s*\{([^}]+)\}\s*from\s*['"]([^'"]+)['"]\s*;?$/)
+    if (valueMatch) {
+      fold(valueMatch[2], valueMatch[1], valueIdx, valueNames, (s, n) => `import { ${[...n].join(', ')} } from '${s}'`)
+    } else if (typeMatch) {
+      fold(typeMatch[2], typeMatch[1], typeIdx, typeNames, (s, n) => `import type { ${[...n].join(', ')} } from '${s}'`)
+    } else if (!seenOther.has(line)) {
+      seenOther.add(line)
+      result.push(line)
+    }
+  }
+
+  return result.filter(Boolean).join('\n')
+}
+
 // =============================================================================
 // Multiple Component Compilation
 // =============================================================================
@@ -264,20 +328,17 @@ function compileMultipleComponents(
     return { files, errors }
   }
 
-  // Merge imports from all components, deduplicating by line
-  const seenImportLines = new Set<string>()
-  const uniqueImports: string[] = []
-  for (const output of allOutputs) {
-    if (output.imports) {
-      for (const line of output.imports.split('\n')) {
-        if (line.trim() && !seenImportLines.has(line)) {
-          seenImportLines.add(line)
-          uniqueImports.push(line)
-        }
-      }
-    }
-  }
-  const mergedImports = uniqueImports.join('\n')
+  // Merge imports from all components. Named imports from the same source
+  // are combined into their first occurrence rather than deduplicated by
+  // exact line: in a multi-component file each component emits its own
+  // `import { … } from '@barefootjs/hono/utils'` listing only the symbols
+  // it uses, so plain line-dedup leaves several statements that re-declare
+  // the same binding (e.g. `bfComment`). Bun tolerates the redeclaration,
+  // but stricter ESM parsers — including Deno, used to render the SSR
+  // template — reject it as a SyntaxError.
+  const mergedImports = mergeTemplateImports(
+    allOutputs.flatMap(o => (o.imports ? o.imports.split('\n') : [])),
+  )
 
   // Combine unique type definitions
   const seenTypes = new Set<string>()

package/src/index.ts

@@ -280,6 +280,10 @@ export type { WrapReason } from './ir-to-client-js/reactivity'
 // HTML constants
 export { BOOLEAN_ATTRS, isBooleanAttr } from './html-constants'
 
+// Shared props-object-pattern helpers for the Go / Mojo template adapters
+export { augmentInheritedPropAccesses, parseRecordIndexAccess, evalStringArrayJoin, collectContextConsumers } from './augment-inherited-props'
+export type { RecordIndexAccess, RecordIndexEntry, ContextConsumer } from './augment-inherited-props'
+
 // HTML element attribute types
 export type {
   // Event types