@barefootjs/jsx 0.17.1 → 0.18.0

package/src/loop-destructure.ts

@@ -1,31 +1,60 @@
 import type { IRLoop, IRNode, AttrValue, IRTemplatePart } from './types.ts'
 
-const SIMPLE_FIELD = /^\.[A-Za-z_$][\w$]*$/
-
 /**
- * True when a loop's destructure param is the single shape the non-JS SSR
- * adapters (Go template / Mojolicious / Xslate) can lower today:
+ * True when a loop's `.map()` destructure param is one of the shapes this
+ * repo's per-adapter emitters can lower to a native accessor, WITHOUT
+ * relying on the JS/CSR runtime to evaluate an arbitrary residual object.
+ *
+ * Admitted (all via `LoopParamBinding.segments` — the structured, non-string
+ * accessor path built by `extractLoopParamBindings`; see #2087):
  *
- *   `arr.map(({ id, title, ...rest }) => …)`
+ *   - fixed bindings at any depth / shape: `.field` (`{ id }`), array-index
+ *     (`[k, v]`), and nested paths through either (`{ cells: [head] }`,
+ *     `{ user: { name } }`) — anything the IR walker turned into a
+ *     `segments` path. `segments` is required; a fixed binding with no
+ *     `segments` is stale/foreign IR and refused conservatively.
+ *   - array-rest bindings (`[first, ...tail]`): the lowered value IS the
+ *     exact JS slice (`tail === item.slice(1)`), so there is no way for an
+ *     adapter to observe a "wrong" value from any use of the name — no
+ *     use-restriction scan needed, unlike object-rest below.
+ *   - object-rest bindings (`{ id, ...rest }`) whose every use in the loop
+ *     subtree is one of:
+ *       (a) a member-access base (`rest.flag` / `rest?.flag` — the
+ *           "read one field back off the rest" idiom), or
+ *       (b) NEW: a spread attr (`{...rest}`) on an intrinsic ELEMENT node
+ *           (`<li {...rest}>`) whose `expr` is *exactly* the rest name —
+ *           "forward everything else onto this element" is a residual the
+ *           adapters can express as "all attrs not already destructured",
+ *           without ever materializing the residual object itself.
+ *     A spread on a `component` or `provider` node still refuses — a
+ *     component's own props lowering is a different code path with its own
+ *     contract, not something this gate should reach into. A spread whose
+ *     expr merely *contains* the name (`{...fn(rest)}`) still refuses too —
+ *     that's an opaque call, not a literal forward.
  *
- * where every binding is a simple `.field` access or an **object-rest read only
- * via member access** (`rest.flag`). The adapters lower the rest binding as an
- * alias to the whole iteration item, which matches JS rest semantics only for
- * member reads of non-consumed keys — so any other use must be refused:
+ * Still refused, and why:
  *
- *   - array-rest / array-index / nested paths (`[a, ...t]`, `{ cells: [h] }`)
- *     need index/slice the `range`/`for` can't express inline;
- *   - spread (`{...rest}`) and bare value uses (`String(rest)`, `{rest}`,
- *     `fn(rest)`) would observe the consumed keys too — they need a residual
- *     object the templates can't build inline;
- *   - a chained `.filter().map(destructure)` would need the filter-param
- *     rewrite to target the synthetic per-item var, so it's refused as well.
+ *   - any OTHER use of an object-rest name (`String(rest)`, `{rest}` as a
+ *     text/expression node, `onClick={() => fn(rest)}`, `{...fn(rest)}`)
+ *     needs the actual residual *object*, which the non-JS template
+ *     adapters can't build inline — only "read one field" (member access)
+ *     and "spread all remaining attrs onto this element" (the new spread
+ *     case) have an adapter-side answer that doesn't require constructing
+ *     the value.
+ *   - a chained `.filter().map(destructure)` needs the filter-param
+ *     rewrite to retarget the synthetic per-item var; out of scope here.
+ *   - a binding name (or `loop.index`) in the reserved `__bf_` namespace
+ *     would collide with the synthetic per-item loop variable the SSR
+ *     adapters emit (duplicate locals, ambiguous accessors).
+ *   - computed property keys (`{ [k]: v }`) can't be expressed as any
+ *     accessor path at all — they raise `BF025` at Phase 1 and never reach
+ *     this gate (`loop.paramBindings` is simply absent).
  *
- * Unsupported shapes fall through to the adapters' BF104 diagnostic. The scan
- * is conservative: an ambiguous use refuses (false-negative is safe — it keeps
- * the existing build-time error rather than shipping wrong output).
+ * Unsupported shapes fall through to the adapters' BF104 diagnostic. The
+ * scan is conservative: an ambiguous use refuses (false-negative is safe —
+ * it keeps the existing build-time error rather than shipping wrong output).
  */
-export function isLowerableObjectRestDestructure(loop: IRLoop): boolean {
+export function isLowerableLoopDestructure(loop: IRLoop): boolean {
   const bindings = loop.paramBindings
   if (!bindings || bindings.length === 0) return false
   if (loop.filterPredicate) return false
@@ -39,31 +68,49 @@ export function isLowerableObjectRestDestructure(loop: IRLoop): boolean {
   }
   for (const b of bindings) {
     if (b.rest) {
-      if (b.rest.kind !== 'object') return false
-    } else if (!SIMPLE_FIELD.test(b.path)) {
+      // Both rest kinds require `segments` (the array-rest kind may
+      // legitimately have an empty one, at the loop root — `([...rest]) =>`).
+      if (!b.segments) return false
+    } else if (!b.segments || b.segments.length === 0) {
+      // Fixed binding with no structured path: stale/foreign IR built
+      // before `segments` existed. Refuse rather than guess from `path`.
       return false
     }
   }
-  const restNames = bindings.filter(b => b.rest).map(b => b.name)
-  if (restNames.length === 0) return true
-  return !restNamesMisused(loop, restNames)
+  const objectRestNames = bindings.filter(b => b.rest?.kind === 'object').map(b => b.name)
+  if (objectRestNames.length === 0) return true
+  return !restNamesMisused(loop, objectRestNames)
 }
 
+/** @deprecated Use {@link isLowerableLoopDestructure}. Kept as an alias so
+ * existing template-adapter imports keep compiling; the underlying gate now
+ * admits more shapes (array-index / nested paths / array-rest / the
+ * spread-onto-element case) than the name suggests — see #2087 Phase A.
+ */
+export const isLowerableObjectRestDestructure = isLowerableLoopDestructure
+
 /**
  * Walks the whole loop subtree (every node type, every expression-bearing
- * field) and reports whether any rest name is referenced as something other
- * than a member-access base (`rest.flag` / `rest?.flag`). A spread expr
- * (`{...rest}` → expr `"rest"`) and bare value uses are caught by the same
- * regex; a property of an unrelated object (`foo.rest`) is excluded by the
- * lookbehind.
+ * field) and reports whether any object-rest name is referenced as
+ * something other than:
+ *
+ *   - a member-access base (`rest.flag` / `rest?.flag`), or
+ *   - a spread attr on an intrinsic ELEMENT node whose expr is *exactly*
+ *     the rest name (`<li {...rest}>`) — the one new admitted shape.
+ *
+ * A spread expr on a `component` / `provider` node, or a spread whose expr
+ * merely contains the name, still counts as misuse (falls through to the
+ * generic bare-value-use regex below). A property of an unrelated object
+ * (`foo.rest`) is excluded by the lookbehind, same as before.
  *
  * The scan covers the gated loop's own non-children expression fields too
- * (`array` / `key` / `mapPreamble` / `flatMapCallback` body) — a bare rest use
- * can surface there (e.g. `.map(({ ...rest }) => { const x = rest; … })`
+ * (`array` / `key` / `mapPreamble` / `flatMapCallback` body) — a bare rest
+ * use can surface there (e.g. `.map(({ ...rest }) => { const x = rest; … })`
  * lifts `const x = rest` into `mapPreamble`), plus intrinsic element event
  * handlers (`onClick={() => fn(rest)}`).
  */
 function restNamesMisused(loop: IRLoop, names: string[]): boolean {
+  const nameSet = new Set(names)
   const valueUse = names.map(
     n => new RegExp(`(?<![\\w.$])${escapeRe(n)}(?!\\s*\\??\\.)(?![\\w$])`),
   )
@@ -77,7 +124,13 @@ function restNamesMisused(loop: IRLoop, names: string[]): boolean {
       }
     }
   }
-  const attr = (v: AttrValue): void => {
+  // `isIntrinsicElementAttrs` distinguishes `<li {...rest}>` (element,
+  // admitted) from `<Child {...rest} />` / a provider's value prop
+  // (still refused) — same spread AttrValue shape, different node kind.
+  const attr = (v: AttrValue, isIntrinsicElementAttrs: boolean): void => {
+    if (v.kind === 'spread' && isIntrinsicElementAttrs && nameSet.has(v.expr.trim())) {
+      return
+    }
     if (v.kind === 'expression' || v.kind === 'spread') {
       check(v.expr)
       check(v.templateExpr)
@@ -134,16 +187,16 @@ function restNamesMisused(loop: IRLoop, names: string[]): boolean {
         if (node.alternate) visit(node.alternate)
         break
       case 'element':
-        node.attrs.forEach(a => attr(a.value))
+        node.attrs.forEach(a => attr(a.value, true))
         node.events.forEach(e => check(e.handler))
         node.children.forEach(visit)
         break
       case 'component':
-        node.props.forEach(p => attr(p.value))
+        node.props.forEach(p => attr(p.value, false))
         node.children.forEach(visit)
         break
       case 'provider':
-        attr(node.valueProp.value)
+        attr(node.valueProp.value, false)
         node.children.forEach(visit)
         break
       case 'fragment':

package/src/lowering-registry.ts

@@ -141,6 +141,22 @@ export function matchLoweringCall(
   return null
 }
 
+/**
+ * Whether a `LoweringNode.helper` id is safe to splice directly into an
+ * adapter's runtime-helper naming convention (`bf_${helper}` in Go,
+ * `bf->${helper}` in Perl/Mojolicious, `$bf.${helper}` in Xslate/Kolon,
+ * `bf.${helper}` in Ruby/ERB and the Jinja-family adapters — Jinja,
+ * MiniJinja/Rust, Twig). Every adapter derives its helper's target-language
+ * name FROM the helper id (#2069) rather than keeping a per-id lookup
+ * table, so a plugin author could otherwise inject arbitrary syntax via a
+ * malformed id. A valid id is a plain identifier fragment —
+ * letters/digits/underscore, not starting with a digit — which is the only
+ * shape every target language's function/method-name grammar accepts.
+ */
+export function isValidHelperId(helper: string): boolean {
+  return /^[A-Za-z_][A-Za-z0-9_]*$/.test(helper)
+}
+
 /**
  * Test-only: replace the registry contents wholesale. The double-underscore
  * prefix marks it as an internal seam — tests use it to restore global state in

package/src/relocate.ts

@@ -19,6 +19,8 @@ import type {
   TemplatePrimitiveRegistry,
   TemplateCallAcceptor,
 } from './adapters/interface.ts'
+import { tsNodeToParsedExpr, type ParsedExpr } from './expression-parser.ts'
+import { prepareLoweringMatchers, type LoweringMatcher } from './lowering-registry.ts'
 
 export interface RelocateEnv {
   /**
@@ -65,6 +67,33 @@ export interface RelocateEnv {
    * in `templatePrimitives`. Returning true marks the call as accepted.
    */
   acceptsTemplateCall?: TemplateCallAcceptor
+  /**
+   * Lowering-registry matchers (#2057) bound to this component's metadata
+   * (`prepareLoweringMatchers`), consulted by `isCallAcceptedByAdapter` as a
+   * third acceptance path alongside `templatePrimitives` /
+   * `acceptsTemplateCall`. A call recognised by ANY matcher (returns a
+   * non-null `LoweringNode`) is treated as adapter-accepted — the matcher
+   * result itself isn't used here (relocate only needs a boolean; the
+   * adapter's own render pass re-runs the matcher to get the node). Bound
+   * once per component (`buildRelocateEnvFromIR`), so checking it per call
+   * site is cheap. Undefined/empty behaves like pre-#2069 (no matcher path).
+   */
+  loweringMatchers?: readonly LoweringMatcher[]
+  /**
+   * One-hop alias resolution table (#2069 R2): name → the bare identifier
+   * or dotted identifier-path text of its initializer, for local constants
+   * whose value is itself just another identifier/path reference
+   * (`const fmt = customSerialize`, `const f = Math.floor`) — NOT a call,
+   * object, or any other expression shape. `isCallAcceptedByAdapter` uses
+   * this to resolve a call's callee ONE hop before keying
+   * `templatePrimitives` / dispatching matchers, so a locally-aliased
+   * import or global still resolves to a registrable name. Deliberately
+   * shallow — an alias-to-alias chain (`const g = f` where `f` is itself
+   * an alias) is NOT resolved transitively; the shadow guard naturally
+   * rejects it because the one-hop target's own binding kind is
+   * `init-local`/`module-local` with no further resolution.
+   */
+  aliasTargets?: ReadonlyMap<string, string>
 }
 
 export interface RelocateResult {
@@ -155,6 +184,34 @@ function decideAction(
   }
 
   if ((kind === 'init-local' || kind === 'sub-init-local') && toScope === 'template') {
+    // One-hop alias resolution (#2069 R2): `const fmt = customSerialize`
+    // is a pure identifier/path alias — its bare reference is
+    // interchangeable with the target text (checked BEFORE `env.inlinable`,
+    // which isn't populated yet when this runs from inside
+    // `computeInlinability`'s own Stage-1 classification loop; the alias
+    // table is built once at env-construction time so it's always ready).
+    // This resolves the CALLEE identifier itself (`fmt` → `customSerialize`
+    // wherever it's referenced) — a separate concern from
+    // `isCallAcceptedByAdapter`'s own one-hop resolution, which only
+    // decides whether a *call* is safe to inline, not how its callee text
+    // renders.
+    //
+    // Only substitute when the alias TARGET's own leftmost identifier is
+    // itself bare-visible at `toScope` (module-import / module-local /
+    // global) — this is what keeps the resolution to exactly one hop: an
+    // alias-of-an-alias (`const g = f` where `f` is itself just another
+    // local) has a target whose kind is `init-local`, which fails the
+    // visibility check below, so `g` falls through to the normal
+    // `env.inlinable` / fallback path instead of being blindly rewritten
+    // to the still-unreachable `f`.
+    const aliasTarget = env.aliasTargets?.get(name)
+    if (aliasTarget !== undefined) {
+      const targetLeftmost = aliasTarget.includes('.') ? aliasTarget.split('.')[0]! : aliasTarget
+      const targetKind = classify(targetLeftmost, env)
+      if (isVisibleIn(toScope, targetKind)) {
+        return { action: 'inline', rewrittenAs: aliasTarget }
+      }
+    }
     // Try inline; fall back if not eligible.
     const inlineForm = env.inlinable.get(name)
     if (inlineForm !== undefined) {
@@ -341,10 +398,31 @@ export function isInlinableInTemplate(
  * `obj` is a value of a particular TypeScript type, so method calls on
  * arbitrary receivers (`props.name.toUpperCase()`) cannot be matched
  * against type-anchored registry keys like `String.prototype.toUpperCase`.
- * This is the V1 limitation #1187 R1 records — users fall back to
+ * This remains out of scope in V2 (#1187 R1) — users fall back to
  * `/* @client *\/` for those cases.
+ *
+ * V2 (#2069): the registry is still identifier-path-only, but two things
+ * widen it beyond the raw path this function returns:
+ *   1. One-hop alias resolution (`isCallAcceptedByAdapter`) — a callee whose
+ *      leftmost identifier is a local const aliasing another identifier/path
+ *      (`const fmt = customSerialize`) resolves through that one hop before
+ *      the path returned here is keyed against `templatePrimitives`.
+ *   2. A THIRD acceptance path alongside `templatePrimitives` /
+ *      `acceptsTemplateCall`: `RelocateEnv.loweringMatchers` (#2057). A
+ *      user-imported helper is never added to the string-keyed registry —
+ *      it's recognised structurally by a `LoweringPlugin` (import-aware via
+ *      `prepare(metadata)`), which accepts calls this function's textual
+ *      path can't key at all (the plugin matches on the parsed callee/args
+ *      shape, not a string).
  */
 function getCalleeIdentifierPath(callee: ts.Expression): string | null {
+  // Unwrap `(expr)` — `csrSubstitute`'s AST splicer wraps every identifier
+  // substitution in parens (`(customSerialize)(x)` after a one-hop alias
+  // resolves `fmt` → `customSerialize`), so a callee that started as a bare
+  // identifier can arrive here re-parsed as a `ParenthesizedExpression`.
+  // Unwrapping is always safe: a paren never changes *which* identifier
+  // path a callee resolves to, only re-parse shape.
+  if (ts.isParenthesizedExpression(callee)) return getCalleeIdentifierPath(callee.expression)
   if (ts.isIdentifier(callee)) return callee.text
   if (ts.isPropertyAccessExpression(callee)) {
     const left = getCalleeIdentifierPath(callee.expression)
@@ -363,6 +441,7 @@ function getCalleeIdentifierPath(callee: ts.Expression): string | null {
  * (the shadowing case — the registry must not fire then).
  */
 function getCalleeLeftmostIdentifier(callee: ts.Expression): string | null {
+  if (ts.isParenthesizedExpression(callee)) return getCalleeLeftmostIdentifier(callee.expression)
   if (ts.isIdentifier(callee)) return callee.text
   if (ts.isPropertyAccessExpression(callee)) {
     return getCalleeLeftmostIdentifier(callee.expression)
@@ -386,33 +465,94 @@ const REGISTRY_SAFE_BINDING_KINDS: ReadonlySet<BindingKind> = new Set([
 
 /**
  * Whether `env`'s adapter promises it can render this call in template
- * scope. Resolves the callee path and consults `templatePrimitives` first,
- * then `acceptsTemplateCall`. Either match returns true.
+ * scope. Three independent acceptance paths, any of which is sufficient:
  *
- * Shadow guard: rejects when the leftmost identifier of the callee
- * resolves to a local-ish binding kind. This prevents a local variable
- * named after a registered primitive (e.g. `const JSON = props.config`)
- * from accidentally activating the registry.
+ *   1. `templatePrimitives` — string-keyed identifier-path registry
+ *      (`JSON.stringify`, `Math.floor`).
+ *   2. `acceptsTemplateCall` — broad predicate for full-JS-runtime adapters.
+ *   3. `loweringMatchers` (#2057/#2069) — structural `LoweringPlugin`
+ *      recognition, for user-imported helpers that were never (and can
+ *      never be) added to the string-keyed registry.
+ *
+ * Before any of the three checks, the callee path is resolved through
+ * `aliasTargets` ONE hop (#2069 R2): `const fmt = customSerialize; fmt(x)`
+ * keys/matches as `customSerialize`, not `fmt`. Resolution only replaces a
+ * BARE-identifier leftmost segment with a bare-identifier target — a
+ * dotted alias target (`Math.floor`) only feeds the string-keyed path
+ * (matchers structurally expect a real callee shape, not a synthesised
+ * dotted identifier).
+ *
+ * Shadow guard: rejects when the leftmost identifier of the (possibly
+ * alias-resolved) callee resolves to a local-ish binding kind. This
+ * prevents a local variable named after a registered primitive (e.g.
+ * `const JSON = props.config`) from accidentally activating the registry,
+ * and — because the guard runs AFTER alias resolution — also rejects an
+ * alias-to-alias chain (`const g = f` where `f` is itself an unresolved
+ * local) without needing special-case transitive-chain detection: the
+ * one-hop target `f` is still `init-local`/`module-local`-shadowed.
  */
 function isCallAcceptedByAdapter(
   call: ts.CallExpression,
   env: RelocateEnv,
 ): boolean {
-  const name = getCalleeIdentifierPath(call.expression)
-  if (name === null) return false
+  const originalPath = getCalleeIdentifierPath(call.expression)
+  if (originalPath === null) return false
 
-  // Shadow guard. `undefined` (not in bindings) means truly global —
-  // safe; we let it through. A tracked binding must be in the safe set.
   const leftmost = getCalleeLeftmostIdentifier(call.expression)
+
+  // One-hop alias resolution: replace the callee's LEFTMOST SEGMENT with
+  // its alias target when eligible. This resolves both a bare-identifier
+  // callee (`fmt(x)` → `customSerialize(x)`) and an aliased-namespace
+  // member callee (`m.floor(x)` → `Math.floor(x)` when `const m = Math`)
+  // — the target text is spliced in place of the leftmost segment and any
+  // remaining `.path` tail is carried over. Matcher dispatch below is
+  // narrower (bare identifiers only); the string-keyed registry path uses
+  // the full spliced text.
+  let resolvedPath = originalPath
+  let resolvedLeftmost = leftmost
   if (leftmost !== null) {
-    const kind = env.bindings.get(leftmost)
+    const aliasTarget = env.aliasTargets?.get(leftmost)
+    if (aliasTarget !== undefined) {
+      resolvedPath =
+        originalPath === leftmost
+          ? aliasTarget
+          : `${aliasTarget}${originalPath.slice(leftmost.length)}`
+      resolvedLeftmost = aliasTarget.includes('.') ? aliasTarget.split('.')[0] : aliasTarget
+    }
+  }
+
+  // Shadow guard, applied to the RESOLVED leftmost identifier. `undefined`
+  // (not in bindings) means truly global — safe; we let it through. A
+  // tracked binding must be in the safe set.
+  if (resolvedLeftmost !== null) {
+    const kind = env.bindings.get(resolvedLeftmost)
     if (kind !== undefined && !REGISTRY_SAFE_BINDING_KINDS.has(kind)) {
       return false
     }
   }
 
-  if (env.templatePrimitives && env.templatePrimitives[name]) return true
-  if (env.acceptsTemplateCall && env.acceptsTemplateCall(name)) return true
+  if (env.templatePrimitives && env.templatePrimitives[resolvedPath]) return true
+  if (env.acceptsTemplateCall && env.acceptsTemplateCall(resolvedPath)) return true
+
+  if (env.loweringMatchers && env.loweringMatchers.length > 0) {
+    const parsed = tsNodeToParsedExpr(call)
+    if (parsed.kind === 'call') {
+      // Only substitute the callee for matcher dispatch when the alias
+      // target is itself a bare identifier (no dots) — matchers expect a
+      // real parsed callee shape (`kind: 'identifier'`), not a synthesised
+      // dotted path.
+      const calleeForMatch =
+        resolvedPath !== originalPath &&
+        !resolvedPath.includes('.') &&
+        parsed.callee.kind === 'identifier'
+          ? { kind: 'identifier' as const, name: resolvedPath }
+          : parsed.callee
+      for (const matcher of env.loweringMatchers) {
+        if (matcher(calleeForMatch, parsed.args)) return true
+      }
+    }
+  }
+
   return false
 }
 
@@ -626,6 +766,15 @@ export function buildRelocateEnvFromIR(
   const env = buildRelocateEnvFromFields(metadata)
   if (options?.templatePrimitives) env.templatePrimitives = options.templatePrimitives
   if (options?.acceptsTemplateCall) env.acceptsTemplateCall = options.acceptsTemplateCall
+  // Bind every registered LoweringPlugin (built-in + userland, #2057) to
+  // THIS component's metadata once here, so `isCallAcceptedByAdapter`'s
+  // per-call check is just an array iteration + matcher call — no
+  // per-call import resolution (#2069). `metadata.imports` must be the
+  // REAL import list for plugin `prepare()` to resolve local names
+  // correctly; callers that reconstruct a synthetic `IRMetadata` (e.g.
+  // `compute-inlinability.ts`'s `buildEnvFromCtx`) must populate `imports`
+  // from the real component, not `[]`.
+  env.loweringMatchers = prepareLoweringMatchers(metadata)
   return env
 }
 
@@ -711,11 +860,49 @@ function buildRelocateEnvFromFields(src: EnvFields): RelocateEnv {
     if (kind === 'prop') propsForLift.add(name)
   }
 
+  // aliasTargets (#2069 R2): one-hop alias resolution table for
+  // `isCallAcceptedByAdapter`. A const whose FINAL resolved binding kind
+  // is `init-local` or `module-local` (i.e. not a signal/memo/prop-alias
+  // override) AND whose initializer is nothing but a bare identifier or
+  // dotted identifier path (`customSerialize`, `Math.floor` — no calls,
+  // no operators, no literals) is eligible. Eligibility is decided on the
+  // analyzer's structured `ConstantInfo.parsed` tree (never on the raw
+  // source text — see CLAUDE.md's no-regex-parsing rule); a const whose
+  // initializer didn't parse is simply not an alias. Built AFTER
+  // `bindings` is fully resolved (signals/memos have already overridden
+  // same-named consts) so eligibility reflects the FINAL kind, not a
+  // shadowed one.
+  const aliasTargets = new Map<string, string>()
+  for (const c of src.localConstants) {
+    const kind = bindings.get(c.name)
+    if (kind !== 'init-local' && kind !== 'module-local') continue
+    const target = identifierPathFromParsed(c.parsed)
+    if (target !== null) aliasTargets.set(c.name, target)
+  }
+
   return {
     bindings,
     inlinable: new Map(), // populated by compute-inlinability after analyzer runs
     propsForLift,
     propsObjectName,
     allowFallback: true,
+    aliasTargets,
   }
 }
+
+/**
+ * The dotted identifier-path text of a parsed expression that is nothing
+ * but a bare identifier or a chain of non-computed member accesses on one
+ * (`foo`, `foo.bar`, `Math.floor`) — or null for every other shape
+ * (calls, literals, computed access, operators…). The structured
+ * counterpart of `getCalleeIdentifierPath` for `ParsedExpr` trees.
+ */
+function identifierPathFromParsed(expr: ParsedExpr | undefined): string | null {
+  if (!expr) return null
+  if (expr.kind === 'identifier') return expr.name
+  if (expr.kind === 'member' && !expr.computed) {
+    const object = identifierPathFromParsed(expr.object)
+    return object === null ? null : `${object}.${expr.property}`
+  }
+  return null
+}

package/src/ssr-defaults.ts

@@ -93,27 +93,29 @@ export function extractSsrDefaults(metadata: IRMetadata): Record<string, SsrDefa
   if (metadata.propsObjectName) propsLike.add(metadata.propsObjectName)
   for (const p of metadata.propsParams) propsLike.add(p.name)
 
-  // Prop destructure defaults. Only emit entries for the
-  // destructured-prop form (`function Foo({ variant = 'default' })`)
-  // where each `propsParam` name corresponds to a template-stash
-  // variable. The bare-props-arg form (`function Foo(props: Props)`)
-  // also populates `propsParams` from the type, but those names are
-  // never referenced as bare scalars in the generated template —
-  // accesses go through `$props->{X}` — so seeding them would just
-  // crowd the manifest with no-op entries.
-  if (metadata.propsObjectName === null) {
-    for (const p of metadata.propsParams) {
-      if (p.isRest) continue
-      if (p.defaultValue !== undefined) {
-        const value = tryStaticEval(p.defaultValue, { bindings: {}, propsLike })
-        out[p.name] = { propName: p.name, value: resultToJsonable(value) }
-      } else {
-        // No destructure default — the template will read it as-is, source
-        // from props and let Perl's `//` operator decide what `undef`
-        // becomes. We still register the entry so consumers can supply
-        // the propName even with no static fallback.
-        out[p.name] = { propName: p.name, value: null }
-      }
+  // Prop entries. Both parameter forms need one entry per prop:
+  //   - Destructured form (`function Foo({ variant = 'default' })`):
+  //     each `propsParam` is a template-stash variable; a literal
+  //     destructure default becomes the static fallback value.
+  //   - Bare-props form (`function Foo(props: Props)`): template-stash
+  //     adapters flatten `props.X` to the same bare scalar (`$X` — see
+  //     the Mojo emitter's `member()`), NOT a `$props->{X}` hash read,
+  //     so an unseeded prop the caller forgets to pass is a strict-mode
+  //     compile error, not a soft `undef` (#2126). Seed every declared
+  //     prop with a `null` fallback (→ undef; the template-side `// …`
+  //     recompute supplies the real default, and a caller-passed prop
+  //     wins via `propName`).
+  for (const p of metadata.propsParams) {
+    if (p.isRest) continue
+    if (metadata.propsObjectName === null && p.defaultValue !== undefined) {
+      const value = tryStaticEval(p.defaultValue, { bindings: {}, propsLike })
+      out[p.name] = { propName: p.name, value: resultToJsonable(value) }
+    } else {
+      // No destructure default — the template reads the prop as-is;
+      // Perl's `//` operator decides what `undef` becomes. The entry
+      // still matters so the template variable exists and consumers
+      // can supply the propName even with no static fallback.
+      out[p.name] = { propName: p.name, value: null }
     }
   }
   // Rest-props bag (`...props`) — tracked separately from `propsParams`
@@ -159,17 +161,17 @@ export function extractSsrDefaults(metadata: IRMetadata): Record<string, SsrDefa
     bindings[memo.name] = value
   }
 
-  // Bare-props-arg form (`function Foo(props: Props)`): a signal / memo
-  // whose initializer reads `props.X` is lowered by template-stash
-  // adapters to a *bare scalar* recompute (`my $count = ($initial // 0)`,
-  // the #1297 prop-derived seeding) — not a `$props->{X}` hash read. That
-  // bare `$initial` has to exist in the stash or Perl's strict mode aborts
-  // the render with `Global symbol "$initial" requires explicit package
-  // name`. The top block skips bare-props props on the assumption they're
-  // only ever read via `$props->{X}`, which the prop-derived seeding
-  // violates — so seed every prop a signal / memo initializer references.
-  // Value is `null` (→ undef): the recompute's own `?? <literal>` supplies
-  // the real fallback, and a caller-passed prop still wins via `propName`.
+  // Bare-props-arg safety net: the prop block above covers every prop
+  // *declared* on the props type, but `propsParams` can miss props read
+  // through an untyped / inline-typed `props` object. A signal / memo
+  // initializer's `props.X` read is lowered by template-stash adapters
+  // to a *bare scalar* recompute (`my $count = ($initial // 0)`, the
+  // #1297 prop-derived seeding), and that bare `$initial` has to exist
+  // in the stash or Perl's strict mode aborts the render with `Global
+  // symbol "$initial" requires explicit package name` — so also seed
+  // every prop a signal / memo initializer references. Value is `null`
+  // (→ undef): the recompute's own `?? <literal>` supplies the real
+  // fallback, and a caller-passed prop still wins via `propName`.
   if (metadata.propsObjectName !== null) {
     const referenced = new Set<string>()
     for (const sig of metadata.signals) {