@barefootjs/xslate 0.31.9 → 0.31.10

package/dist/adapter/index.js

@@ -188198,8 +188198,12 @@ function generateDerivedMemoSeed(ctx, ir) {
     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))
+    if (new RegExp(`\\$${step.name}\\b`).test(kolon)) {
+      const tmp = `__bf_seed_${step.name}`;
+      lines.push(`: my $${tmp} = ${kolon};`);
+      lines.push(`: my $${step.name} = $${tmp};`);
       continue;
+    }
     lines.push(`: my $${step.name} = ${kolon};`);
   }
   return lines.length > 0 ? lines.join(`

package/dist/adapter/memo/seed.d.ts

@@ -26,13 +26,19 @@ export declare function generateContextConsumerSeed(ir: ComponentIR): string;
  * 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)
+ * and capture-before-shadow 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,
+ * e.g. `createMemo(() => props.size ?? 'icon')` lowers `props.size` straight
+ * to the stash var `$size`, colliding with the memo's own name). The
+ * self-referencing case still emits the SAME verbatim Kolon — nothing about
+ * `kolon` changes — just as the RHS of a throwaway `__bf_seed_*` local
+ * declared BEFORE `$<name>` is shadowed, so `$<name>` inside `kolon` still
+ * resolves to the stash var, not the fresh lexical; a second statement then
+ * binds the real name off the already-evaluated capture. `env-reader` and
+ * `opaque` steps emit nothing (the runtime supplies the reader, or the
+ * adapter's ssr-defaults path already covers it). (#1297, #2075, #2679)
  */
 export declare function generateDerivedMemoSeed(ctx: XslateMemoContext, ir: ComponentIR): string;
 //# sourceMappingURL=seed.d.ts.map

package/dist/adapter/memo/seed.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"seed.d.ts","sourceRoot":"","sources":["../../../src/adapter/memo/seed.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EACL,KAAK,WAAW,EAChB,KAAK,eAAe,EAGrB,MAAM,iBAAiB,CAAA;AAExB,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAA;AAE3D,sEAAsE;AACtE,wBAAgB,mBAAmB,CAAC,CAAC,EAAE,eAAe,GAAG,MAAM,CAM9D;AAED;;;;GAIG;AACH,wBAAgB,2BAA2B,CAAC,EAAE,EAAE,WAAW,GAAG,MAAM,CAWnE;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,uBAAuB,CAAC,GAAG,EAAE,iBAAiB,EAAE,EAAE,EAAE,WAAW,GAAG,MAAM,CAcvF"}
+{"version":3,"file":"seed.d.ts","sourceRoot":"","sources":["../../../src/adapter/memo/seed.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EACL,KAAK,WAAW,EAChB,KAAK,eAAe,EAGrB,MAAM,iBAAiB,CAAA;AAExB,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAA;AAE3D,sEAAsE;AACtE,wBAAgB,mBAAmB,CAAC,CAAC,EAAE,eAAe,GAAG,MAAM,CAM9D;AAED;;;;GAIG;AACH,wBAAgB,2BAA2B,CAAC,EAAE,EAAE,WAAW,GAAG,MAAM,CAWnE;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,uBAAuB,CAAC,GAAG,EAAE,iBAAiB,EAAE,EAAE,EAAE,WAAW,GAAG,MAAM,CA4BvF"}

package/dist/index.js

@@ -188198,8 +188198,12 @@ function generateDerivedMemoSeed(ctx, ir) {
     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))
+    if (new RegExp(`\\$${step.name}\\b`).test(kolon)) {
+      const tmp = `__bf_seed_${step.name}`;
+      lines.push(`: my $${tmp} = ${kolon};`);
+      lines.push(`: my $${step.name} = $${tmp};`);
       continue;
+    }
     lines.push(`: my $${step.name} = ${kolon};`);
   }
   return lines.length > 0 ? lines.join(`

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

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

package/dist/vite.js

@@ -3916,6 +3916,38 @@ function classify(name, origin, expr, parsed, available) {
   }
   return { kind: "derived", name, origin, expr, parsed, frees: [...frees] };
 }
+function localConstExprsByName(metadata) {
+  const out = new Map;
+  for (const c of metadata.localConstants ?? []) {
+    if (c.isModule || c.declarationKind !== "const" || c.value === undefined)
+      continue;
+    out.set(c.name, c.parsed ?? parseExpression(c.value.trim()));
+  }
+  return out;
+}
+function resolveThroughLocalConsts(parsed, localConsts) {
+  let current = parsed;
+  const maxIter = localConsts.size + 1;
+  for (let i = 0;i < maxIter; i++) {
+    const frees = freeIdentifiers(current);
+    if (frees === null)
+      break;
+    let changed = false;
+    for (const name of frees) {
+      const value = localConsts.get(name);
+      if (!value)
+        continue;
+      const inlined = inlineBinding(current, name, value);
+      if (inlined === null)
+        continue;
+      current = inlined;
+      changed = true;
+    }
+    if (!changed)
+      break;
+  }
+  return current;
+}
 function computeSsrSeedPlan(metadata) {
   const baseScope = metadata.propsParams.map((p) => p.name);
   if (metadata.propsObjectName)
@@ -3924,6 +3956,7 @@ function computeSsrSeedPlan(metadata) {
     baseScope.push(name);
   }
   const available = new Set(baseScope);
+  const localConsts = localConstExprsByName(metadata);
   const steps = [];
   for (const signal of metadata.signals) {
     if (signal.envReader) {
@@ -3935,13 +3968,13 @@ function computeSsrSeedPlan(metadata) {
       }
     }
     const expr = signal.initialValue.trim();
-    steps.push(expr === "" ? { kind: "opaque", name: signal.getter, origin: "signal" } : classify(signal.getter, "signal", expr, parseExpression(expr), available));
+    steps.push(expr === "" ? { kind: "opaque", name: signal.getter, origin: "signal" } : classify(signal.getter, "signal", expr, resolveThroughLocalConsts(parseExpression(expr), localConsts), available));
     available.add(signal.getter);
   }
   for (const memo of metadata.memos) {
     const body = extractArrowBodyExpression(memo.computation);
     const expr = body?.trim() ?? "";
-    steps.push(expr === "" ? { kind: "opaque", name: memo.name, origin: "memo" } : classify(memo.name, "memo", expr, memo.parsed ?? parseExpression(expr), available));
+    steps.push(expr === "" ? { kind: "opaque", name: memo.name, origin: "memo" } : classify(memo.name, "memo", expr, resolveThroughLocalConsts(memo.parsed ?? parseExpression(expr), localConsts), available));
     available.add(memo.name);
   }
   return { baseScope, steps };
@@ -6004,8 +6037,12 @@ function generateDerivedMemoSeed(ctx, ir) {
     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))
+    if (new RegExp(`\\$${step.name}\\b`).test(kolon)) {
+      const tmp = `__bf_seed_${step.name}`;
+      lines.push(`: my $${tmp} = ${kolon};`);
+      lines.push(`: my $${step.name} = $${tmp};`);
       continue;
+    }
     lines.push(`: my $${step.name} = ${kolon};`);
   }
   return lines.length > 0 ? lines.join(`

package/lib/BarefootJS/Backend/Xslate.pm

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@barefootjs/xslate",
-  "version": "0.31.9",
+  "version": "0.31.10",
   "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,7 +55,7 @@
     "directory": "packages/adapter-xslate"
   },
   "dependencies": {
-    "@barefootjs/shared": "0.31.9"
+    "@barefootjs/shared": "0.31.10"
   },
   "peerDependencies": {
     "@barefootjs/jsx": ">=0.2.0",
@@ -72,9 +72,9 @@
   },
   "devDependencies": {
     "@barefootjs/adapter-tests": "0.1.0",
-    "@barefootjs/jsx": "0.31.9",
-    "@barefootjs/vite": "0.31.9",
-    "@barefootjs/client": "0.31.9",
+    "@barefootjs/jsx": "0.31.10",
+    "@barefootjs/vite": "0.31.10",
+    "@barefootjs/client": "0.31.10",
     "typescript": "^5.0.0",
     "vite": "^6.0.0"
   }

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

@@ -199,9 +199,11 @@ export function Item(props: { defaultOn?: boolean }) {
     expect(template).toContain(': my $on = ($defaultOn // 0);')
   })
 
-  // Kolon can't `: my $x = … $x …`; a same-name signal stays on the existing
-  // (harness/manifest) seeding rather than an in-template seed.
-  test('does NOT in-template-seed a same-name signal', () => {
+  // Kolon can't `: my $x = … $x …` directly (the declaration shadows the
+  // RHS's own reference), so a same-name signal captures the lowered
+  // expression into a throwaway `__bf_seed_<name>` local BEFORE `$x` is
+  // declared, then binds `$x` off that capture (#2679).
+  test('in-template-seeds a same-name signal via capture-before-shadow', () => {
     const { template } = compileAndGenerate(`
 'use client'
 import { createSignal } from '@barefootjs/client'
@@ -210,7 +212,8 @@ export function C(props: { x?: number }) {
   return <span>{x()}</span>
 }
 `)
-    expect(template).not.toContain(': my $x =')
+    expect(template).toContain(': my $__bf_seed_x = ($x // 7);')
+    expect(template).toContain(': my $x = $__bf_seed_x;')
   })
 
   test('emits data_key_attr on the component root', () => {

package/src/adapter/memo/seed.ts

@@ -53,13 +53,19 @@ export function generateContextConsumerSeed(ir: ComponentIR): string {
  * 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)
+ * and capture-before-shadow 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,
+ * e.g. `createMemo(() => props.size ?? 'icon')` lowers `props.size` straight
+ * to the stash var `$size`, colliding with the memo's own name). The
+ * self-referencing case still emits the SAME verbatim Kolon — nothing about
+ * `kolon` changes — just as the RHS of a throwaway `__bf_seed_*` local
+ * declared BEFORE `$<name>` is shadowed, so `$<name>` inside `kolon` still
+ * resolves to the stash var, not the fresh lexical; a second statement then
+ * binds the real name off the already-evaluated capture. `env-reader` and
+ * `opaque` steps emit nothing (the runtime supplies the reader, or the
+ * adapter's ssr-defaults path already covers it). (#1297, #2075, #2679)
  */
 export function generateDerivedMemoSeed(ctx: XslateMemoContext, ir: ComponentIR): string {
   // Package G attached this to metadata at compile time; the `??` fallback
@@ -71,7 +77,21 @@ export function generateDerivedMemoSeed(ctx: XslateMemoContext, ir: ComponentIR)
     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
+    if (new RegExp(`\\$${step.name}\\b`).test(kolon)) {
+      // Self-referencing lowering (#2679): capture the RHS into a
+      // throwaway local BEFORE `$<name>` is declared — `$<name>` inside
+      // `kolon` still reads the stash var at this point, nothing is
+      // shadowed yet — then bind the real name off the capture. The
+      // `__bf_seed_` prefix follows the adapter's established internal-
+      // temporary convention (`__bf_item` / `__bf_pair` in the loop
+      // lowering); suffixing with `step.name` keeps two derived steps in
+      // the same template from colliding, since `step.name` is itself
+      // unique per plan (each step declares a distinct local).
+      const tmp = `__bf_seed_${step.name}`
+      lines.push(`: my $${tmp} = ${kolon};`)
+      lines.push(`: my $${step.name} = $${tmp};`)
+      continue
+    }
     lines.push(`: my $${step.name} = ${kolon};`)
   }
   return lines.length > 0 ? lines.join('\n') + '\n' : ''

package/src/render-divergences.ts

@@ -9,5 +9,11 @@
 
 import type { RenderDivergences } from '@barefootjs/jsx'
 
-export const renderDivergences: RenderDivergences = {
-}
+// #2679 graduated (capture-before-shadow in `generateDerivedMemoSeed`,
+// packages/adapter-xslate/src/adapter/memo/seed.ts): a self-referencing
+// derived signal/memo now seeds a throwaway `__bf_seed_<name>` local from
+// the RAW-stash-var Kolon lowering BEFORE `$<name>` is declared, then binds
+// the real name off that capture — the same in-template recompute the other
+// six template-stash backends already had. Keep the file even when the set
+// is empty — the next divergence lands here, not in a re-created file.
+export const renderDivergences: RenderDivergences = {}

package/src/test-render.ts

@@ -568,6 +568,16 @@ function buildPerlProps(
     // Env signals (#2057) are bound below via `search_params('')`, not from a
     // static initial value.
     if (signal.envReader) continue
+    // #2669: a self-derivation collision (the signal's own initializer
+    // derives from a same-named prop, e.g. `createSignal(props.label ??
+    // 'Default')`) already got the correct RAW-prop seed above via
+    // `derivedProps` / the user-props loop — `extractSsrDefaults` marks that
+    // with a `propName`-carrying entry (see its docstring's invariant).
+    // Re-seeding here with this harness's OWN recompute
+    // (`evaluateSignalInit`) would clobber the correctly-derived caller
+    // value with the harness's evaluated-from-static-props number, papering
+    // over the exact production bug this fixture exists to catch.
+    if (rootSsrDefaults[signal.getter]?.propName !== undefined) continue
     const value = evaluateSignalInit(signal.initialValue.trim(), props)
     if (value !== null) {
       entries.push(`${signal.getter} => ${toPerlLiteral(value)}`)
@@ -577,6 +587,12 @@ function buildPerlProps(
   // Memo values seeded from the statically-evaluated ssrDefaults, same
   // as the production plugin's before_render hook.
   for (const memo of ir.metadata.memos) {
+    // #2669: same self-derivation skip as the signal loop above — a
+    // `propName`-carrying memo entry already stands as the correctly
+    // prop-derived seed; don't clobber it with the memo's OWN evaluated
+    // value (which for a non-idempotent derivation is already the WRONG,
+    // double-applied number).
+    if (rootSsrDefaults[memo.name]?.propName !== undefined) continue
     const entry = rootSsrDefaults[memo.name]
     const value = entry ? entry.value : 0
     entries.push(`${memo.name} => ${toPerlLiteral(value ?? 0)}`)