@barefootjs/mojolicious 0.16.0 → 0.17.1

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

@@ -1 +1 @@
-{"version":3,"file":"test-render.d.ts","sourceRoot":"","sources":["../src/test-render.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAeH,qBAAa,qBAAsB,SAAQ,KAAK;IAC9C,YAAY,OAAO,EAAE,MAAM,EAG1B;CACF;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAKxE;AAkCD,MAAM,WAAW,aAAa;IAC5B,sBAAsB;IACtB,MAAM,EAAE,MAAM,CAAA;IACd,8BAA8B;IAC9B,OAAO,EAAE,OAAO,iBAAiB,EAAE,eAAe,CAAA;IAClD,iCAAiC;IACjC,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAC/B,qDAAqD;IACrD,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACnC;;;;;OAKG;IACH,aAAa,CAAC,EAAE,MAAM,CAAA;CACvB;AAED,wBAAsB,mBAAmB,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,MAAM,CAAC,CAgNjF;AAmWD;;;GAGG;AACH,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,MAAM,EACZ,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC9B,OAAO,CAuBT"}
+{"version":3,"file":"test-render.d.ts","sourceRoot":"","sources":["../src/test-render.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAeH,qBAAa,qBAAsB,SAAQ,KAAK;IAC9C,YAAY,OAAO,EAAE,MAAM,EAG1B;CACF;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAKxE;AAkCD,MAAM,WAAW,aAAa;IAC5B,sBAAsB;IACtB,MAAM,EAAE,MAAM,CAAA;IACd,8BAA8B;IAC9B,OAAO,EAAE,OAAO,iBAAiB,EAAE,eAAe,CAAA;IAClD,iCAAiC;IACjC,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAC/B,qDAAqD;IACrD,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACnC;;;;;OAKG;IACH,aAAa,CAAC,EAAE,MAAM,CAAA;CACvB;AAED,wBAAsB,mBAAmB,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,MAAM,CAAC,CAgNjF;AAqWD;;;GAGG;AACH,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,MAAM,EACZ,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC9B,OAAO,CAuBT"}

package/lib/BarefootJS/Backend/Mojo.pm

@@ -1,5 +1,5 @@
 package BarefootJS::Backend::Mojo;
-our $VERSION = "0.15.2";
+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.15.2";
+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.15.2";
+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.16.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.16.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.16.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
@@ -122,10 +130,15 @@ runAdapterConformanceTests({
     // (Go) and new `bf->trim` helper (Mojo) handle the strip
     // (#1448 Tier A ninth PR, closing out Tier A).
     // `.find` / `.findIndex` / `.findLast` / `.findLastIndex` are no longer
-    // pinned — the Mojo `higherOrder` emitter now lowers them to the runtime
-    // `bf->find` / `find_index` / `find_last` / `find_last_index` helpers
+    // pinned — the Mojo `callbackMethod` predicate arm now lowers them to the
+    // 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.
@@ -239,8 +248,9 @@ describe('MojoAdapter - searchParams() env-signal lowering (#1922)', () => {
   // generic hash deref `$searchParams->{get}` (which drops the arg).
   test('lowers searchParams().get(k) to a method call on $searchParams', () => {
     const { template } = compileAndGenerate(`
-import { searchParams } from '@barefootjs/client'
+import { createSearchParams } from '@barefootjs/client'
 function SortLabel() {
+  const [searchParams] = createSearchParams()
   return <p>{searchParams().get('sort') ?? 'none'}</p>
 }
 `)
@@ -248,13 +258,14 @@ function SortLabel() {
     expect(template).not.toContain('$searchParams->{get}')
   })
 
-  // An aliased import binds the env signal to a different local name; the
-  // expression reads `sp()`, but it still lowers to the canonical
+  // An aliased destructured getter binds the env signal to a different local
+  // name; the expression reads `sp()`, but it still lowers to the canonical
   // `$searchParams` reader (the harness/plugin seed that fixed var).
-  test('matches an aliased import (`searchParams as sp`) and emits canonical $searchParams', () => {
+  test('matches an aliased env-signal getter (`const [sp] = createSearchParams()`) and emits canonical $searchParams', () => {
     const { template } = compileAndGenerate(`
-import { searchParams as sp } from '@barefootjs/client'
+import { createSearchParams } from '@barefootjs/client'
 function SortLabel() {
+  const [sp] = createSearchParams()
   return <p>{sp().get('sort') ?? 'none'}</p>
 }
 `)
@@ -720,10 +731,12 @@ export function C() {
       // empty array there, which a template can't mirror.
       { name: 'reduce (no init)',  body: `<div>{items().reduce((s, x) => s + x)}</div>`,                                                             needle: '.reduce(' },
       { name: 'forEach',           body: `<ul>{items().forEach(x => x)}</ul>`,                                                                       needle: '.forEach(' },
-      // Self / field / field-tuple `.flatMap` now lowers (#1448 Tier C) —
-      // even as a loop base — so those moved to positive tests below. A
-      // tuple with a non-leaf element (a string literal) stays refused.
-      { name: 'flatMap (literal element)', body: `<div>{items().flatMap(x => [x.tag, "x"])}</div>`,                                                needle: '.flatMap(' },
+      // #2018 P5: an array-literal projection with a literal element
+      // (`x => [x.tag, "x"]`) now lowers through the runtime evaluator
+      // (`bf->flat_map_eval`) — the structured-tuple restriction that
+      // refused a non-`self`/`field` leaf is gone. See the positive
+      // flat_map_eval pins below. The remaining BF101 flatMap surface
+      // (a projection the evaluator can't serialize) has no example here.
     ]
 
     for (const { name, body, needle } of cases) {
@@ -760,7 +773,11 @@ export function C() {
 }`, '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 { $_->{done} } @{$items}')
+    // #2018 P2: the `.filter().map()` loop hoists over the filtered array,
+    // now produced by the evaluator (`bf->filter_eval`). (Hoisting the call
+    // into a single `my` var is a P3 optimization.)
+    expect(template).toContain('bf->filter_eval($items,')
+    expect(template).toContain('"property":"done"')
   })
 
   test('lowers nested .filter(...).length > 0 in outer filter predicate (#1443 PR4)', () => {
@@ -784,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
@@ -798,7 +840,11 @@ export function C() {
 }`, '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 { $_->{done} } @{$items}')
+    // #2018 P2: the `.filter().map()` loop hoists over the filtered array,
+    // now produced by the evaluator (`bf->filter_eval`). (Hoisting the call
+    // into a single `my` var is a P3 optimization.)
+    expect(template).toContain('bf->filter_eval($items,')
+    expect(template).toContain('"property":"done"')
   })
 
   test('lowers the registry Slot\'s [a, b].filter(Boolean).join(\' \') chain (#1443)', () => {
@@ -977,17 +1023,18 @@ export { A }`, 'A.tsx', { adapter })
     expect(template).not.toContain('$bf->trim')
   })
 
-  test('lowers .find / .findIndex / .findLast / .findLastIndex via runtime helpers', () => {
-    // The runtime `bf->find` / `find_index` / `find_last` / `find_last_index`
-    // call the predicate as a per-element coderef; the camelCase JS names map
-    // to the snake_case helpers (matching Xslate's Kolon-lambda lowering).
-    const cases: Array<[string, string]> = [
-      ['find', 'find'],
-      ['findIndex', 'find_index'],
-      ['findLast', 'find_last'],
-      ['findLastIndex', 'find_last_index'],
+  test('lowers .find / .findIndex / .findLast / .findLastIndex via the evaluator', () => {
+    // #2018 P2: the pure predicate `x => x === 'b'` serializes and lowers
+    // through the evaluator. find / findIndex share `bf->find_eval` /
+    // `bf->find_index_eval` with findLast / findLastIndex, distinguished by
+    // the `forward` flag (1 = forward, 0 = backward).
+    const cases: Array<[string, string, number]> = [
+      ['find', 'find_eval', 1],
+      ['findIndex', 'find_index_eval', 1],
+      ['findLast', 'find_eval', 0],
+      ['findLastIndex', 'find_index_eval', 0],
     ]
-    for (const [js, helper] of cases) {
+    for (const [js, helper, fwd] of cases) {
       const adapter = new MojoAdapter()
       const result = compileJSX(`function A({ items }: { items: string[] }) {
   return <div>{items.${js}(x => x === 'b')}</div>
@@ -995,11 +1042,60 @@ export { A }`, 'A.tsx', { adapter })
 export { A }`, 'A.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(`bf->${helper}($items, sub { my $x = $_[0]; $x eq 'b' })`)
+      expect(template).toContain(`bf->${helper}($items,`)
+      expect(template).toContain(`'x', ${fwd}, {})`)
       expect(template).not.toContain(`$bf->${helper}`)
     }
   })
 
+  test('lowers .every / .some via the evaluator, with grep fallback for a method-call predicate', () => {
+    // #2018 P2: a pure predicate routes `.every` / `.some` through
+    // `bf->every_eval` / `bf->some_eval`; a method-call predicate the
+    // evaluator can't model (`serializeParsedExpr` → null) falls back to the
+    // inline `grep` form.
+    const evalCases: Array<[string, string]> = [
+      ['every', 'every_eval'],
+      ['some', 'some_eval'],
+    ]
+    for (const [js, helper] of evalCases) {
+      const adapter = new MojoAdapter()
+      const result = compileJSX(`function A({ items }: { items: { done: boolean }[] }) {
+  return <div>{items.${js}(x => x.done) ? 'y' : 'n'}</div>
+}
+export { A }`, 'A.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(`bf->${helper}($items,`)
+      expect(template).toContain('"property":"done"')
+    }
+
+    // #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.toUpperCase() === 'A') ? 'y' : 'n'}</div>
+}
+export { A }`, 'A.tsx', { adapter })
+    const fbTemplate = fb.files.find(f => f.path.endsWith('.html.ep'))?.content ?? ''
+    expect(fbTemplate).toContain('grep {')
+    expect(fbTemplate).not.toContain('every_eval')
+  })
+
   test('lowers .reverse().join(\' \') via bf->reverse + join (#1448 Tier A)', () => {
     // SSR templates render a snapshot, so `.reverse` and
     // `.toReversed` share a Mojo lowering — both return a new
@@ -1355,19 +1451,26 @@ describe('MojoAdapter - #1448 Tier A/B fixture-driven lowering pins', () => {
     // #1448 Tier B — string → string, padded to a target width.
     { fixture: stringPadStartFixture,   expect: `bf->pad_start($value, 5, '0')` },
     { fixture: stringPadEndFixture,     expect: `bf->pad_end($value, 5, '.')` },
-    // #1448 Tier B — sort / toSorted. The loop-chained field cases
-    // hoist into a `my $bf_iter_lN = bf->sort(...)` local; the
-    // standalone primitive cases inline the call. Each comparison key
-    // is one hash under `keys` (a single-key comparator → one element).
-    { fixture: arraySortFieldAscFixture,  expect: `bf->sort($items, { keys => [{ key_kind => 'field', key => 'price', compare_type => 'numeric', direction => 'asc' }] })` },
-    { fixture: arraySortFieldDescFixture, expect: `bf->sort($items, { keys => [{ key_kind => 'field', key => 'price', compare_type => 'numeric', direction => 'desc' }] })` },
-    { fixture: arraySortPrimitiveFixture, expect: `bf->sort($nums, { keys => [{ key_kind => 'self', compare_type => 'numeric', direction => 'asc' }] })` },
+    // #1448 Tier B — sort / toSorted. EXPR2 migration (#2018): both a
+    // STANDALONE `.sort(cmp)` value call AND the `.sort().map()` loop-hoist
+    // (#2018 P3) serialize the comparator body and emit `bf->sort_eval(...)`
+    // (JSON body + param names + captured env). `localeCompare` comparators
+    // fall back to the structured `bf->sort` — `serializeParsedExpr` refuses
+    // them. (Loop-hoist field cases pin only the helper + receiver; their
+    // comparator JSON is verified by the render conformance.)
+    { fixture: arraySortFieldAscFixture,  expect: `bf->sort_eval($items,` },
+    { fixture: arraySortFieldDescFixture, expect: `bf->sort_eval($items,` },
+    { fixture: arraySortPrimitiveFixture, expect: `bf->sort_eval($nums, '{"kind":"binary","op":"-","left":{"kind":"identifier","name":"a"},"right":{"kind":"identifier","name":"b"}}', 'a', 'b', {})` },
+    // localeCompare → outside the evaluator surface → legacy `bf->sort`.
     { fixture: arraySortLocaleFixture,    expect: `bf->sort($names, { keys => [{ key_kind => 'self', compare_type => 'string', direction => 'asc' }] })` },
-    // Multi-key (`||`-chain): one hash per comparison key, in order.
+    // Multi-key (`||`-chain): the second key is a `localeCompare`, so the
+    // whole comparator falls back to the structured `bf->sort` (one hash
+    // per comparison key, in order).
     { fixture: arraySortMultiKeyFixture,  expect: `bf->sort($items, { keys => [{ key_kind => 'field', key => 'price', compare_type => 'numeric', direction => 'asc' }, { key_kind => 'field', key => 'name', compare_type => 'string', direction => 'asc' }] })` },
-    // Relational-ternary comparator lowers to a single `auto` key.
-    { fixture: arraySortTernaryFixture,   expect: `bf->sort($items, { keys => [{ key_kind => 'field', key => 'rank', compare_type => 'auto', direction => 'asc' }] })` },
-    { fixture: arrayToSortedFixture,      expect: `bf->sort($nums, { keys => [{ key_kind => 'self', compare_type => 'numeric', direction => 'asc' }] })` },
+    // Relational-ternary comparator — a pure body, so the loop-hoist now
+    // serializes it through `bf->sort_eval` like the other field sorts.
+    { fixture: arraySortTernaryFixture,   expect: `bf->sort_eval($items,` },
+    { fixture: arrayToSortedFixture,      expect: `bf->sort_eval($nums, '{"kind":"binary","op":"-","left":{"kind":"identifier","name":"a"},"right":{"kind":"identifier","name":"b"}}', 'a', 'b', {})` },
     // #1448 Tier B — iteration shapes. These are loop-level patterns.
     // .entries() → for loop with both $i index var and $v value var
     { fixture: arrayEntriesFixture,       expect: '% my $v = $items->[$i];' },
@@ -1375,17 +1478,19 @@ describe('MojoAdapter - #1448 Tier A/B fixture-driven lowering pins', () => {
     { fixture: arrayKeysFixture,          expect: '% for my $k (0..$#{$items})' },
     // .values() → standard for loop (same as plain .map())
     { fixture: arrayValuesFixture,        expect: '% my $v = $items->[$_i];' },
-    // #1448 Tier C — .reduce(fn, init) arithmetic fold. The structured
-    // ReduceOp lowers to a single `bf->reduce(...)` call with op /
-    // key / type / init / direction in the options hash. Each shape
-    // exercises one arm: field-numeric sum, self-numeric sum,
-    // string-concat fold, the product (`*`) operator, and the
-    // right-to-left `direction` of reduceRight.
-    { fixture: reduceSumFieldFixture,     expect: `bf->reduce($items, { op => '+', key_kind => 'field', key => 'duration', type => 'numeric', init => 0, direction => 'left' })` },
-    { fixture: reduceSumSelfFixture,      expect: `bf->reduce($nums, { op => '+', key_kind => 'self', type => 'numeric', init => 0, direction => 'left' })` },
-    { fixture: reduceConcatFixture,       expect: `bf->reduce($items, { op => '+', key_kind => 'field', key => 'label', type => 'string', init => '', direction => 'left' })` },
-    { fixture: reduceProductFixture,      expect: `bf->reduce($items, { op => '*', key_kind => 'field', key => 'qty', type => 'numeric', init => 1, direction => 'left' })` },
-    { fixture: reduceRightConcatFixture,  expect: `bf->reduce($items, { op => '+', key_kind => 'field', key => 'label', type => 'string', init => '', direction => 'right' })` },
+    // #1448 Tier C — .reduce(fn, init) arithmetic fold. EXPR2 migration
+    // (#2018): the reducer body is serialized to ParsedExpr JSON and
+    // folded by `bf->reduce_eval(json, accName, itemName, init, direction,
+    // env)` — the runtime evaluator subsumes the old `+`/`*` catalogue.
+    // A numeric seed passes through bare (`0` / `1`); a concat seed as a
+    // single-quoted string (`''`). Each shape exercises one arm: field-
+    // numeric sum, self-numeric sum, string-concat fold, the product
+    // (`*`) operator, and the right-to-left `direction` of reduceRight.
+    { fixture: reduceSumFieldFixture,     expect: `bf->reduce_eval($items, '{"kind":"binary","op":"+","left":{"kind":"identifier","name":"sum"},"right":{"kind":"member","object":{"kind":"identifier","name":"t"},"property":"duration"}}', 'sum', 't', 0, 'left', {})` },
+    { fixture: reduceSumSelfFixture,      expect: `bf->reduce_eval($nums, '{"kind":"binary","op":"+","left":{"kind":"identifier","name":"a"},"right":{"kind":"identifier","name":"b"}}', 'a', 'b', 0, 'left', {})` },
+    { fixture: reduceConcatFixture,       expect: `bf->reduce_eval($items, '{"kind":"binary","op":"+","left":{"kind":"identifier","name":"acc"},"right":{"kind":"member","object":{"kind":"identifier","name":"x"},"property":"label"}}', 'acc', 'x', '', 'left', {})` },
+    { fixture: reduceProductFixture,      expect: `bf->reduce_eval($items, '{"kind":"binary","op":"*","left":{"kind":"identifier","name":"acc"},"right":{"kind":"member","object":{"kind":"identifier","name":"x"},"property":"qty"}}', 'acc', 'x', 1, 'left', {})` },
+    { fixture: reduceRightConcatFixture,  expect: `bf->reduce_eval($items, '{"kind":"binary","op":"+","left":{"kind":"identifier","name":"acc"},"right":{"kind":"member","object":{"kind":"identifier","name":"x"},"property":"label"}}', 'acc', 'x', '', 'right', {})` },
   ]
 
   for (const { fixture, expect: expectedHelper } of cases) {
@@ -1432,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()
@@ -1444,20 +1653,26 @@ export { C }
     return a.generate(ir).template ?? ''
   }
 
-  test('.flatMap(i => i.field) emits bf->flat_map with the raw field key', () => {
-    expect(emitFlatMap('rows.flatMap(i => i.tags).join(" ")')).toContain(`bf->flat_map($rows, 'field', 'tags')`)
-  })
-
-  test('.flatMap(i => i) emits the self projection', () => {
-    expect(emitFlatMap('rows.flatMap(i => i).join(" ")')).toContain(`bf->flat_map($rows, 'self', '')`)
+  // #2018 P3: `.flatMap(proj)` lowers through the evaluator — the projection
+  // body serializes to ParsedExpr JSON and `bf->flat_map_eval` flattens the
+  // results one level. (In Mojo the JSON rides in a single-quoted Perl string,
+  // so its double quotes are literal and assertable.)
+  test('.flatMap(i => i.field) emits bf->flat_map_eval with the field projection', () => {
+    const t = emitFlatMap('rows.flatMap(i => i.tags).join(" ")')
+    expect(t).toContain(`bf->flat_map_eval($rows,`)
+    expect(t).toContain(`"property":"tags"`)
   })
 
-  test('.flatMap(i => [i.a, i.b]) emits bf->flat_map_tuple with leaf specs', () => {
-    expect(emitFlatMap('rows.flatMap(i => [i.a, i.b]).join(" ")')).toContain(`bf->flat_map_tuple($rows, ['field', 'a'], ['field', 'b'])`)
+  test('.flatMap(i => i) emits bf->flat_map_eval (self/identifier projection)', () => {
+    const t = emitFlatMap('rows.flatMap(i => i).join(" ")')
+    expect(t).toContain(`bf->flat_map_eval($rows,`)
+    expect(t).toContain(`"kind":"identifier","name":"i"`)
   })
 
-  test('tuple self + field leaves', () => {
-    expect(emitFlatMap('rows.flatMap(i => [i, i.a]).join(" ")')).toContain(`bf->flat_map_tuple($rows, ['self', ''], ['field', 'a'])`)
+  test('.flatMap(i => [i.a, i.b]) emits bf->flat_map_eval over an array-literal projection', () => {
+    const t = emitFlatMap('rows.flatMap(i => [i.a, i.b]).join(" ")')
+    expect(t).toContain(`bf->flat_map_eval($rows,`)
+    expect(t).toContain(`"kind":"array-literal"`)
   })
 
   test('field-projection flatMap as a loop base lowers (no BF101)', () => {
@@ -1470,7 +1685,7 @@ export function C() {
 }`, a)
     const template = a.generate(ir).template ?? ''
     expect((a.errors ?? []).filter(e => e.code === 'BF101')).toEqual([])
-    expect(template).toContain(`bf->flat_map($items, 'field', 'tags')`)
+    expect(template).toContain(`bf->flat_map_eval($items,`)
   })
 })
 
@@ -1537,9 +1752,11 @@ export function C() {
     // the no-initial-value form stays refused — JS throws on an empty
     // array there, which a template can't mirror.
     { name: 'reduce (no init)', expr: `items().reduce((a, b) => a + b.n)`, badEmit: '->{reduce}' },
-    // Self / field / field-tuple `.flatMap` now lowers (#1448 Tier C); a
-    // tuple with a non-leaf element (here a string literal) stays refused.
-    { name: 'flatMap (literal element)', expr: `items().flatMap(i => [i.name, "x"])`, badEmit: '->{flatMap}' },
+    // #2018 P5: an array-literal projection with a literal element
+    // (`i => [i.name, "x"]`) now lowers through the runtime evaluator
+    // (`bf->flat_map_eval`) rather than refusing — the structured-tuple
+    // leaf restriction is gone. (Cross-adapter isomorphic with the Go
+    // adapter's `bf_flat_map_eval`.) Pinned positively below.
     // Lowered methods whose MEANINGFUL extra argument isn't lowered yet
     // (#1448): the `fromIndex` of `.includes`/`.indexOf`/`.lastIndexOf`
     // and the variadic `.concat`. The parser refuses these (silently