@barefootjs/jsx 0.31.9 → 0.31.10

package/dist/analyzer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"analyzer.d.ts","sourceRoot":"","sources":["../src/analyzer.ts"],"names":[],"mappings":"AACA;;;;;GAKG;AAEH,OAAO,EAAE,MAAM,YAAY,CAAA;AAG3B,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,yBAAyB,CAAA;AAInE,OAAO,EACL,KAAK,eAAe,EAUrB,MAAM,uBAAuB,CAAA;AAqB9B;;;;GAIG;AACH,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAU/D;AA8BD;;;;;;;;;;GAUG;AACH,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,MAAM,GACf;IAAE,OAAO,EAAE,EAAE,CAAC,OAAO,CAAC;IAAC,UAAU,EAAE,EAAE,CAAC,UAAU,CAAC;IAAC,OAAO,EAAE,EAAE,CAAC,WAAW,CAAA;CAAE,GAAG,IAAI,CA8CpF;AAMD,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,MAAM,EAChB,mBAAmB,CAAC,EAAE,MAAM,EAC5B,OAAO,CAAC,EAAE,EAAE,CAAC,OAAO,EACpB,mBAAmB,CAAC,EAAE,oBAAoB,EAC1C,eAAe,CAAC,EAAE,OAAO,GACxB,eAAe,CAkKjB;AAuhBD;;;;;;;;;;GAUG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,EAAE,CAAC,UAAU,GAAG,EAAE,CAAC,UAAU,CAavE;AAuuCD,MAAM,MAAM,aAAa,GAAG,EAAE,CAAC,UAAU,GAAG,EAAE,CAAC,qBAAqB,GAAG,EAAE,CAAC,WAAW,CAAA;AAErF;;;;GAIG;AACH,MAAM,WAAW,sBAAsB;IACrC,QAAQ,EAAE,KAAK,CAAC;QACd,SAAS,EAAE,EAAE,CAAC,UAAU,CAAA;QACxB,SAAS,EAAE,aAAa,GAAG,IAAI,CAAA;QAC/B;;;;;WAKG;QACH,mBAAmB,CAAC,EAAE,EAAE,CAAC,UAAU,EAAE,CAAA;KACtC,CAAC,CAAA;IACF,QAAQ,EAAE,aAAa,GAAG,IAAI,CAAA;IAC9B,kBAAkB,CAAC,EAAE,EAAE,CAAC,UAAU,CAAA;IAClC;;;;;;;;;OASG;IACH,QAAQ,CAAC,EAAE,EAAE,CAAC,iBAAiB,EAAE,CAAA;CAClC;AAuBD;;;;GAIG;AACH,wBAAgB,6BAA6B,CAC3C,IAAI,EAAE,EAAE,CAAC,KAAK,EACd,aAAa,UAAQ,GACpB,sBAAsB,GAAG,IAAI,CA+J/B;AAsGD;;;;;;;;;GASG;AACH,wBAAgB,4BAA4B,CAAC,IAAI,EAAE,EAAE,CAAC,KAAK,GAAG,OAAO,CA6BpE;AA2LD;;;;;;;;;GASG;AACH,wBAAgB,8BAA8B,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,GAAG,GAAG,CAAC,MAAM,CAAC,CAuCzE;AAuDD;;;;;;;;;;;GAWG;AACH,wBAAgB,2BAA2B,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,GAAG,OAAO,CAelE;AA6tCD,eAAO,MAAM,wBAAwB,aAOnC,CAAA;AAqBF;;;GAGG;AACH,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,MAAM,GACf,MAAM,EAAE,CA0DV;AAcD,eAAO,MAAM,mBAAmB,aAG9B,CAAA;AA25CF;;;;;;;;;;;GAWG;AACH,wBAAgB,4BAA4B,CAAC,GAAG,EAAE,eAAe,GAAG,IAAI,CA4EvE;AAiID,OAAO,EAAE,KAAK,eAAe,EAAE,MAAM,uBAAuB,CAAA"}
+{"version":3,"file":"analyzer.d.ts","sourceRoot":"","sources":["../src/analyzer.ts"],"names":[],"mappings":"AACA;;;;;GAKG;AAEH,OAAO,EAAE,MAAM,YAAY,CAAA;AAG3B,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,yBAAyB,CAAA;AAInE,OAAO,EACL,KAAK,eAAe,EAUrB,MAAM,uBAAuB,CAAA;AAqB9B;;;;GAIG;AACH,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAU/D;AA8BD;;;;;;;;;;GAUG;AACH,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,MAAM,GACf;IAAE,OAAO,EAAE,EAAE,CAAC,OAAO,CAAC;IAAC,UAAU,EAAE,EAAE,CAAC,UAAU,CAAC;IAAC,OAAO,EAAE,EAAE,CAAC,WAAW,CAAA;CAAE,GAAG,IAAI,CA8CpF;AAMD,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,MAAM,EAChB,mBAAmB,CAAC,EAAE,MAAM,EAC5B,OAAO,CAAC,EAAE,EAAE,CAAC,OAAO,EACpB,mBAAmB,CAAC,EAAE,oBAAoB,EAC1C,eAAe,CAAC,EAAE,OAAO,GACxB,eAAe,CAkKjB;AAuhBD;;;;;;;;;;GAUG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,EAAE,CAAC,UAAU,GAAG,EAAE,CAAC,UAAU,CAavE;AAuuCD,MAAM,MAAM,aAAa,GAAG,EAAE,CAAC,UAAU,GAAG,EAAE,CAAC,qBAAqB,GAAG,EAAE,CAAC,WAAW,CAAA;AAErF;;;;GAIG;AACH,MAAM,WAAW,sBAAsB;IACrC,QAAQ,EAAE,KAAK,CAAC;QACd,SAAS,EAAE,EAAE,CAAC,UAAU,CAAA;QACxB,SAAS,EAAE,aAAa,GAAG,IAAI,CAAA;QAC/B;;;;;WAKG;QACH,mBAAmB,CAAC,EAAE,EAAE,CAAC,UAAU,EAAE,CAAA;KACtC,CAAC,CAAA;IACF,QAAQ,EAAE,aAAa,GAAG,IAAI,CAAA;IAC9B,kBAAkB,CAAC,EAAE,EAAE,CAAC,UAAU,CAAA;IAClC;;;;;;;;;OASG;IACH,QAAQ,CAAC,EAAE,EAAE,CAAC,iBAAiB,EAAE,CAAA;CAClC;AAuBD;;;;GAIG;AACH,wBAAgB,6BAA6B,CAC3C,IAAI,EAAE,EAAE,CAAC,KAAK,EACd,aAAa,UAAQ,GACpB,sBAAsB,GAAG,IAAI,CA+J/B;AAsGD;;;;;;;;;GASG;AACH,wBAAgB,4BAA4B,CAAC,IAAI,EAAE,EAAE,CAAC,KAAK,GAAG,OAAO,CA6BpE;AA2LD;;;;;;;;;GASG;AACH,wBAAgB,8BAA8B,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,GAAG,GAAG,CAAC,MAAM,CAAC,CAuCzE;AAuDD;;;;;;;;;;;GAWG;AACH,wBAAgB,2BAA2B,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,GAAG,OAAO,CAelE;AAsxCD,eAAO,MAAM,wBAAwB,aAOnC,CAAA;AAqBF;;;GAGG;AACH,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,MAAM,GACf,MAAM,EAAE,CA0DV;AAcD,eAAO,MAAM,mBAAmB,aAG9B,CAAA;AA25CF;;;;;;;;;;;GAWG;AACH,wBAAgB,4BAA4B,CAAC,GAAG,EAAE,eAAe,GAAG,IAAI,CA4EvE;AAiID,OAAO,EAAE,KAAK,eAAe,EAAE,MAAM,uBAAuB,CAAA"}

package/dist/expression-parser.d.ts

@@ -426,6 +426,26 @@ export interface FoldBlockOptions {
      */
     pureCallNames?: ReadonlySet<string>;
 }
+/**
+ * Inline `name → value` everywhere it appears free in `expr` (the let-inline
+ * step). Returns `null` if the substitution would capture a free variable of
+ * `value` under a nested callback parameter of the same name — that shape is
+ * unsound to inline non-hygienically, so the caller refuses with
+ * {@link CAPTURE_BLOCK_REASON}. A nested arrow parameter that shadows `name`
+ * leaves that inner reference untouched (it is the parameter, not the binding).
+ * Mirrors the structural walk of `substituteDestructuredFields`; every
+ * `ParsedExpr` kind is handled so a new kind surfaces as a compile error here.
+ *
+ * Exported for `computeSsrSeedPlan` (`ssr-seed-plan.ts`), which reuses this
+ * SAME let-inline step to resolve a signal/memo initializer through
+ * component-scope `const` locals sitting between it and the prop it reads
+ * (`const mid = props.label; createSignal(mid ?? 'Default')`) — the
+ * structural (never string-splicing) analogue of what `foldBlockToExpr`
+ * already does for a block-bodied memo's own internal `const`s, and of what
+ * the CSR client-JS emitter's `csrSubstitute` does over TS source text for
+ * the compiled JS domain (#2685 review).
+ */
+export declare function inlineBinding(expr: ParsedExpr, name: string, value: ParsedExpr): ParsedExpr | null;
 /**
  * Fold a value-producing block body — a {@link ParsedStatement} sequence of
  * `const` bindings, value-producing `if` / early `return`, and a terminal

package/dist/expression-parser.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"expression-parser.d.ts","sourceRoot":"","sources":["../src/expression-parser.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"expression-parser.d.ts","sourceRoot":"","sources":["../src/expression-parser.ts"],"names":[],"mappings":"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"}

package/dist/index.js

@@ -7849,15 +7849,28 @@ function collectKeysFromMembers(members, ctx) {
   }
   return keys;
 }
+function isResolvableMemberType(info) {
+  switch (info.kind) {
+    case "primitive":
+      return info.primitive === "string" || info.primitive === "number" || info.primitive === "boolean";
+    case "interface":
+      return CATALOGUED_RICH_TYPE_NAMES.has(baseTypeName(info.raw));
+    case "array":
+      return !!info.elementType && isResolvableMemberType(info.elementType);
+    case "object":
+      return info.properties !== undefined && info.properties.every((prop) => isResolvableMemberType(prop.type));
+    default:
+      return false;
+  }
+}
 function collectMemberTypes(typeNode, ctx) {
-  const isResolvablePrimitive = (info) => info.kind === "primitive" && (info.primitive === "string" || info.primitive === "number" || info.primitive === "boolean") || info.kind === "interface" && CATALOGUED_RICH_TYPE_NAMES.has(baseTypeName(info.raw));
   const fromMembers = (members) => {
     const map = new Map;
     for (const member of members) {
       if (ts9.isPropertySignature(member) && member.name) {
         const info = member.type ? typeNodeToTypeInfo(member.type, ctx.sourceFile) : null;
         map.set(member.name.getText(ctx.sourceFile), {
-          type: info && isResolvablePrimitive(info) ? info : null,
+          type: info && isResolvableMemberType(info) ? info : null,
           optional: !!member.questionToken
         });
       }
@@ -23208,6 +23221,7 @@ function extractSsrDefaults(metadata) {
     out[metadata.restPropsName] = { isRestProps: true, value: {} };
   }
   const bindings = {};
+  const localConsts = localConstValuesByName(metadata);
   for (const c of metadata.localConstants ?? []) {
     if (!c.isModule || c.value === undefined)
       continue;
@@ -23223,14 +23237,26 @@ function extractSsrDefaults(metadata) {
     if (sig.envReader)
       continue;
     const value = tryStaticEval(sig.initialValue, { bindings, propsLike });
-    out[sig.getter] = { value: resultToJsonable(value) };
+    if (metadata.propsObjectName !== null && referencesOwnProp(sig.initialValue, metadata.propsObjectName, sig.getter, localConsts)) {
+      if (!(sig.getter in out)) {
+        out[sig.getter] = { propName: sig.getter, value: null };
+      }
+    } else {
+      out[sig.getter] = { value: resultToJsonable(value) };
+    }
     bindings[sig.getter] = value;
   }
   for (const memo of metadata.memos) {
     if (memo.isModule)
       continue;
     const value = tryStaticEval(memo.computation, { bindings, propsLike });
-    out[memo.name] = { value: resultToJsonable(value) };
+    if (metadata.propsObjectName !== null && referencesOwnProp(memo.computation, metadata.propsObjectName, memo.name, localConsts)) {
+      if (!(memo.name in out)) {
+        out[memo.name] = { propName: memo.name, value: null };
+      }
+    } else {
+      out[memo.name] = { value: resultToJsonable(value) };
+    }
     bindings[memo.name] = value;
   }
   if (metadata.propsObjectName !== null) {
@@ -23238,12 +23264,12 @@ function extractSsrDefaults(metadata) {
     for (const sig of metadata.signals) {
       if (!sig.getter || sig.isModule || sig.envReader)
         continue;
-      collectPropRefs(sig.initialValue, metadata.propsObjectName, referenced);
+      collectPropRefsTransitive(sig.initialValue, metadata.propsObjectName, localConsts, referenced);
     }
     for (const memo of metadata.memos) {
       if (memo.isModule)
         continue;
-      collectPropRefs(memo.computation, metadata.propsObjectName, referenced);
+      collectPropRefsTransitive(memo.computation, metadata.propsObjectName, localConsts, referenced);
     }
     for (const name of referenced) {
       if (name in out)
@@ -23253,6 +23279,20 @@ function extractSsrDefaults(metadata) {
   }
   return Object.keys(out).length === 0 ? undefined : out;
 }
+function localConstValuesByName(metadata) {
+  const out = new Map;
+  for (const c of metadata.localConstants ?? []) {
+    if (c.isModule || c.value === undefined)
+      continue;
+    out.set(c.name, c.value);
+  }
+  return out;
+}
+function referencesOwnProp(expr, propsObjectName, name, localConsts) {
+  const referenced = new Set;
+  collectPropRefsTransitive(expr, propsObjectName, localConsts, referenced);
+  return referenced.has(name);
+}
 function collectPropRefs(expr, propsObjectName, out) {
   if (!expr || !expr.trim())
     return;
@@ -23268,6 +23308,23 @@ function collectPropRefs(expr, propsObjectName, out) {
   };
   visit3(node);
 }
+function collectPropRefsTransitive(expr, propsObjectName, localConsts, out, visited = new Set) {
+  if (!expr || !expr.trim())
+    return;
+  collectPropRefs(expr, propsObjectName, out);
+  const node = parseExpression2(expr);
+  if (!node)
+    return;
+  for (const id of extractFreeIdentifiersFromNode(node)) {
+    if (visited.has(id))
+      continue;
+    const constValue = localConsts.get(id);
+    if (constValue === undefined)
+      continue;
+    visited.add(id);
+    collectPropRefsTransitive(constValue, propsObjectName, localConsts, out, visited);
+  }
+}
 function resultToJsonable(v) {
   if (v === UNRESOLVED)
     return null;
@@ -23312,7 +23369,7 @@ function evalStatementsForReturn(statements, ctx) {
   return NO_RETURN;
 }
 function parseExpression2(expr) {
-  const sf = ts22.createSourceFile("__ssr_default__.ts", `(${expr})`, ts22.ScriptTarget.Latest, false, ts22.ScriptKind.TS);
+  const sf = ts22.createSourceFile("__ssr_default__.ts", `(${expr})`, ts22.ScriptTarget.Latest, true, ts22.ScriptKind.TS);
   const stmt = sf.statements[0];
   if (!stmt || !ts22.isExpressionStatement(stmt))
     return null;
@@ -23943,6 +24000,38 @@ function classify2(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)
@@ -23951,6 +24040,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) {
@@ -23962,13 +24052,13 @@ function computeSsrSeedPlan(metadata) {
       }
     }
     const expr = signal.initialValue.trim();
-    steps.push(expr === "" ? { kind: "opaque", name: signal.getter, origin: "signal" } : classify2(signal.getter, "signal", expr, parseExpression(expr), available));
+    steps.push(expr === "" ? { kind: "opaque", name: signal.getter, origin: "signal" } : classify2(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" } : classify2(memo.name, "memo", expr, memo.parsed ?? parseExpression(expr), available));
+    steps.push(expr === "" ? { kind: "opaque", name: memo.name, origin: "memo" } : classify2(memo.name, "memo", expr, resolveThroughLocalConsts(memo.parsed ?? parseExpression(expr), localConsts), available));
     available.add(memo.name);
   }
   return { baseScope, steps };

package/dist/ssr-defaults.d.ts

@@ -19,6 +19,16 @@ export interface SsrDefault {
      * (`{ variant = 'default' }`) where the template variable maps 1:1
      * to a caller-supplied prop. Omitted for signal / memo entries that
      * are internal to the component.
+     *
+     * Invariant (#2669): a signal / memo entry carries `propName` IF AND
+     * ONLY IF it's a self-derivation collision — the signal/memo's own
+     * template variable shares a name with the prop its initializer
+     * derives from (`const [label] = createSignal(props.label ?? 'x')`).
+     * Every OTHER signal/memo entry is `propName`-less. Consumers (e.g.
+     * every template-stash adapter's conformance harness, `test-render.ts`)
+     * rely on this to know a signal/memo's stash seed must defer to the
+     * already-derived prop value rather than re-seeding from its own
+     * evaluated initial — see `extractSsrDefaults`'s signal/memo loops.
      */
     propName?: string;
     /**

package/dist/ssr-defaults.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ssr-defaults.d.ts","sourceRoot":"","sources":["../src/ssr-defaults.ts"],"names":[],"mappings":"AAgCA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAA;AAE5C;;;;;GAKG;AACH,MAAM,WAAW,UAAU;IACzB;;;;;OAKG;IACH,KAAK,EAAE,OAAO,CAAA;IACd;;;;;;OAMG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB;;;;OAIG;IACH,WAAW,CAAC,EAAE,OAAO,CAAA;CACtB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,wBAAgB,uBAAuB,CACrC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,EACpC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC7B,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAuBzB;AAkBD;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,GAAG,SAAS,CA8G/F"}
+{"version":3,"file":"ssr-defaults.d.ts","sourceRoot":"","sources":["../src/ssr-defaults.ts"],"names":[],"mappings":"AAiCA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAA;AAE5C;;;;;GAKG;AACH,MAAM,WAAW,UAAU;IACzB;;;;;OAKG;IACH,KAAK,EAAE,OAAO,CAAA;IACd;;;;;;;;;;;;;;;;OAgBG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB;;;;OAIG;IACH,WAAW,CAAC,EAAE,OAAO,CAAA;CACtB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,wBAAgB,uBAAuB,CACrC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,EACpC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC7B,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAuBzB;AAkBD;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,GAAG,SAAS,CA8K/F"}

package/dist/ssr-seed-plan.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ssr-seed-plan.d.ts","sourceRoot":"","sources":["../src/ssr-seed-plan.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAGH,OAAO,EAAsB,KAAK,eAAe,EAAE,MAAM,0BAA0B,CAAA;AACnF,OAAO,EAKL,KAAK,UAAU,EAChB,MAAM,wBAAwB,CAAA;AAC/B,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAA;AAE5C;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,MAAM,WAAW,GACnB;IAAE,IAAI,EAAE,YAAY,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,eAAe,CAAA;CAAE,GAC7D;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,QAAQ,GAAG,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,UAAU,CAAC;IAAC,KAAK,EAAE,MAAM,EAAE,CAAA;CAAE,GAC/G;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,QAAQ,GAAG,MAAM,CAAA;CAAE,CAAA;AAE/D,MAAM,WAAW,WAAW;IAC1B;;;;OAIG;IACH,SAAS,EAAE,MAAM,EAAE,CAAA;IACnB,KAAK,EAAE,WAAW,EAAE,CAAA;CACrB;AA0BD;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,UAAU,GAAG,WAAW,CAwCpE"}
+{"version":3,"file":"ssr-seed-plan.d.ts","sourceRoot":"","sources":["../src/ssr-seed-plan.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAGH,OAAO,EAAsB,KAAK,eAAe,EAAE,MAAM,0BAA0B,CAAA;AACnF,OAAO,EAML,KAAK,UAAU,EAChB,MAAM,wBAAwB,CAAA;AAC/B,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAA;AAE5C;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,MAAM,WAAW,GACnB;IAAE,IAAI,EAAE,YAAY,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,eAAe,CAAA;CAAE,GAC7D;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,QAAQ,GAAG,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,UAAU,CAAC;IAAC,KAAK,EAAE,MAAM,EAAE,CAAA;CAAE,GAC/G;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,QAAQ,GAAG,MAAM,CAAA;CAAE,CAAA;AAE/D,MAAM,WAAW,WAAW;IAC1B;;;;OAIG;IACH,SAAS,EAAE,MAAM,EAAE,CAAA;IACnB,KAAK,EAAE,WAAW,EAAE,CAAA;CACrB;AA4FD;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,UAAU,GAAG,WAAW,CAqDpE"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@barefootjs/jsx",
-  "version": "0.31.9",
+  "version": "0.31.10",
   "description": "JSX compiler for BarefootJS - transforms JSX to server HTML + client JS",
   "type": "module",
   "main": "./dist/index.js",
@@ -49,7 +49,7 @@
     "directory": "packages/jsx"
   },
   "dependencies": {
-    "@barefootjs/shared": "0.31.9"
+    "@barefootjs/shared": "0.31.10"
   },
   "peerDependencies": {
     "@barefootjs/client": ">=0.2.0",

package/src/__tests__/date-lowering.test.ts

@@ -101,7 +101,7 @@ describe('datePlugin matcher recognition (#2274)', () => {
     // destructured path reads the type from propsType, not propsParams, so
     // the widening isn't load-bearing for the matcher above, but propsParams
     // is itself observable IR metadata this plugin's existence is meant to
-    // unlock (see analyzer.ts's docstring on `isResolvablePrimitive`).
+    // unlock (see analyzer.ts's docstring on `isResolvableMemberType`).
     const md = metadata(`
       export function Foo({ createdAt }: { createdAt: Date }) {
         return <div>{createdAt.toISOString()}</div>

package/src/__tests__/props-destructuring.test.ts

@@ -426,7 +426,13 @@ describe('Destructured props keep their declared types (BF043 fixture #2150)', (
     })
   })
 
-  test('leaves NON-primitive members (arrays/objects) as unknown', () => {
+  // #2677: a STRUCTURAL member (array/object) built entirely out of
+  // primitives resolves fully now — go-template's `emitSynthPropStructs`
+  // (#2674/#2676) can synthesize a real struct for either shape, so the
+  // #2150 "unchecked assertion" concern doesn't apply to them any more.
+  // `rows: number[][]` is a nested array of primitives; `meta: { id:
+  // string }` is an inline object literal with a primitive property.
+  test('resolves STRUCTURAL members (nested arrays / inline objects) built entirely out of primitives (#2677)', () => {
     const source = `
       type Props = { rows: number[][]; meta: { id: string } }
 
@@ -437,7 +443,38 @@ describe('Destructured props keep their declared types (BF043 fixture #2150)', (
 
     const ctx = analyzeComponent(source, 'Component.tsx')
 
-    expect(typeOf(ctx, 'rows')).toEqual({ kind: 'unknown', raw: 'unknown' })
-    expect(typeOf(ctx, 'meta')).toEqual({ kind: 'unknown', raw: 'unknown' })
+    expect(typeOf(ctx, 'rows')).toEqual({
+      kind: 'array',
+      raw: 'number[][]',
+      elementType: { kind: 'array', raw: 'number[]', elementType: { kind: 'primitive', raw: 'number', primitive: 'number' } },
+    })
+    expect(typeOf(ctx, 'meta')).toEqual({
+      kind: 'object',
+      raw: '{ id: string }',
+      properties: [{ name: 'id', type: { kind: 'primitive', raw: 'string', primitive: 'string' }, optional: false, readonly: false }],
+    })
+  })
+
+  // A structural member declines WHOLLY (not per-leaf) when ANY reachable
+  // leaf is a union, a function, or an un-catalogued named type — the same
+  // three shapes `isResolvableMemberType` declines at the top level.
+  test('declines a structural member when a nested leaf is a union/function/un-catalogued named type (#2677)', () => {
+    const source = `
+      type Props = {
+        variants: { id: string; kind: 'a' | 'b' }[]
+        handlers: { onClick: () => void }
+        configs: { data: Map<string, string> }
+      }
+
+      export function Component({ variants, handlers, configs }: Props) {
+        return <div>{variants.length}</div>
+      }
+    `
+
+    const ctx = analyzeComponent(source, 'Component.tsx')
+
+    expect(typeOf(ctx, 'variants')).toEqual({ kind: 'unknown', raw: 'unknown' })
+    expect(typeOf(ctx, 'handlers')).toEqual({ kind: 'unknown', raw: 'unknown' })
+    expect(typeOf(ctx, 'configs')).toEqual({ kind: 'unknown', raw: 'unknown' })
   })
 })

package/src/__tests__/ssr-defaults.test.ts

@@ -103,6 +103,211 @@ describe('extractSsrDefaults', () => {
     expect(defaults?.n).toEqual({ value: 0 })
   })
 
+  test('self-derived signal collision (#2669, shape A): entry stays a PROP entry, not the evaluated signal value', () => {
+    // `props.label` and the signal getter `label` share a name — the
+    // bare-props-arg form is the only shape where this collides (a
+    // destructured-arg `function C({ label })` + `const [label] = ...`
+    // is a JS redeclaration error, so it can't happen there). The
+    // emitted template reads the stash var `label` as the RAW caller
+    // prop and OVERWRITES it with the derived signal value under that
+    // SAME name (`{% set label = (label if label is defined else
+    // 'Default') %}`). Seeding the stash with the pre-fix `{ value:
+    // 'Default' }` (the EVALUATED signal value, discarding `propName`)
+    // means a caller-passed `label` can never win — production seeds
+    // 'Default', the template sees a non-none value, and keeps it. The
+    // fix: this entry must stay a PROP entry (`propName` set, `value:
+    // null`) so the template's own `?? 'Default'` guard supplies the
+    // real fallback, and a caller-supplied prop still wins via
+    // `propName`.
+    const metadata = metadataFor(`
+      'use client'
+      import { createSignal } from '@barefootjs/client'
+      function C(props: { label?: string }) {
+        const [label, setLabel] = createSignal(props.label ?? 'Default')
+        return <span>{label()}</span>
+      }
+    `)
+
+    const defaults = extractSsrDefaults(metadata)
+    expect(defaults?.label).toEqual({ propName: 'label', value: null })
+  })
+
+  test('self-derived signal collision (#2669, shape B): non-idempotent derivation must not seed the pre-fix double-applied value', () => {
+    // `(props.count ?? 1) * 2` is NOT idempotent: seeding the stash with
+    // the pre-fix EVALUATED value (2, for no caller prop) makes the
+    // template's own recompute apply the `* 2` a second time (`2 * 2 =
+    // 4`) — wrong even with no caller props at all. Pin that the entry
+    // is the RAW-prop shape (`value: null`), not `{ value: 2 }`.
+    const metadata = metadataFor(`
+      'use client'
+      import { createSignal } from '@barefootjs/client'
+      function C(props: { count?: number }) {
+        const [count, setCount] = createSignal((props.count ?? 1) * 2)
+        return <span>{count()}</span>
+      }
+    `)
+
+    const defaults = extractSsrDefaults(metadata)
+    expect(defaults?.count).toEqual({ propName: 'count', value: null })
+  })
+
+  test('self-derived memo collision (#2669): the same rule applies to a memo whose computation derives from a same-named prop', () => {
+    // Same collision, memo flavor: `createMemo(() => (props.label ??
+    // 'Default') + n())` — the memo's OWN name (`label`) is the
+    // template variable the emitted template both reads (raw prop) and
+    // overwrites (derived memo value). `n` is an unrelated ordinary
+    // signal and must be unaffected (plain `{ value }` entry, no
+    // `propName`).
+    const metadata = metadataFor(`
+      'use client'
+      import { createSignal, createMemo } from '@barefootjs/client'
+      function C(props: { label?: string }) {
+        const [n, setN] = createSignal(0)
+        const label = createMemo(() => (props.label ?? 'Default') + n())
+        return <span>{label()}</span>
+      }
+    `)
+
+    const defaults = extractSsrDefaults(metadata)
+    expect(defaults?.label).toEqual({ propName: 'label', value: null })
+    expect(defaults?.n).toEqual({ value: 0 })
+  })
+
+  test('NON-self-derived collision (#2669, shape C — out of scope, must be unchanged): signal value still wins, no `propName`', () => {
+    // Same-named `label` getter and `label` prop, but the signal's OWN
+    // initializer does NOT derive from `props.label` (it's a plain
+    // string literal) — the JSX body separately reads `label()` AND
+    // `props.label`. That's a template-variable-ALIASING defect (both
+    // expressions lower to the same template variable, so no seeding
+    // choice can be right for both readers) — a different bug, tracked
+    // separately, and this fix must leave it byte-identical: the entry
+    // stays the plain evaluated-signal-value shape with no `propName`.
+    const metadata = metadataFor(`
+      'use client'
+      import { createSignal } from '@barefootjs/client'
+      function C(props: { label?: string }) {
+        const [label, setLabel] = createSignal('sig')
+        return <span>{label()}{props.label}</span>
+      }
+    `)
+
+    const defaults = extractSsrDefaults(metadata)
+    expect(defaults?.label).toEqual({ value: 'sig' })
+  })
+
+  test('self-derived signal collision THROUGH a component-scope const (#2685 review): entry stays a PROP entry', () => {
+    // One hop of pure indirection past #2669's shape A: `referencesOwnProp`
+    // (built on `collectPropRefs`) only saw a DIRECT `props.<name>` access
+    // in the initializer — a `const mid = props.label` sitting between the
+    // prop read and `createSignal(mid ?? 'Default')` defeated the
+    // detection, so this entry regressed to the pre-#2669 `{ value:
+    // 'Default' }` shape (no `propName`) even after the #2669 fix landed.
+    // Same fix, widened: `collectPropRefsTransitive` now looks through
+    // component-scope const locals.
+    const metadata = metadataFor(`
+      'use client'
+      import { createSignal } from '@barefootjs/client'
+      function C(props: { label?: string }) {
+        const mid = props.label
+        const [label, setLabel] = createSignal(mid ?? 'Default')
+        return <span>{label()}</span>
+      }
+    `)
+
+    const defaults = extractSsrDefaults(metadata)
+    expect(defaults?.label).toEqual({ propName: 'label', value: null })
+  })
+
+  test('self-derived memo collision THROUGH a component-scope const (#2685 review)', () => {
+    const metadata = metadataFor(`
+      'use client'
+      import { createMemo } from '@barefootjs/client'
+      function C(props: { label?: string }) {
+        const mid = props.label
+        const label = createMemo(() => mid ?? 'Default')
+        return <span>{label()}</span>
+      }
+    `)
+
+    const defaults = extractSsrDefaults(metadata)
+    expect(defaults?.label).toEqual({ propName: 'label', value: null })
+  })
+
+  test('multi-hop const chain resolves transitively (#2685 review): `const a = props.x; const b = a`', () => {
+    // Two hops of indirection (`b` reads `a`, `a` reads `props.x`) — the
+    // signal here is named `count`, a DIFFERENT name from the prop `x`, so
+    // this exercises the bare-props safety net's transitive resolution
+    // (not the self-derivation `propName` collision path above): `x` must
+    // still be seeded, or the template-stash adapters' bare-scalar
+    // recompute for `x` aborts at render time (#1297/#2126).
+    const metadata = metadataFor(`
+      'use client'
+      import { createSignal } from '@barefootjs/client'
+      function C(props: { x?: number }) {
+        const a = props.x
+        const b = a
+        const [count, setCount] = createSignal(b ?? 1)
+        return <span>{count()}</span>
+      }
+    `)
+
+    const defaults = extractSsrDefaults(metadata)
+    expect(defaults?.count).toEqual({ value: 1 })
+    expect(defaults?.x).toEqual({ propName: 'x', value: null })
+  })
+
+  test('safety-net seeding sees a prop through a component-scope const (#2685 review)', () => {
+    // The #1297/#2126 bare-props safety net (`collectPropRefs` at the
+    // bottom of `extractSsrDefaults`) only saw a DIRECT `props.X` access
+    // too — this is that same gap, single hop: `const mid = props.initial;
+    // createSignal(mid ?? 0)` misses seeding `initial`, which is a
+    // `Global symbol "$initial" requires explicit package name` render
+    // abort on Perl-strict backends. `count` (the signal's own name) is
+    // unrelated to `initial`, so this is NOT the self-collision path —
+    // purely the safety net.
+    const metadata = metadataFor(`
+      'use client'
+      import { createSignal } from '@barefootjs/client'
+      function Counter(props: { initial?: number }) {
+        const mid = props.initial
+        const [count, setCount] = createSignal(mid ?? 0)
+        return <p>{count()}</p>
+      }
+    `)
+
+    const defaults = extractSsrDefaults(metadata)
+    expect(defaults?.count).toEqual({ value: 0 })
+    expect(defaults?.initial).toEqual({ propName: 'initial', value: null })
+  })
+
+  test('NEGATIVE (#2685 review): a const NOT derived from props keeps the signal-wins behavior', () => {
+    // Same-named `label` getter and `label` prop, wrapped in a const — but
+    // the const's OWN value doesn't read `props` at all, so
+    // `collectPropRefsTransitive` must NOT report a collision here. Must
+    // stay the plain evaluated-signal-value shape with no `propName` — the
+    // const-chain widening only ever ADDS prop references it finds by
+    // actually walking through `props.X`, never invents one.
+    //
+    // (The value resolves to `null`, not `'sig'`: `tryStaticEval` doesn't
+    // bind component-scope const locals into its evaluation `bindings` —
+    // see the signal loop's `bindings` comment above — so `mid` itself is
+    // unresolved for VALUE purposes independent of this fix; only the
+    // separate `propName`-detection walk this test is pinning follows the
+    // const chain.)
+    const metadata = metadataFor(`
+      'use client'
+      import { createSignal } from '@barefootjs/client'
+      function C(props: { label?: string }) {
+        const mid = 'sig'
+        const [label, setLabel] = createSignal(mid)
+        return <span>{label()}{props.label}</span>
+      }
+    `)
+
+    const defaults = extractSsrDefaults(metadata)
+    expect(defaults?.label).toEqual({ value: null })
+  })
+
   test('aliased destructured prop (#2460): `propName` is the CALLER-facing key, not the local binding', () => {
     // `{ n: count }` — the caller passes `n`, the template variable (and
     // stash entry key) is the local binding `count`. The manifest
@@ -302,6 +507,31 @@ describe('deriveStashFromDefaults', () => {
     expect(deriveStashFromDefaults(defaults, { n: 0 })).toEqual({ count: 0 })
   })
 
+  test('self-derived signal collision (#2669): the caller-supplied prop now wins, and an absent prop falls back to null', () => {
+    // End-to-end proof of the fix's effect at the `deriveStashFromDefaults`
+    // layer: run the real `extractSsrDefaults` output for shape A through
+    // the seeding function. Pre-fix, this entry was `{ value: 'Default' }`
+    // (propName-less) so a caller's `label: 'Hello'` was IGNORED —
+    // `deriveStashFromDefaults` had no `propName` to resolve against and
+    // always used the static value. Post-fix the entry is a PROP entry, so
+    // the caller's value wins, and an absent prop resolves to the RAW
+    // fallback `null` (not the old evaluated `'Default'`) — the emitted
+    // template's own `?? 'Default'` guard supplies the real default from
+    // there.
+    const metadata = metadataFor(`
+      'use client'
+      import { createSignal } from '@barefootjs/client'
+      function C(props: { label?: string }) {
+        const [label, setLabel] = createSignal(props.label ?? 'Default')
+        return <span>{label()}</span>
+      }
+    `)
+    const defaults = extractSsrDefaults(metadata)!
+
+    expect(deriveStashFromDefaults(defaults, { label: 'Hello' })).toEqual({ label: 'Hello' })
+    expect(deriveStashFromDefaults(defaults, {})).toEqual({ label: null })
+  })
+
   test('propName-less entry (signal / memo local): always uses the static value', () => {
     // A caller cannot override an internal signal/memo by construction —
     // even a same-named caller prop must not leak in.

package/src/__tests__/ssr-seed-plan.test.ts

@@ -209,4 +209,76 @@ describe('computeSsrSeedPlan', () => {
       expect(on.frees).toEqual(['props'])
     }
   })
+
+  test('prop-derived signal init THROUGH a component-scope const (#2685 review): still derived, resolves to the prop free', () => {
+    // Pre-fix, `mid` (a component-scope const, not part of `baseScope`)
+    // was a free identifier `classify` couldn't find in `available`, so
+    // this step fell to `opaque` — no adapter emits an in-template
+    // recompute for it at all (a DIFFERENT, worse-than-#2669 defect: even
+    // with `propName` restored on the manifest side, an absent caller prop
+    // would render permanently empty instead of the signal's own
+    // `'Default'`). `resolveThroughLocalConsts` inlines `mid` to
+    // `props.defaultOn` before classification, so this now derives exactly
+    // like the direct-access form above.
+    const plan = planFor(`
+      'use client'
+      import { createSignal } from '@barefootjs/client'
+      function Toggle(props: { defaultOn?: boolean }) {
+        const mid = props.defaultOn
+        const [on, setOn] = createSignal(mid ?? false)
+        return <button aria-pressed={on()}>t</button>
+      }
+    `)
+
+    const on = step(plan, 'on')
+    expect(on.kind).toBe('derived')
+    if (on.kind === 'derived') {
+      expect(on.origin).toBe('signal')
+      // The RESOLVED free set names `props` (what the inlined form reads),
+      // never the intermediate const `mid` — a consumer emitting `on`'s
+      // seed line never needs to know `mid` existed.
+      expect(on.frees).toEqual(['props'])
+    }
+  })
+
+  test('multi-hop const chain THROUGH TWO component-scope consts (#2685 review): still derived', () => {
+    const plan = planFor(`
+      'use client'
+      import { createSignal } from '@barefootjs/client'
+      function C(props: { x?: number }) {
+        const a = props.x
+        const b = a
+        const [count, setCount] = createSignal(b ?? 1)
+        return <p>{count()}</p>
+      }
+    `)
+
+    const count = step(plan, 'count')
+    expect(count.kind).toBe('derived')
+    if (count.kind === 'derived') {
+      expect(count.frees).toEqual(['props'])
+    }
+  })
+
+  test('const chain that bottoms out on an UNAVAILABLE name → opaque (fails safe, not a wrong substitution)', () => {
+    // `mid` inlines to `laterMemo`, a memo declared AFTER `on` in source —
+    // per the plan's ordering guarantee, `laterMemo` is not yet in
+    // `available` when `on` is classified, so this must stay `opaque`
+    // exactly like a direct forward-reference would (mirrors the existing
+    // "forward reference … → opaque" case above, one hop of const
+    // indirection removed).
+    const plan = planFor(`
+      'use client'
+      import { createSignal, createMemo } from '@barefootjs/client'
+      function C() {
+        const mid = laterMemo()
+        const [on, setOn] = createSignal(mid ?? false)
+        const laterMemo = createMemo(() => true)
+        return <button aria-pressed={on()}>{laterMemo()}</button>
+      }
+    `)
+
+    const on = step(plan, 'on')
+    expect(on.kind).toBe('opaque')
+  })
 })

package/src/analyzer.ts

@@ -3429,6 +3429,82 @@ function collectKeysFromMembers(
   return keys
 }
 
+/**
+ * Decide whether a member's `TypeInfo` is admissible for
+ * `collectMemberTypes`'s destructured-parameter resolution (#2677 —
+ * widened from the original string/number/boolean-only gate).
+ *
+ * #2150 originally restricted the gate to string/number/boolean, because a
+ * non-primitive `TypeInfo` there used to mean "the typed adapters will emit
+ * an unchecked scalar assertion (`in.X.(int)`) that panics" for a shape the
+ * template layer had no representation for. That reasoning does NOT extend
+ * to a rich type with a CATALOGUED lowering (#2274: `Date` → the `date`
+ * helper): its propsParams `TypeInfo` is consumed only as call-site
+ * evidence for `resolveReceiverType` (rich-type-evidence.ts) — never
+ * emitted as a concrete field type (`typeInfoToGo`'s `interface` case falls
+ * through to `interface{}` for an unbacked host name exactly as `unknown`
+ * already did) — so there is no assertion to panic. Gating on
+ * `CATALOGUED_RICH_TYPE_NAMES` specifically (not `HOST_RICH_TYPE_NAMES`
+ * wholesale) keeps an un-catalogued rich type (`Map`, `Set`, …) at
+ * `unknown`, i.e. avoids resurrecting the #2150 mistake for a shape no
+ * lowering plugin exists for yet.
+ *
+ * Nor does it extend to a STRUCTURAL shape (`kind: 'array'` /
+ * `kind: 'object'`) any more. `typeNodeToTypeInfo` already builds these
+ * fully recursively (`elementType`, `properties`) — the same walk the
+ * `props`-object form (`extractPropsFromTypeMembers`) always got — and
+ * go-template's `emitSynthPropStructs` (#2674/#2676) synthesizes a real,
+ * json-tagged Go struct for any anonymous object type it reaches through
+ * `ir.metadata.propsParams[].type`, array-element positions included. A
+ * structural `TypeInfo` is representable today, so admitting it here no
+ * longer resurrects #2150 either — it lets `propsParams[].type` carry the
+ * SAME shape the props-object form already resolved, closing the
+ * asymmetry #2677 reports (`{ items }: { items: {...}[] }` degrading to
+ * `unknown` while `(props: { items: {...}[] })` resolved fully).
+ *
+ * `array`/`object` admit only when EVERY reachable leaf resolves — an
+ * array's element type and an object's every property type must pass this
+ * same check, recursively. A union, a function, or an un-catalogued named
+ * type reachable ANYWHERE inside the shape declines the WHOLE member (not
+ * just that one leaf): `collectMemberTypes` is an all-or-nothing gate per
+ * member, so a partially-resolvable structural type must still decline —
+ * per-field graceful degradation is `typeInfoToGo`'s job downstream, not
+ * this gate's.
+ *
+ * The `object` arm requires `properties` to be PRESENT, not merely falsy-
+ * coalesced to `[]` — an absent-members claim and a zero-members claim are
+ * different things, and `.every()` on a defaulted-to-`[]` array would admit
+ * both identically (vacuously `true`), which is the #2150 failure mode
+ * wearing a different hat: a concrete representation with no evidence
+ * behind it. `typeNodeToTypeInfo`'s `object` arm DOES omit `properties`
+ * entirely in its `synthetic` mode (the checker-driven `tsTypeToTypeInfo`
+ * path, used for e.g. `createMemo` inference off a resolved `ts.Type`,
+ * which has no source positions for `membersToProperties`' `getText()`).
+ * This gate's only caller (`collectMemberTypes`'s `fromMembers`) always
+ * calls the NON-synthetic 2-arg form, so `properties` is in practice always
+ * at least `[]` here today — but `isResolvableMemberType` is a module-level
+ * function, not a closure scoped to that one caller, so it guards the
+ * general case rather than trust a caller-specific invariant. A genuinely
+ * EMPTY object literal (`{}`, real zero members) DOES resolve — an empty
+ * synthesized struct is exactly as faithful a representation as the type
+ * itself claims, nothing is being guessed.
+ */
+function isResolvableMemberType(info: TypeInfo): boolean {
+  switch (info.kind) {
+    case 'primitive':
+      return info.primitive === 'string' || info.primitive === 'number' || info.primitive === 'boolean'
+    case 'interface':
+      return CATALOGUED_RICH_TYPE_NAMES.has(baseTypeName(info.raw))
+    case 'array':
+      return !!info.elementType && isResolvableMemberType(info.elementType)
+    case 'object':
+      return info.properties !== undefined && info.properties.every(prop => isResolvableMemberType(prop.type))
+    // Unions, functions, and `unknown` all decline — see docstring.
+    default:
+      return false
+  }
+}
+
 /**
  * Build a property-name -> { type, optional } map from a props type
  * annotation, for destructured params (`{ value }: Props`) so they carry the
@@ -3443,36 +3519,17 @@ function collectKeysFromMembers(
  *   degraded to `unknown` -> `interface{}` for attribute omission, because
  *   #2252's nullish-flip machinery supplies the nillable representation
  *   exactly where absence is semantically observable (#2259).
- * - Only PRIMITIVE members (string/number/boolean) resolve a type. Those are
- *   the types that otherwise produce an unchecked scalar assertion (`in.X.(int)`)
- *   that panics. Arrays/objects/functions are left as `unknown` because typed
- *   adapters lower them through interface{}-based helpers (`bf_flat`, spread,
- *   `bf_json`); giving them concrete types would break that lowering and is a
- *   larger, separate change.
+ * - A member resolves a type when it is a PRIMITIVE (string/number/boolean),
+ *   a CATALOGUED rich type (`Date`), or a STRUCTURAL shape (array/object)
+ *   built entirely out of those, recursively (#2677). Unions, functions, and
+ *   un-catalogued named types (`Map`, `Set`, …) are left as `unknown` — see
+ *   `isResolvableMemberType`'s own docstring for why the structural cases
+ *   are safe to admit and why those three still are not.
  */
 function collectMemberTypes(
   typeNode: ts.TypeNode,
   ctx: AnalyzerContext
 ): Map<string, { type: TypeInfo | null; optional: boolean }> | null {
-  // #2150 originally restricted this gate to string/number/boolean only,
-  // because a non-primitive TypeInfo here used to mean "the typed adapters
-  // will emit an unchecked scalar assertion (`in.X.(int)`) that panics" for
-  // a shape the template layer has no representation for. That reasoning
-  // does NOT extend to a rich type with a CATALOGUED lowering (#2274: `Date`
-  // → the `date` helper): its propsParams TypeInfo is consumed only as
-  // call-site evidence for `resolveReceiverType` (rich-type-evidence.ts) —
-  // never emitted as a concrete field type (`typeInfoToGo`'s `interface`
-  // case falls through to `interface{}` for an unbacked host name exactly
-  // as `unknown` already did) — so there is no assertion to panic. Gating on
-  // `CATALOGUED_RICH_TYPE_NAMES` specifically (not `HOST_RICH_TYPE_NAMES`
-  // wholesale) keeps an un-catalogued rich type (`Map`, `Set`, …) at
-  // `unknown`, i.e. avoids resurrecting the #2150 mistake for a shape no
-  // lowering plugin exists for yet.
-  const isResolvablePrimitive = (info: TypeInfo): boolean =>
-    (info.kind === 'primitive' &&
-      (info.primitive === 'string' || info.primitive === 'number' || info.primitive === 'boolean')) ||
-    (info.kind === 'interface' && CATALOGUED_RICH_TYPE_NAMES.has(baseTypeName(info.raw)))
-
   const fromMembers = (
     members: ts.NodeArray<ts.TypeElement>
   ): Map<string, { type: TypeInfo | null; optional: boolean }> => {
@@ -3481,7 +3538,7 @@ function collectMemberTypes(
       if (ts.isPropertySignature(member) && member.name) {
         const info = member.type ? typeNodeToTypeInfo(member.type, ctx.sourceFile) : null
         map.set(member.name.getText(ctx.sourceFile), {
-          type: info && isResolvablePrimitive(info) ? info : null,
+          type: info && isResolvableMemberType(info) ? info : null,
           optional: !!member.questionToken,
         })
       }

package/src/expression-parser.ts

@@ -3037,8 +3037,17 @@ function usesPerPath(name: string, expr: ParsedExpr): { min: number; max: number
  * leaves that inner reference untouched (it is the parameter, not the binding).
  * Mirrors the structural walk of `substituteDestructuredFields`; every
  * `ParsedExpr` kind is handled so a new kind surfaces as a compile error here.
+ *
+ * Exported for `computeSsrSeedPlan` (`ssr-seed-plan.ts`), which reuses this
+ * SAME let-inline step to resolve a signal/memo initializer through
+ * component-scope `const` locals sitting between it and the prop it reads
+ * (`const mid = props.label; createSignal(mid ?? 'Default')`) — the
+ * structural (never string-splicing) analogue of what `foldBlockToExpr`
+ * already does for a block-bodied memo's own internal `const`s, and of what
+ * the CSR client-JS emitter's `csrSubstitute` does over TS source text for
+ * the compiled JS domain (#2685 review).
  */
-function inlineBinding(
+export function inlineBinding(
   expr: ParsedExpr,
   name: string,
   value: ParsedExpr,

package/src/ssr-defaults.ts

@@ -30,6 +30,7 @@
 // `undef`, which Mojo renders as empty string).
 
 import ts from 'typescript'
+import { extractFreeIdentifiersFromNode } from './analyzer.ts'
 import type { IRMetadata } from './types.ts'
 
 /**
@@ -52,6 +53,16 @@ export interface SsrDefault {
    * (`{ variant = 'default' }`) where the template variable maps 1:1
    * to a caller-supplied prop. Omitted for signal / memo entries that
    * are internal to the component.
+   *
+   * Invariant (#2669): a signal / memo entry carries `propName` IF AND
+   * ONLY IF it's a self-derivation collision — the signal/memo's own
+   * template variable shares a name with the prop its initializer
+   * derives from (`const [label] = createSignal(props.label ?? 'x')`).
+   * Every OTHER signal/memo entry is `propName`-less. Consumers (e.g.
+   * every template-stash adapter's conformance harness, `test-render.ts`)
+   * rely on this to know a signal/memo's stash seed must defer to the
+   * already-derived prop value rather than re-seeding from its own
+   * evaluated initial — see `extractSsrDefaults`'s signal/memo loops.
    */
   propName?: string
   /**
@@ -204,6 +215,11 @@ export function extractSsrDefaults(metadata: IRMetadata): Record<string, SsrDefa
   // fed into the bindings map so subsequent memos can reference earlier
   // signals (Counter's `doubled = createMemo(() => count() * 2)`).
   const bindings: Record<string, EvalResult> = {}
+  // Component-scope const locals, for the transitive prop-reference
+  // resolution both `referencesOwnProp` calls below and the bare-props
+  // safety net (further down) use — computed once so every caller shares
+  // the same table.
+  const localConsts = localConstValuesByName(metadata)
 
   // (#checkbox) Seed module-scope constants so a memo template-literal that
   // references them resolves to a concrete string. Checkbox's `classes` memo
@@ -225,14 +241,73 @@ export function extractSsrDefaults(metadata: IRMetadata): Record<string, SsrDefa
     // baked initial value.
     if (sig.envReader) continue
     const value = tryStaticEval(sig.initialValue, { bindings, propsLike })
-    out[sig.getter] = { value: resultToJsonable(value) }
+    // Self-derivation collision (#2669): a signal whose getter shares its
+    // name with the prop its OWN initializer derives from
+    // (`const [label] = createSignal(props.label ?? 'Default')`) gets a
+    // template-stash variable that the emitted template both READS (as the
+    // raw caller prop) and OVERWRITES (with the derived signal value) under
+    // that SAME name — see the Mojo/Jinja/etc. emitter's `{% set label =
+    // (label if label is defined else 'Default') %}`. Seeding the stash
+    // with the DERIVED value here would either permanently lock out a
+    // caller-supplied prop (idempotent derivations like `?? 'Default'` hide
+    // this — a caller's real value can never win) or double-apply a
+    // non-idempotent derivation (`(props.count ?? 1) * 2` seeded with the
+    // evaluated `2` re-derives to `2 * 2 = 4`). The correct seed is the RAW
+    // prop, so the entry must be a PROP entry (`propName` set, `value:
+    // null`) instead of a plain signal-value entry — the template's own
+    // `?? <default>` / `is not none` guard performs the real derivation,
+    // exactly like the bare-props safety net below.
+    //
+    // NOT self-derived (the initializer references a DIFFERENT prop, or no
+    // prop at all) keeps today's behavior: the signal's evaluated value
+    // wins the entry outright. This also correctly leaves alone the
+    // separate (out-of-scope) case where the signal's OWN initializer does
+    // NOT reference the same-named prop but the JSX body separately reads
+    // both `label()` and `props.label` — that's a template-variable-
+    // aliasing defect, not this one, and must render byte-identically.
+    //
+    // Invariant this establishes (relied on by every template-stash
+    // conformance harness's seeding loops — see `test-render.ts`): a
+    // signal/memo entry carries `propName` IF AND ONLY IF it went through
+    // this collision path. An ordinary signal/memo entry never has
+    // `propName` — that's exclusively how a harness (or a production
+    // manifest consumer) can tell "this local's stash seed must come from
+    // the caller-facing prop, not the local's own evaluated value" apart
+    // from "this is an internal signal/memo the caller cannot override".
+    if (metadata.propsObjectName !== null && referencesOwnProp(sig.initialValue, metadata.propsObjectName, sig.getter, localConsts)) {
+      // Pass 1 above already wrote the prop entry when the prop is
+      // *declared* on the props type — leave it as-is. An undeclared
+      // (untyped / inline-typed) prop has no pass-1 entry yet; create it
+      // here so the collision is still resolved for that shape.
+      if (!(sig.getter in out)) {
+        out[sig.getter] = { propName: sig.getter, value: null }
+      }
+    } else {
+      out[sig.getter] = { value: resultToJsonable(value) }
+    }
+    // `bindings` always gets the EVALUATED value regardless of which stash
+    // seed the entry above ended up with — a later memo referencing this
+    // getter (`createMemo(() => label() + '!')`) must keep resolving
+    // through the chain exactly as before; only the manifest's own seed
+    // choice changes, not the static-eval semantics.
     bindings[sig.getter] = value
   }
 
   for (const memo of metadata.memos) {
     if (memo.isModule) continue
     const value = tryStaticEval(memo.computation, { bindings, propsLike })
-    out[memo.name] = { value: resultToJsonable(value) }
+    // Same self-derivation collision as signals above, for a memo whose
+    // computation derives from a same-named prop
+    // (`createMemo(() => (props.label ?? 'Default') + n())`). See the
+    // signal loop's comment for the full mechanism and the `propName`
+    // invariant this relies on.
+    if (metadata.propsObjectName !== null && referencesOwnProp(memo.computation, metadata.propsObjectName, memo.name, localConsts)) {
+      if (!(memo.name in out)) {
+        out[memo.name] = { propName: memo.name, value: null }
+      }
+    } else {
+      out[memo.name] = { value: resultToJsonable(value) }
+    }
     bindings[memo.name] = value
   }
 
@@ -251,11 +326,11 @@ export function extractSsrDefaults(metadata: IRMetadata): Record<string, SsrDefa
     const referenced = new Set<string>()
     for (const sig of metadata.signals) {
       if (!sig.getter || sig.isModule || sig.envReader) continue
-      collectPropRefs(sig.initialValue, metadata.propsObjectName, referenced)
+      collectPropRefsTransitive(sig.initialValue, metadata.propsObjectName, localConsts, referenced)
     }
     for (const memo of metadata.memos) {
       if (memo.isModule) continue
-      collectPropRefs(memo.computation, metadata.propsObjectName, referenced)
+      collectPropRefsTransitive(memo.computation, metadata.propsObjectName, localConsts, referenced)
     }
     for (const name of referenced) {
       // Don't clobber a signal / memo (or already-seeded prop) of the same
@@ -268,6 +343,47 @@ export function extractSsrDefaults(metadata: IRMetadata): Record<string, SsrDefa
   return Object.keys(out).length === 0 ? undefined : out
 }
 
+/**
+ * Component-scope (non-module) `const` locals, by name → value source text.
+ * `referencesOwnProp` and `collectPropRefsTransitive` (below) use this to
+ * see PAST one hop of pure indirection between a prop read and the
+ * signal/memo that derives from it — `const mid = props.label;
+ * createSignal(mid ?? 'Default')` (#2685 review, one hop past #2669's
+ * direct-access-only detection). Module-scope consts are excluded: a
+ * MODULE const's value is fixed at compile time and isn't a `props.X` read
+ * (a module const referencing `props` isn't legal JS — `props` is a
+ * function parameter), so it can never contribute a prop reference here.
+ */
+function localConstValuesByName(metadata: IRMetadata): ReadonlyMap<string, string> {
+  const out = new Map<string, string>()
+  for (const c of metadata.localConstants ?? []) {
+    if (c.isModule || c.value === undefined) continue
+    out.set(c.name, c.value)
+  }
+  return out
+}
+
+/**
+ * Does `expr` (a signal initializer or memo computation) read
+ * `propsObjectName.<name>` where `name` is that SAME signal's getter / that
+ * SAME memo's name — directly, or through a chain of component-scope
+ * `const` locals? This is the #2669 self-derivation test (widened by
+ * #2685 review to see through indirection): reuses `collectPropRefsTransitive`
+ * (never a bespoke walker — see the CLAUDE.md rule this file already
+ * follows for `props.X` collection) and just checks membership of the one
+ * name we care about.
+ */
+function referencesOwnProp(
+  expr: string | undefined,
+  propsObjectName: string,
+  name: string,
+  localConsts: ReadonlyMap<string, string>,
+): boolean {
+  const referenced = new Set<string>()
+  collectPropRefsTransitive(expr, propsObjectName, localConsts, referenced)
+  return referenced.has(name)
+}
+
 /**
  * Collect the first-level property name of every `propsObjectName.X` access
  * within `expr` (e.g. `props.initial ?? 0` → `initial`). Used to seed the
@@ -276,6 +392,11 @@ export function extractSsrDefaults(metadata: IRMetadata): Record<string, SsrDefa
  * prop `a`: adapters lower that to `$a->{b}`, so the bare `$a` needs
  * seeding just the same — the walk stops at the first
  * `propsObjectName.<name>` match and collects `a` (not `b`).
+ *
+ * Direct-access only — does NOT look through a component-scope `const`
+ * that itself reads `propsObjectName.X`. Callers that need to see past
+ * that indirection use `collectPropRefsTransitive` below, which wraps this
+ * function rather than duplicating its walk.
  */
 function collectPropRefs(
   expr: string | undefined,
@@ -304,6 +425,46 @@ function collectPropRefs(
   visit(node)
 }
 
+/**
+ * `collectPropRefs`, widened to look THROUGH component-scope `const`
+ * locals (#2685 review): a signal/memo initializer often reads a prop one
+ * hop removed — `const mid = props.label; createSignal(mid ?? 'Default')`
+ * — rather than `propsObjectName.X` directly. Runs the existing
+ * direct-access walk over `expr` first (unchanged behavior for the common
+ * case), then finds every VALUE-POSITION identifier `expr` references
+ * (via the analyzer's `extractFreeIdentifiersFromNode` — never a bespoke
+ * identifier scan, so a property-access tail like `foo.mid` or an
+ * object-literal key like `{ mid: 1 }` is correctly NOT mistaken for a
+ * read of a local named `mid`) and, for each one that names a local
+ * const, recurses into THAT const's own value expression the same way.
+ *
+ * `visited` guards re-entering the same const twice — both for the
+ * (source-impossible, since JS TDZ forbids a const referencing itself)
+ * pathological-cycle case, and for the ordinary diamond case (two
+ * branches of `expr` both reading the same local) so it isn't walked
+ * twice. Fresh per top-level call via the default parameter, so unrelated
+ * calls for different signals/memos don't share state.
+ */
+function collectPropRefsTransitive(
+  expr: string | undefined,
+  propsObjectName: string,
+  localConsts: ReadonlyMap<string, string>,
+  out: Set<string>,
+  visited: Set<string> = new Set(),
+): void {
+  if (!expr || !expr.trim()) return
+  collectPropRefs(expr, propsObjectName, out)
+  const node = parseExpression(expr)
+  if (!node) return
+  for (const id of extractFreeIdentifiersFromNode(node)) {
+    if (visited.has(id)) continue
+    const constValue = localConsts.get(id)
+    if (constValue === undefined) continue
+    visited.add(id)
+    collectPropRefsTransitive(constValue, propsObjectName, localConsts, out, visited)
+  }
+}
+
 function resultToJsonable(v: EvalResult): unknown {
   if (v === UNRESOLVED) return null
   if (v === undefined) return null
@@ -366,12 +527,16 @@ function evalStatementsForReturn(
 
 function parseExpression(expr: string): ts.Expression | null {
   // Wrap in parens so a leading `{}` parses as an object literal rather
-  // than an empty block statement.
+  // than an empty block statement. Parent nodes ARE set (unlike a bare
+  // parse) so `collectPropRefsTransitive` can call the analyzer's
+  // `extractFreeIdentifiersFromNode` — which needs `.parent` to tell a
+  // value-position identifier from a property-access tail / object-literal
+  // key / parameter name — on the result.
   const sf = ts.createSourceFile(
     '__ssr_default__.ts',
     `(${expr})`,
     ts.ScriptTarget.Latest,
-    false,
+    true,
     ts.ScriptKind.TS,
   )
   const stmt = sf.statements[0]

package/src/ssr-seed-plan.ts

@@ -35,6 +35,7 @@ import { envSignalReaderFor, type EnvSignalReader } from './adapters/env-signal.
 import {
   extractArrowBodyExpression,
   freeIdentifiers,
+  inlineBinding,
   isSupported,
   parseExpression,
   type ParsedExpr,
@@ -97,6 +98,72 @@ function classify(
   return { kind: 'derived', name, origin, expr, parsed, frees: [...frees] }
 }
 
+/**
+ * Component-scope (non-module) `const` locals, by name, parsed to their
+ * `ParsedExpr` value — the substitution table `resolveThroughLocalConsts`
+ * inlines through. Module-scope consts are excluded: they're already part
+ * of `baseScope` (every adapter compile-time-inlines them to their literal
+ * value, so a reference to one is never a template-variable read — see the
+ * module doc), and a `let` has no stable value to substitute.
+ */
+function localConstExprsByName(metadata: IRMetadata): ReadonlyMap<string, ParsedExpr> {
+  const out = new Map<string, ParsedExpr>()
+  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
+}
+
+/**
+ * Resolve a signal/memo's parsed expression through any component-scope
+ * `const` locals it references, so a hop of pure indirection between a
+ * prop read and its derived signal/memo — `const mid = props.label;
+ * createSignal(mid ?? 'Default')` — classifies from the SAME scope its
+ * fully-inlined form (`props.label ?? 'Default'`) would (#2685 review, the
+ * jsx-side twin of `ssr-defaults.ts`'s own `collectPropRefs` closure).
+ *
+ * Structural substitution only (never string splicing, per CLAUDE.md):
+ * reuses `inlineBinding`, the exact "let-inline" step `foldBlockToExpr`
+ * already performs for a block-bodied memo's own internal `const`s. A
+ * chained const (`const a = props.x; const b = a; createSignal(b ?? 1)`)
+ * closes the same way — each pass substitutes whatever local consts are
+ * still free in the current form, so `b` resolves to `a` first and `a`
+ * resolves to `props.x` on the next pass. Bounded to `localConsts.size + 1`
+ * iterations (the longest possible chain) purely as a cycle guard; a real
+ * cycle is impossible in valid source (JS TDZ forbids a const referencing
+ * itself, directly or transitively).
+ *
+ * `inlineBinding` returns `null` only on a capture hazard (the const's own
+ * free variable would be shadowed by a nested callback parameter of the
+ * same name inside the current form) — that occurrence is left un-inlined,
+ * so its name simply stays free and later fails `classify`'s availability
+ * check like any other out-of-scope reference (fails safe to `opaque`,
+ * never a wrong substitution).
+ */
+function resolveThroughLocalConsts(
+  parsed: ParsedExpr,
+  localConsts: ReadonlyMap<string, ParsedExpr>,
+): ParsedExpr {
+  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
+}
+
 /**
  * Compute the component's SSR seed plan from its metadata. See the module
  * doc for the contract. Memo steps are gated to EXPRESSION-BODIED memos
@@ -111,6 +178,7 @@ export function computeSsrSeedPlan(metadata: IRMetadata): SsrSeedPlan {
   }
 
   const available = new Set<string>(baseScope)
+  const localConsts = localConstExprsByName(metadata)
   const steps: SsrSeedStep[] = []
 
   for (const signal of metadata.signals) {
@@ -126,7 +194,13 @@ export function computeSsrSeedPlan(metadata: IRMetadata): SsrSeedPlan {
     steps.push(
       expr === ''
         ? { kind: 'opaque', name: signal.getter, origin: 'signal' }
-        : classify(signal.getter, 'signal', expr, parseExpression(expr), available),
+        : classify(
+            signal.getter,
+            'signal',
+            expr,
+            resolveThroughLocalConsts(parseExpression(expr), localConsts),
+            available,
+          ),
     )
     available.add(signal.getter)
   }
@@ -137,7 +211,13 @@ export function computeSsrSeedPlan(metadata: IRMetadata): SsrSeedPlan {
     steps.push(
       expr === ''
         ? { kind: 'opaque', name: memo.name, origin: 'memo' }
-        : classify(memo.name, 'memo', expr, memo.parsed ?? parseExpression(expr), available),
+        : classify(
+            memo.name,
+            'memo',
+            expr,
+            resolveThroughLocalConsts(memo.parsed ?? parseExpression(expr), localConsts),
+            available,
+          ),
     )
     available.add(memo.name)
   }