@barefootjs/xslate 0.17.0 → 0.18.0

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

@@ -13,13 +13,11 @@
  */
 
 import { describe, test, expect } from 'bun:test'
-import {
-  runAdapterConformanceTests,
-  TemplatePrimitiveCaseId,
-} from '@barefootjs/adapter-tests'
+import { runAdapterConformanceTests } from '@barefootjs/adapter-tests'
 import { XslateAdapter } from '../adapter'
 import { renderXslateComponent, XslateNotAvailableError } from '../test-render'
 import { compileJSX, type ComponentIR } from '@barefootjs/jsx'
+import { conformancePins } from '../conformance-pins'
 
 runAdapterConformanceTests({
   name: 'xslate',
@@ -33,91 +31,26 @@ runAdapterConformanceTests({
   // body children (TableCell) now receive `_bf_slot` for deterministic
   // parent-scope-derived IDs matching Hono.
   // Per-fixture build-time contracts for shapes the Xslate adapter
-  // intentionally refuses to lower. Mirrors mojo's set — the lowering
-  // gates are shared code paths in the ported adapter.
-  expectedDiagnostics: {
-    // Sibling-imported child component in a loop body: emits a
-    // cross-template call needing separate registration. BF103 makes
-    // the requirement loud (same as mojo).
-    'static-array-children': [{ code: 'BF103', severity: 'error' }],
-    // TodoApp / TodoAppSSR import `TodoItem` from a sibling file and
-    // call it inside a keyed `.map`. With the standalone-filter fix in
-    // place these reach the SAME BF103 (imported child in `.map`) as
-    // mojo — NOT BF101 — confirming the `.filter(...)` chain itself now
-    // lowers and the only remaining gate is the imported-child one.
-    'todo-app': [{ code: 'BF103', severity: 'error' }],
-    'todo-app-ssr': [{ code: 'BF103', severity: 'error' }],
-    // Array-destructure loop param (`([k, v]) => …`) can't lower to a
-    // single Kolon loop variable (same BF104 as mojo).
-    'static-array-from-props': [{ code: 'BF104', severity: 'error' }],
-    // Both BF103 (imported child) and BF104 (destructure) fire.
-    'static-array-from-props-with-component': [
-      { code: 'BF103', severity: 'error' },
-      { code: 'BF104', severity: 'error' },
-    ],
-    // Rest-destructure `.map()` callbacks — the object-rest shape read via
-    // member access (`rest-destructure-object-in-map`) now lowers via Kolon
-    // `: my` binding locals (`$rest` aliases the item). The other three stay
-    // refused: rest SPREAD needs a residual object, array-index / nested paths
-    // can't unpack a tuple (same surface as mojo).
-    'rest-destructure-object-spread-in-map': [{ code: 'BF104', severity: 'error' }],
-    'rest-destructure-array-in-map': [{ code: 'BF104', severity: 'error' }],
-    'rest-destructure-nested-in-map': [{ code: 'BF104', severity: 'error' }],
-    // XSLATE-SPECIFIC (mojo passes this): the site/ui Button auto-infers a
-    // `<Slot>` sibling that spreads `{...props}` / `{...children.props}`
-    // onto its root element. Kolon hashref method args can't splat a
-    // runtime hash into named entries (no `%$h`-into-call-args form), so
-    // the adapter refuses the spread with BF101 rather than emit a broken
-    // render_child call. Mojo's EP `%= include` accepts a flat stash, so it
-    // lowers the same shape; this is a genuine engine divergence, pinned
-    // declaratively here.
-    'button': [{ code: 'BF101', severity: 'error' }],
-    // `kbd` auto-infers the same `<Slot>` `{...props}` spread as `button`
-    // above — refused with BF101 for the identical Kolon engine reason, not a
-    // render-mismatch (so it's pinned here, not in `skipJsx`).
-    'kbd': [{ code: 'BF101', severity: 'error' }],
-    // #1467 demo-corpus context providers (`radio-group`, `select`,
-    // `dropdown-menu`, `combobox`, `command`) are no longer pinned — an
-    // object-literal provider value (`{ value: currentValue,
-    // onValueChange: (v) => {…} }`) lowers to a Kolon hashref via
-    // `parseProviderObjectLiteral` (#1897): getter members snapshot
-    // their body's SSR value, handler / function-shaped members lower
-    // to `nil`. The command demo's `ref={(el) => {…}}` function prop on
-    // an imported component is skipped at SSR like `on*` handlers.
-    //
-    // #1467 Phase 2e: `data-table` is no longer pinned here — it
-    // compiles clean now (`selected()[index]` → `index-access`,
-    // `.toFixed(2)` → `$bf.to_fixed`, `/* @client */` memo SSR-folded)
-    // and renders to Hono parity on real Text::Xslate. The keyed-loop
-    // scope-ID divergence (#1896) was fixed by the body-children
-    // `inLoop` reset (loop-item children get `_bf_slot`); data-table is
-    // off `skipJsx` entirely and only kept in `skipMarkerConformance`
-    // below for the shared `/* @client */` keyed-map slot-id elision
-    // contract (same as `todo-app`), not a render or BF101 gap.
-    // `style-3-signals` / `style-object-dynamic` no longer pinned — a
-    // `style={{ … }}` object literal now lowers to a CSS string with dynamic
-    // values interpolated (`background-color:<: $color :>;padding:8px`) via
-    // `tryLowerStyleObject` (#1322).
-    // 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.
-  },
-  // Template-primitive registry parity: same V1 surface as mojo, so the
-  // same two cases stay skipped (bespoke user import + customSerialize
-  // can't render server-side without user-supplied helper mappings).
-  skipTemplatePrimitives: new Set([
-    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).
+  // intentionally refuses to lower. Lives in `../conformance-pins` —
+  // mirrors mojo's set (the lowering gates are shared code paths in
+  // the ported adapter).
+  expectedDiagnostics: conformancePins,
+  // Template-primitive registry: `USER_IMPORT_VIA_CONST` and
+  // `NO_DOUBLE_REWRITE_OF_PROPS_OBJECT` now pass (#2069) — a bespoke user
+  // import can never be added to the string-keyed registry, but the
+  // shared `RelocateEnv.loweringMatchers` acceptance path recognises it
+  // via a `LoweringPlugin` the case setup registers around the compile
+  // (see `packages/adapter-tests/src/cases/template-primitives.ts`). No
+  // skips left, so `skipTemplatePrimitives` is omitted entirely.
+  // `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 +229,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 +357,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
@@ -305,7 +326,28 @@ export function renderSortMethod(recv: string, c: SortComparator): string {
 }
 
 // `.flat(depth?)` → `$bf.flat($recv, $depth)`.
-export function renderFlatMethod(recv: string, depth: FlatDepth): string {
+export function renderFlatMethod(
+  recv: string,
+  depth: FlatDepth | { expr: ParsedExpr },
+  emit: (e: ParsedExpr) => string,
+): string {
+  if (typeof depth === 'object') {
+    // Dynamic depth (#2094): routed to a SEPARATE runtime helper
+    // (`$bf.flat_dynamic`), not `$bf.flat`. The literal-depth path below
+    // already uses `-1` as a compile-time SENTINEL baked into the template
+    // source meaning "the source literally said `Infinity`". A genuinely
+    // dynamic depth that happens to evaluate to `-1` at render time means
+    // the OPPOSITE in real JS (`[1,[2]].flat(-1)` never recurses — same as
+    // `.flat(0)`). Since both paths would otherwise hand the same
+    // literal-looking argument to one shared helper, that helper couldn't
+    // tell which case it's in — so `flat_dynamic` performs its own
+    // `ToIntegerOrInfinity`-style coercion (truncate toward zero; negative
+    // -> 0; NaN/non-numeric -> 0; +Infinity or a huge finite value ->
+    // flatten fully) and then delegates to `flat`. See `sub flat_dynamic`
+    // in BarefootJS.pm and the Go reference (`FlatDynamicDepth`/
+    // `coerceFlatDepth` in bf.go).
+    return `$bf.flat_dynamic(${recv}, ${emit(depth.expr)})`
+  }
   const d = depth === 'infinity' ? -1 : depth
   return `$bf.flat(${recv}, ${d})`
 }

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)
   }
 
@@ -177,8 +183,12 @@ export class XslateFilterEmitter implements ParsedExprEmitter {
     return renderArrayMethod(method, object, args, emit)
   }
 
-  flatMethod(object: ParsedExpr, depth: FlatDepth, emit: (e: ParsedExpr) => string): string {
-    return renderFlatMethod(emit(object), depth)
+  flatMethod(
+    object: ParsedExpr,
+    depth: FlatDepth | { expr: ParsedExpr },
+    emit: (e: ParsedExpr) => string,
+  ): string {
+    return renderFlatMethod(emit(object), depth, emit)
   }
 
   conditional(_test: ParsedExpr, _consequent: ParsedExpr, _alternate: ParsedExpr): string {
@@ -398,6 +408,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
@@ -468,8 +490,12 @@ export class XslateTopLevelEmitter implements ParsedExprEmitter {
     return renderArrayMethod(method, object, args, emit)
   }
 
-  flatMethod(object: ParsedExpr, depth: FlatDepth, emit: (e: ParsedExpr) => string): string {
-    return renderFlatMethod(emit(object), depth)
+  flatMethod(
+    object: ParsedExpr,
+    depth: FlatDepth | { expr: ParsedExpr },
+    emit: (e: ParsedExpr) => string,
+  ): string {
+    return renderFlatMethod(emit(object), depth, emit)
   }
 
   conditional(
@@ -519,12 +545,16 @@ export class XslateTopLevelEmitter implements ParsedExprEmitter {
     return "''"
   }
 
-  objectLiteral(_properties: ObjectLiteralProperty[], _raw: string, _emit: (e: ParsedExpr) => string): string {
-    // Mirror `unsupported`: a bare object literal reaching the dispatcher
-    // lowers to the safe empty-string literal, exactly as before the
-    // `object-literal` kind existed (byte-identical; Roadmap A-1). Object
-    // values that round-trip to a Kolon hashref go through the dedicated
-    // `objectLiteralToKolonHashref` lowering in the conditional/attr paths.
-    return "''"
+  objectLiteral(properties: ObjectLiteralProperty[], _raw: string, _emit: (e: ParsedExpr) => string): string {
+    // The shared `isSupported` gate only ever lets this dispatcher see an
+    // object literal as the EMPTY (`?? {}`) fallback operand of `??`
+    // (expression-parser.ts, `logical` case) — any other object literal is
+    // refused before reaching here. Emit Kolon's real empty hashref
+    // literal, matching the `'{}'` convention `objectLiteralToKolonHashref`
+    // already uses for the zero-property case in the spread path. A
+    // populated literal is structurally unreachable given the gate, but
+    // still degrades safely to the pre-existing empty-string sentinel
+    // rather than silently dropping keys.
+    return properties.length === 0 ? '{}' : "''"
   }
 }

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
-}

package/src/adapter/memo/seed.ts

@@ -13,13 +13,10 @@ import {
   type ComponentIR,
   type ContextConsumer,
   collectContextConsumers,
-  extractArrowBodyExpression,
-  isSupported,
-  parseExpression,
+  computeSsrSeedPlan,
 } from '@barefootjs/jsx'
 
 import type { XslateMemoContext } from '../emit-context.ts'
-import { referencedVarsAreAvailable } from '../lib/ir-scope.ts'
 
 /** Kolon literal for a context-consumer's `createContext` default. */
 export function contextDefaultKolon(c: ContextConsumer): string {
@@ -49,77 +46,33 @@ export function generateContextConsumerSeed(ir: ComponentIR): string {
 }
 
 /**
- * Seed memos whose SSR default is `null` (not statically evaluable) by
- * computing them in-template from the already-seeded prop / signal vars
- * (`createMemo(() => props.value * 10)` → `: my $x = $value * 10;`). Without
- * this the memo's `$x` renders empty — the reason
- * `props-reactivity-comparison` was skipped. Only emitted when every var the
- * lowering references is already in scope. (#1297)
+ * Emit `: my $<name> = <kolon>;` line-statements for every `derived` step of
+ * the backend-neutral SSR seed plan — the scope/availability/ordering
+ * analysis lives in `computeSsrSeedPlan` (packages/jsx/src/ssr-seed-plan.ts);
+ * this only lowers each step's expression to Kolon and applies the
+ * backend-specific emit guards: skip an empty lowering, skip a lowering that
+ * references no `$var` at all (a constant init/body — e.g. a `derived` step
+ * with empty `frees` — keeps the existing static ssr-defaults seed instead),
+ * and skip a self-referencing lowering (Kolon's `my` shadows the RHS, so
+ * `: my $x = … $x …` would read the just-declared undefined lexical rather
+ * than the render var — the plan rules out SOURCE-level self-refs, but a
+ * lowered canonical name could still collide, so this stays as the cheap
+ * defense it always was). `env-reader` and `opaque` steps emit nothing (the
+ * runtime supplies the reader, or the adapter's ssr-defaults path already
+ * covers it). (#1297, #2075)
  */
 export function generateDerivedMemoSeed(ctx: XslateMemoContext, ir: ComponentIR): string {
-  const memos = ir.metadata.memos ?? []
-  const signals = ir.metadata.signals ?? []
-  if (memos.length === 0 && signals.length === 0) return ''
-  // Props seed first; each signal/memo adds its own name as it lands.
-  const available = new Set<string>(ir.metadata.propsParams.map(p => p.name))
+  // Package G attached this to metadata at compile time; the `??` fallback
+  // only covers hand-built metadata in older tests that predate the attached
+  // plan — same shared function, so there's no divergence from the compiler.
+  const plan = ir.metadata.ssrSeedPlan ?? computeSsrSeedPlan(ir.metadata)
   const lines: string[] = []
-
-  // Prop/signal-derived signals (`createSignal(props.defaultOn ?? false)`):
-  // a loop-child render gets no stash seed, so its `$on` would render nil;
-  // and the static default can't capture the per-call prop. Seed it
-  // in-template when the init lowers cleanly AND references an in-scope var.
-  // Object/array/constant inits keep the existing ssr-defaults seeding.
-  for (const signal of signals) {
-    const kolon = tryLowerToKolon(ctx, signal.initialValue, available)
-    // Kolon can't express `: my $x = … $x …` — declaring `my $x` makes the
-    // RHS `$x` an undefined lexical rather than the render var. A same-name
-    // signal (`createSignal(props.x ?? d)`, getter == prop) is just the prop
-    // with a default, which the harness already seeds correctly from the
-    // passed prop — skip the in-template seed for it. (Different-name
-    // prop-derived signals like toggle's `on` from `defaultOn` are unaffected.)
-    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) {
-    // Seed every memo whose body lowers cleanly — not just the ones whose
-    // static SSR default is null. A statically-foldable prop-derived memo
-    // (`createMemo(() => props.disabled ?? false)` → default `false`)
-    // still depends on the per-call prop: the static stash seed bakes in
-    // the absent-prop fold, so a caller passing `disabled => 1` would
-    // render the default branch (#1897, select's disabled item). The
-    // in-template recomputation reads the prop lexical already in scope;
-    // block-bodied arrows / out-of-scope references fall back to the
-    // static ssr-defaults seed. Same self-reference guard as the signal
-    // loop above — Kolon's `my` shadows the render var on the RHS.
-    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('\n') + '\n' : ''
 }
-
-/**
- * Lower a signal init / memo body to Kolon for an in-template SSR seed, or
- * `null` when it shouldn't be seeded this way: not a supported shape
- * (`isSupported` pre-check, so object/array literals don't fail the build),
- * references no in-scope var (a constant — keep ssr-defaults seeding), or
- * references an out-of-scope binding. (#1297)
- */
-export function tryLowerToKolon(
-  ctx: XslateMemoContext,
-  expr: string,
-  available: ReadonlySet<string>,
-): string | null {
-  const trimmed = expr.trim()
-  if (!trimmed) return null
-  if (!isSupported(parseExpression(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
-}