@barefootjs/mojolicious 0.17.0 → 0.17.1

package/dist/index.js

@@ -2,10 +2,10 @@
 import {
   BaseAdapter,
   isBooleanAttr,
-  parseExpression as parseExpression3,
+  parseExpression as parseExpression2,
   stringifyParsedExpr as stringifyParsedExpr2,
   parseStyleObjectEntries,
-  isSupported as isSupported2,
+  isSupported,
   exprToString,
   parseProviderObjectLiteral,
   emitParsedExpr as emitParsedExpr2,
@@ -128,13 +128,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 {
@@ -307,6 +300,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}'`;
@@ -360,10 +360,12 @@ class MojoFilterEmitter {
   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)
@@ -442,12 +444,14 @@ class MojoFilterEmitter {
     return `(${l} // ${r})`;
   }
   callbackMethod(method, object, arrow, _restArgs, emit) {
-    if (!PREDICATE_METHODS.has(method))
+    if (!PREDICATE_METHODS.has(method)) {
+      this.onUnsupported?.(`Filter predicate contains a nested '.${method}(...)' callback, which has no Perl scalar form`, `Rewrite the predicate without a nested callback method, or add /* @client */ for client-only evaluation (no SSR).`);
       return "1";
+    }
     const param = arrow.params[0];
     const predicate = arrow.body;
     const arrayExpr = emit(object);
-    const predBody = emitParsedExpr(predicate, new MojoFilterEmitter(param, this.localVarMap, this.isStringName));
+    const predBody = emitParsedExpr(predicate, new MojoFilterEmitter(param, this.localVarMap, this.isStringName, this.onUnsupported));
     const grepBody = predBody.replace(new RegExp(`\\$${param}\\b`, "g"), "$_");
     if (method === "filter")
       return `[grep { ${grepBody} } @{${arrayExpr}}]`;
@@ -455,6 +459,7 @@ class MojoFilterEmitter {
       return `!(grep { !(${grepBody}) } @{${arrayExpr}})`;
     if (method === "some")
       return `!!(grep { ${grepBody} } @{${arrayExpr}})`;
+    this.onUnsupported?.(`Filter predicate contains a nested '.${method}(...)' callback, which has no Perl scalar form`, `Rewrite the predicate without a nested callback method, or add /* @client */ for client-only evaluation (no SSR).`);
     return arrayExpr;
   }
   arrayLiteral(elements, emit) {
@@ -620,6 +625,13 @@ class MojoTopLevelEmitter {
       this.ctx._recordExprBF101(`.flatMap(...) projection is not lowerable to a template flat-map`, `Pre-compute the projection in the route handler, or mark the loop @client-only.`);
       return "''";
     }
+    if (method === "map") {
+      const evalForm = renderMapEval(recv, body, params[0], emit);
+      if (evalForm !== null)
+        return evalForm;
+      this.ctx._recordExprBF101(`.map(...) projection is not lowerable to a template map`, `Pre-compute the projection in the route handler, or mark the position @client-only.`);
+      return "''";
+    }
     const cb = {
       method,
       object,
@@ -863,9 +875,7 @@ function recordIndexAccessToPerl(ctx, val) {
 // src/adapter/memo/seed.ts
 import {
   collectContextConsumers,
-  extractArrowBodyExpression,
-  isSupported,
-  parseExpression as parseExpression2
+  computeSsrSeedPlan
 } from "@barefootjs/jsx";
 function contextDefaultPerl(c) {
   const d = c.defaultValue;
@@ -886,42 +896,20 @@ 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 perl = tryLowerToPerl(ctx, signal.initialValue, available);
-    if (perl !== null)
-      lines.push(`% my $${signal.getter} = ${perl};`);
-    available.add(signal.getter);
-  }
-  for (const memo of memos) {
-    const body = extractArrowBodyExpression(memo.computation);
-    if (body !== null) {
-      const perl = tryLowerToPerl(ctx, body, available);
-      if (perl !== null)
-        lines.push(`% my $${memo.name} = ${perl};`);
-    }
-    available.add(memo.name);
+  for (const step of plan.steps) {
+    if (step.kind !== "derived")
+      continue;
+    const perl = ctx.convertExpressionToPerl(step.expr, step.parsed);
+    if (perl === "" || !/\$[A-Za-z_]\w*/.test(perl))
+      continue;
+    lines.push(`% my $${step.name} = ${perl};`);
   }
   return lines.length > 0 ? lines.join(`
 `) + `
 ` : "";
 }
-function tryLowerToPerl(ctx, expr, available) {
-  const trimmed = expr.trim();
-  if (!trimmed)
-    return null;
-  if (!isSupported(parseExpression2(trimmed)).supported)
-    return null;
-  const perl = ctx.convertExpressionToPerl(trimmed);
-  if (perl === "" || !/\$[A-Za-z_]\w*/.test(perl))
-    return null;
-  return referencedVarsAreAvailable(perl, available) ? perl : null;
-}
 
 // src/adapter/value/parsed-literal.ts
 function isStringTypeInfo(type) {
@@ -1043,7 +1031,7 @@ class MojoAdapter extends BaseAdapter {
     return this.booleanTypedProps.has(bare);
   }
   parseUndefinedAlternateTernary(expr) {
-    const parsed = parseExpression3(expr.trim());
+    const parsed = parseExpression2(expr.trim());
     if (parsed?.kind !== "conditional")
       return null;
     const alt = parsed.alternate;
@@ -1291,8 +1279,9 @@ ${whenTrue}
     return `<%== bf->comment("cond-start:${condId}") %>${content}<%== bf->comment("cond-end:${condId}") %>`;
   }
   renderLoop(loop) {
-    if (loop.clientOnly)
-      return "";
+    if (loop.clientOnly) {
+      return `<%== bf->comment("loop:${loop.markerId}") %><%== bf->comment("/loop:${loop.markerId}") %>`;
+    }
     const destructure = !!(loop.paramBindings && loop.paramBindings.length > 0);
     const supportableDestructure = destructure && isLowerableObjectRestDestructure(loop);
     if (destructure && !supportableDestructure) {
@@ -1547,7 +1536,7 @@ ${children}`;
         if (localConst?.value !== undefined) {
           const initTrimmed = localConst.value.trim();
           if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(initTrimmed)) {
-            const resolved = conditionalSpreadToPerl(this.spreadCtx, parseExpression3(initTrimmed));
+            const resolved = conditionalSpreadToPerl(this.spreadCtx, parseExpression2(initTrimmed));
             if (resolved !== null) {
               return `<%== bf->spread_attrs(${resolved}) %>`;
             }
@@ -1565,7 +1554,7 @@ ${children}`;
     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.convertExpressionToPerl(e.expr)} %>`).join(";");
@@ -1601,7 +1590,7 @@ ${children}`;
     return `${BF_COND}="${condId}"`;
   }
   renderPerlFilterExpr(expr, param, localVarMap = new Map) {
-    return emitParsedExpr2(expr, new MojoFilterEmitter(param, localVarMap, (n) => this._isStringValueName(n)));
+    return emitParsedExpr2(expr, new MojoFilterEmitter(param, localVarMap, (n) => this._isStringValueName(n), (message, reason) => this._recordExprBF101(message, reason)));
   }
   convertTemplateLiteralPartsToPerl(literalParts) {
     const parts = [];
@@ -1646,8 +1635,8 @@ ${children}`;
     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);
@@ -1695,7 +1684,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) {
@@ -1706,7 +1695,7 @@ ${reason}` : "";
         }
       }
     }
-    const support = isSupported2(parsed);
+    const support = isSupported(parsed);
     if (!support.supported) {
       this.errors.push({
         code: "BF101",

package/lib/BarefootJS/Backend/Mojo.pm

@@ -1,5 +1,5 @@
 package BarefootJS::Backend::Mojo;
-our $VERSION = "0.16.0";
+our $VERSION = "0.17.0";
 use Mojo::Base -base, -signatures;
 
 use Mojo::ByteStream qw(b);

package/lib/Mojolicious/Plugin/BarefootJS/DevReload.pm

@@ -1,5 +1,5 @@
 package Mojolicious::Plugin::BarefootJS::DevReload;
-our $VERSION = "0.16.0";
+our $VERSION = "0.17.0";
 use Mojo::Base 'Mojolicious::Plugin', -signatures;
 
 =head1 NAME

package/lib/Mojolicious/Plugin/BarefootJS.pm

@@ -1,5 +1,5 @@
 package Mojolicious::Plugin::BarefootJS;
-our $VERSION = "0.16.0";
+our $VERSION = "0.17.0";
 use Mojo::Base 'Mojolicious::Plugin', -signatures;
 
 use Mojo::File qw(path);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@barefootjs/mojolicious",
-  "version": "0.17.0",
+  "version": "0.17.1",
   "description": "Mojolicious EP template adapter for BarefootJS - generates .html.ep files from IR",
   "type": "module",
   "main": "./dist/index.js",
@@ -52,7 +52,7 @@
     "directory": "packages/adapter-mojolicious"
   },
   "dependencies": {
-    "@barefootjs/shared": "0.17.0"
+    "@barefootjs/shared": "0.17.1"
   },
   "peerDependencies": {
     "@barefootjs/jsx": ">=0.2.0",
@@ -60,6 +60,6 @@
   },
   "devDependencies": {
     "@barefootjs/adapter-tests": "0.1.0",
-    "@barefootjs/jsx": "0.17.0"
+    "@barefootjs/jsx": "0.17.1"
   }
 }

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

@@ -65,6 +65,14 @@ runAdapterConformanceTests({
     // (`cn\`base \${tone()}\``) — same family as #1322 above and refused
     // via the same gate.
     'tagged-template-classname': [{ code: 'BF101', severity: 'error' }],
+    // #2038: a filter predicate containing a nested `.find(...)` callback.
+    // `find*` returns an element, not a boolean — there is no inline grep
+    // form, and the emitter used to degrade the call to its receiver.
+    // The nested `.some` sibling (`filter-nested-callback-predicate`) is
+    // NOT pinned: Mojo lowers it to a real inline Perl `grep` and must
+    // render to Hono parity instead.
+    // https://github.com/piconic-ai/barefootjs/issues/2038
+    'filter-nested-find-predicate': [{ code: 'BF101', severity: 'error' }],
     // #1467 demo-corpus context providers (`radio-group`, `accordion`,
     // `dialog`, `popover`, `select`, `dropdown-menu`, `combobox`,
     // `command`) are no longer pinned — an object-literal provider value
@@ -126,6 +134,11 @@ runAdapterConformanceTests({
     // runtime `bf->find` / `find_index` / `find_last` / `find_last_index` helpers
     // (per-element coderef predicate), matching Xslate. `.join` was never
     // pinned (handled by `renderArrayMethod`'s `case 'join'`).
+    // #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' }],
   },
   // `JSON_STRINGIFY_VIA_CONST` and `MATH_FLOOR_VIA_CONST` now pass
   // via `MojoAdapter.templatePrimitives` (#1189). The two remaining
@@ -143,16 +156,12 @@ runAdapterConformanceTests({
     TemplatePrimitiveCaseId.USER_IMPORT_VIA_CONST,
     TemplatePrimitiveCaseId.NO_DOUBLE_REWRITE_OF_PROPS_OBJECT,
   ]),
-  // Mojo `renderLoop` does not yet emit the `bf->comment("loop:<id>")`
-  // boundary markers when the loop is `@client` (Hono and Go both do).
-  // The client runtime relies on these markers to locate the insertion
-  // anchor when hydrating the array; without them, mapArray() resolves
-  // anchor = null and appends after sibling markers (#872 parity).
-  // Tracked as a follow-up; remove from this set when Mojo emits the
-  // boundary pair for clientOnly loops too.
+  // `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: `/* @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.
@@ -792,6 +801,31 @@ export function C() {
     expect(template).toContain('scalar(@{[grep { $_->{active} } @{$t->{tags}}]})')
   })
 
+  test('lowers nested .some(...) in filter predicate to an inline grep — no BF101 (#2038)', () => {
+    // The evaluator refuses the nested arrow (`serializeParsedExpr` → null),
+    // but the Perl filter emitter has a FAITHFUL form for nested
+    // filter / every / some: a real inline `grep` closing over the outer
+    // loop var. Pin the emitted EP shape positively so the #2038 loudness
+    // fix (which targets the degrade-only arms: nested `find*`,
+    // sort / reduce / flatMap — see the `filter-nested-find-predicate`
+    // expectedDiagnostics entry) never over-reaches into this supported
+    // shape. The rendered-HTML side of this contract lives in the shared
+    // `filter-nested-callback-predicate` fixture (Hono-parity render).
+    const adapter = new MojoAdapter()
+    const result = compileJSX(`'use client'
+import { createSignal } from '@barefootjs/client'
+type Item = { id: number }
+export function Picker() {
+  const [items] = createSignal<Item[]>([])
+  const [picked] = createSignal<Item[]>([])
+  return <ul>{items().filter(t => !picked().some(p => p.id === t.id)).map(t => <li key={t.id}>{t.id}</li>)}</ul>
+}`, 'C.tsx', { adapter })
+    expect(result.errors?.filter(e => e.code === 'BF101') ?? []).toEqual([])
+    const template = result.files.find(f => f.path.endsWith('.html.ep'))?.content ?? ''
+    expect(template).toContain('grep')
+    expect(template).toContain('@{$picked}')
+  })
+
   test('lowers .filter(function (x) { return x.done }).map(...) — function-keyword filter (#1443)', () => {
     // Function expressions with a single `return <expr>` body normalise
     // to the arrow-fn IR shape at parse time, so the higher-order
@@ -1035,11 +1069,26 @@ export { A }`, 'A.tsx', { adapter })
       expect(template).toContain('"property":"done"')
     }
 
-    // Fallback: a method-call predicate (`x => x.name.includes('a')`) is
-    // outside the evaluator surface, so `.every` keeps the inline grep form.
+    // #2075: `.includes(x)` is now in the evaluator surface (`array-method`
+    // gate, shared with the Perl `Evaluator.pm` runtime), so a method-call
+    // predicate built from it ALSO routes through `every_eval` rather than
+    // falling back — it's no longer the "unsupported method call" example.
+    const includesAdapter = new MojoAdapter()
+    const includesResult = compileJSX(`function A({ items }: { items: { name: string }[] }) {
+  return <div>{items.every(x => x.name.includes('a')) ? 'y' : 'n'}</div>
+}
+export { A }`, 'A.tsx', { adapter: includesAdapter })
+    const includesTemplate = includesResult.files.find(f => f.path.endsWith('.html.ep'))?.content ?? ''
+    expect(includesTemplate).toContain('bf->every_eval($items,')
+    expect(includesTemplate).toContain('"method":"includes"')
+    expect(includesTemplate).not.toContain('grep {')
+
+    // Fallback: a method-call predicate the evaluator still can't model
+    // (`.toUpperCase()` is outside the `array-method` gate — only `includes`
+    // is recognized there) keeps the inline grep form.
     const adapter = new MojoAdapter()
     const fb = compileJSX(`function A({ items }: { items: { name: string }[] }) {
-  return <div>{items.every(x => x.name.includes('a')) ? 'y' : 'n'}</div>
+  return <div>{items.every(x => x.name.toUpperCase() === 'A') ? 'y' : 'n'}</div>
 }
 export { A }`, 'A.tsx', { adapter })
     const fbTemplate = fb.files.find(f => f.path.endsWith('.html.ep'))?.content ?? ''
@@ -1488,6 +1537,110 @@ export { C }
   })
 })
 
+describe('MojoAdapter - #2075 searchParams()-derived memo seeding', () => {
+  // A memo derived from the createSearchParams() env signal must seed
+  // in-template from the canonical per-request `$searchParams` reader —
+  // including under a local alias (`const [sp] = …`), which the expression
+  // lowering canonicalises.
+  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');")
+  })
+
+  // A list-filter memo chained off the derived memo seeds too: the inline
+  // grep's `$_` topic and the callback param are lowering-internal bindings,
+  // not out-of-scope template vars (the pre-#2075 availability check
+  // rejected them and the list rendered empty at SSR).
+  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).toMatch(/% my \$visible = \[grep/)
+  })
+
+  // The seed-scope guard used to scan the LOWERED
+  // Perl 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 that would crash Perl strict mode. 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 (not the `grep` topic var of an
+  // in-scope higher-order lowering) must not seed either — the old
+  // unconditional `allowed.add('_')` 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('MojoAdapter - #2073 value-producing .map(cb)', () => {
+  function emitMap(expr: string): string {
+    const a = new MojoAdapter()
+    const ir = compileToIR(`
+function C({ tags, users }: { tags: string[]; users: { name: string }[] }) {
+  return <div>{${expr}}</div>
+}
+export { C }
+`, a)
+    return a.generate(ir).template ?? ''
+  }
+
+  // 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 `.join`.
+  test('.map(t => `#${t}`).join(" ") emits bf->map_eval composed into join', () => {
+    const t = emitMap("tags.map(t => `#${t}`).join(' ')")
+    expect(t).toContain(`join(' ', @{bf->map_eval($tags,`)
+    expect(t).toContain(`"kind":"template-literal"`)
+  })
+
+  test('.map(u => u.name) emits bf->map_eval with the field projection', () => {
+    const t = emitMap("users.map(u => u.name).join(', ')")
+    expect(t).toContain(`bf->map_eval($users,`)
+    expect(t).toContain(`"property":"name"`)
+  })
+
+  // The function-reference `.map(format)` BF101 refusal is now covered
+  // cross-adapter by the `array-map-function-reference` shared fixture's
+  // `expectedDiagnostics` entry above.
+})
+
 describe('MojoAdapter - #1448 Tier C .flatMap(field projection)', () => {
   function emitFlatMap(expr: string): string {
     const a = new MojoAdapter()

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

@@ -372,6 +372,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, and the caller
+ * records 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 Mojo emit for `.sort(cmp)` / `.toSorted(cmp)` (#1448 Tier B).
  * Used by both the filter-context emitter and the top-level emitter,

package/src/adapter/expr/emitters.ts

@@ -38,6 +38,7 @@ import {
   renderPredicateEval,
   renderFlatMethod,
   renderFlatMapEval,
+  renderMapEval,
 } from './array-method.ts'
 
 /**
@@ -81,6 +82,11 @@ export class MojoFilterEmitter implements ParsedExprEmitter {
     // against it lowers to `eq`/`ne` (#1672). Defaults to "never" for callers
     // that don't thread it through.
     private readonly isStringName: (n: string) => boolean = () => false,
+    // Records a BF101 for nested callback shapes this emitter can only
+    // degrade — `find*` and the non-predicate methods (#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 {
@@ -172,20 +178,34 @@ export class MojoFilterEmitter implements ParsedExprEmitter {
   ): string {
     // Filter context only meaningfully handles the predicate methods
     // (filter / every / some land here through nested `.filter(...)` chains).
-    // Sort / reduce / flatMap never arise inside a predicate, so route them to
-    // the truthy sentinel like the old `default` arm did.
-    if (!PREDICATE_METHODS.has(method)) return '1'
+    // Sort / reduce / flatMap have no scalar Perl form here — the old
+    // `default` arm degraded them to the truthy sentinel, silently rewriting
+    // the predicate, so surface BF101 instead (#2038).
+    if (!PREDICATE_METHODS.has(method)) {
+      this.onUnsupported?.(
+        `Filter predicate contains a nested '.${method}(...)' callback, which has no Perl scalar form`,
+        `Rewrite the predicate without a nested callback method, or add /* @client */ for client-only evaluation (no SSR).`,
+      )
+      return '1'
+    }
     // The predicate body is also a filter context, but with this
     // callback's own `param` (potentially shadowing the outer one),
     // so we spin up a nested emitter with the inner param.
     const param = arrow.params[0]
     const predicate = arrow.body
     const arrayExpr = emit(object)
-    const predBody = emitParsedExpr(predicate, new MojoFilterEmitter(param, this.localVarMap, this.isStringName))
+    const predBody = emitParsedExpr(predicate, new MojoFilterEmitter(param, this.localVarMap, this.isStringName, this.onUnsupported))
     const grepBody = predBody.replace(new RegExp(`\\$${param}\\b`, 'g'), '$_')
     if (method === 'filter') return `[grep { ${grepBody} } @{${arrayExpr}}]`
     if (method === 'every') return `!(grep { !(${grepBody}) } @{${arrayExpr}})`
     if (method === 'some') return `!!(grep { ${grepBody} } @{${arrayExpr}})`
+    // `find` / `findIndex` / `findLast` / `findLastIndex` return an element
+    // (or index), not a boolean — there is no inline grep form. Degrading to
+    // the receiver silently changes predicate semantics, so be loud (#2038).
+    this.onUnsupported?.(
+      `Filter predicate contains a nested '.${method}(...)' callback, which has no Perl scalar form`,
+      `Rewrite the predicate without a nested callback method, or add /* @client */ for client-only evaluation (no SSR).`,
+    )
     return arrayExpr
   }
 
@@ -448,6 +468,18 @@ export class MojoTopLevelEmitter implements ParsedExprEmitter {
       return "''"
     }
 
+    // Value-producing map (#2073): eval-only; BF101 when the projection is
+    // outside the surface. (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 not lowerable to a template map`,
+        `Pre-compute the projection in the route handler, or mark the position @client-only.`,
+      )
+      return "''"
+    }
+
     // Predicate methods: filter / find / every / some / findIndex / findLast /
     // findLastIndex. Eval-first (#2018 P2), then the inline `grep` / `bf->find`
     // fallback for a predicate the evaluator can't model.

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

@@ -55,16 +55,3 @@ export function collectRootScopeNodes(node: IRNode): Set<IRNode> {
   visit(node)
   return out
 }
-
-/**
- * True when every `$var` the lowered (Perl / Kolon) expression references is
- * in the available set — i.e. the template already has that var in scope.
- * Guards in-template memo seeding from referencing an out-of-scope binding
- * (which would trip Perl strict mode). (#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
-}