@barefootjs/jsx 0.31.1 → 0.31.3

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,27 @@ 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.typeAnnotation ?? constant.type)
+            ? `: ${constant.typeAnnotation ?? constant.type?.raw}`
+            : ''
+        lines.push(`  ${keyword} ${constant.name}${typeAnnotation}`)
         continue
       }
       const value = constant.value.trim()
@@ -193,11 +216,24 @@ export abstract class JsxAdapter extends BaseAdapter {
       const constValue = preserveTypes
         ? (constant.typedValue ?? constant.value)
         : constant.value
-      lines.push(`  ${keyword} ${constant.name} = ${constValue}`)
+      // Preserve an explicit `let` type annotation from source (#2589) —
+      // without it, TS infers the initializer's (often narrower) type and
+      // later reassignments/reads fail under strict (TS7034/TS7005, and
+      // TS2339 via `never` narrowing). `const` is left alone: its type
+      // always infers correctly from the (immutable) initializer, so
+      // adding annotations there would only churn snapshots.
+      const letTypeAnnotation =
+        preserveTypes && keyword === 'let' && constant.typeAnnotation
+          ? `: ${constant.typeAnnotation}`
+          : ''
+      lines.push(`  ${keyword} ${constant.name}${letTypeAnnotation} = ${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 +255,222 @@ 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) {
+        // No initializer (e.g. module-scope `let pending: number`) — carry
+        // the declared type annotation through, mirroring the function-scope
+        // fix above (#2573 / #2589).
+        const typeAnnotation =
+          preserveTypes && (c.typeAnnotation ?? c.type)
+            ? `: ${c.typeAnnotation ?? c.type?.raw}`
+            : ''
+        entries.push({ line: c.loc.start.line, text: `${exportKw}${keyword} ${c.name}${typeAnnotation}` })
+        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
+      // Preserve an explicit module-scope `let` type annotation from source
+      // (#2589) — see the function-scope sibling above for rationale. `const`
+      // is left alone: its type always infers correctly from the (immutable)
+      // initializer.
+      const letTypeAnnotation =
+        preserveTypes && keyword === 'let' && c.typeAnnotation
+          ? `: ${c.typeAnnotation}`
+          : ''
+      entries.push({ line: c.loc.start.line, text: `${exportKw}${keyword} ${c.name}${letTypeAnnotation} = ${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 +485,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 {

package/src/analyzer.ts

@@ -8,9 +8,10 @@
 
 import ts from 'typescript'
 import type { ImportSpecifier, TypeInfo, ParamInfo, ReactiveFactoryInfo, DeclinedReactiveFactory, RequiredFactoryImport, FactoryRenameSite, SourceLocation } from './types.ts'
-import { parseExpression, parseBlockBodyTolerant, foldBlockToExpr } from './expression-parser.ts'
+import { parseExpression, parseBlockBodyTolerant, foldBlockToExpr, tsNodeToParsedExpr } from './expression-parser.ts'
 import type { CallbackBodyAcceptor } from './adapters/interface.ts'
 import { rewriteBarePropRefs } from './prop-rewrite.ts'
+import { buildPropAliasMap } from './props-binding.ts'
 import { incrementCounter } from './instrumentation.ts'
 import {
   type AnalyzerContext,
@@ -503,8 +504,18 @@ function visit(
     collectAmbientGlobals(node, ctx)
   }
 
-  // Module-level constants (outside component)
-  if (ts.isVariableStatement(node) && !ctx.componentNode) {
+  // Module-level constants (outside component). Ambient statements
+  // (`declare let X: T`) are type-only contracts with no runtime binding —
+  // collectAmbientGlobals above already tracks them for BF052, and
+  // re-emitting one as a runtime `let` would shadow the real global, so
+  // they must not reach collectConstant. (Previously excluded only by
+  // accident: this path required an initializer, which `declare`
+  // statements never have — the #2589 uninitialized-`let` fix removed
+  // that gate, so the exclusion is now explicit.)
+  const isDeclareStatement =
+    ts.isVariableStatement(node) &&
+    (node.modifiers?.some(m => m.kind === ts.SyntaxKind.DeclareKeyword) ?? false)
+  if (ts.isVariableStatement(node) && !ctx.componentNode && !isDeclareStatement) {
     const isExported = node.modifiers?.some(m => m.kind === ts.SyntaxKind.ExportKeyword) ?? false
     const isLet = (node.declarationList.flags & ts.NodeFlags.Let) !== 0
     const isModuleClientDirective = hasLeadingClientDirectiveOnStatement(node, ctx.sourceFile)
@@ -524,9 +535,15 @@ function visit(
         }
         continue
       }
+      // An initializer is required for `const` (TS grammar enforces this),
+      // but an uninitialized module-scope `let` (e.g. `let pending: number`)
+      // is legal source and must still be collected — mirroring the
+      // component-scope path below (line ~687), which has never gated on
+      // `decl.initializer` — so its declared type carries into the emitted
+      // template instead of the declaration vanishing outright (#2589).
       if (
         ts.isIdentifier(decl.name) &&
-        decl.initializer &&
+        (decl.initializer || isLet) &&
         !isArrowComponentFunction(decl)
       ) {
         collectConstant(decl, ctx, true, isLet ? 'let' : 'const', isExported)
@@ -1273,7 +1290,8 @@ function collectSignal(node: ts.VariableDeclaration, ctx: AnalyzerContext): void
   if (!ctx.propsObjectName && callExpr.arguments[0]) {
     const propNames = new Set(ctx.propsParams.map(p => p.name))
     if (propNames.size > 0) {
-      templateInitialValue = rewriteBarePropRefs(initialValue, callExpr.arguments[0], propNames)
+      const propAliases = buildPropAliasMap(ctx.propsParams)
+      templateInitialValue = rewriteBarePropRefs(initialValue, callExpr.arguments[0], propNames, undefined, propAliases)
     }
   }
 
@@ -1613,7 +1631,8 @@ function collectMemo(node: ts.VariableDeclaration, ctx: AnalyzerContext): void {
   if (!ctx.propsObjectName && callExpr.arguments[0]) {
     const propNames = new Set(ctx.propsParams.map(p => p.name))
     if (propNames.size > 0) {
-      templateComputation = rewriteBarePropRefs(computation, callExpr.arguments[0], propNames)
+      const propAliases = buildPropAliasMap(ctx.propsParams)
+      templateComputation = rewriteBarePropRefs(computation, callExpr.arguments[0], propNames, undefined, propAliases)
     }
   }
 
@@ -3129,9 +3148,15 @@ function collectConstant(
   let templateValue: string | undefined
   if (value && ctx.propsParams.length > 0 && node.initializer) {
     let propNames: Set<string>
+    // Local → caller-facing key (#2524 CSR half) — only Case 1 propsParams
+    // entries can carry `sourceName`; Case 2's alias set below is keyed by
+    // the destructured-from-`props.X` local name, which by its own
+    // `isPureAlias` construction always equals the source key.
+    let propAliases: Map<string, string> | undefined
     if (!ctx.propsObjectName) {
       // Case 1: destructured-arg — all propsParams are bare locals.
       propNames = new Set(ctx.propsParams.map(p => p.name))
+      propAliases = buildPropAliasMap(ctx.propsParams)
     } else {
       // Case 2: `(props)`-arg — restrict to body-destructured pure aliases
       // of `props.X` (entries pushed by the body-destructure expansion at
@@ -3157,7 +3182,7 @@ function collectConstant(
       )
     }
     if (propNames.size > 0) {
-      const rewritten = rewriteBarePropRefs(value, node.initializer, propNames)
+      const rewritten = rewriteBarePropRefs(value, node.initializer, propNames, undefined, propAliases)
       if (rewritten !== undefined) {
         templateValue = rewritten
         // For the body-destructure case, also rewrite the init-body
@@ -3194,6 +3219,7 @@ function collectConstant(
     value,
     parsed,
     typedValue: typedValue !== value ? typedValue : undefined,
+    typeAnnotation: node.type ? node.type.getText(ctx.sourceFile) : undefined,
     valueBranches,
     declarationKind,
     isExported,
@@ -3307,6 +3333,12 @@ function extractProps(param: ts.ParameterDeclaration, ctx: AnalyzerContext): voi
         const resolvedType: TypeInfo = member?.type ?? { kind: 'unknown', raw: 'unknown' }
 
         const defaultContainsArrow = element.initializer ? nodeContainsArrow(element.initializer) : false
+        // Structured mirror of `defaultValue`, from the binding element's OWN
+        // `initializer` node — `tsNodeToParsedExpr` converts the already-parsed
+        // AST directly, no re-parse of the `defaultValue` text (same convention
+        // as `SignalInfo.parsed`). An unsupported shape leaves `parsed` unset;
+        // consumers fall back to `defaultValue` text.
+        const parsedDefault = element.initializer ? tsNodeToParsedExpr(element.initializer) : undefined
         ctx.propsParams.push({
           name: localName,
           type: resolvedType,
@@ -3314,6 +3346,7 @@ function extractProps(param: ts.ParameterDeclaration, ctx: AnalyzerContext): voi
           // the caller may omit the prop.
           optional: !!member?.optional || !!element.initializer,
           defaultValue,
+          ...(parsedDefault && parsedDefault.kind !== 'unsupported' && { parsed: parsedDefault }),
           defaultContainsArrow: defaultContainsArrow || undefined,
           // Only aliased bindings carry the source key — see ParamInfo.sourceName.
           ...(sourcePropName !== localName && { sourceName: sourcePropName }),
@@ -3631,21 +3664,47 @@ function inferTypeFromValue(value: string): TypeInfo {
   return { kind: 'unknown', raw: 'unknown' }
 }
 
+/**
+ * Identifiers that appear as a direct call (`name(...)`) in `code`,
+ * collected off a real TS parse — never a regex over the raw text, which
+ * false-matches inside comments and string literals (the repo-wide
+ * "no regex over JS syntax" rule). A doc comment mentioning
+ * `otherSignal()` inside a memo body must NOT become a dependency
+ * (phantom `internalValue`/`controlledValue` deps on slider's
+ * `percentage`, #2581 review). A raw token scan is not enough either:
+ * without a parser driving `reScanTemplateToken`, everything between a
+ * substitution's closing `}` and the next backtick is mis-lexed as code
+ * (and the template tail swallows real code after it), so a read
+ * following a `${...}` template — xyflow's `visibleClass` reading
+ * `animated()` after the `${BF_FLOW_EDGE_SELECTED}` line — would vanish.
+ */
+function collectCalledIdentifiers(code: string): Set<string> {
+  const called = new Set<string>()
+  const sf = ts.createSourceFile('__deps__.tsx', code, ts.ScriptTarget.Latest, false, ts.ScriptKind.TSX)
+  const visit = (node: ts.Node): void => {
+    if (ts.isCallExpression(node) && ts.isIdentifier(node.expression)) {
+      called.add(node.expression.text)
+    }
+    ts.forEachChild(node, visit)
+  }
+  visit(sf)
+  return called
+}
+
 function extractDependencies(code: string, ctx: AnalyzerContext): string[] {
+  const called = collectCalledIdentifiers(code)
   const deps: string[] = []
 
   // Find signal getter calls: signalName()
   for (const signal of ctx.signals) {
-    const pattern = new RegExp(`\\b${signal.getter}\\s*\\(`, 'g')
-    if (pattern.test(code)) {
+    if (called.has(signal.getter)) {
       deps.push(signal.getter)
     }
   }
 
   // Find memo calls: memoName()
   for (const memo of ctx.memos) {
-    const pattern = new RegExp(`\\b${memo.name}\\s*\\(`, 'g')
-    if (pattern.test(code)) {
+    if (called.has(memo.name)) {
       deps.push(memo.name)
     }
   }