@barefootjs/rust 0.18.3 → 0.18.5

package/dist/index.js

@@ -187369,7 +187369,7 @@ function isAriaBooleanAttr(name) {
 }
 
 // src/adapter/minijinja-adapter.ts
-import { BF_SLOT, BF_COND, BF_REGION } from "@barefootjs/shared";
+import { BF_SLOT, BF_COND, BF_REGION, escapeHtml } from "@barefootjs/shared";
 
 // src/adapter/lib/constants.ts
 var JINJA_TEMPLATE_PRIMITIVES = {
@@ -187378,7 +187378,10 @@ var JINJA_TEMPLATE_PRIMITIVES = {
   Number: { arity: 1, emit: (args) => `bf.number(${args[0]})` },
   "Math.floor": { arity: 1, emit: (args) => `bf.floor(${args[0]})` },
   "Math.ceil": { arity: 1, emit: (args) => `bf.ceil(${args[0]})` },
-  "Math.round": { arity: 1, emit: (args) => `bf.round(${args[0]})` }
+  "Math.round": { arity: 1, emit: (args) => `bf.round(${args[0]})` },
+  "Math.min": { arity: 2, emit: (args) => `bf.min(${args[0]}, ${args[1]})` },
+  "Math.max": { arity: 2, emit: (args) => `bf.max(${args[0]}, ${args[1]})` },
+  "Math.abs": { arity: 1, emit: (args) => `bf.abs(${args[0]})` }
 };
 var JINJA_PRIMITIVE_EMIT_MAP = Object.fromEntries(Object.entries(JINJA_TEMPLATE_PRIMITIVES).map(([k, v]) => [k, v.emit]));
 
@@ -187544,6 +187547,12 @@ function renderArrayMethod(method, object, args, emit) {
       const recv = emit(object);
       return `bf.trim(${recv})`;
     }
+    case "trimStart":
+    case "trimEnd": {
+      const fn = method === "trimStart" ? "trim_start" : "trim_end";
+      const recv = emit(object);
+      return `bf.${fn}(${recv})`;
+    }
     case "toFixed": {
       const recv = emit(object);
       const digits = args.length >= 1 ? emit(args[0]) : "0";
@@ -187577,6 +187586,12 @@ function renderArrayMethod(method, object, args, emit) {
       const newS = emit(args[1]);
       return `bf.replace(${recv}, ${oldS}, ${newS})`;
     }
+    case "replaceAll": {
+      const recv = emit(object);
+      const oldS = emit(args[0]);
+      const newS = emit(args[1]);
+      return `bf.replace_all(${recv}, ${oldS}, ${newS})`;
+    }
     case "repeat": {
       const recv = emit(object);
       const count = args.length === 0 ? "0" : emit(args[0]);
@@ -187673,6 +187688,7 @@ function renderFlatMethod(recv, depth, emit) {
 
 // src/adapter/expr/emitters.ts
 import {
+  groupBinaryOperand,
   identifierPath,
   matchSearchParamsMethodCall,
   sortComparatorFromArrow
@@ -187718,7 +187734,7 @@ class JinjaFilterEmitter {
       return "none";
     return String(value);
   }
-  member(object, property, _computed, emit) {
+  member(object, property, _computed, _optional, emit) {
     if (property === "length") {
       return `bf.length(${emit(object)})`;
     }
@@ -187741,8 +187757,8 @@ class JinjaFilterEmitter {
     return emit(argument);
   }
   binary(op, left, right, emit) {
-    const l = emit(left);
-    const r = emit(right);
+    const l = groupBinaryOperand(left, emit(left));
+    const r = groupBinaryOperand(right, emit(right));
     const opMap = {
       "===": "==",
       "!==": "!=",
@@ -187824,7 +187840,7 @@ class JinjaTopLevelEmitter {
       return "none";
     return String(value);
   }
-  member(object, property, _computed, emit) {
+  member(object, property, _computed, _optional, emit) {
     if (object.kind === "identifier" && object.name === "props") {
       return minijinjaIdent(property);
     }
@@ -187870,8 +187886,8 @@ class JinjaTopLevelEmitter {
     return emit(argument);
   }
   binary(op, left, right, emit) {
-    const l = emit(left);
-    const r = emit(right);
+    const l = groupBinaryOperand(left, emit(left));
+    const r = groupBinaryOperand(right, emit(right));
     const opMap = {
       "===": "==",
       "!==": "!=",
@@ -188251,6 +188267,7 @@ class MinijinjaAdapter extends BaseAdapter {
   options;
   errors = [];
   inLoop = false;
+  currentLoopKeyDepth = 0;
   propsObjectName = null;
   propsParams = [];
   booleanTypedProps = new Set;
@@ -188327,7 +188344,7 @@ class MinijinjaAdapter extends BaseAdapter {
     return this.renderElement(node);
   }
   emitText(node) {
-    return node.value;
+    return escapeHtml(node.value);
   }
   emitExpression(node) {
     return this.renderExpression(node);
@@ -188557,7 +188574,7 @@ ${whenTrue}
     const renderedChildren = this.renderChildren(loop.children);
     const loopVar = loop.iterationShape === "keys" ? "__bf_item" : supportableDestructure ? "__bf_item" : param;
     const indexLocalLines = [];
-    if (loop.iterationShape === "keys") {
+    if (loop.objectIteration) {} else if (loop.iterationShape === "keys") {
       indexLocalLines.push(`{% set ${minijinjaIdent(param)} = loop.index0 %}`);
     } else if (loop.index) {
       indexLocalLines.push(`{% set ${minijinjaIdent(loop.index)} = loop.index0 %}`);
@@ -188577,13 +188594,17 @@ ${whenTrue}
     }
     const prevInLoop = this.inLoop;
     this.inLoop = true;
+    const prevLoopKeyDepth = this.currentLoopKeyDepth;
+    this.currentLoopKeyDepth = loop.depth;
     const childrenUnderLoop = this.renderChildren(loop.children);
+    this.currentLoopKeyDepth = prevLoopKeyDepth;
     this.inLoop = prevInLoop;
     const bodyChildren = loop.bodyIsItemConditional && loop.key ? `{{ bf.comment("loop-i:" ~ bf.string(${this.convertExpressionToJinja(loop.key)})) | safe }}
 ${childrenUnderLoop}` : childrenUnderLoop;
     const lines = [];
     lines.push(`{{ bf.comment("loop:${loop.markerId}") | safe }}`);
-    lines.push(`{% for ${minijinjaIdent(loopVar)} in ${array} %}`);
+    const forHeader = loop.objectIteration === "entries" ? `{% for ${minijinjaIdent(loop.index ?? param)}, ${minijinjaIdent(param)} in ${array}|items %}` : loop.objectIteration === "keys" ? `{% for ${minijinjaIdent(param)}, __bf_v in ${array}|items %}` : loop.objectIteration === "values" ? `{% for __bf_k, ${minijinjaIdent(param)} in ${array}|items %}` : `{% for ${minijinjaIdent(loopVar)} in ${array} %}`;
+    lines.push(forHeader);
     for (const il of indexLocalLines)
       lines.push(il);
     if (loop.filterPredicate) {
@@ -188655,9 +188676,20 @@ ${childrenUnderLoop}` : childrenUnderLoop;
   renderComponent(comp) {
     const segments = [{ kind: "entries", parts: [] }];
     const currentEntries = () => this.componentPropSegmentEntries(segments);
+    const namedSlotSetBlocks = [];
     for (const p of comp.props) {
       if ((p.name.match(/^on[A-Z]/) || p.name === "ref") && p.value.kind === "expression")
         continue;
+      if (p.value.kind === "jsx-children" && p.name !== "children") {
+        const prevInLoop = this.inLoop;
+        this.inLoop = false;
+        const slotBody = this.renderChildren(p.value.children);
+        this.inLoop = prevInLoop;
+        const captureName = `bf_prop_${this.childrenCaptureCounter++}`;
+        namedSlotSetBlocks.push(`{% set ${captureName} %}${slotBody}{% endset %}`);
+        currentEntries().push(`${minijinjaHashKey(p.name)}: ${captureName}`);
+        continue;
+      }
       if (p.value.kind === "spread") {
         const trimmed = p.value.expr.trim();
         if (this.propsObjectName && this.propsObjectName === trimmed) {
@@ -188686,11 +188718,11 @@ ${childrenUnderLoop}` : childrenUnderLoop;
       const captureName = `bf_children_${comp.slotId ?? "c" + this.childrenCaptureCounter++}`;
       currentEntries().push(`${minijinjaHashKey("children")}: ${captureName}`);
       const dict = this.combineComponentPropSegments(segments);
-      return `{% set ${captureName} %}${childrenBody}{% endset %}{{ bf.render_child('${tplName}', ${dict}) | safe }}`;
+      return `${namedSlotSetBlocks.join("")}{% set ${captureName} %}${childrenBody}{% endset %}{{ bf.render_child('${tplName}', ${dict}) | safe }}`;
     }
     const isEmpty = segments.every((s) => s.kind === "entries" && s.parts.length === 0);
     const dictEntries = isEmpty ? "" : `, ${this.combineComponentPropSegments(segments)}`;
-    return `{{ bf.render_child('${tplName}'${dictEntries}) | safe }}`;
+    return `${namedSlotSetBlocks.join("")}{{ bf.render_child('${tplName}'${dictEntries}) | safe }}`;
   }
   childrenCaptureCounter = 0;
   presenceVarCounter = 0;
@@ -188735,7 +188767,7 @@ ${alternate}
 ${children}`;
   }
   elementAttrEmitter = {
-    emitLiteral: (value, name) => `${name}="${value.value}"`,
+    emitLiteral: (value, name) => `${name}="${escapeHtml(value.value)}"`,
     emitExpression: (value, name) => {
       if (name === "style") {
         const css = this.tryLowerStyleObject(value.expr);
@@ -188843,9 +188875,10 @@ ${name}="{{ bf.string(${val}) }}"
       let attrName;
       if (attr.name === "className")
         attrName = "class";
-      else if (attr.name === "key")
-        attrName = "data-key";
-      else
+      else if (attr.name === "key") {
+        const depth = this.currentLoopKeyDepth;
+        attrName = depth > 0 ? `data-key-${depth}` : "data-key";
+      } else
         attrName = attr.name;
       const lowered = emitAttrValue(attr.value, this.elementAttrEmitter, attrName);
       if (lowered)
@@ -189104,24 +189137,10 @@ var conformancePins = {
     { code: "BF101", severity: "error", issue: "https://github.com/piconic-ai/barefootjs/issues/2038" }
   ],
   "array-map-function-reference": [{ code: "BF101", severity: "error" }],
-  "dangerous-inner-html": [{ code: "BF101", severity: "error" }],
-  "string-replaceall": [{ code: "BF101", severity: "error" }]
+  "dangerous-inner-html": [{ code: "BF101", severity: "error" }]
 };
 // src/render-divergences.ts
-var renderDivergences = {
-  "arithmetic-text": "`(count() + 2) * 3` renders 10 instead of 18 — the parenthesised sub-expression loses its grouping (silent wrong arithmetic)",
-  "html-entity-text": "`©` in JSX literal text: Hono decodes to `©`, this adapter re-emits the raw entity — same DOM, different bytes",
-  "math-methods": "Math.min/max/abs over a signal render empty (only Math.floor is in the template-primitive registry)",
-  "boolean-attr-literals": 'camelCase boolean alias `readOnly`: Hono SSRs `readOnly="true"`, this adapter emits bare presence',
-  "camelcase-attributes": "`htmlFor` is not lowered to `for` (Hono maps it)",
-  "static-attr-escape": 'static attribute values are not HTML-escaped (`title="Fish & Chips"` emitted raw; Hono escapes)',
-  "svg-icon": "SVG camelCase presentation attrs (`strokeWidth`, `strokeLinecap`) pass through unmapped; Hono lowers to kebab-case",
-  "object-entries-map": "`Object.entries(prop).map(([k, v]) => …)` renders an EMPTY list — the object-shaped prop silently produces zero iterations",
-  "nested-loop-outer-binding": "nested-loop inner items carry `data-key` where the reference emits the depth-suffixed `data-key-1`",
-  "jsx-element-prop": "a JSX element passed as a NON-children prop renders an empty slot — the element value is silently dropped",
-  "string-slice": "`.slice()` on a STRING renders empty (array-slice helper misfires on strings)",
-  "string-trim-sided": "`.trimStart()` / `.trimEnd()` render empty (no lowering)"
-};
+var renderDivergences = {};
 export {
   renderDivergences,
   minijinjaAdapter,

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;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAA;AAExD,eAAO,MAAM,iBAAiB,EAAE,iBAyB/B,CAAA"}
+{"version":3,"file":"render-divergences.d.ts","sourceRoot":"","sources":["../src/render-divergences.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAA;AAExD,eAAO,MAAM,iBAAiB,EAAE,iBAAsB,CAAA"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@barefootjs/rust",
-  "version": "0.18.3",
+  "version": "0.18.5",
   "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.18.3"
+    "@barefootjs/shared": "0.18.5"
   },
   "peerDependencies": {
     "@barefootjs/jsx": ">=0.2.0"
   },
   "devDependencies": {
     "@barefootjs/adapter-tests": "0.1.0",
-    "@barefootjs/jsx": "0.18.3",
+    "@barefootjs/jsx": "0.18.5",
     "typescript": "^5.0.0"
   }
 }

package/runtime/src/num.rs

@@ -373,6 +373,36 @@ pub fn js_round(n: f64) -> f64 {
     (n + 0.5).floor()
 }
 
+/// `Math.min(a, b)` / `Math.max(a, b)` -- two-arg forms only (#2168
+/// math-methods). NOT `f64::min`/`f64::max`: those follow IEEE-754
+/// `minNum`/`maxNum` semantics and return the non-NaN operand when only
+/// one side is NaN, whereas JS returns NaN if EITHER operand is NaN.
+pub fn js_min(a: f64, b: f64) -> f64 {
+    if a.is_nan() {
+        return a;
+    }
+    if b.is_nan() {
+        return b;
+    }
+    if a < b { a } else { b }
+}
+
+pub fn js_max(a: f64, b: f64) -> f64 {
+    if a.is_nan() {
+        return a;
+    }
+    if b.is_nan() {
+        return b;
+    }
+    if a > b { a } else { b }
+}
+
+/// `Math.abs()` (#2168 math-methods). `f64::abs` already matches JS for
+/// NaN (NaN.abs() is NaN) and both infinities, no guard needed.
+pub fn js_abs(n: f64) -> f64 {
+    n.abs()
+}
+
 /// JS `%`: remainder with the dividend's sign. Rust's `%` on `f64` already
 /// implements C `fmod` semantics (IEEE-754 remainder), so this is a
 /// documentation-only wrapper -- see the module docstring for why no

package/runtime/src/runtime.rs

@@ -166,6 +166,34 @@ fn char_slice_to(s: &str, n: usize) -> String {
     s.chars().take(n).collect()
 }
 
+/// `[start, end)` range slice by Unicode scalar value (`char`), not
+/// byte offset -- shared by `slice`'s string branch. Matches JS except
+/// for astral-plane input, the same divergence boundary `char_len` /
+/// `char_slice_from` / `char_slice_to` already accept.
+fn char_slice_range(s: &str, start: usize, end: usize) -> String {
+    if start >= end {
+        return String::new();
+    }
+    s.chars().skip(start).take(end - start).collect()
+}
+
+/// Clamp JS `.slice(start, end?)` bounds against a receiver of
+/// `length` elements -- shared by `slice`'s array and string branches
+/// below.
+fn clamp_slice_range(length: i64, start: &JsValue, end: &JsValue) -> (i64, i64) {
+    let mut s = if matches!(start, JsValue::Null) { 0 } else { num::to_f64(start) as i64 };
+    if s < 0 {
+        s += length;
+    }
+    s = s.clamp(0, length);
+    let mut e = if matches!(end, JsValue::Null) { length } else { num::to_f64(end) as i64 };
+    if e < 0 {
+        e += length;
+    }
+    e = e.clamp(0, length);
+    (s, e)
+}
+
 // ---------------------------------------------------------------------------
 // spread_attrs support (JSX intrinsic-element spread, #1407).
 // ---------------------------------------------------------------------------
@@ -1155,6 +1183,9 @@ impl Object for BfInstance {
             "floor" => Ok(MjValue::from(num::js_floor(js_number(a(0))))),
             "ceil" => Ok(MjValue::from(num::js_ceil(js_number(a(0))))),
             "round" => Ok(MjValue::from(num::js_round(js_number(a(0))))),
+            "min" => Ok(MjValue::from(num::js_min(js_number(a(0)), js_number(a(1))))),
+            "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))),
 
             // -- Array / string method helpers (#1448 Tier A) ------------------
@@ -1191,6 +1222,8 @@ impl Object for BfInstance {
                 Ok(js_to_mj(&flat_map_tuple(a(0), &specs)))
             }
             "trim" => Ok(MjValue::from(trim(a(0)))),
+            "trim_start" => Ok(MjValue::from(trim_start(a(0)))),
+            "trim_end" => Ok(MjValue::from(trim_end(a(0)))),
             "split" => {
                 let sep = if args.len() > 1 { Some(a(1)) } else { None };
                 let limit = if args.len() > 2 && !matches!(a(2), JsValue::Null) { Some(num::to_f64(a(2)) as i64) } else { None };
@@ -1199,6 +1232,7 @@ impl Object for BfInstance {
             "starts_with" => Ok(MjValue::from(starts_with(a(0), a(1), a(2)))),
             "ends_with" => Ok(MjValue::from(ends_with(a(0), a(1), a(2)))),
             "replace" => Ok(MjValue::from(replace(a(0), a(1), a(2)))),
+            "replace_all" => Ok(MjValue::from(replace_all(a(0), a(1), a(2)))),
             "query" => Ok(MjValue::from(query(a(0), &js_args[1..]))),
             "repeat" => Ok(MjValue::from(repeat(a(0), a(1)))),
             "pad_start" => Ok(MjValue::from(pad(&scalar_or_empty(a(0)), a(1), a(2), true))),
@@ -1351,7 +1385,18 @@ pub fn concat(a: &JsValue, b: &JsValue) -> JsValue {
     JsValue::Array(out)
 }
 
+/// `Array.prototype.slice(start, end?)` AND `String.prototype.slice`
+/// (the `string-slice` divergence) -- the adapter emits the same
+/// `bf.slice(recv, start, end)` call for both receiver shapes (it
+/// can't disambiguate string vs. array at compile time), so this
+/// dispatches on `recv`'s `JsValue` variant, mirroring `includes` /
+/// `length` above.
 pub fn slice(recv: &JsValue, start: &JsValue, end: &JsValue) -> JsValue {
+    if let JsValue::String(s) = recv {
+        let length = char_len(s) as i64;
+        let (s_idx, e_idx) = clamp_slice_range(length, start, end);
+        return JsValue::String(char_slice_range(s, s_idx as usize, e_idx as usize));
+    }
     let items = match recv.as_array() {
         Some(a) => a,
         None => return JsValue::Array(Vec::new()),
@@ -1360,16 +1405,7 @@ pub fn slice(recv: &JsValue, start: &JsValue, end: &JsValue) -> JsValue {
     if length == 0 {
         return JsValue::Array(Vec::new());
     }
-    let mut s = if matches!(start, JsValue::Null) { 0 } else { num::to_f64(start) as i64 };
-    if s < 0 {
-        s += length;
-    }
-    s = s.clamp(0, length);
-    let mut e = if matches!(end, JsValue::Null) { length } else { num::to_f64(end) as i64 };
-    if e < 0 {
-        e += length;
-    }
-    e = e.clamp(0, length);
+    let (s, e) = clamp_slice_range(length, start, end);
     if s >= e {
         return JsValue::Array(Vec::new());
     }
@@ -1420,6 +1456,24 @@ pub fn trim(recv: &JsValue) -> String {
     }
 }
 
+/// `String.prototype.trimStart()` -- the one-sided sibling of `trim`
+/// above (#2183 follow-up), via Rust's native `str::trim_start`.
+pub fn trim_start(recv: &JsValue) -> String {
+    match recv {
+        JsValue::Null | JsValue::Array(_) | JsValue::Object(_) => String::new(),
+        other => js_string(other).trim_start().to_string(),
+    }
+}
+
+/// `String.prototype.trimEnd()` -- the one-sided sibling of `trim`
+/// above (#2183 follow-up), via Rust's native `str::trim_end`.
+pub fn trim_end(recv: &JsValue) -> String {
+    match recv {
+        JsValue::Null | JsValue::Array(_) | JsValue::Object(_) => String::new(),
+        other => js_string(other).trim_end().to_string(),
+    }
+}
+
 pub fn split(recv: &JsValue, sep: Option<&JsValue>, limit: Option<i64>) -> JsValue {
     let s = scalar_or_empty(recv);
     let mut parts: Vec<String> = match sep {
@@ -1488,6 +1542,20 @@ pub fn replace(recv: &JsValue, pattern: &JsValue, replacement: &JsValue) -> Stri
     }
 }
 
+/// `String.prototype.replaceAll(pattern, replacement)`, string-pattern
+/// form only (#2182) -- every occurrence, the all-occurrences sibling
+/// of `replace` above. Rust's own `str::replace` (no count arg) is
+/// already global by default, including the empty-pattern-inserts-at-
+/// every-boundary edge case (`"abc".replace("", "X")` -> "XaXbXcX"),
+/// so it needs no hand-rolled loop the way `replace_all` on the
+/// backends whose native replace is first-occurrence-only does.
+pub fn replace_all(recv: &JsValue, pattern: &JsValue, replacement: &JsValue) -> String {
+    let s = scalar_or_empty(recv);
+    let o = js_string(pattern);
+    let n = js_string(replacement);
+    s.replace(&o, &n)
+}
+
 /// `queryHref(base, {...})` (#2042) -- build `"$base?k=v&..."` from a flat
 /// list of (guard, key, value) triples. A pair is included iff its guard is
 /// JS-truthy AND its value is a non-empty string. A value may also be a

package/runtime/tests/helper_vectors.rs

@@ -116,6 +116,9 @@ fn call_binding(fn_name: &str, args: &[JsValue]) -> Option<JsValue> {
         "floor" => JsValue::Number(num::js_floor(runtime::js_number(&a(0)))),
         "ceil" => JsValue::Number(num::js_ceil(runtime::js_number(&a(0)))),
         "round" => JsValue::Number(num::js_round(runtime::js_number(&a(0)))),
+        "min" => JsValue::Number(num::js_min(runtime::js_number(&a(0)), runtime::js_number(&a(1)))),
+        "max" => JsValue::Number(num::js_max(runtime::js_number(&a(0)), runtime::js_number(&a(1)))),
+        "abs" => JsValue::Number(num::js_abs(runtime::js_number(&a(0)))),
         "to_fixed" => {
             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))
@@ -123,9 +126,12 @@ fn call_binding(fn_name: &str, args: &[JsValue]) -> Option<JsValue> {
         "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))),
+        "trim_start" => JsValue::String(runtime::trim_start(&a(0))),
+        "trim_end" => JsValue::String(runtime::trim_end(&a(0))),
         "starts_with" => JsValue::Bool(runtime::starts_with(&a(0), &a(1), &a(2))),
         "ends_with" => JsValue::Bool(runtime::ends_with(&a(0), &a(1), &a(2))),
         "replace" => JsValue::String(runtime::replace(&a(0), &a(1), &a(2))),
+        "replace_all" => JsValue::String(runtime::replace_all(&a(0), &a(1), &a(2))),
         "repeat" => JsValue::String(runtime::repeat(&a(0), &a(1))),
         "pad_start" => JsValue::String(runtime::pad(&runtime::js_string(&a(0)), &a(1), &a(2), true)),
         "pad_end" => JsValue::String(runtime::pad(&runtime::js_string(&a(0)), &a(1), &a(2), false)),

package/runtime/tests/template_primitives.rs

@@ -169,6 +169,20 @@ fn slice_mutation_isolation_and_clamping() {
     assert_eq!(src, arr(vec![s("a"), s("b"), s("c")]));
 }
 
+/// The `string-slice` divergence (#2182): a string receiver used to
+/// fall through the array-only branch and return an empty array
+/// instead of a substring.
+#[test]
+fn slice_string_receiver() {
+    let word = s("barefootjs");
+    assert_eq!(runtime::slice(&word, &n(0.0), &n(4.0)), s("bare"));
+    assert_eq!(runtime::slice(&word, &n(-4.0), &JsValue::Null), s("otjs"));
+    assert_eq!(runtime::slice(&word, &n(4.0), &JsValue::Null), s("footjs"));
+    assert_eq!(runtime::slice(&word, &n(5.0), &n(2.0)), s(""));
+    // Multi-byte: index by character, not byte.
+    assert_eq!(runtime::slice(&s("héllo"), &n(0.0), &n(2.0)), s("hé"));
+}
+
 #[test]
 fn reverse_mutation_isolation() {
     assert_eq!(runtime::reverse(&arr(vec![s("a"), s("b"), s("c")])), arr(vec![s("c"), s("b"), s("a")]));
@@ -192,6 +206,34 @@ fn trim_helper() {
     assert_eq!(runtime::trim(&n(42.0)), "42");
 }
 
+#[test]
+fn trim_start_and_trim_end_helpers() {
+    // The one-sided siblings of `trim` above (#2183 follow-up). Padding
+    // BOTH sides of the flagship input so a swapped side (or a
+    // routed-through-both-sides regression) fails visibly.
+    assert_eq!(runtime::trim_start(&s("   padded   ")), "padded   ");
+    assert_eq!(runtime::trim_end(&s("   padded   ")), "   padded");
+
+    assert_eq!(runtime::trim_start(&s("\t\nleading")), "leading");
+    assert_eq!(runtime::trim_end(&s("trailing  ")), "trailing");
+
+    assert_eq!(runtime::trim_start(&s("no-pad")), "no-pad");
+    assert_eq!(runtime::trim_end(&s("no-pad")), "no-pad");
+
+    assert_eq!(runtime::trim_start(&s("   ")), "");
+    assert_eq!(runtime::trim_end(&s("   ")), "");
+
+    assert_eq!(runtime::trim_start(&s("")), "");
+    assert_eq!(runtime::trim_end(&s("")), "");
+
+    assert_eq!(runtime::trim_start(&JsValue::Null), "");
+    assert_eq!(runtime::trim_end(&JsValue::Null), "");
+    assert_eq!(runtime::trim_start(&obj(&[("a", n(1.0))])), "");
+    assert_eq!(runtime::trim_end(&obj(&[("a", n(1.0))])), "");
+    assert_eq!(runtime::trim_start(&n(42.0)), "42");
+    assert_eq!(runtime::trim_end(&n(42.0)), "42");
+}
+
 #[test]
 fn split_helper() {
     assert_eq!(runtime::split(&s("a,b,c"), Some(&s(",")), None), arr(vec![s("a"), s("b"), s("c")]));

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

@@ -385,6 +385,27 @@ export function C(props: { count: number }) {
   })
 })
 
+describe('MinijinjaAdapter - named-slot capture identifier safety (#2168 jsx-element-prop)', () => {
+  // A JSX-valued prop under a hyphenated name (`data-slot`, a valid JSX
+  // attribute name) must not leak into the `{% set %}` capture variable's
+  // identifier — minijinja variable names can't contain `-`. The capture
+  // identifier is purely counter-based (never derived from the prop name);
+  // the hash KEY passed to `render_child` still carries the real name,
+  // quoted via `minijinjaHashKey`.
+  test('a hyphenated prop name does not appear in the capture variable', () => {
+    const { template } = compileAndGenerate(`
+function Card(props) { return null }
+export function Parent() {
+  return <Card data-slot={<strong>Title</strong>}>text</Card>
+}
+`)
+    expect(template).toContain('{% set bf_prop_0 %}')
+    expect(template).toContain("'data-slot': bf_prop_0")
+    expect(template).not.toContain('data-slot %}')
+    expect(template).not.toContain('data-slot_')
+  })
+})
+
 // #2038 nested-callback-predicate loudness is pinned at the shared
 // conformance layer (workstream C): `filter-nested-callback-predicate` /
 // `filter-nested-find-predicate` (BF101 via `expectedDiagnostics`) and

package/src/adapter/expr/array-method.ts

@@ -91,6 +91,15 @@ export function renderArrayMethod(
       const recv = emit(object)
       return `bf.trim(${recv})`
     }
+    case 'trimStart':
+    case 'trimEnd': {
+      // `.trimStart()` / `.trimEnd()` — the one-sided siblings of
+      // `.trim()` (#2183 follow-up). Dedicated `bf.trim_start` /
+      // `bf.trim_end` helpers, not `bf.trim` with a flag.
+      const fn = method === 'trimStart' ? 'trim_start' : 'trim_end'
+      const recv = emit(object)
+      return `bf.${fn}(${recv})`
+    }
     case 'toFixed': {
       // `.toFixed(digits?)` — `bf.to_fixed` mirrors JS rounding +
       // zero-padding (default 0 digits). #1897.
@@ -126,6 +135,16 @@ export function renderArrayMethod(
       const newS = emit(args[1])
       return `bf.replace(${recv}, ${oldS}, ${newS})`
     }
+    case 'replaceAll': {
+      // `.replaceAll(old, new)` — string-pattern form, EVERY occurrence,
+      // via the dedicated `bf.replace_all` helper (not `bf.replace`
+      // with a flag) — the regex-pattern form is refused upstream at
+      // the parser, same as `.replace`. See #2182.
+      const recv = emit(object)
+      const oldS = emit(args[0])
+      const newS = emit(args[1])
+      return `bf.replace_all(${recv}, ${oldS}, ${newS})`
+    }
     case 'repeat': {
       const recv = emit(object)
       const count = args.length === 0 ? '0' : emit(args[0])

package/src/adapter/expr/emitters.ts

@@ -48,7 +48,7 @@
  *      entry point `_renderJinjaFilterExprPublic`.
  */
 
-import {
+import { groupBinaryOperand,
   type ParsedExprEmitter,
   type HigherOrderMethod,
   type ArrayMethod,
@@ -141,7 +141,7 @@ export class JinjaFilterEmitter implements ParsedExprEmitter {
     return String(value)
   }
 
-  member(object: ParsedExpr, property: string, _computed: boolean, emit: (e: ParsedExpr) => string): string {
+  member(object: ParsedExpr, property: string, _computed: boolean, _optional: boolean, emit: (e: ParsedExpr) => string): string {
     // `.length` — route through `bf.length` (handles both array element
     // count and string char count, JS-compatibly). Jinja's builtin
     // `|length` filter also faults trying to match JS semantics for every
@@ -175,8 +175,11 @@ export class JinjaFilterEmitter implements ParsedExprEmitter {
   }
 
   binary(op: string, left: ParsedExpr, right: ParsedExpr, emit: (e: ParsedExpr) => string): string {
-    const l = emit(left)
-    const r = emit(right)
+    // Preserve source grouping: a compound operand re-emitted as infix
+    // text is otherwise re-parsed under THIS language's precedence —
+    // `(count() + 2) * 3` would silently become `count + 2 * 3` (#2173).
+    const l = groupBinaryOperand(left, emit(left))
+    const r = groupBinaryOperand(right, emit(right))
     // Jinja's `==` / `!=` are value-equality operators that compare strings
     // and numbers correctly — unlike Perl's numeric `==` (which the Mojo
     // adapter must steer around with `eq`/`ne`). Same reasoning as Kolon.
@@ -310,7 +313,7 @@ export class JinjaTopLevelEmitter implements ParsedExprEmitter {
     return String(value)
   }
 
-  member(object: ParsedExpr, property: string, _computed: boolean, emit: (e: ParsedExpr) => string): string {
+  member(object: ParsedExpr, property: string, _computed: boolean, _optional: boolean, emit: (e: ParsedExpr) => string): string {
     // `props.x` flattens to the bare context var the SSR caller binds each
     // prop to (props arrive as individual top-level context entries, not a
     // nested `props` dict).
@@ -378,8 +381,11 @@ export class JinjaTopLevelEmitter implements ParsedExprEmitter {
   }
 
   binary(op: string, left: ParsedExpr, right: ParsedExpr, emit: (e: ParsedExpr) => string): string {
-    const l = emit(left)
-    const r = emit(right)
+    // Preserve source grouping: a compound operand re-emitted as infix
+    // text is otherwise re-parsed under THIS language's precedence —
+    // `(count() + 2) * 3` would silently become `count + 2 * 3` (#2173).
+    const l = groupBinaryOperand(left, emit(left))
+    const r = groupBinaryOperand(right, emit(right))
     // Jinja's `==` / `!=` handle both strings and numbers (unlike Perl's
     // numeric `==`), so all equality comparisons stay on `==` / `!=`.
     const opMap: Record<string, string> = {

package/src/adapter/lib/constants.ts

@@ -26,6 +26,9 @@ export const JINJA_TEMPLATE_PRIMITIVES: Record<string, PrimitiveSpec> = {
   'Math.floor':     { arity: 1, emit: (args) => `bf.floor(${args[0]})` },
   'Math.ceil':      { arity: 1, emit: (args) => `bf.ceil(${args[0]})` },
   'Math.round':     { arity: 1, emit: (args) => `bf.round(${args[0]})` },
+  'Math.min':       { arity: 2, emit: (args) => `bf.min(${args[0]}, ${args[1]})` },
+  'Math.max':       { arity: 2, emit: (args) => `bf.max(${args[0]}, ${args[1]})` },
+  'Math.abs':       { arity: 1, emit: (args) => `bf.abs(${args[0]})` },
 }
 
 /**