@barefootjs/rust 0.31.1 → 0.31.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@barefootjs/rust",
-  "version": "0.31.1",
+  "version": "0.31.3",
   "description": "minijinja (Rust) adapter for BarefootJS — compiles IR to .j2 templates and ships a Rust rendering runtime (packages/adapter-rust/runtime/); runs under any Rust web framework (axum, etc.)",
   "type": "module",
   "main": "./dist/index.js",
@@ -54,7 +54,7 @@
     "directory": "packages/adapter-rust"
   },
   "dependencies": {
-    "@barefootjs/shared": "0.31.1"
+    "@barefootjs/shared": "0.31.3"
   },
   "peerDependencies": {
     "@barefootjs/jsx": ">=0.2.0",
@@ -71,9 +71,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/runtime/src/bin/bf-render.rs

@@ -12,7 +12,7 @@
 
 use barefootjs::backend_minijinja;
 use barefootjs::num::JsValue;
-use barefootjs::runtime::{js_to_mj, BfInstance, ChildRendererSpec, RenderSession};
+use barefootjs::runtime::{BfInstance, ChildRendererSpec, RenderSession};
 use barefootjs::search_params::SearchParams;
 use minijinja::value::Value as MjValue;
 use serde::Deserialize;
@@ -96,11 +96,12 @@ fn run(payload_path: &str) -> Result<String, String> {
             ChildRendererSpec {
                 component_name: child.name.clone(),
                 template: child.template.clone(),
-                // Converted from JSON to `Value` HERE, at registration time
-                // -- `render_child` keeps props as `Value` end-to-end from
-                // this point on (see `ChildRendererSpec::ssr_defaults`'s
-                // docstring).
-                ssr_defaults: js_to_mj(&decode_value(&child.ssr_defaults)),
+                // Kept RAW (`JsValue`, the FULL `{value, propName?,
+                // isRestProps?}` shape) -- `render_child` resolves this
+                // PER-CALL against the real caller props via
+                // `derive_stash_from_defaults` (see `ChildRendererSpec::
+                // ssr_defaults`'s docstring; #2524).
+                ssr_defaults: decode_value(&child.ssr_defaults),
                 rest_props_name: child.rest_props_name.clone(),
                 param_names: child.param_names.clone(),
             },

package/runtime/src/manifest.rs

@@ -33,22 +33,34 @@
 //! REGISTER a [`ChildRendererSpec`] per entry: [`crate::runtime::BfInstance::
 //! render_child`] already implements that whole contract generically for
 //! every registered child (scope-id chaining, `_bf_slot`/`key` popping,
-//! rest-bag routing, ssrDefaults-then-caller-props merge -- see its
-//! docstring), because it was built to serve `bf-render`'s payload-driven
-//! children the same way. Registering a manifest entry is therefore just:
-//! derive the registry key + template name from `markedTemplate`, flatten
-//! `ssrDefaults` to its static fallback values via
-//! [`derive_stash_from_defaults`] (called with EMPTY props, since the
-//! caller-props override Python's closure applies per-call is already
-//! applied generically, once, inside `render_child`), and derive
-//! `rest_props_name`/`param_names` from which `ssrDefaults` entries carry
-//! `isRestProps`/`propName` (see `packages/jsx/src/ssr-defaults.ts`'s
-//! `extractSsrDefaults`, which only ever sets `propName` to the entry's OWN
-//! key -- so this static-then-override merge order is exactly equivalent
-//! to Python's per-call `props.get(propName, value)` derivation).
+//! rest-bag routing, `derive_stash_from_defaults`-then-caller-props merge --
+//! see its docstring), because it was built to serve `bf-render`'s
+//! payload-driven children the same way. Registering a manifest entry is
+//! therefore just: derive the registry key + template name from
+//! `markedTemplate`, keep `ssrDefaults` RAW (the FULL `{value, propName?,
+//! isRestProps?}` shape, with any STATIC `signal_init` override applied as
+//! a bare replacement value), and derive `rest_props_name`/`param_names`
+//! from which `ssrDefaults` entries carry `isRestProps`/`propName`.
+//!
+//! `ssrDefaults` is stored RAW, not flattened, and resolved PER-CALL inside
+//! `render_child` against the caller's ACTUAL props (#2524). An earlier
+//! version of this function flattened via [`derive_stash_from_defaults`]
+//! called with an EMPTY props document AT REGISTRATION TIME -- on the
+//! (false) assumption that every `propName` equals its own entry's key, so
+//! resolving early against no props and resolving later against the real
+//! caller props would agree. That assumption breaks for an ALIASED
+//! destructured prop (`{ n: count }`, see `packages/jsx/src/ssr-defaults.ts`'s
+//! `extractSsrDefaults`): the entry's own key is the LOCAL binding
+//! (`count`), but `propName` is the CALLER-facing name (`n`) -- resolving
+//! against an empty props document can only ever produce the static
+//! fallback, silently discarding whatever the caller actually passed as
+//! `n`. `param_names` has the matching fix: it carries the CALLER-facing
+//! `propName`, not the entry's own (local) key, since `render_child`'s
+//! rest-bag "keep" set compares against child props keyed by whatever the
+//! calling template passed.
 
 use crate::num::JsValue;
-use crate::runtime::{js_to_mj, ChildRendererSpec, RenderSession};
+use crate::runtime::{ChildRendererSpec, RenderSession};
 use std::collections::{BTreeMap, HashMap};
 use std::sync::Arc;
 
@@ -84,12 +96,17 @@ pub fn to_template_name(component_name: &str) -> String {
 ///     rest-props bag the caller may have already assembled), else the
 ///     static `value` fallback (normally `{}`).
 ///   * `propName` set -- prefer `props[propName]` when present AND not
-///     `null`/`undefined`, else the static `value` fallback. Every
-///     `propName` the TS extractor emits equals its own entry's key (see
-///     `extractSsrDefaults`), so this always reads back the SAME key it
-///     writes -- a caller with no relevant props (this module's own
-///     registration path, below) can pass an empty `props` document to get
-///     pure static fallbacks.
+///     `null`/`undefined`, else the static `value` fallback. For an
+///     UN-aliased prop `propName` equals the entry's own key; for an
+///     ALIASED destructured prop (`{ n: count }`, see
+///     `packages/jsx/src/ssr-defaults.ts`'s `extractSsrDefaults`) the
+///     entry's key is the LOCAL binding (`count`) but `propName` is the
+///     CALLER-facing name (`n`) -- callers MUST pass the real caller props
+///     (not an empty document) for this branch to do anything useful (see
+///     `render_child`, which calls this per-call against the actual caller
+///     props; this module's own registration path keeps `ssrDefaults` RAW
+///     and defers to that per-call resolution rather than resolving early
+///     against an empty `props` document -- #2524).
 ///   * neither set -- the static `value` (a signal/memo's default,
 ///     internal to the component, never sourced from `props`).
 pub fn derive_stash_from_defaults(defaults: &JsValue, props: &JsValue) -> JsValue {
@@ -204,17 +221,49 @@ pub fn register_components_from_manifest(
         let template_name = strip_manifest_template_path(marked);
         let registry_key = to_template_name(&component_name);
 
-        let empty_props = JsValue::Object(BTreeMap::new());
         let ssr_defaults = entry_obj.get("ssrDefaults").cloned().unwrap_or_else(|| JsValue::Object(BTreeMap::new()));
-        let mut defaults = derive_stash_from_defaults(&ssr_defaults, &empty_props);
+
+        // Apply any STATIC `signal_init` overrides by REPLACING the
+        // overridden key's entry with the bare override value --
+        // `resolve_child_vars`'s non-object-entry branch (`runtime.rs`) uses
+        // a bare value as-is, unconditionally (ignoring caller props), so an
+        // overridden key now WINS over a same-named caller prop. This is a
+        // DELIBERATE FLIP from the prior contract, not a preservation of it:
+        // previously this function flattened `ssr_defaults` against an EMPTY
+        // props document at registration time and `render_child` applied the
+        // caller's props LAST (`vars = defaults; vars.extend(props)`), so a
+        // caller prop always beat a `signal_init` override. Now
+        // `render_child` applies the RESOLVED extras last (`vars = props;
+        // vars.extend(extra)`), so an override -- and any `propName` that
+        // resolves against the real caller props -- wins instead. This
+        // matches the Python/PHP/Perl ports, where `signal_init_fn`'s
+        // returned `extra` (or the propName-resolved `_derive_stash_from_
+        // defaults` output) is merged LAST over `props`
+        // (`{**props, **extra}` / `props.merge(extra)`) rather than first.
+        // Resolution against the REAL caller props now happens PER-CALL,
+        // inside `render_child`, against these RAW (un-flattened) defaults
+        // -- registering with an EMPTY props document at THIS point (the
+        // pre-#2524-fix shape) is exactly the production bug: it flattened
+        // via `derive_stash_from_defaults` before any caller was known,
+        // discarding `propName` so an aliased destructured prop's
+        // CALLER-facing key could never later resolve.
+        let mut defaults_map = match &ssr_defaults {
+            JsValue::Object(m) => m.clone(),
+            _ => BTreeMap::new(),
+        };
         if let Some(overrides) = signal_init.get(&registry_key) {
-            if let (JsValue::Object(base), Some(over)) = (&mut defaults, overrides.as_object()) {
+            if let Some(over) = overrides.as_object() {
                 for (k, v) in over {
-                    base.insert(k.clone(), v.clone());
+                    defaults_map.insert(k.clone(), v.clone());
                 }
             }
         }
+        let defaults = JsValue::Object(defaults_map);
 
+        // `param_names` carries the CALLER-facing name (`propName`), not the
+        // entry's own (local) key -- `render_child`'s rest-bag "keep" set
+        // compares against child props keyed by whatever the calling
+        // template passed, not the child's local binding (#2524).
         let (rest_props_name, param_names) = match ssr_defaults.as_object() {
             Some(m) => {
                 let mut rest = None;
@@ -223,8 +272,8 @@ pub fn register_components_from_manifest(
                     let Some(dm) = d.as_object() else { continue };
                     if matches!(dm.get("isRestProps"), Some(JsValue::Bool(true))) {
                         rest = Some(name.clone());
-                    } else if dm.contains_key("propName") {
-                        params.push(name.clone());
+                    } else if let Some(prop_name) = dm.get("propName").and_then(|v| v.as_str()) {
+                        params.push(prop_name.to_string());
                     }
                 }
                 (rest, params)
@@ -237,7 +286,7 @@ pub fn register_components_from_manifest(
             ChildRendererSpec {
                 component_name: template_name.clone(),
                 template: template_name,
-                ssr_defaults: js_to_mj(&defaults),
+                ssr_defaults: defaults,
                 rest_props_name,
                 param_names,
             },

package/runtime/src/runtime.rs

@@ -796,13 +796,19 @@ pub struct ChildRendererSpec {
     pub component_name: String,
     /// snake_case `.j2` template base name.
     pub template: String,
-    /// Static ssrDefaults values (already flattened to plain values, NOT
-    /// the `{value, propName, isRestProps}` wrapper shape -- see the module
-    /// docstring's note on why `_derive_stash_from_defaults` isn't ported).
-    /// Converted from JSON to `Value` at REGISTRATION time (`bf-render.rs`)
-    /// -- see `render_child`'s docstring on why child props stay `Value`
-    /// end-to-end rather than round-tripping through `JsValue`.
-    pub ssr_defaults: MjValue,
+    /// Static ssrDefaults, RAW -- the FULL `{value, propName?, isRestProps?}`
+    /// wrapper shape (or a bare value for a propName-less entry), exactly as
+    /// `extractSsrDefaults` emits it. Resolved PER-CALL against the real
+    /// caller props by [`crate::manifest::derive_stash_from_defaults`] inside
+    /// `render_child` below -- NOT flattened at registration time (that was
+    /// the #2524 production bug: flattening early, before the caller's props
+    /// are known, discards `propName` and so can never resolve an aliased
+    /// destructured prop's CALLER-facing key onto its local template var).
+    /// Kept as `JsValue` (not `MjValue`) because `derive_stash_from_defaults`
+    /// operates in the JSON-shaped `JsValue` domain; converted to `MjValue`
+    /// only for the resolved OUTPUT (see `render_child`'s docstring on why
+    /// child props otherwise stay `Value` end-to-end).
+    pub ssr_defaults: JsValue,
     pub rest_props_name: Option<String>,
     pub param_names: Vec<String>,
 }
@@ -1115,11 +1121,32 @@ impl BfInstance {
             data_key,
         };
 
-        // Seed template vars: static ssrDefaults first, caller's props win
-        // -- mirrors buildChildRenderers' `_vars = {**_defaults, **child_props}`.
-        let mut vars: BTreeMap<String, MjValue> =
-            mj_map_to_btreemap(&spec.ssr_defaults).into_iter().map(|(k, v)| (mangle_ident(&k), v)).collect();
-        vars.extend(map);
+        // Seed template vars through `resolve_child_vars`, resolving each
+        // entry's `propName` against the REAL (already-mangled) caller props
+        // -- mirrors the Ruby/Python/PHP/Perl runtime ports'
+        // `derive_vars_from_defaults` / `_derive_stash_from_defaults` (#2524
+        // SSR half: a flat `{**_defaults, **child_props}` merge never
+        // resolves an aliased destructured prop's CALLER-facing key (`n`)
+        // onto its local template var (`count`) -- `spec.ssr_defaults` is
+        // the FULL `{value, propName?, isRestProps?}` shape, not flattened,
+        // so this resolution has something to read). Caller props still win
+        // for any key resolution did NOT touch (an extraneous, undeclared
+        // prop); `extra` wins for the keys it DOES resolve -- the same
+        // `props.merge(extra)` order every other language port uses.
+        //
+        // Deliberately NOT `crate::manifest::derive_stash_from_defaults`
+        // (the `JsValue`-only free function): that would round-trip every
+        // caller prop through `mj_to_js`/`js_to_mj`, which has no safe/
+        // unsafe distinction and silently strips a SAFE `Value`'s flag (a
+        // JSX children capture, `bf.string(...)`'d markup) -- exactly the
+        // "children lost their safe flag" bug this method's docstring
+        // above warns about. `resolve_child_vars` stays in the `MjValue`
+        // domain for every caller-supplied value; only the STATIC fallback
+        // (`d.value`, from the manifest/generated payload, never JSX
+        // content) goes through `js_to_mj`.
+        let extra = resolve_child_vars(&spec.ssr_defaults, &map);
+        let mut vars: BTreeMap<String, MjValue> = map;
+        vars.extend(extra);
 
         let rendered = backend_minijinja::render_named_from_state_values(state, &spec.template, child.as_mj_value(), vars)?;
         // chomp: remove at most one trailing newline.
@@ -1127,6 +1154,57 @@ impl BfInstance {
     }
 }
 
+/// `MjValue`-domain twin of [`crate::manifest::derive_stash_from_defaults`],
+/// used by [`BfInstance::render_child`] so a caller-supplied prop value --
+/// which may be a SAFE `Value` (a JSX children capture, `bf.string(...)`'d
+/// markup) -- is used AS-IS when `propName` resolves it, never round-tripped
+/// through the JSON-shaped `JsValue` domain (which has no safe/unsafe
+/// distinction and would silently strip that flag, double-escaping the
+/// child's HTML -- see `render_child`'s docstring). `ssr_defaults` is the
+/// RAW (un-flattened) `{value, propName?, isRestProps?}` shape; `props` is
+/// the caller's ALREADY-mangled prop map. Only the STATIC fallback
+/// (`d.value`, from the manifest/generated payload -- JSX prop values are
+/// never statically evaluable, so they're always `null` there) goes through
+/// [`js_to_mj`]. Returns keys already mangled (matching `props`'s own
+/// convention), ready to merge/overwrite directly.
+fn resolve_child_vars(ssr_defaults: &JsValue, props: &BTreeMap<String, MjValue>) -> BTreeMap<String, MjValue> {
+    let mut extra = BTreeMap::new();
+    let defaults_map = match ssr_defaults.as_object() {
+        Some(m) => m,
+        None => return extra,
+    };
+    for (name, d) in defaults_map {
+        let key = mangle_ident(name);
+        let dm = match d.as_object() {
+            Some(m) => m,
+            None => {
+                // Bare (non-object) entry -- used as-is, mirrors every other
+                // port's `ref($d) eq 'HASH'` / `isinstance(d, dict)` guard.
+                extra.insert(key, js_to_mj(d));
+                continue;
+            }
+        };
+        let fallback = || js_to_mj(&dm.get("value").cloned().unwrap_or(JsValue::Null));
+        if matches!(dm.get("isRestProps"), Some(JsValue::Bool(true))) {
+            // The rest bag is already assembled (as a real `Value`, member
+            // safe flags intact) under its own mangled key by the rest-bag
+            // routing above -- prefer that live value over the static
+            // fallback.
+            let v = props.get(&key).cloned().unwrap_or_else(fallback);
+            extra.insert(key, v);
+            continue;
+        }
+        let prop_name = dm.get("propName").and_then(|v| v.as_str());
+        let from_props = prop_name.and_then(|pn| props.get(&mangle_ident(pn)));
+        let v = match from_props {
+            Some(pv) if !matches!(pv.kind(), ValueKind::None | ValueKind::Undefined) => pv.clone(),
+            _ => fallback(),
+        };
+        extra.insert(key, v);
+    }
+    extra
+}
+
 // ---------------------------------------------------------------------------
 // minijinja::Value <-> JsValue conversion. minijinja 2.x represents EVERY
 // sequence/mapping as a `Object` (`ObjectRepr::Seq`/`Map`/`Iterable`) --

package/runtime/tests/manifest.rs

@@ -146,6 +146,41 @@ fn register_from_flat_manifest_applies_signal_init_override() {
     assert_eq!(html.trim(), "9");
 }
 
+/// A `signal_init` override wins over a CALLER-SUPPLIED prop of the same
+/// name, not just the manifest's static default (#2524 precedence flip --
+/// see `manifest.rs`'s registration-site comment). Pre-#2524 this function
+/// flattened `ssr_defaults` at registration time and `render_child` applied
+/// the caller's props LAST, so a caller-supplied `level` would have beaten
+/// the override; now `render_child` applies the resolved `signal_init`
+/// override LAST, matching the Python/PHP/Perl ports' `{**props, **extra}`
+/// / `props.merge(extra)` merge order.
+#[test]
+fn register_from_flat_manifest_override_wins_over_caller_prop() {
+    let dir = TempDir::new("override-vs-caller");
+    dir.write("root.j2", "{{ bf.render_child('widget', {'level': 3}) | safe }}");
+    dir.write("Widget.j2", "{{ bf.string(level) }}");
+
+    let manifest = obj(vec![(
+        "Widget",
+        obj(vec![
+            ("markedTemplate", JsValue::String("templates/Widget.j2".into())),
+            ("ssrDefaults", obj(vec![("level", obj(vec![("value", JsValue::Number(1.0))]))])),
+        ]),
+    )]);
+
+    let mut signal_init = HashMap::new();
+    signal_init.insert("widget".to_string(), obj(vec![("level", JsValue::Number(9.0))]));
+
+    let session = RenderSession::new();
+    register_components_from_manifest(&session, &manifest, &signal_init);
+
+    let env = backend_minijinja::build_environment(&dir.0);
+    let root = BfInstance::root(Arc::clone(&session), "test".to_string());
+    let html = backend_minijinja::render_named(&env, "root", root.as_mj_value(), &JsValue::Object(BTreeMap::new())).unwrap();
+    // The caller passed `level: 3`, but the `signal_init` override (9) wins.
+    assert_eq!(html.trim(), "9");
+}
+
 /// `ui/<name>/index`-shaped entries (the component-library registry
 /// convention Python's port targets) still register correctly.
 #[test]

package/runtime/tests/render_child.rs

@@ -14,9 +14,8 @@
 //! additionally exercises the actual `Object::call_method` dispatch path.
 
 use barefootjs::num::JsValue;
-use barefootjs::runtime::{js_to_mj, ChildRendererSpec};
+use barefootjs::runtime::ChildRendererSpec;
 use barefootjs::{backend_minijinja, BfInstance, RenderSession};
-use minijinja::value::Value as MjValue;
 use std::collections::BTreeMap;
 use std::path::PathBuf;
 use std::sync::Arc;
@@ -46,10 +45,11 @@ fn no_defaults() -> JsValue {
     JsValue::Object(BTreeMap::new())
 }
 
-/// `ChildRendererSpec::ssr_defaults`, which is `minijinja::Value` (props
-/// stay `Value` end-to-end through `render_child` -- see its docstring).
-fn no_ssr_defaults() -> MjValue {
-    MjValue::from(BTreeMap::<String, MjValue>::new())
+/// `ChildRendererSpec::ssr_defaults`, which is a RAW `JsValue` (the FULL
+/// `{value, propName?, isRestProps?}` shape, resolved per-call against the
+/// real caller props inside `render_child` -- see its docstring).
+fn no_ssr_defaults() -> JsValue {
+    JsValue::Object(BTreeMap::new())
 }
 
 #[test]
@@ -128,7 +128,7 @@ fn rest_bag_routing_and_ssr_defaults_merge() {
         ChildRendererSpec {
             component_name: "Card".to_string(),
             template: "card".to_string(),
-            ssr_defaults: js_to_mj(&JsValue::Object(defaults)),
+            ssr_defaults: JsValue::Object(defaults),
             rest_props_name: Some("rest".to_string()),
             param_names: vec!["title".to_string()],
         },
@@ -138,6 +138,40 @@ fn rest_bag_routing_and_ssr_defaults_merge() {
     assert_eq!(out, "Hi|Sub|E|dark");
 }
 
+#[test]
+fn aliased_prop_resolves_callers_facing_key_onto_local_template_var() {
+    // #2524 (SSR half): a renaming destructure (`{ n: count }`) keys the
+    // ssrDefaults entry by the LOCAL binding (`count`) but its `propName`
+    // is the CALLER-facing key (`n`) -- the call site passes `n` (it has no
+    // visibility into how the child renames it internally), so
+    // `render_child` must resolve `n` onto the child template's `count`,
+    // not leave `count` at its static (`null`) fallback.
+    let dir = TempDir::new("aliased");
+    dir.write("root.j2", "{{ bf.render_child('badge', {'n': 7}) }}");
+    dir.write("badge.j2", "{{ count }}");
+
+    let env = backend_minijinja::build_environment(&dir.0);
+    let session = RenderSession::new();
+    let mut count_entry = BTreeMap::new();
+    count_entry.insert("value".to_string(), JsValue::Null);
+    count_entry.insert("propName".to_string(), JsValue::from("n"));
+    let mut defaults = BTreeMap::new();
+    defaults.insert("count".to_string(), JsValue::Object(count_entry));
+    session.register_child_renderer(
+        "badge".to_string(),
+        ChildRendererSpec {
+            component_name: "Badge".to_string(),
+            template: "badge".to_string(),
+            ssr_defaults: JsValue::Object(defaults),
+            rest_props_name: None,
+            param_names: vec!["n".to_string()],
+        },
+    );
+    let root = BfInstance::root(session, "Root_test");
+    let out = backend_minijinja::render_entry(&env, "root", root.as_mj_value(), &no_defaults(), &[]).unwrap();
+    assert_eq!(out, "7");
+}
+
 #[test]
 fn loop_child_without_slot_gets_a_fresh_component_prefixed_scope() {
     let dir = TempDir::new("loopchild");

package/src/render-divergences.ts

@@ -22,20 +22,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

@@ -28,8 +28,8 @@
  * that closes that gap.
  */
 
-import { compileJSX, extractSsrDefaults, importsSearchParams, evaluateSignalInit } 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'
 
@@ -362,24 +362,30 @@ function collectImportedComponentNames(ir: ComponentIR): string[] {
  * design doc; see `runtime/src/backend_minijinja.rs`'s `render_child` for
  * the Rust-side closure — the near-verbatim structural counterpart of
  * adapter-jinja's `buildChildRenderers`, which instead emitted Python
- * closure SOURCE per child). `ssr_defaults` mirrors `ssrDefaultsToPy`:
- * only the static fallback `value` of each `{ value, propName?,
- * isRestProps? }` ssrDefaults entry is needed — the child renderer's
- * caller props always win over it.
+ * closure SOURCE per child). `ssr_defaults` is sent VERBATIM — `value` /
+ * `propName` / `isRestProps` intact — so the Rust runtime's
+ * `derive_stash_from_defaults` (called per-call, inside `render_child`,
+ * against the REAL child props) can resolve an aliased destructured prop's
+ * CALLER-facing key (`n`) onto its local template var (`count`). Sending
+ * only the flattened static `value` here was the #2524 SSR-half bug — it
+ * left nothing for that resolution to read. `param_names` carries the
+ * CALLER-facing name (`sourceName ?? name`) per prop — `render_child`'s
+ * rest-bag "keep" set compares against child props keyed by whatever the
+ * calling template passed, not the child's local binding.
  */
 function buildChildrenPayload(
   childTemplates: Map<string, { template: string; ir: ComponentIR }>,
 ): Array<{
   name: string
   template: string
-  ssr_defaults: Record<string, unknown>
+  ssr_defaults: Record<string, SsrDefault>
   rest_props_name: string | null
   param_names: string[]
 }> {
   const out: Array<{
     name: string
     template: string
-    ssr_defaults: Record<string, unknown>
+    ssr_defaults: Record<string, SsrDefault>
     rest_props_name: string | null
     param_names: string[]
   }> = []
@@ -388,29 +394,14 @@ function buildChildrenPayload(
     out.push({
       name: componentName,
       template: toSnakeCase(componentName),
-      ssr_defaults: ssrDefaultsToVars(ssrDefaults),
+      ssr_defaults: ssrDefaults,
       rest_props_name: childIR.metadata.restPropsName ?? null,
-      param_names: (childIR.metadata.propsParams ?? []).map(p => p.name),
+      param_names: (childIR.metadata.propsParams ?? []).map(p => p.sourceName ?? p.name),
     })
   }
   return out
 }
 
-/** Reduce an ssrDefaults map to its static fallback values (plain JS object). */
-function ssrDefaultsToVars(defaults: Record<string, unknown>): Record<string, unknown> {
-  const out: Record<string, unknown> = {}
-  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.
-    out[name] =
-      d && typeof d === 'object' && 'value' in (d as Record<string, unknown>)
-        ? (d as Record<string, unknown>).value
-        : d
-  }
-  return out
-}
-
 /**
  * Convert PascalCase to snake_case for template naming (matches the
  * adapter's `toTemplateName`).
@@ -445,24 +436,31 @@ function buildVars(
   const vars: Record<string, unknown> = {}
 
   // 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` the Rust runtime calls at
+  // render time for child components — see `render_child` in
+  // `runtime/src/runtime.rs`) 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 value = evaluateSignalInit(param.defaultValue.trim(), props)
-      if (value !== null) {
-        vars[param.name] = value
-        continue
-      }
-    }
+    if (param.isRest) continue
     // No default + no caller value: pass `null` (Rust's `None`/minijinja
     // Undefined) so a bare reference to an optional prop doesn't fault
     // before its falsy branch elides.
-    vars[param.name] = null
+    vars[param.name] = derivedProps[param.name] ?? null
   }
 
   // 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)) {
@@ -477,11 +475,20 @@ function buildVars(
     vars[restPropsName] = 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-assigning 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' ||
         typeof value === 'number' ||
@@ -507,11 +514,9 @@ function buildVars(
 
   // 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
-    vars[memo.name] = value ?? 0
+    const entry = rootSsrDefaults[memo.name]
+    vars[memo.name] = entry ? (entry.value ?? 0) : 0
   }
 
   return vars