@barefootjs/xslate 0.18.4 → 0.18.7

package/dist/index.js

@@ -187308,7 +187308,13 @@ import {
   queryHrefArgs,
   isValidHelperId,
   sortComparatorFromArrow as sortComparatorFromArrow2,
-  isLowerableLoopDestructure
+  isLowerableLoopDestructure,
+  isDangerousInnerHtmlAttr,
+  resolveDangerousInnerHtml,
+  dangerousInnerHtmlMetacharViolation,
+  dangerousInnerHtmlDiagnostic,
+  resolveStaticLoopSource,
+  collectLoopBoundNames as collectLoopBoundNames2
 } from "@barefootjs/jsx";
 
 // src/adapter/boolean-result.ts
@@ -187365,7 +187371,7 @@ function isAriaBooleanAttr(name) {
 }
 
 // src/adapter/xslate-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 XSLATE_TEMPLATE_PRIMITIVES = {
@@ -187374,7 +187380,10 @@ var XSLATE_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 XSLATE_PRIMITIVE_EMIT_MAP = Object.fromEntries(Object.entries(XSLATE_TEMPLATE_PRIMITIVES).map(([k, v]) => [k, v.emit]));
 
@@ -187479,6 +187488,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";
@@ -187512,6 +187527,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]);
@@ -187609,6 +187630,39 @@ function renderFlatMethod(recv, depth, emit) {
   return `$bf.flat(${recv}, ${d})`;
 }
 
+// src/adapter/lib/static-value.ts
+function staticValueToKolon(value) {
+  if (value === null || value === undefined)
+    return "nil";
+  if (typeof value === "boolean")
+    return null;
+  if (typeof value === "number")
+    return String(value);
+  if (typeof value === "string")
+    return `'${escapeKolonSingleQuoted(value)}'`;
+  if (Array.isArray(value)) {
+    const items = [];
+    for (const el of value) {
+      const serialized = staticValueToKolon(el);
+      if (serialized === null)
+        return null;
+      items.push(serialized);
+    }
+    return `[${items.join(", ")}]`;
+  }
+  if (typeof value === "object") {
+    const entries = [];
+    for (const [key, val] of Object.entries(value)) {
+      const serialized = staticValueToKolon(val);
+      if (serialized === null)
+        return null;
+      entries.push(`${kolonHashKey(key)} => ${serialized}`);
+    }
+    return `{ ${entries.join(", ")} }`;
+  }
+  return null;
+}
+
 // src/adapter/expr/emitters.ts
 import {
   groupBinaryOperand,
@@ -187655,7 +187709,7 @@ class XslateFilterEmitter {
       return "nil";
     return String(value);
   }
-  member(object, property, _computed, emit) {
+  member(object, property, _computed, _optional, emit) {
     if (property === "length") {
       return `$bf.length(${emit(object)})`;
     }
@@ -187767,7 +187821,7 @@ class XslateTopLevelEmitter {
       return "nil";
     return String(value);
   }
-  member(object, property, _computed, emit) {
+  member(object, property, _computed, _optional, emit) {
     if (object.kind === "identifier" && object.name === "props") {
       return `$${property}`;
     }
@@ -188152,6 +188206,9 @@ function generateDerivedMemoSeed(ctx, ir) {
 ` : "";
 }
 
+// src/adapter/props/prop-classes.ts
+import { collectLoopBoundNames } from "@barefootjs/jsx";
+
 // src/adapter/value/parsed-literal.ts
 import { evalStringArrayJoin } from "@barefootjs/jsx";
 function isStringTypeInfo(type2) {
@@ -188182,6 +188239,12 @@ function collectStringValueNames(ir) {
     if (isStringTypeInfo(p.type))
       names.add(p.name);
   }
+  for (const c of ir.metadata.localConstants) {
+    if (isStringTypeInfo(c.type ?? undefined) || isBareStringLiteral(c.value))
+      names.add(c.name);
+  }
+  for (const bound of collectLoopBoundNames(ir))
+    names.delete(bound);
   return names;
 }
 
@@ -188208,6 +188271,7 @@ class XslateAdapter extends BaseAdapter {
   options;
   errors = [];
   inLoop = false;
+  currentLoopKeyDepth = 0;
   propsObjectName = null;
   propsParams = [];
   booleanTypedProps = new Set;
@@ -188216,6 +188280,7 @@ class XslateAdapter extends BaseAdapter {
   _searchParamsLocals = new Set;
   _loweringMatchers = [];
   localConstants = [];
+  staticLoopSourceBoundNames = new Set;
   nullableOptionalProps = new Set;
   constructor(options = {}) {
     super();
@@ -188231,6 +188296,7 @@ class XslateAdapter extends BaseAdapter {
     this.propsParams = ir.metadata.propsParams.map((p) => ({ name: p.name }));
     this.booleanTypedProps = collectBooleanTypedProps(ir);
     this.localConstants = ir.metadata.localConstants ?? [];
+    this.staticLoopSourceBoundNames = collectLoopBoundNames2(ir);
     this.nullableOptionalProps = collectNullableOptionalProps(ir);
     this.stringValueNames = collectStringValueNames(ir);
     this.moduleStringConsts = collectModuleStringConsts(ir.metadata.localConstants);
@@ -188284,7 +188350,7 @@ class XslateAdapter extends BaseAdapter {
     return this.renderElement(node);
   }
   emitText(node) {
-    return node.value;
+    return escapeHtml(node.value);
   }
   emitExpression(node) {
     return this.renderExpression(node);
@@ -188347,7 +188413,8 @@ class XslateAdapter extends BaseAdapter {
   renderElement(element) {
     const tag = element.tag;
     const attrs = this.renderAttributes(element);
-    const children = this.renderChildren(element.children);
+    const dangerousHtml = this.renderDangerousInnerHtml(element);
+    const children = dangerousHtml !== null ? dangerousHtml : this.renderChildren(element.children);
     let hydrationAttrs = "";
     if (element.needsScope) {
       hydrationAttrs += ` ${this.renderScopeMarker("")}`;
@@ -188382,6 +188449,22 @@ class XslateAdapter extends BaseAdapter {
     }
     return `<${tag}${attrs}${hydrationAttrs}>${children}</${tag}>`;
   }
+  renderDangerousInnerHtml(element) {
+    const resolution = resolveDangerousInnerHtml(element);
+    if (!resolution)
+      return null;
+    if (resolution.kind === "dynamic") {
+      this.errors.push(dangerousInnerHtmlDiagnostic(resolution.expr, resolution.loc));
+      return "";
+    }
+    const violation = dangerousInnerHtmlMetacharViolation(resolution.html, this.name);
+    if (violation) {
+      const attr = element.attrs.find(isDangerousInnerHtmlAttr);
+      this.errors.push(dangerousInnerHtmlDiagnostic(`{ __html: ${JSON.stringify(resolution.html)} }`, attr.loc, violation));
+      return "";
+    }
+    return resolution.html;
+  }
   renderExpression(expr) {
     if (expr.clientOnly) {
       if (expr.slotId) {
@@ -188389,7 +188472,7 @@ class XslateAdapter extends BaseAdapter {
       }
       return "";
     }
-    const perlExpr = this.convertExpressionToKolon(expr.expr);
+    const perlExpr = this.convertExpressionToKolon(expr.expr, expr.parsed);
     if (expr.slotId) {
       return `<: $bf.text_start("${expr.slotId}") | mark_raw :><: ${perlExpr} :><: $bf.text_end() | mark_raw :>`;
     }
@@ -188481,8 +188564,12 @@ ${whenTrue}
         }
       });
     }
+    const staticItems = resolveStaticLoopSource(loop.arrayParsed, this.localConstants, {
+      isNameShadowed: (name) => this.staticLoopSourceBoundNames.has(name)
+    });
+    const staticArray = staticItems !== null ? staticValueToKolon(staticItems) : null;
     const arrayName = loop.array.trim();
-    if (/^[A-Za-z_$][\w$]*$/.test(arrayName)) {
+    if (staticArray === null && /^[A-Za-z_$][\w$]*$/.test(arrayName)) {
       const arrayConst = (this.localConstants ?? []).find((c) => c.name === arrayName);
       if (arrayConst && !arrayConst.isModule && this._resolveLiteralConst(arrayName) === null) {
         this.errors.push({
@@ -188496,7 +188583,7 @@ ${whenTrue}
         });
       }
     }
-    const rawArray = this.convertExpressionToKolon(loop.array);
+    const rawArray = staticArray ?? this.convertExpressionToKolon(loop.array);
     let array = rawArray;
     if (loop.sortComparator) {
       const sort = loop.sortComparator;
@@ -188508,9 +188595,12 @@ ${whenTrue}
     }
     const param = loop.param;
     const renderedChildren = this.renderChildren(loop.children);
-    const loopVar = loop.iterationShape === "keys" ? "__bf_item" : supportableDestructure ? "__bf_item" : param;
+    const loopVar = loop.objectIteration === "entries" ? "__bf_pair" : loop.objectIteration ? param : loop.iterationShape === "keys" ? "__bf_item" : supportableDestructure ? "__bf_item" : param;
     const indexLocalLines = [];
-    if (loop.iterationShape === "keys") {
+    if (loop.objectIteration === "entries") {
+      indexLocalLines.push(`: my $${loop.index ?? param} = $${loopVar}.key;`);
+      indexLocalLines.push(`: my $${param} = $${loopVar}.value;`);
+    } else if (loop.objectIteration) {} else if (loop.iterationShape === "keys") {
       indexLocalLines.push(`: my $${param} = $~${loopVar}.index;`);
     } else if (loop.index) {
       indexLocalLines.push(`: my $${loop.index} = $~${loopVar}.index;`);
@@ -188530,13 +188620,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:" ~ ${this.convertExpressionToKolon(loop.key)}) | mark_raw :>
 ${childrenUnderLoop}` : childrenUnderLoop;
     const lines = [];
     lines.push(`<: $bf.comment("loop:${loop.markerId}") | mark_raw :>`);
-    lines.push(`: for ${array} -> $${loopVar} {`);
+    const forHeader = loop.objectIteration === "entries" ? `: for ${array}.kv() -> $${loopVar} {` : loop.objectIteration === "keys" ? `: for ${array}.keys() -> $${loopVar} {` : loop.objectIteration === "values" ? `: for ${array}.values() -> $${loopVar} {` : `: for ${array} -> $${loopVar} {`;
+    lines.push(forHeader);
     for (const il of indexLocalLines)
       lines.push(il);
     if (loop.filterPredicate) {
@@ -188607,9 +188701,20 @@ ${childrenUnderLoop}` : childrenUnderLoop;
   renderComponent(comp) {
     const segments = [{ kind: "entries", parts: [] }];
     const currentEntries = () => this.componentPropSegmentEntries(segments);
+    const namedSlotMacros = [];
     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 macroName = `bf_prop_${this.childrenCaptureCounter++}`;
+        namedSlotMacros.push(`<: macro ${macroName} -> () { :>${slotBody}<: } :>`);
+        currentEntries().push(`${kolonHashKey(p.name)} => ${macroName}()`);
+        continue;
+      }
       if (p.value.kind === "spread") {
         const trimmed = p.value.expr.trim();
         if (this.propsObjectName && this.propsObjectName === trimmed) {
@@ -188638,11 +188743,11 @@ ${childrenUnderLoop}` : childrenUnderLoop;
       const macroName = `bf_children_${comp.slotId ?? "c" + this.childrenCaptureCounter++}`;
       currentEntries().push(`children => ${macroName}()`);
       const dict = this.combineComponentPropSegments(segments);
-      return `<: macro ${macroName} -> () { :>${childrenBody}<: } :><: $bf.render_child('${tplName}', ${dict}) | mark_raw :>`;
+      return `${namedSlotMacros.join("")}<: macro ${macroName} -> () { :>${childrenBody}<: } :><: $bf.render_child('${tplName}', ${dict}) | mark_raw :>`;
     }
     const isEmpty = segments.every((s) => s.kind === "entries" && s.parts.length === 0);
     const hashEntries = isEmpty ? "" : `, ${this.combineComponentPropSegments(segments)}`;
-    return `<: $bf.render_child('${tplName}'${hashEntries}) | mark_raw :>`;
+    return `${namedSlotMacros.join("")}<: $bf.render_child('${tplName}'${hashEntries}) | mark_raw :>`;
   }
   childrenCaptureCounter = 0;
   presenceVarCounter = 0;
@@ -188687,7 +188792,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);
@@ -188791,12 +188896,15 @@ ${name}="<: ${val} :>"
     for (const attr of element.attrs) {
       if (attr.clientOnly)
         continue;
+      if (isDangerousInnerHtmlAttr(attr))
+        continue;
       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)
@@ -188973,6 +189081,8 @@ Options:
     return this.booleanTypedProps.has(bare);
   }
   _resolveLiteralConst(name) {
+    if (this.staticLoopSourceBoundNames.has(name))
+      return null;
     const c = (this.localConstants ?? []).find((lc) => lc.name === name);
     if (c?.value === undefined)
       return null;
@@ -188985,6 +189095,8 @@ Options:
     return null;
   }
   _resolveStaticRecordLiteral(objectName, key) {
+    if (this.staticLoopSourceBoundNames.has(objectName))
+      return null;
     const hit = lookupStaticRecordLiteral(objectName, key, this.localConstants);
     if (!hit)
       return null;
@@ -189022,35 +189134,18 @@ Options:
 var xslateAdapter = new XslateAdapter;
 // src/conformance-pins.ts
 var conformancePins = {
-  "static-array-children": [{ code: "BF103", severity: "error" }],
-  "todo-app": [{ code: "BF103", severity: "error" }],
-  "todo-app-ssr": [{ code: "BF103", severity: "error" }],
   "static-array-from-props": [{ code: "BF101", severity: "error" }],
-  "static-array-from-props-with-component": [
-    { code: "BF103", severity: "error" },
-    { code: "BF101", severity: "error" }
-  ],
+  "static-array-from-props-with-component": [{ code: "BF101", severity: "error" }],
   "filter-nested-callback-predicate": [
     { code: "BF101", severity: "error", issue: "https://github.com/piconic-ai/barefootjs/issues/2038" }
   ],
   "filter-nested-find-predicate": [
     { 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-dynamic": [{ code: "BF101", severity: "error", issue: "https://github.com/piconic-ai/barefootjs/issues/2215" }]
 };
 // src/render-divergences.ts
-var renderDivergences = {
-  "html-entity-text": "`&copy;` 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)",
-  "static-attr-escape": 'static attribute values are not HTML-escaped (`title="Fish & Chips"` emitted raw; Hono escapes)',
-  "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 misfires through the array slice helper",
-  "string-trim-sided": "`.trimStart()` / `.trimEnd()` render empty (no lowering)"
-};
+var renderDivergences = {};
 export {
   xslateAdapter,
   renderDivergences,

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

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

package/lib/BarefootJS/Backend/Xslate.pm

@@ -1,5 +1,5 @@
 package BarefootJS::Backend::Xslate;
-our $VERSION = "0.18.3";
+our $VERSION = "0.18.5";
 use strict;
 use warnings;
 use utf8;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@barefootjs/xslate",
-  "version": "0.18.4",
+  "version": "0.18.7",
   "description": "Text::Xslate (Kolon) adapter for BarefootJS — compiles IR to .tx templates and ships the Xslate rendering backend; runs under any PSGI/Plack app",
   "type": "module",
   "main": "./dist/index.js",
@@ -55,14 +55,14 @@
     "directory": "packages/adapter-xslate"
   },
   "dependencies": {
-    "@barefootjs/shared": "0.18.4"
+    "@barefootjs/shared": "0.18.7"
   },
   "peerDependencies": {
     "@barefootjs/jsx": ">=0.2.0"
   },
   "devDependencies": {
     "@barefootjs/adapter-tests": "0.1.0",
-    "@barefootjs/jsx": "0.18.4",
+    "@barefootjs/jsx": "0.18.7",
     "typescript": "^5.0.0"
   }
 }

package/src/__tests__/xslate-adapter.test.ts

@@ -396,8 +396,147 @@ export { A }
   })
 })
 
+describe('XslateAdapter - 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 Kolon macro's identifier — Kolon
+  // macro names can't contain `-`. The macro name is purely counter-based
+  // (never derived from the prop name); the hash KEY passed to
+  // `render_child` still carries the real name, quoted via `kolonHashKey`.
+  test('a hyphenated prop name does not appear in the macro name', () => {
+    const { template } = compileAndGenerate(`
+function Card(props) { return null }
+export function Parent() {
+  return <Card data-slot={<strong>Title</strong>}>text</Card>
+}
+`)
+    expect(template).toContain('<: macro 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: `filter-nested-callback-predicate` /
 // `filter-nested-find-predicate` (BF101 via `expectedDiagnostics` above) and
 // `filter-nested-callback-predicate-client` (the `/* @client */` suppression
 // twin, which must render clean).
+
+// #2221: `_resolveLiteralConst` is a flat name lookup against
+// `ir.metadata.localConstants` with no notion of AST scope — it used to
+// substitute an outer const's literal value even at an occurrence that is
+// actually an enclosing loop callback's own (shadowing) parameter, so every
+// iteration rendered the same hard-coded literal. Guarded with the same
+// coarse `collectLoopBoundNames` exclusion as #2212: any name a loop binds
+// anywhere in the component never inlines, falling back to the bare
+// identifier.
+describe('XslateAdapter - const inlining vs loop-param shadowing (#2221)', () => {
+  test('a loop param shadowing an outer literal const emits the identifier, not the const value', () => {
+    const { template } = compileAndGenerate(`
+function Widget() {
+  const label: string = 'x'
+  return <ul>{[2, 5].map((label) => <li key={label}>{1 + label}</li>)}</ul>
+}
+`)
+    // The loop body must reference the per-iteration loop var...
+    expect(template).toContain('1 + $label')
+    // ...never the outer const's hard-coded value.
+    expect(template).not.toContain("1 + 'x'")
+  })
+
+  test('a numeric const shadowed by a loop param emits the identifier too', () => {
+    const { template } = compileAndGenerate(`
+function Widget() {
+  const count = 7
+  return <ul>{[2, 5].map((count) => <li key={count}>{1 + count}</li>)}</ul>
+}
+`)
+    expect(template).toContain('1 + $count')
+    expect(template).not.toContain('1 + 7')
+  })
+
+  test('a literal const NOT shadowed by any loop still inlines (#1897 pin)', () => {
+    const { template } = compileAndGenerate(`
+function Widget({ values }: { values: number[] }) {
+  const totalPages = 5
+  return <div>
+    <p>Page 1 of {1 + totalPages}</p>
+    <ul>{values.map((v) => <li key={v}>{v}</li>)}</ul>
+  </div>
+}
+`)
+    expect(template).toContain('1 + 5')
+  })
+
+  // The accepted coarse-exclusion trade-off (same as #2212): a name that is
+  // loop-bound ANYWHERE in the component never inlines, even at a genuinely
+  // non-shadowed occurrence outside the loop — the bare identifier is
+  // emitted instead of the value.
+  test('a const referenced outside the loop whose name is loop-bound elsewhere falls back to the identifier (accepted trade-off)', () => {
+    const { template } = compileAndGenerate(`
+function Widget({ values }: { values: number[] }) {
+  const label: string = 'x'
+  return <div>
+    <p>{1 + label}</p>
+    <ul>{values.map((label) => <li key={label}>{2 + label}</li>)}</ul>
+  </div>
+}
+`)
+    expect(template).not.toContain("1 + 'x'")
+    expect(template).toContain('2 + $label')
+  })
+})
+
+// #2237: `_resolveStaticRecordLiteral` (`IDENT.key` on a module-scope
+// object-literal const, e.g. `variantClasses.ghost` — #1896/#1897) is a
+// flat name lookup on `objectName` with no notion of AST scope, the
+// record-literal sibling of #2221's `_resolveLiteralConst` bug. It used to
+// substitute the outer const's member value even at an occurrence that is
+// actually an enclosing loop callback's own (shadowing) parameter, so every
+// iteration rendered the same hard-coded literal instead of the per-item
+// value. Guarded with the same coarse `staticLoopSourceBoundNames`
+// exclusion as #2221: any name a loop binds anywhere in the component
+// never inlines, falling back to the bare `$cfg.x` member expression.
+describe('XslateAdapter - record-literal member lookup vs loop-param shadowing (#2237)', () => {
+  test('a loop param shadowing an outer module object const emits the member access, not the outer literal', () => {
+    const { template } = compileAndGenerate(`
+const cfg = { x: 'outer-lit' }
+function Widget({ rows }: { rows: { x: string }[] }) {
+  return <ul>{rows.map((cfg) => <li key={cfg.x}>{cfg.x}</li>)}</ul>
+}
+`)
+    // The loop body must reference the per-iteration member access...
+    expect(template).toContain('<: $cfg.x :>')
+    // ...never the outer const's hard-coded value.
+    expect(template).not.toContain("<: 'outer-lit' :>")
+  })
+
+  test('a module object const NOT shadowed by any loop still inlines (variantClasses.ghost shape, #1896/#1897 pin)', () => {
+    const { template } = compileAndGenerate(`
+const variantClasses = { solid: 'bg-solid', ghost: 'bg-ghost' }
+function Widget({ variant }: { variant: 'solid' | 'ghost' }) {
+  return <div>{variantClasses.ghost}</div>
+}
+`)
+    expect(template).toContain("<: 'bg-ghost' :>")
+  })
+
+  // The accepted coarse-exclusion trade-off (same as #2221/#2212): an
+  // object name that is loop-bound ANYWHERE in the component never
+  // inlines its member lookups, even at a genuinely non-shadowed
+  // occurrence outside the loop — the bare member expression is emitted
+  // instead of the value.
+  test('a record member referenced outside the loop whose object name is loop-bound elsewhere falls back to the member expression (accepted trade-off)', () => {
+    const { template } = compileAndGenerate(`
+const cfg = { x: 'outer-lit' }
+function Widget({ rows }: { rows: { x: string }[] }) {
+  return <div>
+    <p>{cfg.x}</p>
+    <ul>{rows.map((cfg) => <li key={cfg.x}>{cfg.x}</li>)}</ul>
+  </div>
+}
+`)
+    expect(template).not.toContain("<: 'outer-lit' :>")
+    expect(template).toContain('<: $cfg.x :>')
+  })
+})

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

@@ -89,6 +89,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.
@@ -124,6 +133,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

@@ -94,7 +94,7 @@ export class XslateFilterEmitter 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). Kolon's builtin `.size()`
     // is array-only and faults on a string.
@@ -263,7 +263,7 @@ export class XslateTopLevelEmitter 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 `$x` the SSR caller binds each prop to
     // (props arrive as individual top-level vars, not a `$props` hashref).
     if (object.kind === 'identifier' && object.name === 'props') {

package/src/adapter/lib/constants.ts

@@ -23,6 +23,9 @@ export const XSLATE_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]})` },
 }
 
 /**