@barefootjs/rust 0.19.1 → 0.21.0

package/dist/adapter/index.js

@@ -188814,7 +188814,7 @@ ${alternate}
   renderFragment(fragment) {
     const children = this.renderChildren(fragment.children);
     if (fragment.needsScopeComment) {
-      return `{{ bf.scope_comment() | safe }}${children}`;
+      return `{{ bf.scope_comment() | safe }}${children}{{ bf.scope_comment_end() | safe }}`;
     }
     return children;
   }

package/dist/adapter/minijinja-adapter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"minijinja-adapter.d.ts","sourceRoot":"","sources":["../../src/adapter/minijinja-adapter.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"minijinja-adapter.d.ts","sourceRoot":"","sources":["../../src/adapter/minijinja-adapter.ts"],"names":[],"mappings":"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"}

package/dist/build.js

@@ -188814,7 +188814,7 @@ ${alternate}
   renderFragment(fragment) {
     const children = this.renderChildren(fragment.children);
     if (fragment.needsScopeComment) {
-      return `{{ bf.scope_comment() | safe }}${children}`;
+      return `{{ bf.scope_comment() | safe }}${children}{{ bf.scope_comment_end() | safe }}`;
     }
     return children;
   }

package/dist/conformance-pins.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"conformance-pins.d.ts","sourceRoot":"","sources":["../src/conformance-pins.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAA;AAEtD,eAAO,MAAM,eAAe,EAAE,eA4F7B,CAAA"}
+{"version":3,"file":"conformance-pins.d.ts","sourceRoot":"","sources":["../src/conformance-pins.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAA;AAEtD,eAAO,MAAM,eAAe,EAAE,eAkG7B,CAAA"}

package/dist/index.js

@@ -188814,7 +188814,7 @@ ${alternate}
   renderFragment(fragment) {
     const children = this.renderChildren(fragment.children);
     if (fragment.needsScopeComment) {
-      return `{{ bf.scope_comment() | safe }}${children}`;
+      return `{{ bf.scope_comment() | safe }}${children}{{ bf.scope_comment_end() | safe }}`;
     }
     return children;
   }
@@ -189201,7 +189201,8 @@ var conformancePins = {
   "filter-nested-find-predicate": [
     { code: "BF101", severity: "error", issue: "https://github.com/piconic-ai/barefootjs/issues/2038" }
   ],
-  "dangerous-inner-html-dynamic": [{ code: "BF101", severity: "error", issue: "https://github.com/piconic-ai/barefootjs/issues/2215" }]
+  "dangerous-inner-html-dynamic": [{ code: "BF101", severity: "error", issue: "https://github.com/piconic-ai/barefootjs/issues/2215" }],
+  "date-method-uncatalogued": [{ code: "BF021", severity: "error", issue: "https://github.com/piconic-ai/barefootjs/issues/2274" }]
 };
 // src/render-divergences.ts
 var renderDivergences = {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@barefootjs/rust",
-  "version": "0.19.1",
+  "version": "0.21.0",
   "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,14 +54,14 @@
     "directory": "packages/adapter-rust"
   },
   "dependencies": {
-    "@barefootjs/shared": "0.19.1"
+    "@barefootjs/shared": "0.21.0"
   },
   "peerDependencies": {
     "@barefootjs/jsx": ">=0.2.0"
   },
   "devDependencies": {
     "@barefootjs/adapter-tests": "0.1.0",
-    "@barefootjs/jsx": "0.19.1",
+    "@barefootjs/jsx": "0.21.0",
     "typescript": "^5.0.0"
   }
 }

package/runtime/src/date.rs

@@ -0,0 +1,196 @@
+//! `date(recv, op)` -- zero-arg `Date.prototype` method lowering
+//! (spec/template-helpers.md "date", #2274). `recv` is either this
+//! runtime's own [`JsValue::Date`] (an epoch-millisecond `i64`) or an
+//! ISO-8601 `String` (a template prop may carry either depending on how
+//! the host populated it) -- both normalize to a single epoch-ms integer
+//! via [`epoch_ms_of`] before dispatch.
+//!
+//! No `chrono` (or any other date crate) is a dependency of this crate --
+//! see the design doc's fixed dependency list, the same constraint
+//! `num.rs`'s numeric-string grammar docstring cites for avoiding `regex`.
+//! Calendar <-> day-count conversion is Howard Hinnant's `civil_from_days`
+//! / `days_from_civil` (public-domain algorithm,
+//! <http://howardhinnant.github.io/date_algorithms.html>), correct for the
+//! full proleptic-Gregorian range this catalogue's vectors exercise
+//! (epoch 0, a pre-1970 instant, a leap day, and a four-digit-year
+//! boundary). Every division that must floor (not truncate) toward
+//! -Infinity for a negative dividend uses `div_euclid`/`rem_euclid`
+//! explicitly rather than plain `/`/`%` (which truncate toward zero in
+//! Rust) -- the one correctness trap this port must not reproduce.
+
+use crate::num::JsValue;
+
+const MS_PER_DAY: i64 = 86_400_000;
+
+/// Hinnant `days_from_civil`: (proleptic-Gregorian y/m/d) -> days since the
+/// Unix epoch (1970-01-01). `m` is 1-based (January = 1).
+fn days_from_civil(y: i64, m: i64, d: i64) -> i64 {
+    let y = if m <= 2 { y - 1 } else { y };
+    let era = y.div_euclid(400);
+    let yoe = y.rem_euclid(400); // [0, 399]
+    let mp = if m > 2 { m - 3 } else { m + 9 }; // [0, 11], Mar=0 .. Feb=11
+    let doy = (153 * mp + 2).div_euclid(5) + d - 1; // [0, 365]
+    let doe = yoe * 365 + yoe.div_euclid(4) - yoe.div_euclid(100) + doy; // [0, 146096]
+    era * 146_097 + doe - 719_468
+}
+
+/// Hinnant `civil_from_days`: days since the Unix epoch -> (y, m, d), `m`
+/// 1-based. Inverse of [`days_from_civil`].
+fn civil_from_days(z: i64) -> (i64, i64, i64) {
+    let z = z + 719_468;
+    let era = z.div_euclid(146_097);
+    let doe = z.rem_euclid(146_097); // [0, 146096], always non-negative
+    // `doe` (and everything derived from it below) stays within [0,
+    // 146096] for the rest of this function, so plain truncating `/`
+    // already equals floor division here -- only the two extractions above
+    // (on a value that CAN be negative) need `div_euclid`.
+    let yoe = (doe - doe / 1460 + doe / 36524 - doe / 146_096) / 365; // [0, 399]
+    let y = yoe + era * 400;
+    let doy = doe - (365 * yoe + yoe / 4 - yoe / 100); // [0, 365]
+    let mp = (5 * doy + 2) / 153; // [0, 11]
+    let d = doy - (153 * mp + 2) / 5 + 1; // [1, 31]
+    let m = if mp < 10 { mp + 3 } else { mp - 9 }; // [1, 12]
+    let y = if m <= 2 { y + 1 } else { y };
+    (y, m, d)
+}
+
+/// Parse the exact ISO-8601 shape this catalogue's contract uses --
+/// `YYYY-MM-DDTHH:MM:SS(.mmm)?Z`, always UTC (a bare `Z`, no numeric
+/// offset) -- into epoch milliseconds. This is the one shape every string
+/// the golden vectors pass in uses, and the one shape [`format_iso8601`]
+/// below ever produces, so a fixed-width positional parse (no `regex`
+/// crate in this crate's dependency set) covers the full contract without
+/// a general-purpose date-string grammar.
+pub fn parse_iso8601(s: &str) -> Option<i64> {
+    let b = s.as_bytes();
+    let has_ms = match b.len() {
+        20 => false,
+        24 => true,
+        _ => return None,
+    };
+    if b[4] != b'-' || b[7] != b'-' || b[10] != b'T' || b[13] != b':' || b[16] != b':' {
+        return None;
+    }
+    if has_ms && b[19] != b'.' {
+        return None;
+    }
+    if b[b.len() - 1] != b'Z' {
+        return None;
+    }
+    let year: i64 = s.get(0..4)?.parse().ok()?;
+    let month: i64 = s.get(5..7)?.parse().ok()?;
+    let day: i64 = s.get(8..10)?.parse().ok()?;
+    let hour: i64 = s.get(11..13)?.parse().ok()?;
+    let minute: i64 = s.get(14..16)?.parse().ok()?;
+    let second: i64 = s.get(17..19)?.parse().ok()?;
+    let ms: i64 = if has_ms { s.get(20..23)?.parse().ok()? } else { 0 };
+    if !(1..=12).contains(&month) || !(1..=31).contains(&day) {
+        return None;
+    }
+    if hour > 23 || minute > 59 || second > 60 {
+        return None;
+    }
+    let days = days_from_civil(year, month, day);
+    Some(days * MS_PER_DAY + hour * 3_600_000 + minute * 60_000 + second * 1000 + ms)
+}
+
+/// The inverse of [`parse_iso8601`]: epoch milliseconds -> the exact JS
+/// `Date.prototype.toISOString` shape (always millisecond precision,
+/// always UTC).
+pub fn format_iso8601(ms: i64) -> String {
+    let days = ms.div_euclid(MS_PER_DAY);
+    let ms_of_day = ms.rem_euclid(MS_PER_DAY); // always [0, 86_399_999]
+    let (y, m, d) = civil_from_days(days);
+    let hour = ms_of_day / 3_600_000;
+    let minute = (ms_of_day / 60_000) % 60;
+    let second = (ms_of_day / 1000) % 60;
+    let msec = ms_of_day % 1000;
+    format!("{y:04}-{m:02}-{d:02}T{hour:02}:{minute:02}:{second:02}.{msec:03}Z")
+}
+
+/// Normalize a `date()` receiver to a single epoch-ms integer: this
+/// runtime's own [`JsValue::Date`] unwraps directly; an ISO-8601
+/// [`JsValue::String`] parses via [`parse_iso8601`]. Anything else (the
+/// receiver contract's only two accepted shapes are not met) is `None`,
+/// letting [`date`] apply its documented zero-value fallback.
+pub fn epoch_ms_of(recv: &JsValue) -> Option<i64> {
+    match recv {
+        JsValue::Date(ms) => Some(*ms),
+        JsValue::String(s) => parse_iso8601(s),
+        _ => None,
+    }
+}
+
+/// Dispatch one of the zero-arg `Date.prototype` ops the compiler's
+/// lowering plugin recognizes against an already-normalized epoch-ms
+/// instant. Every accessor and `getTime` render as an INTEGER (a whole
+/// `f64`, never fractional) -- `civil_from_days`'s inputs/outputs are all
+/// exact integers, so no rounding is possible here regardless of how far
+/// `ms` sits from the epoch. `getUTCMonth` is 0-based, matching JS (NOT
+/// `civil_from_days`'s own 1-based `m`, hence the `- 1`).
+pub fn date_op(ms: i64, op: &str) -> JsValue {
+    match op {
+        "getTime" => return JsValue::Number(ms as f64),
+        "toISOString" => return JsValue::String(format_iso8601(ms)),
+        _ => {}
+    }
+    let days = ms.div_euclid(MS_PER_DAY);
+    let ms_of_day = ms.rem_euclid(MS_PER_DAY);
+    let (y, m, d) = civil_from_days(days);
+    match op {
+        "getUTCFullYear" => JsValue::Number(y as f64),
+        "getUTCMonth" => JsValue::Number((m - 1) as f64),
+        "getUTCDate" => JsValue::Number(d as f64),
+        "getUTCHours" => JsValue::Number((ms_of_day / 3_600_000) as f64),
+        "getUTCMinutes" => JsValue::Number(((ms_of_day / 60_000) % 60) as f64),
+        "getUTCSeconds" => JsValue::Number(((ms_of_day / 1000) % 60) as f64),
+        _ => JsValue::Number(0.0),
+    }
+}
+
+/// `date(recv, op)` -- the full helper: normalize `recv` (native
+/// [`JsValue::Date`] or ISO-8601 string) then dispatch `op`. An
+/// unrecognized receiver shape falls back to `toTime`'s documented
+/// zero-value contract (mirrors the Go runtime's `Date`/`toTime` fallback
+/// pair): `''` for `toISOString`, `0` for every accessor/`getTime`.
+pub fn date(recv: &JsValue, op: &str) -> JsValue {
+    match epoch_ms_of(recv) {
+        Some(ms) => date_op(ms, op),
+        None if op == "toISOString" => JsValue::String(String::new()),
+        None => JsValue::Number(0.0),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn round_trips_epoch_0() {
+        let ms = parse_iso8601("1970-01-01T00:00:00.000Z").unwrap();
+        assert_eq!(ms, 0);
+        assert_eq!(format_iso8601(ms), "1970-01-01T00:00:00.000Z");
+    }
+
+    #[test]
+    fn round_trips_pre_1970() {
+        let ms = parse_iso8601("1969-07-20T20:17:40.123Z").unwrap();
+        assert_eq!(ms, -14_182_939_877);
+        assert_eq!(format_iso8601(ms), "1969-07-20T20:17:40.123Z");
+    }
+
+    #[test]
+    fn round_trips_leap_day() {
+        let ms = parse_iso8601("2024-02-29T23:59:59.999Z").unwrap();
+        assert_eq!(format_iso8601(ms), "2024-02-29T23:59:59.999Z");
+        assert_eq!(date_op(ms, "getUTCMonth"), JsValue::Number(1.0));
+        assert_eq!(date_op(ms, "getUTCDate"), JsValue::Number(29.0));
+    }
+
+    #[test]
+    fn round_trips_far_future() {
+        let ms = parse_iso8601("9999-12-31T23:59:59.999Z").unwrap();
+        assert_eq!(format_iso8601(ms), "9999-12-31T23:59:59.999Z");
+        assert_eq!(date_op(ms, "getUTCFullYear"), JsValue::Number(9999.0));
+    }
+}

package/runtime/src/evaluator.rs

@@ -306,6 +306,14 @@ pub fn to_number(v: &JsValue) -> f64 {
             }
         }
         JsValue::Array(_) | JsValue::Object(_) => f64::NAN,
+        // Unreachable in practice: this evaluator only ever sees `JsValue`s
+        // decoded from a `serde_json::Value` ParsedExpr tree or produced by
+        // its own arithmetic, and JSON can't spell a `Date` (see the `num`
+        // module docstring) -- kept exhaustive rather than `unreachable!()`
+        // since `JsValue` is a shared, cross-module enum. `valueOf`-style
+        // (matches `runtime::js_number`'s `JsValue::Date` arm) for
+        // consistency if that ever changes.
+        JsValue::Date(ms) => *ms as f64,
     }
 }
 
@@ -335,6 +343,10 @@ pub fn to_string(v: &JsValue) -> String {
             .collect::<Vec<_>>()
             .join(","),
         JsValue::Object(_) => "[object Object]".to_string(),
+        // Unreachable in practice -- see `to_number`'s `JsValue::Date` arm
+        // above. `toISOString` is the one Date->string shape this
+        // catalogue defines (matches `runtime::js_string`).
+        JsValue::Date(ms) => crate::date::format_iso8601(*ms),
     }
 }
 
@@ -345,6 +357,10 @@ pub fn truthy(v: &JsValue) -> bool {
         JsValue::Number(n) => !n.is_nan() && *n != 0.0, // nonzero and not NaN
         JsValue::String(s) => !s.is_empty(),          // incl. the truthy "0"
         JsValue::Array(_) | JsValue::Object(_) => true,
+        // Unreachable in practice -- see `to_number`'s `JsValue::Date` arm
+        // above. A JS Date object is always truthy, like every other
+        // object.
+        JsValue::Date(_) => true,
     }
 }
 

package/runtime/src/lib.rs

@@ -7,6 +7,7 @@
 //! documented divergences.
 
 pub mod backend_minijinja;
+pub mod date;
 pub mod evaluator;
 pub mod manifest;
 pub mod num;

package/runtime/src/num.rs

@@ -94,6 +94,16 @@ pub enum JsValue {
     /// contract for free, in one place, rather than re-sorting at the
     /// JSON-encoding boundary.
     Object(BTreeMap<String, JsValue>),
+    /// This runtime's own native `Date` receiver shape for `date()`'s
+    /// zero-arg method lowering (spec/template-helpers.md "date", #2274) --
+    /// a signed epoch-MILLISECOND integer (never a float), so a pre-1970
+    /// instant round-trips exactly with no rounding risk. The other half of
+    /// `date()`'s receiver contract, an ISO-8601 `String`, needs no
+    /// dedicated variant since [`JsValue::String`] already carries it; see
+    /// `date::epoch_ms_of`. JSON can't spell this type (`from_json` never
+    /// produces one); `to_json` renders it via its `toISOString` form,
+    /// matching JS `JSON.stringify(date)`.
+    Date(i64),
 }
 
 impl JsValue {
@@ -159,6 +169,9 @@ impl JsValue {
             JsValue::Object(o) => {
                 JsonValue::Object(o.iter().map(|(k, v)| (k.clone(), v.to_json())).collect())
             }
+            // Matches JS `JSON.stringify(date)`, which calls the date's own
+            // `toJSON` -> `toISOString`.
+            JsValue::Date(ms) => JsonValue::String(crate::date::format_iso8601(*ms)),
         }
     }
 }

package/runtime/src/runtime.rs

@@ -43,9 +43,10 @@
 //!     operator it emits.
 
 use crate::backend_minijinja;
+use crate::date;
 use crate::evaluator;
 use crate::num::{self, JsValue};
-use minijinja::value::{from_args, Enumerator, Kwargs, Object, Value as MjValue, ValueKind};
+use minijinja::value::{from_args, Enumerator, Kwargs, Object, ObjectRepr, Value as MjValue, ValueKind};
 use minijinja::{Error, ErrorKind, State};
 use std::collections::{BTreeMap, HashMap, HashSet};
 use std::sync::{Arc, Mutex};
@@ -111,6 +112,11 @@ pub fn js_string(v: &JsValue) -> String {
             .collect::<Vec<_>>()
             .join(","),
         JsValue::Object(_) => "[object Object]".to_string(),
+        // No JS `Date.prototype.toString()` port (that format -- e.g. "Fri
+        // Jul 20 1969 20:17:40 GMT+0000" -- is out of this catalogue's
+        // scope, #2274); `toISOString` is the one Date->string shape the
+        // spec defines, so a bare `bf.string(date)` uses it too.
+        JsValue::Date(ms) => date::format_iso8601(*ms),
     }
 }
 
@@ -125,6 +131,9 @@ pub fn js_number(v: &JsValue) -> f64 {
         JsValue::Number(n) => *n,
         JsValue::String(s) => if num::looks_like_number(s) { num::parse_number_literal(s) } else { f64::NAN },
         JsValue::Array(_) | JsValue::Object(_) => f64::NAN,
+        // `Number(date)` mirrors JS `Date`'s default `valueOf` coercion:
+        // the epoch-ms count itself.
+        JsValue::Date(ms) => *ms as f64,
     }
 }
 
@@ -137,6 +146,7 @@ pub fn js_truthy(v: &JsValue) -> bool {
         JsValue::Number(n) => !n.is_nan() && *n != 0.0, // not NaN, not zero
         JsValue::String(s) => !s.is_empty(),          // incl. the JS-truthy "0"
         JsValue::Array(_) | JsValue::Object(_) => true,
+        JsValue::Date(_) => true, // a JS Date object is always truthy
     }
 }
 
@@ -440,13 +450,13 @@ fn is_numeric_like(v: &JsValue) -> bool {
         JsValue::Null | JsValue::Bool(_) => false,
         JsValue::Number(_) => true,
         JsValue::String(s) => num::looks_like_number(s),
-        JsValue::Array(_) | JsValue::Object(_) => false,
+        JsValue::Array(_) | JsValue::Object(_) | JsValue::Date(_) => false,
     }
 }
 
 fn numeric_value(v: &JsValue) -> f64 {
     match v {
-        JsValue::Null | JsValue::Array(_) | JsValue::Object(_) => 0.0,
+        JsValue::Null | JsValue::Array(_) | JsValue::Object(_) | JsValue::Date(_) => 0.0,
         JsValue::Bool(b) => if *b { 1.0 } else { 0.0 },
         JsValue::Number(n) => *n,
         JsValue::String(s) => if num::looks_like_number(s) { num::parse_number_literal(s) } else { 0.0 },
@@ -936,6 +946,13 @@ impl BfInstance {
         format!("<!--bf-scope:{}{host_segment}{props_json}-->", self.scope_id)
     }
 
+    /// Paired end marker for `scope_comment`, emitted after the fragment's
+    /// last top-level node. No host/props segments -- the client only needs
+    /// the scope id to close the boundary (#2289).
+    fn scope_comment_end(&self) -> String {
+        format!("<!--bf-/scope:{}-->", self.scope_id)
+    }
+
     fn provide_context(&self, name: &str, value: JsValue) {
         self.session.context_stacks.lock().unwrap().entry(name.to_string()).or_default().push(value);
     }
@@ -1075,6 +1092,14 @@ impl BfInstance {
 // ---------------------------------------------------------------------------
 
 pub fn mj_to_js(v: &MjValue) -> JsValue {
+    // A `JsDate`-wrapped native Date prop (see that struct's docstring)
+    // isn't a Seq/Map/Iterable, so it would otherwise fall into the
+    // catch-all `_ => JsValue::Null` below, silently losing the receiver
+    // `date()` needs -- checked first, ahead of the generic `v.kind()`
+    // dispatch.
+    if let Some(d) = v.downcast_object_ref::<JsDate>() {
+        return JsValue::Date(d.0);
+    }
     match v.kind() {
         ValueKind::Undefined | ValueKind::None => JsValue::Null,
         ValueKind::Bool => JsValue::Bool(v.is_true()),
@@ -1148,6 +1173,39 @@ pub fn js_to_mj(v: &JsValue) -> MjValue {
             let map: BTreeMap<String, MjValue> = o.iter().map(|(k, v)| (k.clone(), js_to_mj(v))).collect();
             MjValue::from(map)
         }
+        JsValue::Date(ms) => MjValue::from_object(JsDate(*ms)),
+    }
+}
+
+/// This runtime's own native "Date" value, wrapped as a minijinja
+/// `Object` so a host can seed a template var with a real Date-typed
+/// receiver instead of always going through `date()`'s ISO-8601-string
+/// contract half (spec/template-helpers.md "date", #2274; mirrors the Go
+/// runtime's `time.Time` / the Ruby runtime's `Time` as the "native"
+/// receiver shape). Carries nothing but the epoch-ms integer
+/// `JsValue::Date` already carries -- `mj_to_js`/`js_to_mj` above
+/// round-trip it losslessly via `downcast_object_ref`/`from_object`.
+#[derive(Debug)]
+struct JsDate(i64);
+
+impl Object for JsDate {
+    fn repr(self: &Arc<Self>) -> ObjectRepr {
+        ObjectRepr::Plain
+    }
+
+    // A JS `Date` object is always truthy, like every other object.
+    fn is_true(self: &Arc<Self>) -> bool {
+        true
+    }
+
+    fn render(self: &Arc<Self>, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result
+    where
+        Self: Sized + 'static,
+    {
+        // `toISOString` is the one Date->string shape this catalogue
+        // defines (see `js_string`'s `JsValue::Date` arm); a bare
+        // interpolation of a native Date value uses the same shape.
+        write!(f, "{}", date::format_iso8601(self.0))
     }
 }
 
@@ -1240,6 +1298,7 @@ impl Object for BfInstance {
             "text_start" => Ok(safe(format!("<!--bf:{}-->", js_string(a(0))))),
             "text_end" => Ok(safe("<!--/-->".to_string())),
             "scope_comment" => Ok(safe(self.scope_comment())),
+            "scope_comment_end" => Ok(safe(self.scope_comment_end())),
 
             // -- Script registration ---------------------------------------
             "register_script" => {
@@ -1272,6 +1331,13 @@ impl Object for BfInstance {
             "max" => Ok(MjValue::from(num::js_max(js_number(a(0)), js_number(a(1))))),
             "abs" => Ok(MjValue::from(num::js_abs(js_number(a(0))))),
             "to_fixed" => Ok(MjValue::from(num::to_fixed(js_number(a(0)), num::to_f64(a(1)) as i32))),
+            // `date(recv, op)` -- zero-arg `Date.prototype` method
+            // lowering (spec/template-helpers.md "date", #2274). `recv` is
+            // either a `JsDate`-wrapped native receiver (already converted
+            // to `JsValue::Date` by `mj_to_js` above) or an ISO-8601
+            // string; `date::date` normalizes and dispatches both. `op`
+            // stays a plain string arg, never routed through `js_number`.
+            "date" => Ok(js_to_mj(&date::date(a(0), a(1).as_str().unwrap_or("")))),
 
             // -- Array / string method helpers (#1448 Tier A) ------------------
             "includes" => Ok(MjValue::from(includes(a(0), a(1)))),

package/runtime/tests/helper_vectors.rs

@@ -24,6 +24,7 @@
 //! `tests/vector-divergences.json`.
 
 use barefootjs::backend_minijinja;
+use barefootjs::date;
 use barefootjs::num::{self, JsValue};
 use barefootjs::runtime;
 use barefootjs::SearchParams;
@@ -44,6 +45,31 @@ fn obj(v: &JsValue, key: &str) -> JsValue {
     v.as_object().and_then(|m| m.get(key)).cloned().unwrap_or(JsValue::Null)
 }
 
+/// Materializes the `{"$date": "<ISO>"}` native-date arg sentinel (#2288)
+/// into this runtime's own `JsValue::Date`, so `date()`'s native-receiver
+/// branch (not just its ISO-string branch) is exercised. Recurses through
+/// arrays/objects the same shape the Perl port's `normalize_arg` walks,
+/// since a vector's `args` may nest the sentinel inside a higher-order
+/// projection payload. Panics on an unparseable `$date` string -- the
+/// corpus is generated from a fixed set of known-good ISO instants, so a
+/// parse failure here means the harness itself is broken, not the case
+/// under test.
+fn materialize_arg(v: &JsonValue) -> JsValue {
+    if let Some(o) = v.as_object() {
+        if let Some(iso) = o.get("$date").and_then(|d| d.as_str()) {
+            if o.len() == 1 {
+                let ms = date::parse_iso8601(iso).unwrap_or_else(|| panic!("materialize_arg: invalid $date {iso:?}"));
+                return JsValue::Date(ms);
+            }
+        }
+        return JsValue::Object(o.iter().map(|(k, x)| (k.clone(), materialize_arg(x))).collect());
+    }
+    if let Some(a) = v.as_array() {
+        return JsValue::Array(a.iter().map(materialize_arg).collect());
+    }
+    JsValue::from_json(v)
+}
+
 /// Mirrors `test_helper_vectors.py`'s `_truthy_pred`.
 fn truthy_pred(item: &JsValue, field: &str) -> bool {
     runtime::js_truthy(&obj(item, field))
@@ -123,6 +149,7 @@ fn call_binding(fn_name: &str, args: &[JsValue]) -> Option<JsValue> {
             let digits = if args.len() > 1 { num::to_f64(&a(1)) as i32 } else { 0 };
             JsValue::String(num::to_fixed(runtime::js_number(&a(0)), digits))
         }
+        "date" => date::date(&a(0), a(1).as_str().unwrap_or("")),
         "lower" => JsValue::String(runtime::js_string(&a(0)).to_lowercase()),
         "upper" => JsValue::String(runtime::js_string(&a(0)).to_uppercase()),
         "trim" => JsValue::String(runtime::trim(&a(0))),
@@ -237,6 +264,11 @@ fn py_truthy(v: &JsValue) -> bool {
         JsValue::String(s) => !s.is_empty(),
         JsValue::Array(a) => !a.is_empty(),
         JsValue::Object(o) => !o.is_empty(),
+        // Unreachable: no binding in this file ever returns a
+        // `JsValue::Date` (`date()` itself always returns `Number` or
+        // `String`, per its own return type) -- kept exhaustive since
+        // `JsValue` is a shared enum.
+        JsValue::Date(_) => true,
     }
 }
 
@@ -298,7 +330,7 @@ fn helper_vectors_match_js_reference_or_declared_divergence() {
         let note = case["note"].as_str().unwrap();
         let key = format!("{fn_name}/{note}");
         let raw_args = case["args"].as_array().cloned().unwrap_or_default();
-        let args: Vec<JsValue> = raw_args.iter().map(JsValue::from_json).collect();
+        let args: Vec<JsValue> = raw_args.iter().map(materialize_arg).collect();
         let expect = &case["expect"];
 
         if let Some(reason) = div_file.unsupported.get(fn_name) {

package/src/__tests__/minijinja-adapter-unit.test.ts

@@ -530,3 +530,28 @@ function Widget({ rows }: { rows: { x: string }[] }) {
     expect(template).toContain('bf.string(cfg.x)')
   })
 })
+
+describe('MinijinjaAdapter - fragment-root scope comment end marker (#2289)', () => {
+  // A fragment-rooted component (multiple top-level nodes) uses a
+  // comment-based scope marker instead of a real DOM element, so it needs a
+  // paired end marker after the last top-level node -- otherwise
+  // client-side queries from this scope leak onto later siblings owned by
+  // the parent. See `scope_comment_end` in `runtime/src/runtime.rs`.
+  test('emits a bf-/scope end marker with the same scope id as the begin marker', () => {
+    const { template } = compileAndGenerate(`
+export function Wrapper({ children }: { children?: any }) {
+  return (
+    <>
+      <div>Header</div>
+      {children}
+    </>
+  )
+}
+`)
+    expect(template).toContain('{{ bf.scope_comment() | safe }}')
+    expect(template).toContain('{{ bf.scope_comment_end() | safe }}')
+    expect(template.indexOf('bf.scope_comment()')).toBeLessThan(
+      template.indexOf('bf.scope_comment_end()'),
+    )
+  })
+})

package/src/adapter/minijinja-adapter.ts

@@ -1262,7 +1262,10 @@ export class MinijinjaAdapter extends BaseAdapter implements IRNodeEmitter<Jinja
   private renderFragment(fragment: IRFragment): string {
     const children = this.renderChildren(fragment.children)
     if (fragment.needsScopeComment) {
-      return `{{ bf.scope_comment() | safe }}${children}`
+      // End marker bounds the scope's sibling range -- without it, queries
+      // from the fragment scope leak onto later siblings owned by the
+      // parent (#2289).
+      return `{{ bf.scope_comment() | safe }}${children}{{ bf.scope_comment_end() | safe }}`
     }
     return children
   }

package/src/conformance-pins.ts

@@ -103,4 +103,10 @@ export const conformancePins: ConformancePins = {
   // A dynamic/signal-derived value still refuses with BF101 — see the
   // `dangerous-inner-html-dynamic` fixture/pin below (tracked: #2215).
   'dangerous-inner-html-dynamic': [{ code: 'BF101', severity: 'error', issue: 'https://github.com/piconic-ai/barefootjs/issues/2215' }],
+  // #2273: a method call on a prop typed as a built-in host rich type
+  // (Date, Map, …) has no catalogued lowering in any adapter — this is a
+  // compiler-level refusal (`checkRichTypeMethodCalls`, wired ahead of
+  // `adapter.generate()`), not an adapter-specific gap, so it is pinned
+  // identically across every adapter package including Hono.
+  'date-method-uncatalogued': [{ code: 'BF021', severity: 'error', issue: 'https://github.com/piconic-ai/barefootjs/issues/2274' }],
 }

package/src/test-render.ts

@@ -529,6 +529,15 @@ function buildVars(
  * uniformly rather than threading the transform through each builder.
  */
 function encodeSpecials(value: unknown): unknown {
+  if (value instanceof Date) {
+    // A Date prop crosses the language boundary as its ISO-8601 string —
+    // the shared `date()` runtime helper (#2274/#2288) accepts an ISO
+    // string as well as a native `chrono` date type. MUST come before the
+    // generic object branch below, which REBUILDS the object via
+    // `Object.entries()` — a Date's fields are non-enumerable, so that
+    // rebuild would silently erase it into `{}`.
+    return value.toISOString()
+  }
   if (typeof value === 'number') {
     if (Number.isNaN(value)) return { __bf_special: 'nan' }
     if (value === Infinity) return { __bf_special: 'inf' }