@barefootjs/jinja 0.31.1 → 0.31.3

package/dist/index.js

@@ -189275,10 +189275,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,
   jinjaAdapter,

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";
@@ -1974,6 +1977,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";
 
@@ -2075,6 +2101,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) {
@@ -2125,6 +2161,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() {
@@ -2138,14 +2195,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 = {
@@ -2161,6 +2218,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",
@@ -2190,6 +2248,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.",
@@ -2363,6 +2422,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",
@@ -2381,7 +2488,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 = {
@@ -2463,10 +2570,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
@@ -2784,6 +2891,83 @@ var toLocaleDatePlugin = {
   }
 };
 
+// ../jsx/src/scope/binding-scope.ts
+class BindingScope {
+  frames;
+  static EMPTY = new BindingScope([]);
+  constructor(frames) {
+    this.frames = frames;
+  }
+  enterLoopRow(loop) {
+    const bindings = new Map;
+    if (loop.paramBindings && loop.paramBindings.length > 0) {
+      for (const b of loop.paramBindings)
+        bindings.set(b.name, { source: "destructure" });
+    } else {
+      bindings.set(loop.param, { source: "item" });
+    }
+    if (loop.index != null)
+      bindings.set(loop.index, { source: "index" });
+    for (const name of loop.preamble?.declaredNames ?? [])
+      bindings.set(name, { source: "preamble" });
+    const frame = { kind: "loop-row", bindings };
+    return new BindingScope([frame, ...this.frames]);
+  }
+  enterCallback(params) {
+    const bindings = new Map;
+    for (const name of params)
+      bindings.set(name, { source: "param" });
+    const frame = { kind: "callback", bindings };
+    return new BindingScope([frame, ...this.frames]);
+  }
+  isBound(name) {
+    for (const frame of this.frames) {
+      if (frame.bindings.has(name))
+        return true;
+    }
+    return false;
+  }
+  lookup(name) {
+    for (let depth = 0;depth < this.frames.length; depth++) {
+      const frame = this.frames[depth];
+      const binding = frame.bindings.get(name);
+      if (binding)
+        return { depth, frame, binding };
+    }
+    return null;
+  }
+  boundNames() {
+    if (this.boundNamesCache)
+      return this.boundNamesCache;
+    const names = new Set;
+    for (const frame of this.frames) {
+      for (const name of frame.bindings.keys())
+        names.add(name);
+    }
+    this.boundNamesCache = names;
+    return names;
+  }
+  boundNamesCache;
+  valueBoundNamesCache;
+  valueBoundNames() {
+    if (this.valueBoundNamesCache)
+      return this.valueBoundNamesCache;
+    const names = new Set;
+    for (const frame of this.frames) {
+      for (const [name, binding] of frame.bindings) {
+        if (binding.source === "item" || binding.source === "index" || binding.source === "destructure") {
+          names.add(name);
+        }
+      }
+    }
+    this.valueBoundNamesCache = names;
+    return names;
+  }
+  asShadowPredicate() {
+    return (name) => this.isBound(name);
+  }
+}
+
 // ../jsx/src/jsx-to-ir.ts
 var EMPTY_BOUND = new Set;
 var constInitializerCache = new WeakMap;
@@ -2880,13 +3064,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 = [];
@@ -3103,10 +3287,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 }
@@ -3156,7 +3340,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([
@@ -3171,7 +3355,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+/";
@@ -3262,15 +3446,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;
@@ -3302,47 +3486,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;
 }
@@ -3367,25 +3551,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);
   };
@@ -3496,33 +3680,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)
@@ -3553,30 +3737,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;
@@ -3584,28 +3768,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;
@@ -3614,7 +3798,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;
@@ -3622,11 +3806,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;
@@ -3642,35 +3826,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;
@@ -3726,7 +3910,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) {
@@ -3802,7 +3986,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 {
@@ -3821,12 +4005,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.typeAnnotation ?? constant.type) ? `: ${constant.typeAnnotation ?? constant.type?.raw}` : "";
+        lines.push(`  ${keyword} ${constant.name}${typeAnnotation}`);
         continue;
       }
       const value = constant.value.trim();
@@ -3835,9 +4023,12 @@ class JsxAdapter extends BaseAdapter {
       if (!reachable.has(constant.name))
         continue;
       const constValue = preserveTypes ? constant.typedValue ?? constant.value : constant.value;
-      lines.push(`  ${keyword} ${constant.name} = ${constValue}`);
+      const letTypeAnnotation = preserveTypes && keyword === "let" && constant.typeAnnotation ? `: ${constant.typeAnnotation}` : "";
+      lines.push(`  ${keyword} ${constant.name}${letTypeAnnotation} = ${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(", ");
@@ -3847,6 +4038,127 @@ 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) {
+        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;
+      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(`
 `);
   }
   renderNodeRaw(node) {
@@ -3858,6 +4170,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}}`;
   }
@@ -3925,6 +4246,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 ? `
@@ -3933,9 +4255,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 {
@@ -3966,9 +4290,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("");
@@ -3991,7 +4312,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 = [];
@@ -4138,13 +4459,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 = [];
@@ -4618,7 +4933,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;
@@ -4758,9 +5073,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();
@@ -5586,7 +5901,7 @@ function collectImportedLoopChildComponentErrors(ir, componentName) {
 }
 
 // src/adapter/spread/spread-codegen.ts
-import ts26 from "typescript";
+import ts28 from "typescript";
 function conditionalSpreadToJinja(ctx, expr) {
   if (!expr || expr.kind !== "conditional")
     return null;
@@ -5641,7 +5956,7 @@ function recordIndexAccessToJinja(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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@barefootjs/jinja",
-  "version": "0.31.1",
+  "version": "0.31.3",
   "description": "Jinja2 adapter for BarefootJS — compiles IR to .jinja templates and ships the Python BarefootJS rendering runtime; runs under any Python web framework (Flask, etc.)",
   "type": "module",
   "main": "./dist/index.js",
@@ -53,7 +53,7 @@
     "directory": "packages/adapter-jinja"
   },
   "dependencies": {
-    "@barefootjs/shared": "0.31.1"
+    "@barefootjs/shared": "0.31.3"
   },
   "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.3",
+    "@barefootjs/vite": "0.31.3",
+    "@barefootjs/client": "0.31.3",
     "typescript": "^5.0.0",
     "vite": "^6.0.0"
   }

package/python/barefootjs/runtime.py

@@ -484,20 +484,35 @@ _DATE_EPOCH = datetime.datetime(1970, 1, 1, tzinfo=datetime.timezone.utc)
 def _derive_stash_from_defaults(defaults: dict, props: dict) -> dict:
     """Derive template-stash kvs from a manifest entry's `ssrDefaults`
     section. See BarefootJS.pm's `_derive_stash_from_defaults` docstring for
-    the full field-shape contract."""
+    the full field-shape contract.
+
+    `props` arrives ALREADY keyword-mangled (`render_child` / the manifest
+    renderer closure both mangle every prop key via `jinja_ident` before
+    calling in -- see their docstrings), but `defaults`' own keys and each
+    entry's `propName` are the RAW (un-mangled) spellings `extractSsrDefaults`
+    emitted. For a reserved-word prop (`as`, `for`, `class`, ...) an
+    unmangled lookup/output key misses the mangled `props` map entirely --
+    silently falling back to the static default even when the caller DID
+    supply a value -- and then writes the stash under the RAW key, which a
+    subsequent mangling pass (or the template itself, keyed by the mangled
+    name) never reads. Both the output key and the `propName` lookup are
+    mangled here so this resolves correctly regardless of whether the prop
+    name happens to collide with a reserved word (#2524 follow-up)."""
     extra: dict = {}
     for name, d in (defaults or {}).items():
+        key = jinja_ident(name)
         if not isinstance(d, dict):
-            extra[name] = d
+            extra[key] = d
             continue
         if d.get("isRestProps"):
-            extra[name] = props[name] if name in props else d.get("value")
+            extra[key] = props[key] if key in props else d.get("value")
             continue
         prop_name = d.get("propName")
-        if prop_name is not None and props.get(prop_name) is not None:
-            extra[name] = props[prop_name]
+        mangled_prop_name = jinja_ident(prop_name) if prop_name is not None else None
+        if mangled_prop_name is not None and props.get(mangled_prop_name) is not None:
+            extra[key] = props[mangled_prop_name]
         else:
-            extra[name] = d.get("value")
+            extra[key] = d.get("value")
     return extra
 
 

package/src/__tests__/jinja-reserved-word-child-prop.test.ts

@@ -0,0 +1,58 @@
+/**
+ * Regression for the review finding on #2524's SSR half (BLOCKER 1): a
+ * reserved-word aliased/defaulted prop passed to a CHILD component used to
+ * be silently clobbered by the child's static default.
+ *
+ * `child_props` arrives at `_derive_stash_from_defaults` already
+ * keyword-mangled (`jinja_ident`, `runtime.py`) — `as` becomes `as_` — but
+ * the serialised `_defaults` map's own keys and each entry's `propName` were
+ * the RAW (un-mangled) spellings `extractSsrDefaults` emits. For a
+ * reserved-word prop, `_derive_stash_from_defaults` looked up `props['as']`
+ * (never present — the real key is `as_`), missed, and fell back to the
+ * static default under the RAW key `as`; after `_vars = {**child_props,
+ * **_extra}`, the WRONG static default won over the real caller value.
+ *
+ * `_derive_stash_from_defaults` now mangles both the output key and the
+ * `propName` lookup (mirrors the Rust runtime's `resolve_child_vars`), so
+ * this resolves correctly. See `runtime.py`'s `_derive_stash_from_defaults`
+ * docstring.
+ */
+import { test, expect } from 'bun:test'
+import { JinjaAdapter } from '../adapter'
+import { renderJinjaComponent, PythonNotAvailableError } from '../test-render'
+
+const SOURCE = `
+import { Tag } from './Tag'
+export function Wrapper() {
+  return <Tag as="section" label="hi" />
+}
+`
+
+const TAG_SOURCE = `
+export function Tag({ as = 'span', label }: { as?: string; label: string }) {
+  return <div>{as}:{label}</div>
+}
+`
+
+test('a reserved-word aliased/defaulted prop survives the child-render path (jinja, #2524 follow-up)', async () => {
+  let html: string
+  try {
+    html = await renderJinjaComponent({
+      source: SOURCE,
+      adapter: new JinjaAdapter(),
+      components: { './Tag': TAG_SOURCE },
+    })
+  } catch (err) {
+    if (err instanceof PythonNotAvailableError) {
+      console.log(`Skipping: ${err.message}`)
+      return
+    }
+    throw err
+  }
+  // The caller passed `as="section"` — it must win over the child's own
+  // `as = 'span'` destructure default. Text is wrapped in bf slot markers,
+  // so match each interpolated value rather than the literal `x:y` shape.
+  expect(html).toContain('>section<')
+  expect(html).toContain('>hi<')
+  expect(html).not.toContain('>span<')
+})

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

@@ -16,8 +16,8 @@
  * generated render script (Python, not Perl) and its literal syntax differ.
  */
 
-import { compileJSX, extractSsrDefaults, importsSearchParams, evaluateSignalInit, tryEvaluateSignalInit } from '@barefootjs/jsx'
-import type { ComponentIR } from '@barefootjs/jsx'
+import { compileJSX, extractSsrDefaults, deriveStashFromDefaults, importsSearchParams, evaluateSignalInit } from '@barefootjs/jsx'
+import type { ComponentIR, SsrDefault } from '@barefootjs/jsx'
 import { mkdir, rm } from 'node:fs/promises'
 import { resolve } from 'node:path'
 
@@ -252,7 +252,7 @@ import uuid
 
 from barefootjs import BarefootJS, SearchParams
 from barefootjs.backend_jinja import JinjaBackend
-from barefootjs.runtime import jinja_ident
+from barefootjs.runtime import jinja_ident, _derive_stash_from_defaults
 
 # Single Jinja2 backend over the temp template dir.
 backend = JinjaBackend(paths=[${pyStr(tempDir)}])
@@ -333,7 +333,16 @@ function collectImportedComponentNames(ir: ComponentIR): string[] {
  * `runtime.BarefootJS.render_child`'s docstring. So the rest-bag routing
  * below and the `_bf_slot` / `key` / `children` pops all compare against
  * ALREADY-mangled key spellings; the `keep` set mangles the child's declared
- * param names to match.
+ * param (CALLER-facing, `sourceName ?? name`) names to match.
+ *
+ * Template vars seed through the production `_derive_stash_from_defaults`
+ * (`barefootjs.runtime`, the same function `register_components_from_
+ * manifest`'s `make_renderer` calls) rather than a flat `{**_defaults,
+ * **child_props}` merge: the flat merge never resolves an aliased
+ * destructured prop's CALLER-facing key (`n`) onto its local template var
+ * (`count`) — `_defaults` carries the FULL `{value, propName?,
+ * isRestProps?}` shape (not flattened to bare values) so the propName
+ * resolution has something to read (#2524 SSR half).
  */
 function buildChildRenderers(
   childTemplates: Map<string, { template: string; ir: ComponentIR }>,
@@ -348,12 +357,14 @@ function buildChildRenderers(
     const snakeName = toSnakeCase(componentName)
     const fnSuffix = snakeName.replace(/[^a-zA-Z0-9_]/g, '_')
     // Statically-derived ssrDefaults the child template's vars seed from
-    // (prop defaults + signal / memo initial values), serialised to a
-    // Python dict literal.
+    // (prop defaults + signal / memo initial values), serialised VERBATIM
+    // (propName / isRestProps intact) to a Python dict literal — resolved
+    // per-call against the REAL child props by `_derive_stash_from_defaults`
+    // below, not flattened here.
     const ssrDefaults = extractSsrDefaults(childIR.metadata) ?? {}
     const defaultsPy = ssrDefaultsToPy(ssrDefaults)
     const restPropsName = childIR.metadata.restPropsName
-    const paramNames = (childIR.metadata.propsParams ?? []).map(p => p.name)
+    const paramNames = (childIR.metadata.propsParams ?? []).map(p => p.sourceName ?? p.name)
 
     lines.push(`def _make_child_renderer_${fnSuffix}():`)
     lines.push(`    _defaults = ${defaultsPy}`)
@@ -404,8 +415,15 @@ function buildChildRenderers(
     lines.push(`        child_bf._child_renderers(bf._child_renderers())`)
     lines.push(`        child_bf._scripts(bf._scripts())`)
     lines.push(`        child_bf._script_seen(bf._script_seen())`)
-    // Seed template vars: static ssrDefaults first, caller's props win.
-    lines.push(`        _vars = {**_defaults, **child_props}`)
+    // Seed template vars through the production `_derive_stash_from_defaults`
+    // — resolves each entry's `propName` against the REAL `child_props`
+    // (already keyword-mangled above), falling back to the static `value`;
+    // `isRestProps` entries pass the already-routed rest bag through. Caller
+    // props still win overall via the final merge (mirrors the ERB
+    // harness's `child_props.merge(extra)` and the production
+    // `register_components_from_manifest` renderer closure).
+    lines.push(`        _extra = _derive_stash_from_defaults(_defaults, child_props)`)
+    lines.push(`        _vars = {**child_props, **_extra}`)
     lines.push(`        rendered = backend.render_named(${pyStr(snakeName)}, child_bf, _vars)`)
     lines.push(`        if isinstance(rendered, str) and rendered.endswith('\\n'):`)
     lines.push(`            rendered = rendered[:-1]`)
@@ -424,22 +442,31 @@ function pyList(names: string[]): string {
   return `[${names.map(pyStr).join(', ')}]`
 }
 
-/** Serialise an ssrDefaults map to a Python dict literal. */
-function ssrDefaultsToPy(defaults: Record<string, unknown>): string {
+/**
+ * Serialise an ssrDefaults map to a Python dict literal, VERBATIM —
+ * `value` / `propName` / `isRestProps` intact, exactly the shape
+ * `_derive_stash_from_defaults` expects (and exactly what the production
+ * build manifest embeds). Do NOT flatten to bare `value`s 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 ssrDefaultsToPy(defaults: Record<string, SsrDefault>): string {
   const entries: string[] = []
   for (const [name, d] of Object.entries(defaults)) {
-    // ssrDefaults entries are `{ value, propName?, isRestProps? }` or a
-    // bare value. The child renderer's caller props win, so we only need
-    // the static fallback `value` here.
-    let value: unknown = d
-    if (d && typeof d === 'object' && 'value' in (d as Record<string, unknown>)) {
-      value = (d as Record<string, unknown>).value
-    }
-    entries.push(`${pyStr(name)}: ${toPyLiteral(value)}`)
+    entries.push(`${pyStr(name)}: ${ssrDefaultEntryToPy(d)}`)
   }
   return `{${entries.join(', ')}}`
 }
 
+/** Serialise a single `SsrDefault` entry to a Python dict literal. */
+function ssrDefaultEntryToPy(d: SsrDefault): string {
+  const parts: string[] = [`'value': ${toPyLiteral(d.value)}`]
+  if (d.propName !== undefined) parts.push(`'propName': ${pyStr(d.propName)}`)
+  if (d.isRestProps) parts.push(`'isRestProps': True`)
+  return `{${parts.join(', ')}}`
+}
+
 /**
  * Convert PascalCase to snake_case for template naming (matches the
  * adapter's `toTemplateName`).
@@ -465,23 +492,29 @@ function buildPythonProps(
   entries.push(`${pyStr('scope_id')}: ${pyStr(explicitScope)}`)
 
   // Prop params with defaults (before signals, so signals can reference them).
+  // Seeded through the shared `deriveStashFromDefaults` (the TS twin of the
+  // production `_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(`${pyStr(param.name)}: ${toPyLiteral(result.value)}`)
-        continue
-      }
-    }
+    if (param.isRest) continue
     // No default + no caller value: pass `None` so Jinja's var lookup for
     // an optional prop doesn't fault before its falsy branch elides.
-    entries.push(`${pyStr(param.name)}: None`)
+    const value = derivedProps[param.name] ?? null
+    entries.push(`${pyStr(param.name)}: ${toPyLiteral(value)}`)
   }
 
   // Route undeclared props into the rest bag (`bf.spread_attrs($<rest>)`).
   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)) {
@@ -496,11 +529,20 @@ function buildPythonProps(
     entries.push(`${pyStr(restPropsName)}: ${toPyLiteral(Object.fromEntries(restBagEntries))}`)
   }
 
-  // User props.
+  // 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 (key.startsWith('__')) continue
       if (routedKeys.has(key)) continue
+      if (localParamNames.has(key)) continue
       if (typeof value === 'string') {
         entries.push(`${pyStr(key)}: ${pyStr(value)}`)
       } else if (typeof value === 'number') {
@@ -526,10 +568,9 @@ function buildPythonProps(
 
   // Memo values seeded from the statically-evaluated ssrDefaults, same
   // as the production plugin's before_render hook.
-  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(`${pyStr(memo.name)}: ${toPyLiteral(value ?? 0)}`)
   }