@barefootjs/mojolicious 0.31.1 → 0.31.2

package/dist/index.js

@@ -1941,10 +1941,7 @@ var conformancePins = {
   "date-method-uncatalogued": [{ code: "BF021", severity: "error", issue: "https://github.com/piconic-ai/barefootjs/issues/2356" }]
 };
 // src/render-divergences.ts
-var renderDivergences = {
-  "aliased-destructured-prop": "aliased destructured prop `{ n: count }` loses its rename — template vars, ssr-defaults, and the props bridge all key off the local name, so the prop is always undefined (https://github.com/piconic-ai/barefootjs/issues/2524)",
-  "composite-row-child-aliased-prop": "same defect as `aliased-destructured-prop` (#2524), inside a keyed `.map()` loop row: the nested child's renamed prop (`{ n: count }`) is always undefined, so both rows render an empty count (https://github.com/piconic-ai/barefootjs/issues/2524)"
-};
+var renderDivergences = {};
 export {
   renderDivergences,
   mojoAdapter,

package/dist/render-divergences.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"render-divergences.d.ts","sourceRoot":"","sources":["../src/render-divergences.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAA;AAExD,eAAO,MAAM,iBAAiB,EAAE,iBAsB/B,CAAA"}
+{"version":3,"file":"render-divergences.d.ts","sourceRoot":"","sources":["../src/render-divergences.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAA;AAExD,eAAO,MAAM,iBAAiB,EAAE,iBAM/B,CAAA"}

package/dist/vite.js

@@ -4,8 +4,11 @@ import { dirname, resolve } from "node:path";
 import { barefoot as coreBarefoot } from "@barefootjs/vite";
 import { devModuleUrl, loadManifest, resolveDevOrigin, resolveScriptAssets, toPosixRelative } from "@barefootjs/vite";
 
+// ../jsx/src/compiler.ts
+import ts23 from "typescript";
+
 // ../jsx/src/analyzer.ts
-import ts8 from "typescript";
+import ts9 from "typescript";
 
 // ../jsx/src/expression-parser.ts
 import ts from "typescript";
@@ -1922,6 +1925,29 @@ import ts5 from "typescript";
 // ../jsx/src/ir-to-client-js/utils.ts
 import ts3 from "typescript";
 
+// ../jsx/src/template-parts.ts
+function lookupPartToJsExpr(part, opts) {
+  const key = opts?.useTemplate && part.templateKey ? part.templateKey : part.key;
+  const obj = "{" + Object.entries(part.cases).map(([k, v]) => `${JSON.stringify(k)}: ${JSON.stringify(v)}`).join(", ") + "}";
+  const typed = opts?.typed ? " as Record<string, string>" : "";
+  return `(${obj}${typed})[${key}]`;
+}
+function templatePartsToJsExpr(parts, opts) {
+  let result = "`";
+  for (const part of parts) {
+    if (part.type === "string") {
+      result += opts?.useTemplate && part.templateValue ? part.templateValue : part.value;
+    } else if (part.type === "ternary") {
+      const cond = opts?.useTemplate && part.templateCondition ? part.templateCondition : part.condition;
+      result += `\${${cond} ? '${part.whenTrue}' : '${part.whenFalse}'}`;
+    } else if (part.type === "lookup") {
+      result += `\${${lookupPartToJsExpr(part, opts)}}`;
+    }
+  }
+  result += "`";
+  return result;
+}
+
 // ../jsx/src/scanner/js-scanner.ts
 import ts2 from "typescript";
 
@@ -2023,6 +2049,16 @@ function escapeHtml(text) {
 }
 // ../jsx/src/ir-to-client-js/csr-substitute.ts
 import ts4 from "typescript";
+function extractFreeIdentifiersFromText(text) {
+  if (!text || text.trim().length === 0)
+    return new Set;
+  const sf = ts4.createSourceFile("__free_ids__.ts", `(${text});`, ts4.ScriptTarget.Latest, true, ts4.ScriptKind.TS);
+  const stmt = sf.statements[0];
+  if (!stmt || !ts4.isExpressionStatement(stmt))
+    return new Set;
+  const expr = ts4.isParenthesizedExpression(stmt.expression) ? stmt.expression.expression : stmt.expression;
+  return extractFreeIdentifiersFromNode(expr);
+}
 
 // ../jsx/src/adapters/child-scope.ts
 function derivesScopeFromSlot(comp) {
@@ -2073,6 +2109,27 @@ var SKELETON_PATH_FORCE_CLOSE_GROUPS = [
   new Set(["li"])
 ];
 
+// ../jsx/src/props-binding.ts
+import ts6 from "typescript";
+function isIdentifierName(key) {
+  if (key.length === 0)
+    return false;
+  for (let i = 0;i < key.length; ) {
+    const cp = key.codePointAt(i);
+    const ok = i === 0 ? ts6.isIdentifierStart(cp, ts6.ScriptTarget.Latest) : ts6.isIdentifierPart(cp, ts6.ScriptTarget.Latest);
+    if (!ok)
+      return false;
+    i += cp > 65535 ? 2 : 1;
+  }
+  return true;
+}
+function propsDestructureBinding(p) {
+  const callerKey = p.sourceName ?? p.name;
+  const localName = p.name;
+  const binding = callerKey === localName ? localName : `${isIdentifierName(callerKey) ? callerKey : JSON.stringify(callerKey)}: ${localName}`;
+  return p.defaultValue ? `${binding} = ${p.defaultValue}` : binding;
+}
+
 // ../jsx/src/instrumentation.ts
 var _counters = freshCounters();
 function freshCounters() {
@@ -2086,14 +2143,14 @@ function freshCounters() {
 }
 
 // ../jsx/src/analyzer-context.ts
-import ts7 from "typescript";
+import ts8 from "typescript";
 
 // ../jsx/src/strip-types.ts
-import ts6 from "typescript";
+import ts7 from "typescript";
 
 // ../jsx/src/analyzer-context.ts
-var _typePrinter = ts7.createPrinter({ removeComments: true, omitTrailingSemicolon: true });
-var _blankTypeSourceFile = ts7.createSourceFile("__bf_types__.ts", "", ts7.ScriptTarget.Latest);
+var _typePrinter = ts8.createPrinter({ removeComments: true, omitTrailingSemicolon: true });
+var _blankTypeSourceFile = ts8.createSourceFile("__bf_types__.ts", "", ts8.ScriptTarget.Latest);
 
 // ../jsx/src/errors.ts
 var ErrorCodes = {
@@ -2109,6 +2166,7 @@ var ErrorCodes = {
   JSX_IN_LOCAL_FUNCTION: "BF045",
   COMPONENT_REQUIRED_PROP_MISSING: "BF046",
   JSX_BRANCH_LOCAL_IN_CALLBACK: "BF047",
+  SIBLING_COMPONENT_NOT_COMPILED: "BF048",
   SHARED_PROGRAM_REQUIRED: "BF050",
   WRONG_PACKAGE_IMPORT: "BF051",
   BUILTIN_REQUIRES_IMPORT: "BF054",
@@ -2138,6 +2196,7 @@ var errorMessages = {
   [ErrorCodes.JSX_IN_LOCAL_FUNCTION]: "Local function returns JSX but cannot be inlined. Extract it as a top-level PascalCase component or use a single return statement.",
   [ErrorCodes.COMPONENT_REQUIRED_PROP_MISSING]: "Built-in component is missing a required prop.",
   [ErrorCodes.JSX_BRANCH_LOCAL_IN_CALLBACK]: "JSX-typed local declared inside an `if`-block cannot be referenced from a callback body (ref / event handler). " + "Render it as a child instead: `<div ref={...}>{local}</div>`.",
+  [ErrorCodes.SIBLING_COMPONENT_NOT_COMPILED]: "Referenced component did not compile to a template, so this reference would throw " + "`ReferenceError` at render time. Multi-return JSX dispatch (a `switch` or `if`/`else` " + "chain across multiple JSX-returning branches) cannot compile as a component in a " + `'use client' file. Extract it to a separate non-"use client" file (where it is preserved ` + "verbatim, see #932), or rewrite it as a single-return ternary/conditional chain so the " + "component pipeline can compile it.",
   [ErrorCodes.SHARED_PROGRAM_REQUIRED]: "Shared ts.Program required for type-based reactivity classification. This source imports a Reactive<T>-branded library (e.g. @barefootjs/form) whose getters cannot be classified by regex alone. Pass `options.program` (built via `createProgramForCorpus`) so the analyzer can resolve the brand through the TypeChecker.",
   [ErrorCodes.WRONG_PACKAGE_IMPORT]: "Import from wrong package.",
   [ErrorCodes.BUILTIN_REQUIRES_IMPORT]: "Built-in <Async> / <Region> must be imported from '@barefootjs/client'. " + "The compiler recognises these tags by their import (not by tag name), " + "so an unimported tag with this name is treated as an undeclared component.",
@@ -2311,6 +2370,54 @@ var CLIENT_EXPORTS = new Set([
   "Async",
   "Region"
 ]);
+function extractFreeIdentifiersFromNode(node) {
+  const ids = new Set;
+  const boundNames = new Set;
+  function addBindingNames(name, out) {
+    if (ts9.isIdentifier(name))
+      out.push(name.text);
+    else if (ts9.isObjectBindingPattern(name))
+      name.elements.forEach((e) => addBindingNames(e.name, out));
+    else if (ts9.isArrayBindingPattern(name))
+      name.elements.forEach((e) => {
+        if (!ts9.isOmittedExpression(e))
+          addBindingNames(e.name, out);
+      });
+  }
+  function visit(n) {
+    if (ts9.isTypeNode(n))
+      return;
+    if (ts9.isIdentifier(n)) {
+      const parent = n.parent;
+      if (parent && ts9.isPropertyAccessExpression(parent) && parent.name === n)
+        return;
+      if (parent && ts9.isPropertyAssignment(parent) && parent.name === n)
+        return;
+      if (parent && ts9.isParameter(parent) && parent.name === n)
+        return;
+      if (parent && ts9.isVariableDeclaration(parent) && parent.name === n)
+        return;
+      if (boundNames.has(n.text))
+        return;
+      ids.add(n.text);
+      return;
+    }
+    if (ts9.isArrowFunction(n)) {
+      const params = [];
+      for (const p of n.parameters)
+        addBindingNames(p.name, params);
+      for (const name of params)
+        boundNames.add(name);
+      ts9.forEachChild(n, visit);
+      for (const name of params)
+        boundNames.delete(name);
+      return;
+    }
+    ts9.forEachChild(n, visit);
+  }
+  visit(node);
+  return ids;
+}
 var BROWSER_ONLY_CLIENT_APIS = new Set([
   "useContext",
   "provideContext",
@@ -2329,7 +2436,7 @@ var REACTIVE_PRIMITIVES = new Set([
 ]);
 
 // ../jsx/src/jsx-to-ir.ts
-import ts11 from "typescript";
+import ts12 from "typescript";
 
 // ../jsx/src/types.ts
 var SCOPE_FORBIDDEN = {
@@ -2411,10 +2518,10 @@ function findReachableNames(primaryRefs, declarations) {
 }
 
 // ../jsx/src/reactivity-checker.ts
-import ts9 from "typescript";
+import ts10 from "typescript";
 
 // ../jsx/src/free-refs.ts
-import ts10 from "typescript";
+import ts11 from "typescript";
 var _bindingMapCache = new WeakMap;
 
 // ../jsx/src/to-locale-date-lowering.ts
@@ -2828,13 +2935,13 @@ var KEYWORDS_AND_GLOBALS = new Set([
 ]);
 
 // ../jsx/src/ir-to-client-js/walk-prop-accesses.ts
-import ts12 from "typescript";
+import ts13 from "typescript";
 
 // ../jsx/src/value-references.ts
-import ts13 from "typescript";
+import ts14 from "typescript";
 
 // ../jsx/src/relocate.ts
-import ts14 from "typescript";
+import ts15 from "typescript";
 
 // ../jsx/src/lowering-registry.ts
 var plugins = [];
@@ -3051,10 +3158,10 @@ function matchSearchParamsMethodCall(callee, args, localNames) {
 }
 
 // ../jsx/src/ir-to-client-js/prune-unused-prop-extractions.ts
-import ts15 from "typescript";
+import ts16 from "typescript";
 
 // ../jsx/src/ir-to-client-js/control-flow/plan/lazy-preamble.ts
-import ts16 from "typescript";
+import ts17 from "typescript";
 var NO_PREAMBLE = {
   lazySafe: true,
   facts: { declaredNames: new Set, freeNames: new Set }
@@ -3104,7 +3211,7 @@ var INERT_BINDING_GLOBALS = new Set([
 ]);
 
 // ../jsx/src/ir-to-client-js/emit-reactive.ts
-import ts17 from "typescript";
+import ts18 from "typescript";
 
 // ../jsx/src/ir-to-client-js/control-flow/stringify/event-delegation.ts
 var NON_BUBBLING_EVENTS = new Set([
@@ -3119,7 +3226,7 @@ var NON_BUBBLING_EVENTS = new Set([
 ]);
 
 // ../jsx/src/ir-to-client-js/rewrite-props-object.ts
-import ts18 from "typescript";
+import ts19 from "typescript";
 
 // ../jsx/src/ir-to-client-js/source-map.ts
 var BASE64_CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
@@ -3210,15 +3317,15 @@ class SourceMapGenerator {
 }
 
 // ../jsx/src/preprocess-inline-jsx-callbacks.ts
-import ts19 from "typescript";
+import ts20 from "typescript";
 
 // ../jsx/src/ssr-defaults.ts
-import ts20 from "typescript";
+import ts21 from "typescript";
 var UNRESOLVED = Symbol("unresolved");
 var NO_RETURN = Symbol("no-return");
 
 // ../jsx/src/augment-inherited-props.ts
-import ts21 from "typescript";
+import ts22 from "typescript";
 function collectContextConsumers(metadata) {
   const constants = metadata.localConstants ?? [];
   const contextDefaults = new Map;
@@ -3250,47 +3357,47 @@ function collectContextConsumers(metadata) {
 }
 function parseUseContextArg(source) {
   const expr = parseSingleExpression(source);
-  if (!expr || !ts21.isCallExpression(expr))
+  if (!expr || !ts22.isCallExpression(expr))
     return null;
-  if (!ts21.isIdentifier(expr.expression) || expr.expression.text !== "useContext")
+  if (!ts22.isIdentifier(expr.expression) || expr.expression.text !== "useContext")
     return null;
   if (expr.arguments.length !== 1)
     return null;
   const arg = expr.arguments[0];
-  return ts21.isIdentifier(arg) ? arg.text : null;
+  return ts22.isIdentifier(arg) ? arg.text : null;
 }
 function parseCreateContextDefault(source) {
   const expr = parseSingleExpression(source);
-  if (!expr || !ts21.isCallExpression(expr))
+  if (!expr || !ts22.isCallExpression(expr))
     return null;
   if (expr.arguments.length === 0)
     return null;
   const arg = expr.arguments[0];
-  if (ts21.isStringLiteral(arg) || ts21.isNoSubstitutionTemplateLiteral(arg))
+  if (ts22.isStringLiteral(arg) || ts22.isNoSubstitutionTemplateLiteral(arg))
     return arg.text;
-  if (ts21.isNumericLiteral(arg))
+  if (ts22.isNumericLiteral(arg))
     return Number(arg.text);
-  if (arg.kind === ts21.SyntaxKind.TrueKeyword)
+  if (arg.kind === ts22.SyntaxKind.TrueKeyword)
     return true;
-  if (arg.kind === ts21.SyntaxKind.FalseKeyword)
+  if (arg.kind === ts22.SyntaxKind.FalseKeyword)
     return false;
   return null;
 }
 function isObjectLiteralCreateContextDefault(source) {
   const expr = parseSingleExpression(source);
-  if (!expr || !ts21.isCallExpression(expr))
+  if (!expr || !ts22.isCallExpression(expr))
     return false;
   if (expr.arguments.length === 0)
     return false;
-  return ts21.isObjectLiteralExpression(expr.arguments[0]);
+  return ts22.isObjectLiteralExpression(expr.arguments[0]);
 }
 function parseSingleExpression(source) {
-  const sf = ts21.createSourceFile("__ctx.ts", `(${source})`, ts21.ScriptTarget.Latest, false);
+  const sf = ts22.createSourceFile("__ctx.ts", `(${source})`, ts22.ScriptTarget.Latest, false);
   const stmt = sf.statements[0];
-  if (!stmt || !ts21.isExpressionStatement(stmt))
+  if (!stmt || !ts22.isExpressionStatement(stmt))
     return null;
   let e = stmt.expression;
-  while (ts21.isParenthesizedExpression(e))
+  while (ts22.isParenthesizedExpression(e))
     e = e.expression;
   return e;
 }
@@ -3315,25 +3422,25 @@ function augmentInheritedPropAccesses(ir) {
   const pinCoalesceLiterals = (s) => {
     if (!s || !s.includes(propsObj))
       return;
-    const sf = ts21.createSourceFile("__aug.ts", `(${s})`, ts21.ScriptTarget.Latest, false);
+    const sf = ts22.createSourceFile("__aug.ts", `(${s})`, ts22.ScriptTarget.Latest, false);
     const visit = (n) => {
-      if (ts21.isBinaryExpression(n) && (n.operatorToken.kind === ts21.SyntaxKind.QuestionQuestionToken || n.operatorToken.kind === ts21.SyntaxKind.BarBarToken)) {
+      if (ts22.isBinaryExpression(n) && (n.operatorToken.kind === ts22.SyntaxKind.QuestionQuestionToken || n.operatorToken.kind === ts22.SyntaxKind.BarBarToken)) {
         let left = n.left;
-        while (ts21.isParenthesizedExpression(left))
+        while (ts22.isParenthesizedExpression(left))
           left = left.expression;
-        if (ts21.isPropertyAccessExpression(left) && ts21.isIdentifier(left.expression) && left.expression.text === propsObj) {
+        if (ts22.isPropertyAccessExpression(left) && ts22.isIdentifier(left.expression) && left.expression.text === propsObj) {
           const name = left.name.text;
           let right = n.right;
-          while (ts21.isParenthesizedExpression(right))
+          while (ts22.isParenthesizedExpression(right))
             right = right.expression;
-          if (ts21.isPrefixUnaryExpression(right))
+          if (ts22.isPrefixUnaryExpression(right))
             right = right.operand;
-          const kind = ts21.isNumericLiteral(right) ? "number" : right.kind === ts21.SyntaxKind.TrueKeyword || right.kind === ts21.SyntaxKind.FalseKeyword ? "boolean" : ts21.isStringLiteralLike(right) ? "string" : null;
+          const kind = ts22.isNumericLiteral(right) ? "number" : right.kind === ts22.SyntaxKind.TrueKeyword || right.kind === ts22.SyntaxKind.FalseKeyword ? "boolean" : ts22.isStringLiteralLike(right) ? "string" : null;
           if (kind && !coalesceLiteralTypes.has(name))
             coalesceLiteralTypes.set(name, kind);
         }
       }
-      ts21.forEachChild(n, visit);
+      ts22.forEachChild(n, visit);
     };
     visit(sf);
   };
@@ -3444,33 +3551,33 @@ function augmentInheritedPropAccesses(ir) {
   }
 }
 function parseStaticStringConst(source) {
-  const sf = ts21.createSourceFile("__const.ts", `const __x = (${source});`, ts21.ScriptTarget.Latest, false);
+  const sf = ts22.createSourceFile("__const.ts", `const __x = (${source});`, ts22.ScriptTarget.Latest, false);
   const stmt = sf.statements[0];
-  if (!stmt || !ts21.isVariableStatement(stmt))
+  if (!stmt || !ts22.isVariableStatement(stmt))
     return null;
   let init = stmt.declarationList.declarations[0]?.initializer;
-  while (init && ts21.isParenthesizedExpression(init))
+  while (init && ts22.isParenthesizedExpression(init))
     init = init.expression;
   if (!init)
     return null;
-  if (ts21.isStringLiteral(init) || ts21.isNoSubstitutionTemplateLiteral(init)) {
+  if (ts22.isStringLiteral(init) || ts22.isNoSubstitutionTemplateLiteral(init)) {
     return init.text;
   }
   return evalStringArrayJoin(source);
 }
 function evalTemplateOfStringConsts(source, resolved) {
-  const sf = ts21.createSourceFile("__const.ts", `const __x = (${source});`, ts21.ScriptTarget.Latest, false);
+  const sf = ts22.createSourceFile("__const.ts", `const __x = (${source});`, ts22.ScriptTarget.Latest, false);
   const stmt = sf.statements[0];
-  if (!stmt || !ts21.isVariableStatement(stmt))
+  if (!stmt || !ts22.isVariableStatement(stmt))
     return null;
   let init = stmt.declarationList.declarations[0]?.initializer;
-  while (init && ts21.isParenthesizedExpression(init))
+  while (init && ts22.isParenthesizedExpression(init))
     init = init.expression;
-  if (!init || !ts21.isTemplateExpression(init))
+  if (!init || !ts22.isTemplateExpression(init))
     return null;
   let out = init.head.text;
   for (const span of init.templateSpans) {
-    if (!ts21.isIdentifier(span.expression))
+    if (!ts22.isIdentifier(span.expression))
       return null;
     const value = resolved.get(span.expression.text);
     if (value === undefined)
@@ -3501,30 +3608,30 @@ function lookupStaticRecordLiteral(objectName, key, constants) {
   const constInfo = (constants ?? []).find((c) => c.name === objectName && c.isModule);
   if (constInfo?.value === undefined)
     return null;
-  const sf = ts21.createSourceFile("__rec.ts", `(${constInfo.value})`, ts21.ScriptTarget.Latest, true);
+  const sf = ts22.createSourceFile("__rec.ts", `(${constInfo.value})`, ts22.ScriptTarget.Latest, true);
   if (sf.statements.length !== 1)
     return null;
   const stmt = sf.statements[0];
-  if (!ts21.isExpressionStatement(stmt))
+  if (!ts22.isExpressionStatement(stmt))
     return null;
   let parsed = stmt.expression;
-  while (ts21.isParenthesizedExpression(parsed))
+  while (ts22.isParenthesizedExpression(parsed))
     parsed = parsed.expression;
-  if (!ts21.isObjectLiteralExpression(parsed))
+  if (!ts22.isObjectLiteralExpression(parsed))
     return null;
   for (const prop of parsed.properties) {
-    if (!ts21.isPropertyAssignment(prop))
+    if (!ts22.isPropertyAssignment(prop))
       continue;
     const name = prop.name;
-    const propKey = ts21.isIdentifier(name) || ts21.isStringLiteral(name) || ts21.isNoSubstitutionTemplateLiteral(name) ? name.text : null;
+    const propKey = ts22.isIdentifier(name) || ts22.isStringLiteral(name) || ts22.isNoSubstitutionTemplateLiteral(name) ? name.text : null;
     if (propKey !== key)
       continue;
     let v = prop.initializer;
-    while (ts21.isParenthesizedExpression(v))
+    while (ts22.isParenthesizedExpression(v))
       v = v.expression;
-    if (ts21.isNumericLiteral(v))
+    if (ts22.isNumericLiteral(v))
       return { kind: "number", text: v.text };
-    if (ts21.isStringLiteral(v) || ts21.isNoSubstitutionTemplateLiteral(v)) {
+    if (ts22.isStringLiteral(v) || ts22.isNoSubstitutionTemplateLiteral(v)) {
       return { kind: "string", text: v.text };
     }
     return null;
@@ -3532,28 +3639,28 @@ function lookupStaticRecordLiteral(objectName, key, constants) {
   return null;
 }
 function evalStringArrayJoin(source) {
-  const sf = ts21.createSourceFile("__join.ts", `const __x = (${source});`, ts21.ScriptTarget.Latest, false);
+  const sf = ts22.createSourceFile("__join.ts", `const __x = (${source});`, ts22.ScriptTarget.Latest, false);
   const stmt = sf.statements[0];
-  if (!stmt || !ts21.isVariableStatement(stmt))
+  if (!stmt || !ts22.isVariableStatement(stmt))
     return null;
   let node = stmt.declarationList.declarations[0]?.initializer;
-  while (node && ts21.isParenthesizedExpression(node))
+  while (node && ts22.isParenthesizedExpression(node))
     node = node.expression;
-  if (!node || !ts21.isCallExpression(node))
+  if (!node || !ts22.isCallExpression(node))
     return null;
   const callee = node.expression;
-  if (!ts21.isPropertyAccessExpression(callee))
+  if (!ts22.isPropertyAccessExpression(callee))
     return null;
   if (callee.name.text !== "join")
     return null;
   let recv = callee.expression;
-  while (ts21.isParenthesizedExpression(recv))
+  while (ts22.isParenthesizedExpression(recv))
     recv = recv.expression;
-  if (!ts21.isArrayLiteralExpression(recv))
+  if (!ts22.isArrayLiteralExpression(recv))
     return null;
   const parts = [];
   for (const el of recv.elements) {
-    if (ts21.isStringLiteral(el) || ts21.isNoSubstitutionTemplateLiteral(el)) {
+    if (ts22.isStringLiteral(el) || ts22.isNoSubstitutionTemplateLiteral(el)) {
       parts.push(el.text);
     } else {
       return null;
@@ -3562,7 +3669,7 @@ function evalStringArrayJoin(source) {
   let sep = ",";
   if (node.arguments.length >= 1) {
     const arg = node.arguments[0];
-    if (ts21.isStringLiteral(arg) || ts21.isNoSubstitutionTemplateLiteral(arg))
+    if (ts22.isStringLiteral(arg) || ts22.isNoSubstitutionTemplateLiteral(arg))
       sep = arg.text;
     else
       return null;
@@ -3570,11 +3677,11 @@ function evalStringArrayJoin(source) {
   return parts.join(sep);
 }
 function parseRecordIndexAccess(val, localConstants, propsParams, resolveKey) {
-  if (!ts21.isElementAccessExpression(val))
+  if (!ts22.isElementAccessExpression(val))
     return null;
   const obj = val.expression;
   const arg = val.argumentExpression;
-  if (!ts21.isIdentifier(obj) || !ts21.isIdentifier(arg))
+  if (!ts22.isIdentifier(obj) || !ts22.isIdentifier(arg))
     return null;
   let indexPropName;
   let defaultKey;
@@ -3590,35 +3697,35 @@ function parseRecordIndexAccess(val, localConstants, propsParams, resolveKey) {
   const constInfo = localConstants.find((c) => c.name === obj.text && c.isModule);
   if (constInfo?.value === undefined)
     return null;
-  const sf = ts21.createSourceFile("__rec.ts", `(${constInfo.value})`, ts21.ScriptTarget.Latest, true);
+  const sf = ts22.createSourceFile("__rec.ts", `(${constInfo.value})`, ts22.ScriptTarget.Latest, true);
   if (sf.statements.length !== 1)
     return null;
   const stmt = sf.statements[0];
-  if (!ts21.isExpressionStatement(stmt))
+  if (!ts22.isExpressionStatement(stmt))
     return null;
   let parsed = stmt.expression;
-  while (ts21.isParenthesizedExpression(parsed))
+  while (ts22.isParenthesizedExpression(parsed))
     parsed = parsed.expression;
-  if (!ts21.isObjectLiteralExpression(parsed))
+  if (!ts22.isObjectLiteralExpression(parsed))
     return null;
   const entries = [];
   for (const prop of parsed.properties) {
-    if (!ts21.isPropertyAssignment(prop))
+    if (!ts22.isPropertyAssignment(prop))
       return null;
     let key;
-    if (ts21.isIdentifier(prop.name)) {
+    if (ts22.isIdentifier(prop.name)) {
       key = prop.name.text;
-    } else if (ts21.isStringLiteral(prop.name) || ts21.isNoSubstitutionTemplateLiteral(prop.name)) {
+    } else if (ts22.isStringLiteral(prop.name) || ts22.isNoSubstitutionTemplateLiteral(prop.name)) {
       key = prop.name.text;
     } else {
       return null;
     }
     let v = prop.initializer;
-    while (ts21.isParenthesizedExpression(v))
+    while (ts22.isParenthesizedExpression(v))
       v = v.expression;
-    if (ts21.isNumericLiteral(v)) {
+    if (ts22.isNumericLiteral(v)) {
       entries.push({ key, value: { kind: "number", text: v.text } });
-    } else if (ts21.isStringLiteral(v) || ts21.isNoSubstitutionTemplateLiteral(v)) {
+    } else if (ts22.isStringLiteral(v) || ts22.isNoSubstitutionTemplateLiteral(v)) {
       entries.push({ key, value: { kind: "string", text: v.text } });
     } else {
       return null;
@@ -3674,7 +3781,7 @@ function computeSsrSeedPlan(metadata) {
 // ../jsx/src/rich-type-refusal.ts
 var EMPTY_BINDINGS2 = new Map;
 // ../jsx/src/shared-program.ts
-import ts22 from "typescript";
+import ts24 from "typescript";
 // ../jsx/src/adapters/interface.ts
 class BaseAdapter {
   renderChildren(children) {
@@ -3750,7 +3857,7 @@ class JsxAdapter extends BaseAdapter {
       }
       const rawInitialValue = preserveTypes ? signal.typedInitialValue ?? signal.initialValue : signal.initialValue;
       const initialValue = rawInitialValue.trim().startsWith("{") ? `(${rawInitialValue})` : rawInitialValue;
-      const needsTypeAssertion = preserveTypes && !signal.typedInitialValue && signal.type.kind !== "unknown" && signal.type.kind !== "primitive";
+      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 {
@@ -3769,12 +3876,16 @@ class JsxAdapter extends BaseAdapter {
       const computation = preserveTypes ? memo.typedComputation ?? memo.computation : memo.computation;
       lines.push(`  const ${memo.name} = ${computation}`);
     }
+    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}`);
+        const typeAnnotation = preserveTypes && constant.type ? `: ${constant.type.raw}` : "";
+        lines.push(`  ${keyword} ${constant.name}${typeAnnotation}`);
         continue;
       }
       const value = constant.value.trim();
@@ -3786,6 +3897,8 @@ class JsxAdapter extends BaseAdapter {
       lines.push(`  ${keyword} ${constant.name} = ${constValue}`);
     }
     for (const func of localFunctions) {
+      if (moduleScopeNames.has(func.name))
+        continue;
       if (!reachable.has(func.name))
         continue;
       const params = preserveTypes && func.typedParams !== undefined ? func.typedParams : func.params.map(formatParamWithType).join(", ");
@@ -3795,6 +3908,125 @@ class JsxAdapter extends BaseAdapter {
       lines.push(`  ${asyncKw}function ${func.name}(${params})${returnAnnotation} ${body}`);
     }
     return lines.join(`
+`);
+  }
+  moduleScopeNamesCache = new WeakMap;
+  moduleScopeDeclarationNames(ir) {
+    const cached = this.moduleScopeNamesCache.get(ir);
+    if (cached)
+      return cached;
+    const componentScope = new Set;
+    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);
+    }
+    const exported = new Set;
+    const candidates = new Map;
+    for (const c of ir.metadata.localConstants) {
+      if (!c.isModule)
+        continue;
+      if (c.isJsx || c.isJsxFunction)
+        continue;
+      if (c.isExported) {
+        exported.add(c.name);
+        continue;
+      }
+      candidates.set(c.name, c.freeIdentifiers ?? extractFreeIdentifiersFromText(c.value ?? ""));
+    }
+    for (const f of ir.metadata.localFunctions) {
+      if (!f.isModule)
+        continue;
+      if (f.isJsxFunction || f.isMultiReturnJsxHelper)
+        continue;
+      if (f.isExported) {
+        exported.add(f.name);
+        continue;
+      }
+      const params = f.typedParams !== undefined ? f.typedParams : f.params.map(formatParamWithType).join(", ");
+      candidates.set(f.name, extractFreeIdentifiersFromText(`(${params}) => ${f.body}`));
+    }
+    const referencesAny = (refs, names) => {
+      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;
+  }
+  generateModuleScopeDeclarations(ir) {
+    const { preserveTypes } = this.jsxConfig;
+    const moduleNames = this.moduleScopeDeclarationNames(ir);
+    const entries = [];
+    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(`
 `);
   }
   renderNodeRaw(node) {
@@ -3806,6 +4038,15 @@ class JsxAdapter extends BaseAdapter {
     }
     return this.renderNode(node);
   }
+  renderTemplatePartsAsJs(parts) {
+    return templatePartsToJsExpr(parts, { typed: this.jsxConfig.preserveTypes });
+  }
+  expressionValueToJs(value) {
+    if (this.jsxConfig.preserveTypes && value.parts && value.expr === templatePartsToJsExpr(value.parts)) {
+      return this.renderTemplatePartsAsJs(value.parts);
+    }
+    return value.expr;
+  }
   renderScopeMarker(instanceIdExpr) {
     return `${BF_SCOPE}={${instanceIdExpr}}`;
   }
@@ -3873,6 +4114,7 @@ class TestAdapter extends JsxAdapter {
   generate(ir) {
     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);
     const defaultExport = ir.metadata.hasDefaultExport ? `
@@ -3881,9 +4123,11 @@ export default ${this.componentName}` : "";
       imports,
       types: types || "",
       component,
-      defaultExport
+      defaultExport,
+      moduleConstants,
+      moduleConstantsIncludeExports: true
     };
-    const template = [imports, types, component].filter(Boolean).join(`
+    const template = [imports, moduleConstants, types, component].filter(Boolean).join(`
 
 `) + defaultExport;
     return {
@@ -3914,9 +4158,6 @@ export default ${this.componentName}` : "";
   }
   generateTypes(ir) {
     const lines = [];
-    for (const typeDef of ir.metadata.typeDefinitions) {
-      lines.push(typeDef.definition);
-    }
     const propsTypeName = ir.metadata.propsType?.raw;
     if (propsTypeName && !ir.metadata.propsObjectName) {
       lines.push("");
@@ -3939,7 +4180,7 @@ export default ${this.componentName}` : "";
     const bodyRefText = [jsxBody, signalInits, scopeIdLine].join(`
 `);
     const bfScopeAlias = /\b__bfScope\b/.test(bodyRefText) ? "__bfScope" : "__bfScope: _bfScope";
-    const propsParams = ir.metadata.propsParams.map((p) => p.defaultValue ? `${p.name} = ${p.defaultValue}` : p.name).join(", ");
+    const propsParams = ir.metadata.propsParams.map((p) => propsDestructureBinding(p)).join(", ");
     const restPropsName = ir.metadata.restPropsName;
     const hydrationProps = `__instanceId, ${bfScopeAlias}`;
     const parts = [];
@@ -4086,13 +4327,7 @@ export default ${this.componentName}` : "";
   }
   flattenTemplate(value) {
     const v = value;
-    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);
   }
   renderComponentProps(comp) {
     const parts = [];
@@ -4587,7 +4822,7 @@ function dangerousInnerHtmlDiagnostic(expr, loc, reason) {
   };
 }
 // ../jsx/src/combine-client-js.ts
-import ts23 from "typescript";
+import ts25 from "typescript";
 // ../jsx/src/loop-destructure.ts
 function isLowerableLoopDestructure(loop) {
   const bindings = loop.paramBindings;
@@ -4727,9 +4962,9 @@ function escapeRe(s) {
   return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 // ../jsx/src/debug.ts
-import ts24 from "typescript";
+import ts26 from "typescript";
 // ../jsx/src/profiler.ts
-import ts25 from "typescript";
+import ts27 from "typescript";
 
 // ../jsx/src/index.ts
 registerBuiltinLoweringPlugins();
@@ -5555,7 +5790,7 @@ function collectImportedLoopChildComponentErrors(ir, componentName) {
 }
 
 // src/adapter/spread/spread-codegen.ts
-import ts26 from "typescript";
+import ts28 from "typescript";
 function conditionalSpreadToPerl(ctx, expr) {
   if (!expr || expr.kind !== "conditional")
     return null;
@@ -5610,7 +5845,7 @@ function recordIndexAccessToPerl(ctx, val) {
   if (val.kind !== "index-access" || val.object.kind !== "identifier" || val.index.kind !== "identifier") {
     return null;
   }
-  const tsVal = ts26.factory.createElementAccessExpression(ts26.factory.createIdentifier(val.object.name), ts26.factory.createIdentifier(val.index.name));
+  const tsVal = ts28.factory.createElementAccessExpression(ts28.factory.createIdentifier(val.object.name), ts28.factory.createIdentifier(val.index.name));
   const parsed = parseRecordIndexAccess(tsVal, ctx.localConstants, ctx.propsParams);
   if (!parsed)
     return null;

package/lib/BarefootJS/Backend/Mojo.pm

@@ -1,5 +1,5 @@
 package BarefootJS::Backend::Mojo;
-our $VERSION = "0.31.0";
+our $VERSION = "0.31.1";
 use Mojo::Base -base, -signatures;
 
 use Mojo::ByteStream qw(b);

package/lib/Mojolicious/Plugin/BarefootJS/DevReload.pm

@@ -1,5 +1,5 @@
 package Mojolicious::Plugin::BarefootJS::DevReload;
-our $VERSION = "0.31.0";
+our $VERSION = "0.31.1";
 use Mojo::Base 'Mojolicious::Plugin', -signatures;
 
 =head1 NAME

package/lib/Mojolicious/Plugin/BarefootJS.pm

@@ -1,5 +1,5 @@
 package Mojolicious::Plugin::BarefootJS;
-our $VERSION = "0.31.0";
+our $VERSION = "0.31.1";
 use Mojo::Base 'Mojolicious::Plugin', -signatures;
 
 use Mojo::File qw(path);
@@ -110,15 +110,41 @@ sub register ($self, $app, $config = {}) {
         $bf->_scope_id($template . '_' . substr(rand() =~ s/^0\.//r, 0, 6));
         $bf->register_components_from_manifest($m);
 
-        # Seed each ssrDefault into the stash unless the caller has
-        # already supplied a value for that key — callers always win.
+        # Seed each ssrDefault into the stash unless the caller has already
+        # supplied a value for that key — callers always win. Resolved
+        # through the production `BarefootJS::_derive_stash_from_defaults`
+        # (the same call `register_components_from_manifest` above makes for
+        # child components) so an aliased destructured prop's CALLER-facing
+        # key (`propName`, e.g. `n` for `{ n: count }`) is honoured — the
+        # caller stash IS the props document for a top-level render (a route
+        # handler sets `$c->stash(n => 5)` before `$c->render(...)`).
+        # Resolving `$d->{value}` directly, ignoring `propName`, was the
+        # #2524 production bug: it could never see a caller-supplied `n`,
+        # only ever the static default.
+        #
+        # CONSTRAINT (documented, not fixed): because the caller stash IS
+        # the props document here, `propName` resolution also sees every
+        # key Mojolicious itself already populates on `$c->stash` before
+        # this hook runs — `action`, `controller`, `template`,
+        # `template_class`, and friends (Mojolicious::Controller's own
+        # reserved stash keys). A ROOT-level component whose destructured
+        # prop happens to alias FROM one of those names (e.g. `{ action:
+        # label }`) resolves `propName => 'action'` against Mojo's OWN
+        # internal value, not a genuinely absent prop — the component
+        # silently picks up the current route's action name instead of its
+        # static default. This can't collide for a CHILD render
+        # (`register_components_from_manifest`'s renderer closure passes a
+        # fresh, purpose-built props hash, never the live `$c->stash`), only
+        # for a root-level render where the stash doubles as both Mojo's
+        # own bookkeeping and the props document. Avoid destructuring a prop
+        # named `action`/`controller`/`template`/`template_class`/etc. on a
+        # ROOT component if this matters to you.
         my $defaults = $entry->{ssrDefaults};
         if (ref($defaults) eq 'HASH') {
-            for my $name (keys %$defaults) {
+            my %extra = BarefootJS::_derive_stash_from_defaults($defaults, $c->stash);
+            for my $name (keys %extra) {
                 next if exists $c->stash->{$name};
-                my $d = $defaults->{$name};
-                my $value = ref($d) eq 'HASH' ? $d->{value} : $d;
-                $c->stash->{$name} = $value;
+                $c->stash->{$name} = $extra{$name};
             }
         }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@barefootjs/mojolicious",
-  "version": "0.31.1",
+  "version": "0.31.2",
   "description": "Mojolicious EP template adapter for BarefootJS - generates .html.ep files from IR",
   "type": "module",
   "main": "./dist/index.js",
@@ -52,7 +52,7 @@
     "directory": "packages/adapter-mojolicious"
   },
   "dependencies": {
-    "@barefootjs/shared": "0.31.1"
+    "@barefootjs/shared": "0.31.2"
   },
   "peerDependencies": {
     "@barefootjs/jsx": ">=0.2.0",
@@ -70,9 +70,9 @@
   },
   "devDependencies": {
     "@barefootjs/adapter-tests": "0.1.0",
-    "@barefootjs/jsx": "0.31.1",
-    "@barefootjs/vite": "0.31.1",
-    "@barefootjs/client": "0.31.1",
+    "@barefootjs/jsx": "0.31.2",
+    "@barefootjs/vite": "0.31.2",
+    "@barefootjs/client": "0.31.2",
     "vite": "^6.0.0"
   }
 }

package/src/render-divergences.ts

@@ -20,20 +20,4 @@ export const renderDivergences: RenderDivergences = {
   // instead of a fixed regex-shape catalogue) now correctly seeds `todos`
   // from `(props.initialTodos ?? []).map(t => ({ ...t, editing: false }))`.
 
-  // Onboarding TSX-fidelity fixtures (PR #2461): `expectedHtml` was
-  // hand-authored to the CORRECT output while the emission bug lived in
-  // the shared compiler layer — every adapter, including the Hono
-  // reference, used to emit the broken form. That shared-layer defect
-  // (#2460) is now FIXED (b4f5075): `expectedHtml` is generated from the
-  // Hono reference like any other fixture. The remaining gap is
-  // per-template-adapter — this adapter still keys its template vars /
-  // ssr-defaults / props bridge off the local binding instead of
-  // `sourceName ?? name` — tracked by #2524 (the 7 silent template
-  // adapters). Graduate by applying the same `sourceName ?? name` fix to
-  // this adapter's emission path and deleting these lines (and the
-  // matching hono `skipJsx` entries, already gone).
-  'aliased-destructured-prop':
-    'aliased destructured prop `{ n: count }` loses its rename — template vars, ssr-defaults, and the props bridge all key off the local name, so the prop is always undefined (https://github.com/piconic-ai/barefootjs/issues/2524)',
-  'composite-row-child-aliased-prop':
-    'same defect as `aliased-destructured-prop` (#2524), inside a keyed `.map()` loop row: the nested child\'s renamed prop (`{ n: count }`) is always undefined, so both rows render an empty count (https://github.com/piconic-ai/barefootjs/issues/2524)',
 }

package/src/test-render.ts

@@ -5,8 +5,8 @@
  * Used by adapter-tests conformance runner.
  */
 
-import { compileJSX, extractSsrDefaults, augmentInheritedPropAccesses, importsSearchParams, evaluateSignalInit, tryEvaluateSignalInit } from '@barefootjs/jsx'
-import type { ComponentIR } from '@barefootjs/jsx'
+import { compileJSX, extractSsrDefaults, deriveStashFromDefaults, augmentInheritedPropAccesses, importsSearchParams, evaluateSignalInit } from '@barefootjs/jsx'
+import type { ComponentIR, SsrDefault } from '@barefootjs/jsx'
 import { mkdir, rm } from 'node:fs/promises'
 import { resolve } from 'node:path'
 
@@ -376,8 +376,10 @@ function buildChildRenderers(
       // (#1897) Route non-param props into the rest bag (JSX rest
       // semantics): a caller prop the child didn't destructure belongs
       // in the bag, not as a top-level stash var. Mirrors the Xslate
-      // harness and the production isRestProps branch.
-      const paramNames = (childIR.metadata.propsParams ?? []).map(p => p.name)
+      // harness and the production isRestProps branch. Keep-set uses
+      // CALLER-facing names (`sourceName ?? name`) — `$child_props` is
+      // keyed by whatever the calling template passed (#2524).
+      const paramNames = (childIR.metadata.propsParams ?? []).map(p => p.sourceName ?? p.name)
       const keepList = [...new Set([...paramNames, rest, 'children', 'key', '_bf_slot'])]
         .map(n => `'${n.replace(/[\\']/g, m => `\\${m}`)}'`)
         .join(', ')
@@ -408,9 +410,16 @@ function buildChildRenderers(
     lines.push(`    } else {`)
     lines.push(`      $child_bf->_scope_id('${componentName}_' . substr(rand() =~ s/^0\\.//r, 0, 6));`)
     lines.push(`    }`)
-    // Seed statically-derived defaults under the caller's props (#1897)
-    // so undeclared optional props / signals don't abort strict vars.
-    lines.push(`    my $rendered = $child_mt->render($child_tmpl, { %$defaults_${snakeName}, %$child_props, bf => $child_bf });`)
+    // Seed statically-derived defaults under the caller's props (#1897) so
+    // undeclared optional props / signals don't abort strict vars — through
+    // the production `BarefootJS::_derive_stash_from_defaults`, which
+    // resolves each entry's `propName` against the REAL `$child_props`
+    // (falling back to the static `value`) instead of a flat merge that
+    // never resolves an aliased destructured prop's CALLER-facing key (`n`)
+    // onto its local template var (`count`) (#2524 SSR half). Caller props
+    // still win overall via the final merge.
+    lines.push(`    my %extra_${snakeName} = BarefootJS::_derive_stash_from_defaults($defaults_${snakeName}, $child_props);`)
+    lines.push(`    my $rendered = $child_mt->render($child_tmpl, { %$child_props, %extra_${snakeName}, bf => $child_bf });`)
     lines.push(`    die $rendered->to_string if ref $rendered;`)
     lines.push(`    chomp $rendered;`)
     lines.push(`    return $rendered;`)
@@ -441,10 +450,14 @@ function toSnakeCase(name: string): string {
  * `props.<x>` accesses, signal initial values, and memo ssrDefaults.
  * Without these, a child template referencing an optional prop the
  * caller didn't pass (`$id`, `$className`) or its own signal (`$open`)
- * aborts under Mojo::Template's strict vars. Caller-passed props win at
- * merge time (`{ %$defaults, %$child_props }`). Mirrors the root-side
- * seeding in `buildPerlProps` and the production plugin's
- * `ssrDefaults` consumption.
+ * aborts under Mojo::Template's strict vars. Caller-passed props are
+ * resolved at merge time through `BarefootJS::_derive_stash_from_defaults`
+ * (see `buildChildRenderers`), not a flat merge — declared-prop entries
+ * below are therefore emitted VERBATIM (`{value, propName?}`, from
+ * `extractSsrDefaults`, not flattened) so that resolution has an aliased
+ * prop's CALLER-facing key to read (#2524 SSR half). Mirrors the root-side
+ * seeding in `buildPerlProps` and the production plugin's `ssrDefaults`
+ * consumption.
  */
 function buildChildDefaultsPerl(ir: ComponentIR): string {
   // Surface inherited `props.<x>` reads hidden inside template-literal
@@ -454,16 +467,12 @@ function buildChildDefaultsPerl(ir: ComponentIR): string {
   augmentInheritedPropAccesses(ir)
   const entries: string[] = []
   const declared = new Set<string>()
+  const ssrDefaults = extractSsrDefaults(ir.metadata) ?? {}
   for (const param of ir.metadata.propsParams) {
+    if (param.isRest) continue
     declared.add(param.name)
-    if (param.defaultValue) {
-      const result = tryEvaluateSignalInit(param.defaultValue.trim())
-      if (result.ok) {
-        entries.push(`${param.name} => ${toPerlLiteral(result.value)}`)
-        continue
-      }
-    }
-    entries.push(`${param.name} => undef`)
+    const d = ssrDefaults[param.name]
+    entries.push(`${param.name} => ${d ? ssrDefaultEntryToPerl(d) : 'undef'}`)
   }
   if (ir.metadata.propsObjectName) {
     for (const name of collectPropsObjectAccesses(ir, ir.metadata.propsObjectName)) {
@@ -472,16 +481,33 @@ function buildChildDefaultsPerl(ir: ComponentIR): string {
       entries.push(`${name} => undef`)
     }
   }
+  // Signal / memo entries are emitted as BARE Perl values (not the
+  // `{value=>..., propName=>...}` hashref shape `ssrDefaultEntryToPerl`
+  // wraps declared-prop entries in). Under the merge-order flip
+  // (`buildChildRenderers`: `{ %$child_props, %extra, ... }`, extra applied
+  // LAST — see its docstring), a bare entry now wins over a same-named
+  // caller prop, same as it would over an un-mangled caller prop before the
+  // flip it lost to. This is NOT a regression to fix: `_derive_stash_from_
+  // defaults`'s non-hashref branch (`$extra{$name} = $d`, unconditional)
+  // and its hashref-with-no-`propName` branch (`else { $extra{$name} =
+  // $d->{value} }`) are BEHAVIORALLY IDENTICAL — both always use the
+  // static value, ignoring `$props` entirely — so wrapping these in
+  // `{value=>...}` would change nothing. A propName-less entry (signal /
+  // memo local) is BY DESIGN never sourced from props in ANY of the ported
+  // runtimes (see `ssr-defaults.ts`'s `deriveStashFromDefaults` docstring:
+  // "the caller cannot override them by construction") — the Jinja/Twig
+  // harnesses' own signal/memo entries (`{value: X}`, no `propName`) clobber
+  // a same-named caller prop the exact same way under their own extras-win
+  // merge. Mojolicious's bare-entry shape is a representation choice, not a
+  // semantic divergence from those adapters.
   for (const signal of ir.metadata.signals) {
     if (signal.envReader) continue // env signal is the request reader, not a stashed value (#2057)
     const value = evaluateSignalInit(signal.initialValue.trim(), undefined)
     entries.push(`${signal.getter} => ${value !== null ? toPerlLiteral(value) : 'undef'}`)
   }
-  const ssrDefaults = extractSsrDefaults(ir.metadata) ?? {}
   for (const memo of ir.metadata.memos) {
     const entry = ssrDefaults[memo.name]
-    const value =
-      entry && typeof entry === 'object' && 'value' in entry ? entry.value : undefined
+    const value = entry ? entry.value : undefined
     entries.push(
       `${memo.name} => ${value !== undefined && value !== null ? toPerlLiteral(value) : 'undef'}`,
     )
@@ -503,16 +529,18 @@ function buildPerlProps(
   const explicitScope = typeof props?.__instanceId === 'string' ? props.__instanceId : 'test'
   entries.push(`scope_id => '${escapePerlSingleQuoted(explicitScope)}'`)
 
-  // Add props params with defaults (before signals, so signals can reference them)
+  // Add props params with defaults (before signals, so signals can reference
+  // them). Seeded through the shared `deriveStashFromDefaults` (the TS twin
+  // of the production `BarefootJS::_derive_stash_from_defaults` this harness
+  // ALSO calls at render time for child components) so an aliased
+  // destructured prop's CALLER-facing key (`propName`, e.g. `n` for
+  // `{ n: count }`) is honoured, not just the local template var name
+  // (#2524 SSR half). `props` is keyed by the caller-facing name, exactly
+  // what `propName` resolves against.
+  const rootSsrDefaults = extractSsrDefaults(ir.metadata) ?? {}
+  const derivedProps = deriveStashFromDefaults(rootSsrDefaults, props ?? {})
   for (const param of ir.metadata.propsParams) {
-    if (props && param.name in props) continue
-    if (param.defaultValue) {
-      const result = tryEvaluateSignalInit(param.defaultValue.trim(), props)
-      if (result.ok) {
-        entries.push(`${param.name} => ${toPerlLiteral(result.value)}`)
-        continue
-      }
-    }
+    if (param.isRest) continue
     // No default and no caller-supplied value: pass `undef` so the
     // Mojo::Template `vars => 1` auto-declaration fires. Without
     // this, references to an optional prop variable (`$label`,
@@ -523,7 +551,8 @@ function buildPerlProps(
     // Surfaces with #1443: lowering `[a, b].filter(Boolean).join(' ')`
     // emits a literal `$label` reference where the BF101 path used
     // to emit `''`, exposing this latent test-harness gap.
-    entries.push(`${param.name} => undef`)
+    const value = derivedProps[param.name]
+    entries.push(`${param.name} => ${value !== undefined && value !== null ? toPerlLiteral(value) : 'undef'}`)
   }
 
   // (#checkbox) SolidJS props-object pattern: `function Checkbox(props:
@@ -554,7 +583,11 @@ function buildPerlProps(
   // rather than silently dropping it into an unused `my $placeholder`. (#1467
   // Phase 2b — mirrors the Go harness fix in the sibling `test-render.ts`.)
   const restPropsName = ir.metadata.restPropsName
-  const declaredParams = new Set(ir.metadata.propsParams.map(p => p.name))
+  // Caller-facing keys — an aliased destructured prop's DECLARED set for
+  // rest-bag routing must match what the caller actually sent (`n`), not
+  // the local binding (`count`), or the caller's own prop silently gets
+  // swept into the rest bag as an undeclared extra (#2524).
+  const declaredParams = new Set(ir.metadata.propsParams.map(p => p.sourceName ?? p.name))
   const restBagEntries: Array<[string, unknown]> = []
   if (restPropsName && props) {
     for (const [key, value] of Object.entries(props)) {
@@ -579,10 +612,19 @@ function buildPerlProps(
     entries.push(`${restPropsName} => ${toPerlLiteral(Object.fromEntries(restBagEntries))}`)
   }
 
-  // Add user props
+  // Add user props. Skip a key that's already a declared param's LOCAL
+  // template var name — `derivedProps` above already resolved that var
+  // correctly (through `propName`, for an aliased prop); re-pushing the raw
+  // `props[key]` here would silently clobber it with an UNRELATED value
+  // whenever a caller happens to also pass a same-spelled-as-local-name prop
+  // that isn't this param's actual `propName` (#2524 — surfaced by the
+  // aliased-destructured-prop generated data points, which pass both `n`
+  // (the real propName) and an incidental `count` key).
+  const localParamNames = new Set(ir.metadata.propsParams.map(p => p.name))
   if (props) {
     for (const [key, value] of Object.entries(props)) {
       if (routedKeys.has(key)) continue
+      if (localParamNames.has(key)) continue
       if (value === null) {
         // An explicit-null prop must still DECLARE the template var —
         // `typeof null === 'object'` fails every branch below, so the key
@@ -639,10 +681,9 @@ function buildPerlProps(
   // computation. Mirror that here so the test harness doesn't diverge
   // from the plugin: hard-coding `0` masked memos with non-zero
   // initial values until #1423 added a fixture that exposed the gap.
-  const ssrDefaults = extractSsrDefaults(ir.metadata) ?? {}
   for (const memo of ir.metadata.memos) {
-    const entry = ssrDefaults[memo.name]
-    const value = entry && typeof entry === 'object' && 'value' in entry ? entry.value : 0
+    const entry = rootSsrDefaults[memo.name]
+    const value = entry ? entry.value : 0
     entries.push(`${memo.name} => ${toPerlLiteral(value ?? 0)}`)
   }
 
@@ -702,6 +743,21 @@ function perlSingleQuote(s: string): string {
   return `'${s.replace(/\\/g, '\\\\').replace(/'/g, "\\'")}'`
 }
 
+/**
+ * Serialise a single `SsrDefault` entry to a Perl hashref literal, VERBATIM
+ * — `value` / `propName` / `isRestProps` intact, exactly the shape
+ * `BarefootJS::_derive_stash_from_defaults` expects. Do NOT flatten to a
+ * bare `value` here: that was the #2524 SSR-half bug — a flattened entry
+ * has nothing left for the propName-aware resolution to read, so an aliased
+ * destructured prop's caller-facing key is silently dropped.
+ */
+function ssrDefaultEntryToPerl(d: SsrDefault): string {
+  const parts: string[] = [`value => ${toPerlLiteral(d.value)}`]
+  if (d.propName !== undefined) parts.push(`propName => ${perlSingleQuote(d.propName)}`)
+  if (d.isRestProps) parts.push(`isRestProps => 1`)
+  return `{${parts.join(', ')}}`
+}
+
 function toPerlLiteral(value: unknown): string {
   if (typeof value === 'string') return perlSingleQuote(value)
   if (typeof value === 'number') return String(value)