@barefootjs/xslate 0.17.0 → 0.17.1

package/dist/index.js

@@ -187291,12 +187291,12 @@ Additional information: BADCLIENT: Bad error code, ${badCode} not found in range
 import {
   BaseAdapter,
   isBooleanAttr,
-  parseExpression as parseExpression3,
+  parseExpression as parseExpression2,
   stringifyParsedExpr as stringifyParsedExpr2,
   exprToString,
   parseProviderObjectLiteral,
   parseStyleObjectEntries,
-  isSupported as isSupported2,
+  isSupported,
   emitParsedExpr,
   emitIRNode,
   emitAttrValue,
@@ -187417,13 +187417,6 @@ function collectRootScopeNodes(node) {
   visit(node);
   return out;
 }
-function referencedVarsAreAvailable(expr, available) {
-  for (const m of expr.matchAll(/\$([A-Za-z_]\w*)/g)) {
-    if (!available.has(m[1]))
-      return false;
-  }
-  return true;
-}
 
 // src/adapter/expr/array-method.ts
 import {
@@ -187593,6 +187586,13 @@ function renderFlatMapEval(recv, body, param, emit) {
   const env = emitEvalEnvArg(body, [param], emit);
   return `$bf.flat_map_eval(${recv}, '${escapePerlSingleQuote(json)}', '${param}', ${env})`;
 }
+function renderMapEval(recv, body, param, emit) {
+  const json = serializeParsedExpr(body);
+  if (json === null)
+    return null;
+  const env = emitEvalEnvArg(body, [param], emit);
+  return `$bf.map_eval(${recv}, '${escapePerlSingleQuote(json)}', '${param}', ${env})`;
+}
 function renderSortMethod(recv, c) {
   const keyHashes = c.keys.map((k) => {
     const keyEntry = k.key.kind === "self" ? `key_kind => 'self'` : `key_kind => 'field', key => '${k.key.field}'`;
@@ -187625,10 +187625,12 @@ class XslateFilterEmitter {
   param;
   localVarMap;
   isStringName;
-  constructor(param, localVarMap, isStringName = () => false) {
+  onUnsupported;
+  constructor(param, localVarMap, isStringName = () => false, onUnsupported) {
     this.param = param;
     this.localVarMap = localVarMap;
     this.isStringName = isStringName;
+    this.onUnsupported = onUnsupported;
   }
   identifier(name) {
     if (name === this.param)
@@ -187699,6 +187701,7 @@ class XslateFilterEmitter {
     return `(${l} // ${r})`;
   }
   callbackMethod(method, object, _arrow, _restArgs, emit) {
+    this.onUnsupported?.(`Filter predicate contains a nested '.${method}(...)' callback, which has no Kolon scalar form`, `Rewrite the predicate without a nested callback method, or add /* @client */ for client-only evaluation (no SSR).`);
     return emit(object);
   }
   arrayLiteral(elements, emit) {
@@ -187859,6 +187862,13 @@ class XslateTopLevelEmitter {
       this.ctx._recordExprBF101(`'.flatMap(...)' projection is outside the Xslate adapter's evaluable surface`, `Pre-compute the projected array, or move this position to a '/* @client */' boundary.`);
       return "''";
     }
+    if (method === "map") {
+      const evalForm = renderMapEval(recv, body, params[0], emit);
+      if (evalForm !== null)
+        return evalForm;
+      this.ctx._recordExprBF101(`'.map(...)' projection is outside the Xslate adapter's evaluable surface`, `Pre-compute the projected array, or move this position to a '/* @client */' boundary.`);
+      return "''";
+    }
     return recv;
   }
   _emitPredicateCallback(call, arrayExpr, emit) {
@@ -188092,9 +188102,7 @@ function recordIndexAccessToKolon(ctx, val) {
 // src/adapter/memo/seed.ts
 import {
   collectContextConsumers,
-  extractArrowBodyExpression,
-  isSupported,
-  parseExpression as parseExpression2
+  computeSsrSeedPlan
 } from "@barefootjs/jsx";
 function contextDefaultKolon(c) {
   const d = c.defaultValue;
@@ -188115,44 +188123,22 @@ function generateContextConsumerSeed(ir) {
 `;
 }
 function generateDerivedMemoSeed(ctx, ir) {
-  const memos = ir.metadata.memos ?? [];
-  const signals = ir.metadata.signals ?? [];
-  if (memos.length === 0 && signals.length === 0)
-    return "";
-  const available = new Set(ir.metadata.propsParams.map((p) => p.name));
+  const plan = ir.metadata.ssrSeedPlan ?? computeSsrSeedPlan(ir.metadata);
   const lines = [];
-  for (const signal of signals) {
-    const kolon = tryLowerToKolon(ctx, signal.initialValue, available);
-    const refsSelf = kolon !== null && new RegExp(`\\$${signal.getter}\\b`).test(kolon);
-    if (kolon !== null && !refsSelf)
-      lines.push(`: my $${signal.getter} = ${kolon};`);
-    available.add(signal.getter);
-  }
-  for (const memo of memos) {
-    const body = extractArrowBodyExpression(memo.computation);
-    if (body !== null) {
-      const kolon = tryLowerToKolon(ctx, body, available);
-      const refsSelf = kolon !== null && new RegExp(`\\$${memo.name}\\b`).test(kolon);
-      if (kolon !== null && !refsSelf)
-        lines.push(`: my $${memo.name} = ${kolon};`);
-    }
-    available.add(memo.name);
+  for (const step of plan.steps) {
+    if (step.kind !== "derived")
+      continue;
+    const kolon = ctx.convertExpressionToKolon(step.expr, step.parsed);
+    if (kolon === "" || !/\$[A-Za-z_]\w*/.test(kolon))
+      continue;
+    if (new RegExp(`\\$${step.name}\\b`).test(kolon))
+      continue;
+    lines.push(`: my $${step.name} = ${kolon};`);
   }
   return lines.length > 0 ? lines.join(`
 `) + `
 ` : "";
 }
-function tryLowerToKolon(ctx, expr, available) {
-  const trimmed = expr.trim();
-  if (!trimmed)
-    return null;
-  if (!isSupported(parseExpression2(trimmed)).supported)
-    return null;
-  const kolon = ctx.convertExpressionToKolon(trimmed);
-  if (kolon === "" || !/\$[A-Za-z_]\w*/.test(kolon))
-    return null;
-  return referencedVarsAreAvailable(kolon, available) ? kolon : null;
-}
 
 // src/adapter/value/parsed-literal.ts
 import { evalStringArrayJoin } from "@barefootjs/jsx";
@@ -188452,8 +188438,9 @@ ${whenTrue}
     return `<: $bf.comment("cond-start:${condId}") | mark_raw :>${content}<: $bf.comment("cond-end:${condId}") | mark_raw :>`;
   }
   renderLoop(loop) {
-    if (loop.clientOnly)
-      return "";
+    if (loop.clientOnly) {
+      return `<: $bf.comment("loop:${loop.markerId}") | mark_raw :><: $bf.comment("/loop:${loop.markerId}") | mark_raw :>`;
+    }
     const destructure = !!(loop.paramBindings && loop.paramBindings.length > 0);
     const supportableDestructure = destructure && isLowerableObjectRestDestructure(loop);
     if (destructure && !supportableDestructure) {
@@ -188709,7 +188696,7 @@ ${name}="<: ${val} :>"
         if (localConst?.value !== undefined) {
           const initTrimmed = localConst.value.trim();
           if (!/^[A-Za-z_$][\w$]*$/.test(initTrimmed)) {
-            const resolved = conditionalSpreadToKolon(this.spreadCtx, parseExpression3(initTrimmed));
+            const resolved = conditionalSpreadToKolon(this.spreadCtx, parseExpression2(initTrimmed));
             if (resolved !== null) {
               return `<: $bf.spread_attrs(${resolved}) | mark_raw :>`;
             }
@@ -188727,7 +188714,7 @@ ${name}="<: ${val} :>"
     if (!entries)
       return null;
     for (const e of entries) {
-      if (e.kind === "expr" && !isSupported2(parseExpression3(e.expr)).supported)
+      if (e.kind === "expr" && !isSupported(parseExpression2(e.expr)).supported)
         return null;
     }
     return entries.map((e) => e.kind === "literal" ? `${this.escapeAttrText(e.cssKey)}:${this.escapeAttrText(e.value)}` : `${this.escapeAttrText(e.cssKey)}:<: ${this.convertExpressionToKolon(e.expr)} :>`).join(";");
@@ -188763,7 +188750,7 @@ ${name}="<: ${val} :>"
     return `${BF_COND}="${condId}"`;
   }
   renderKolonFilterExpr(expr, param, localVarMap = new Map) {
-    return emitParsedExpr(expr, new XslateFilterEmitter(param, localVarMap, (n) => this._isStringValueName(n)));
+    return emitParsedExpr(expr, new XslateFilterEmitter(param, localVarMap, (n) => this._isStringValueName(n), (message, reason) => this._recordExprBF101(message, reason)));
   }
   convertTemplateLiteralPartsToKolon(literalParts) {
     const parts = [];
@@ -188808,8 +188795,8 @@ ${name}="<: ${val} :>"
     const hasTaggedTemplate = /[A-Za-z_$][\w$]*\s*`/.test(probe);
     if (!startsAsObjectLiteral && !hasTaggedTemplate)
       return false;
-    const parsed = parseExpression3(expr.trim());
-    const support = isSupported2(parsed);
+    const parsed = parseExpression2(expr.trim());
+    const support = isSupported(parsed);
     if (parsed.kind !== "unsupported" && support.supported)
       return false;
     const reason = support.reason ?? (parsed.kind === "unsupported" ? parsed.reason : undefined);
@@ -188856,7 +188843,7 @@ ${reason}` : "";
       const trimmed = expr.trim();
       if (trimmed === "")
         return "''";
-      parsed = parseExpression3(trimmed);
+      parsed = parseExpression2(trimmed);
     }
     if (parsed.kind === "call") {
       for (const matcher of this._loweringMatchers) {
@@ -188867,7 +188854,7 @@ ${reason}` : "";
         }
       }
     }
-    const support = isSupported2(parsed);
+    const support = isSupported(parsed);
     if (!support.supported) {
       this.errors.push({
         code: "BF101",
@@ -188895,7 +188882,7 @@ Options:
     return this.stringValueNames.has(name);
   }
   parseUndefinedAlternateTernary(expr) {
-    const parsed = parseExpression3(expr.trim());
+    const parsed = parseExpression2(expr.trim());
     if (parsed?.kind !== "conditional")
       return null;
     const alt = parsed.alternate;

package/lib/BarefootJS/Backend/Xslate.pm

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

package/package.json

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

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

@@ -101,10 +101,29 @@ runAdapterConformanceTests({
     // Tagged-template-literal call in a className — same family, same
     // refusal (BF101).
     'tagged-template-classname': [{ code: 'BF101', severity: 'error' }],
-    // NB: `.find` / `.findIndex` / `.findLast` / `.findLastIndex` are NOT
-    // pinned here — unlike mojo (which refuses them), Xslate lowers them to
-    // `$bf.find` / `find_index` / `find_last` / `find_last_index` via the same
-    // Kolon-lambda mechanism as `.filter` / `.every` / `.some`, so they render.
+    // #2038: a filter predicate whose body contains a NESTED callback call
+    // (`t => !picked().some(p => …)` / `t => picked().find(p => …)`). Kolon
+    // has no inline `grep` form, so `XslateFilterEmitter.callbackMethod` used
+    // to degrade the inner call to its receiver, silently changing predicate
+    // semantics — the compiler is loud instead of lossy. (Mojo is pinned only
+    // for the `.find` variant: it lowers a nested `.some` to a real inline
+    // Perl `grep`.) The `/* @client */` twin
+    // (`filter-nested-callback-predicate-client`) has no pin here: it must
+    // render clean on every adapter, which asserts the suppression contract.
+    // https://github.com/piconic-ai/barefootjs/issues/2038
+    'filter-nested-callback-predicate': [{ code: 'BF101', severity: 'error' }],
+    'filter-nested-find-predicate': [{ code: 'BF101', severity: 'error' }],
+    // NB: TOP-LEVEL `.find` / `.findIndex` / `.findLast` / `.findLastIndex`
+    // (text position) are NOT pinned here — unlike mojo (which refuses them),
+    // Xslate lowers them to `$bf.find` / `find_index` / `find_last` /
+    // `find_last_index` via the same Kolon-lambda mechanism as `.filter` /
+    // `.every` / `.some`, so they render. Only the NESTED-in-a-predicate form
+    // above is refused (#2038).
+    // #2073 follow-up: a function-reference `.map(format)` callback has no
+    // arrow body to serialize — not a CALLBACK_METHODS shape — so the
+    // UNSUPPORTED_METHODS gate refuses it with BF101 rather than emitting
+    // a broken template.
+    'array-map-function-reference': [{ code: 'BF101', severity: 'error' }],
   },
   // Template-primitive registry parity: same V1 surface as mojo, so the
   // same two cases stay skipped (bespoke user import + customSerialize
@@ -113,11 +132,15 @@ runAdapterConformanceTests({
     TemplatePrimitiveCaseId.USER_IMPORT_VIA_CONST,
     TemplatePrimitiveCaseId.NO_DOUBLE_REWRITE_OF_PROPS_OBJECT,
   ]),
-  // Loop boundary markers for `@client` loops aren't emitted by the
-  // Xslate adapter yet (ported from mojo, which skips the same set).
+  // `client-only` / `client-only-loop-with-sibling-cond` /
+  // `filter-nested-callback-predicate-client` are no longer skipped —
+  // `renderLoop` now emits the `$bf.comment("loop:<id>")` boundary pair
+  // for clientOnly loops (Hono / Go parity), so mapArray() can locate
+  // its insertion anchor at hydration time (#872 / #1087).
   skipMarkerConformance: new Set([
-    'client-only',
-    'client-only-loop-with-sibling-cond',
+    // Same as Hono / Mojo: `/* @client */` markers on TodoApp's keyed
+    // `.map` intentionally elide a slot id from the SSR template that
+    // the IR still declares (s6). See hono-adapter.test for the contract.
     'todo-app',
     // #1467 Phase 2e: same `/* @client */` keyed-map elision (data-table).
     'data-table',
@@ -296,6 +319,98 @@ export function C() {
 // (`$bf.*_eval`), isomorphic with the Go / Mojo `*_eval` helpers. A predicate
 // the evaluator can't model (a method-call predicate) falls back to the Kolon
 // lambda runtime call. Template-text pins guard against silent divergence.
+describe('XslateAdapter - #2075 searchParams()-derived memo seeding', () => {
+  test('seeds an aliased scalar derived memo from the canonical reader', () => {
+    const { template } = compileAndGenerate(`
+'use client'
+import { createMemo, createSearchParams } from '@barefootjs/client'
+export function SortStatus() {
+  const [sp] = createSearchParams()
+  const sort = createMemo(() => sp().get('sort') ?? 'date')
+  return <p>sort: {sort()}</p>
+}
+`)
+    expect(template).toContain(": my $sort = ($searchParams.get('sort') // 'date');")
+  })
+
+  // The Kolon lambda param and the `$bf` runtime object are
+  // lowering-internal, not out-of-scope template vars (#2075).
+  test('seeds a filter memo chained off the derived memo', () => {
+    const { template } = compileAndGenerate(`
+'use client'
+import { createMemo, createSearchParams } from '@barefootjs/client'
+export function TaggedList(props: { items: { title: string; tags: string[] }[] }) {
+  const [searchParams] = createSearchParams()
+  const tag = createMemo(() => searchParams().get('tag') ?? '')
+  const visible = createMemo(() => props.items.filter((p) => !tag() || p.tags.includes(tag())))
+  return <ul>{visible().map((p) => <li key={p.title}>{p.title}</li>)}</ul>
+}
+`)
+    expect(template).toContain(": my $tag = ($searchParams.get('tag') // '');")
+    expect(template).toContain(': my $visible = $bf.filter($items,')
+  })
+
+  // The seed-scope guard used to scan the LOWERED
+  // Kolon string, allowing every arrow-callback param tree-wide. That let an
+  // outer, unbound `p` (shadowed only inside the callback) slip past the
+  // guard as if it were the callback's own bound `$p` — emitting a bogus
+  // seed line. The guard now walks the parsed SOURCE tree with proper
+  // lexical scoping (`freeIdentifiers`), so this shape seeds nothing and
+  // falls back to the null/ssr-defaults path.
+  test('an outer unbound `p` shadowed only inside the callback does not seed', () => {
+    const { template } = compileAndGenerate(`
+'use client'
+import { createMemo } from '@barefootjs/client'
+export function C(props: { items: { ok: boolean }[] }) {
+  const visible = createMemo(() => props.items.filter((p) => p.ok) && p)
+  return <div>{String(visible())}</div>
+}
+`)
+    expect(template).not.toContain('my $visible')
+  })
+
+  // An out-of-scope bare `_` reference must not seed either — the old
+  // unconditional `allowed.add('_')` / `allowed.add('bf')` masked this.
+  test('an out-of-scope bare `_` reference does not seed', () => {
+    const { template } = compileAndGenerate(`
+'use client'
+import { createMemo } from '@barefootjs/client'
+export function C(props: { count: number }) {
+  const doubled = createMemo(() => props.count * 2 + _)
+  return <div>{doubled()}</div>
+}
+`)
+    expect(template).not.toContain('my $doubled')
+  })
+})
+
+describe('XslateAdapter - #2073 value-producing .map(cb)', () => {
+  // The blog-showcase shape (#1938/#1939): a value-returning `.map` (string
+  // projection, not JSX) lowers through the evaluator — `$bf.map_eval`
+  // projects each element (no flatten) and composes through `$bf.join`.
+  test('.map(t => `#${t}`).join(" ") emits $bf.map_eval composed into $bf.join', () => {
+    const { template } = compileAndGenerate(`
+function TagLine({ tags }: { tags: string[] }) {
+  return <p>{tags.map((t) => \`#\${t}\`).join(' ')}</p>
+}
+export { TagLine }
+`)
+    expect(template).toContain("$bf.join($bf.map_eval($tags,")
+    expect(template).toContain('"kind":"template-literal"')
+  })
+
+  test('.map(u => u.name) emits $bf.map_eval with the field projection', () => {
+    const { template } = compileAndGenerate(`
+function NameList({ users }: { users: { name: string }[] }) {
+  return <div>{users.map((u) => u.name).join(', ')}</div>
+}
+export { NameList }
+`)
+    expect(template).toContain('$bf.map_eval($users,')
+    expect(template).toContain('"property":"name"')
+  })
+})
+
 describe('XslateAdapter - higher-order predicate lowering (#2018 P2)', () => {
   test('a serializable predicate lowers to $bf.filter_eval with the JSON body + env', () => {
     // A standalone `.filter().length` exercises the higher-order emitter (the
@@ -332,17 +447,39 @@ export { A }
     expect(findLast).toContain(', 0, {})')
   })
 
-  test('a method-call predicate falls back to the Kolon-lambda runtime call', () => {
+  test('.includes() in a predicate now lowers via the evaluator, not the Kolon-lambda fallback', () => {
+    // #2075: `.includes(x)` joined the evaluator's `array-method` surface
+    // (shared with the Perl `Evaluator.pm` runtime), so a predicate built
+    // from it routes through `$bf.every_eval` like any other pure predicate.
     const { template } = compileAndGenerate(`
 function A({ items }: { items: { name: string }[] }) {
   return <div>{items.every(x => x.name.includes('a')) ? 'y' : 'n'}</div>
 }
 export { A }
 `)
-    // No evaluator helper — the unsupported predicate keeps the `-> $x { … }`
-    // lambda form passed to the runtime `$bf.every`.
+    expect(template).toContain('$bf.every_eval(')
+    expect(template).toContain('"method":"includes"')
+    expect(template).not.toContain('-> $x {')
+  })
+
+  test('a method-call predicate outside the evaluator surface falls back to the Kolon-lambda runtime call', () => {
+    const { template } = compileAndGenerate(`
+function A({ items }: { items: { name: string }[] }) {
+  return <div>{items.every(x => x.name.toUpperCase() === 'A') ? 'y' : 'n'}</div>
+}
+export { A }
+`)
+    // `.toUpperCase()` is outside the evaluator's `array-method` gate (only
+    // `includes` is recognized there), so the predicate keeps the
+    // `-> $x { … }` lambda form passed to the runtime `$bf.every`.
     expect(template).not.toContain('every_eval')
     expect(template).toContain('$bf.every(')
     expect(template).toContain('-> $x {')
   })
 })
+
+// #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).

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

@@ -287,6 +287,27 @@ export function renderFlatMapEval(
   return `$bf.flat_map_eval(${recv}, '${escapePerlSingleQuote(json)}', '${param}', ${env})`
 }
 
+/**
+ * Emit a value-producing `.map(cb)` via the runtime evaluator (#2073): the
+ * projection body serializes to JSON and `$bf.map_eval` projects each element,
+ * one result per element (no flatten — the JS `.map` contract). Composes
+ * through the array-method chain (`.map(cb).join(' ')`). Returns null when
+ * the projection is outside the evaluator surface (→ caller refuses with
+ * BF101). The JSX-returning `.map` is an IRLoop upstream and never reaches
+ * this emit.
+ */
+export function renderMapEval(
+  recv: string,
+  body: ParsedExpr,
+  param: string,
+  emit: (e: ParsedExpr) => string,
+): string | null {
+  const json = serializeParsedExpr(body)
+  if (json === null) return null
+  const env = emitEvalEnvArg(body, [param], emit)
+  return `$bf.map_eval(${recv}, '${escapePerlSingleQuote(json)}', '${param}', ${env})`
+}
+
 /**
  * Shared Kolon emit for `.sort(cmp)` / `.toSorted(cmp)`. Used by both the
  * filter-context emitter and the top-level emitter, plus the loop-array

package/src/adapter/expr/emitters.ts

@@ -35,6 +35,7 @@ import {
   renderPredicateEval,
   renderFlatMethod,
   renderFlatMapEval,
+  renderMapEval,
 } from './array-method.ts'
 
 /**
@@ -62,18 +63,20 @@ const PREDICATE_METHODS = new Set<HigherOrderMethod>([
  * filters. Higher-order predicates are emitted using Kolon's own scalar
  * comparison operators (which delegate to Perl semantics).
  *
- * NOTE: Kolon has no `grep { } @{...}` form, so nested higher-order chains
- * (`x.tags.filter(...).length`) inside a predicate route through the
- * top-level emitter's `$bf`-helper higher-order lowering. This emitter keeps
- * the scalar-comparison surface the predicates the adapter accepts actually
- * use; richer nested shapes fall back to the helper or surface as BF101 via
- * the top-level emitter.
+ * NOTE: Kolon has no `grep { } @{...}` form, so a nested higher-order call
+ * (`x.tags.filter(...)`, `other.some(...)`) inside a predicate has no faithful
+ * scalar lowering here. Such predicates surface BF101 via `onUnsupported`
+ * (#2038) instead of silently degrading to the callback's receiver.
  */
 export class XslateFilterEmitter implements ParsedExprEmitter {
   constructor(
     private readonly param: string,
     private readonly localVarMap: Map<string, string>,
     private readonly isStringName: (n: string) => boolean = () => false,
+    // Records a BF101 for predicate shapes this emitter can only degrade
+    // (#2038). Optional so emitter construction stays possible without an
+    // adapter; a missing hook keeps the old silent-degrade emit.
+    private readonly onUnsupported?: (message: string, reason?: string) => void,
   ) {}
 
   identifier(name: string): string {
@@ -155,12 +158,15 @@ export class XslateFilterEmitter implements ParsedExprEmitter {
     _restArgs: ParsedExpr[],
     emit: (e: ParsedExpr) => string,
   ): string {
-    // Nested callback method inside a filter predicate has no Kolon scalar
-    // form; defer to the receiver so the predicate at least references a real
-    // value (a richer chain would surface its own diagnostic at the top level).
-    // Matches the pre-#2018-P5 `higherOrder` arm, which returned `emit(object)`
-    // for every method.
-    void method
+    // A nested callback method inside a filter predicate has no Kolon scalar
+    // form. The pre-#2038 behavior degraded it to its receiver, which silently
+    // changes predicate semantics (`!other.some(r => …)` collapses to
+    // `!other`), so surface BF101 instead. The receiver emit is kept only so
+    // the template stays syntactically valid while the build fails.
+    this.onUnsupported?.(
+      `Filter predicate contains a nested '.${method}(...)' callback, which has no Kolon scalar form`,
+      `Rewrite the predicate without a nested callback method, or add /* @client */ for client-only evaluation (no SSR).`,
+    )
     return emit(object)
   }
 
@@ -398,6 +404,18 @@ export class XslateTopLevelEmitter implements ParsedExprEmitter {
       return "''"
     }
 
+    // Value-producing `.map(cb)` (#2073): serialize the projection body +
+    // emit `$bf.map_eval`. (The JSX-returning `.map` is an IRLoop upstream.)
+    if (method === 'map') {
+      const evalForm = renderMapEval(recv, body, params[0], emit)
+      if (evalForm !== null) return evalForm
+      this.ctx._recordExprBF101(
+        `'.map(...)' projection is outside the Xslate adapter's evaluable surface`,
+        `Pre-compute the projected array, or move this position to a '/* @client */' boundary.`,
+      )
+      return "''"
+    }
+
     // Unknown callback method (should not arrive — CALLBACK_METHODS is closed).
     void object
     return recv

package/src/adapter/lib/ir-scope.ts

@@ -51,14 +51,3 @@ export function collectRootScopeNodes(node: IRNode): Set<IRNode> {
   visit(node)
   return out
 }
-
-/**
- * True when every `$var` the lowered Kolon expression references is already in
- * scope — guards in-template memo seeding against an out-of-scope binding. (#1297)
- */
-export function referencedVarsAreAvailable(expr: string, available: ReadonlySet<string>): boolean {
-  for (const m of expr.matchAll(/\$([A-Za-z_]\w*)/g)) {
-    if (!available.has(m[1])) return false
-  }
-  return true
-}