@barefootjs/jsx 0.16.0 → 0.17.1

package/dist/ir-to-client-js/csr-substitute.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"csr-substitute.d.ts","sourceRoot":"","sources":["../../src/ir-to-client-js/csr-substitute.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAKH,OAAO,KAAK,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,aAAa,CAAA;AAEvD;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,iBAAiB;IAChC,cAAc,EAAE,MAAM,CAAA;IACtB,eAAe,EAAE,WAAW,CAAC,MAAM,CAAC,CAAA;CACrC;AAED;;;;;GAKG;AACH,MAAM,MAAM,kBAAkB,GAAG,GAAG,CAAC,MAAM,EAAE,iBAAiB,GAAG,IAAI,CAAC,CAAA;AAEtE;;;;GAIG;AACH,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,GAAG,YAAY,CAAA;IAC3B,sEAAsE;IACtE,WAAW,EAAE,MAAM,CAAA;IACnB,qFAAqF;IACrF,eAAe,EAAE,WAAW,CAAC,MAAM,CAAC,CAAA;CACrC;AAED,MAAM,WAAW,MAAM;IACrB;;;;;OAKG;IACH,aAAa,EAAE,GAAG,CAAC,MAAM,EAAE,eAAe,CAAC,CAAA;IAC3C,4EAA4E;IAC5E,eAAe,EAAE,MAAM,GAAG,IAAI,CAAA;CAC/B;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,aAAa,CAC3B,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,MAAM,GACV;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,eAAe,EAAE,WAAW,CAAC,MAAM,CAAC,CAAA;CAAE,CAmB7D;AAmMD;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,EAAE,eAAe,EAAE,MAAM,GAAG,IAAI,GAAG,MAAM,CAGtF;AAiBD;;;;;;;;;;;GAWG;AACH,wBAAgB,mBAAmB,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,CAQ/D;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,SAAS,UAAU,EAAE,EAC9B,KAAK,EAAE,SAAS,QAAQ,EAAE,EAC1B,eAAe,EAAE,MAAM,GAAG,IAAI,GAC7B,MAAM,CAiBR"}
+{"version":3,"file":"csr-substitute.d.ts","sourceRoot":"","sources":["../../src/ir-to-client-js/csr-substitute.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAKH,OAAO,KAAK,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,aAAa,CAAA;AAEvD;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,iBAAiB;IAChC,cAAc,EAAE,MAAM,CAAA;IACtB,eAAe,EAAE,WAAW,CAAC,MAAM,CAAC,CAAA;CACrC;AAED;;;;;GAKG;AACH,MAAM,MAAM,kBAAkB,GAAG,GAAG,CAAC,MAAM,EAAE,iBAAiB,GAAG,IAAI,CAAC,CAAA;AAEtE;;;;GAIG;AACH,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,GAAG,YAAY,CAAA;IAC3B,sEAAsE;IACtE,WAAW,EAAE,MAAM,CAAA;IACnB,qFAAqF;IACrF,eAAe,EAAE,WAAW,CAAC,MAAM,CAAC,CAAA;CACrC;AAED,MAAM,WAAW,MAAM;IACrB;;;;;OAKG;IACH,aAAa,EAAE,GAAG,CAAC,MAAM,EAAE,eAAe,CAAC,CAAA;IAC3C,4EAA4E;IAC5E,eAAe,EAAE,MAAM,GAAG,IAAI,CAAA;CAC/B;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,aAAa,CAC3B,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,MAAM,GACV;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,eAAe,EAAE,WAAW,CAAC,MAAM,CAAC,CAAA;CAAE,CAmB7D;AAmMD;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,EAAE,eAAe,EAAE,MAAM,GAAG,IAAI,GAAG,MAAM,CAGtF;AAiBD;;;;;;;;;;;GAWG;AACH,wBAAgB,mBAAmB,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,CAQ/D;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,SAAS,UAAU,EAAE,EAC9B,KAAK,EAAE,SAAS,QAAQ,EAAE,EAC1B,eAAe,EAAE,MAAM,GAAG,IAAI,GAC7B,MAAM,CAsBR"}

package/dist/ir-to-client-js/plan/build-declaration-emit.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"build-declaration-emit.d.ts","sourceRoot":"","sources":["../../../src/ir-to-client-js/plan/build-declaration-emit.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAA;AAC/D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAA;AACzD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAA;AAClD,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAA;AAE3D,OAAO,KAAK,EAEV,mBAAmB,EAEpB,MAAM,uBAAuB,CAAA;AAE9B;;;;GAIG;AACH,MAAM,WAAW,sBAAsB;IACrC,kBAAkB,EAAE,WAAW,CAAC,UAAU,EAAE,gBAAgB,CAAC,CAAA;IAC7D,UAAU,EAAE,WAAW,CAAC,MAAM,EAAE,SAAS,CAAC,CAAA;CAC3C;AAED,wBAAgB,2BAA2B,CACzC,GAAG,EAAE,eAAe,EACpB,iBAAiB,EAAE,SAAS,gBAAgB,EAAE,GAC7C,sBAAsB,CAMxB;AAED,wBAAgB,wBAAwB,CACtC,IAAI,EAAE,WAAW,EACjB,GAAG,EAAE,eAAe,EACpB,OAAO,EAAE,sBAAsB,GAC9B,mBAAmB,CAkCrB"}
+{"version":3,"file":"build-declaration-emit.d.ts","sourceRoot":"","sources":["../../../src/ir-to-client-js/plan/build-declaration-emit.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAA;AAC/D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAA;AACzD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAA;AAClD,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAA;AAG3D,OAAO,KAAK,EAEV,mBAAmB,EAEpB,MAAM,uBAAuB,CAAA;AAE9B;;;;GAIG;AACH,MAAM,WAAW,sBAAsB;IACrC,kBAAkB,EAAE,WAAW,CAAC,UAAU,EAAE,gBAAgB,CAAC,CAAA;IAC7D,UAAU,EAAE,WAAW,CAAC,MAAM,EAAE,SAAS,CAAC,CAAA;CAC3C;AAED,wBAAgB,2BAA2B,CACzC,GAAG,EAAE,eAAe,EACpB,iBAAiB,EAAE,SAAS,gBAAgB,EAAE,GAC7C,sBAAsB,CAMxB;AAED,wBAAgB,wBAAwB,CACtC,IAAI,EAAE,WAAW,EACjB,GAAG,EAAE,eAAe,EACpB,OAAO,EAAE,sBAAsB,GAC9B,mBAAmB,CAkCrB"}

package/dist/ir-to-client-js/plan/declaration-emit.d.ts

@@ -52,6 +52,15 @@ export interface SignalEmitPlan {
     branchCondition?: string;
     /** Profile-mode IR-aligned id, appended as the `createSignal` 2nd arg (#1690). */
     bfId?: string;
+    /**
+     * When set, the full initializer expression to emit verbatim instead of
+     * `createSignal(<initialValueExpr>)`. Env signals (#2057) emit their own
+     * factory call — e.g. `createSearchParams()` — with no baked initial value,
+     * profile id, controlled effect, or branch condition (the tuple is a stable
+     * request-scoped view, not stored state). When present the stringifier emits
+     * `const [<getter>, <setter>] = <initializerOverride>` and nothing else.
+     */
+    initializerOverride?: string;
 }
 export interface ControlledSignalEffectPlan {
     /** Receiver setter — must equal the parent signal's `setter`. */

package/dist/ir-to-client-js/plan/declaration-emit.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"declaration-emit.d.ts","sourceRoot":"","sources":["../../../src/ir-to-client-js/plan/declaration-emit.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,UAAU,CAAA;IAChB,qDAAqD;IACrD,OAAO,EAAE,OAAO,GAAG,KAAK,GAAG,KAAK,CAAA;IAChC,IAAI,EAAE,MAAM,CAAA;IACZ,+EAA+E;IAC/E,SAAS,EAAE,MAAM,GAAG,IAAI,CAAA;CACzB;AAED,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,QAAQ,CAAA;IACd,kEAAkE;IAClE,MAAM,EAAE,MAAM,CAAA;IACd,wDAAwD;IACxD,MAAM,EAAE,MAAM,GAAG,IAAI,CAAA;IACrB;;;;OAIG;IACH,gBAAgB,EAAE,MAAM,CAAA;IACxB;;;OAGG;IACH,gBAAgB,EAAE,0BAA0B,GAAG,IAAI,CAAA;IACnD;;;;;;;;;;;;OAYG;IACH,eAAe,CAAC,EAAE,MAAM,CAAA;IACxB,kFAAkF;IAClF,IAAI,CAAC,EAAE,MAAM,CAAA;CACd;AAED,MAAM,WAAW,0BAA0B;IACzC,iEAAiE;IACjE,MAAM,EAAE,MAAM,CAAA;IACd,iEAAiE;IACjE,YAAY,EAAE,MAAM,CAAA;IACpB,kFAAkF;IAClF,IAAI,CAAC,EAAE,MAAM,CAAA;CACd;AAED,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;IACZ,qDAAqD;IACrD,eAAe,EAAE,MAAM,CAAA;IACvB,gFAAgF;IAChF,IAAI,CAAC,EAAE,MAAM,CAAA;CACd;AAED,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,UAAU,CAAA;IAChB,IAAI,EAAE,MAAM,CAAA;IACZ,+EAA+E;IAC/E,SAAS,EAAE,MAAM,CAAA;IACjB,yEAAyE;IACzE,IAAI,EAAE,MAAM,CAAA;IACZ,uEAAuE;IACvE,OAAO,EAAE,OAAO,CAAA;CACjB;AAED,MAAM,MAAM,mBAAmB,GAC3B,gBAAgB,GAChB,cAAc,GACd,YAAY,GACZ,gBAAgB,CAAA"}
+{"version":3,"file":"declaration-emit.d.ts","sourceRoot":"","sources":["../../../src/ir-to-client-js/plan/declaration-emit.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,UAAU,CAAA;IAChB,qDAAqD;IACrD,OAAO,EAAE,OAAO,GAAG,KAAK,GAAG,KAAK,CAAA;IAChC,IAAI,EAAE,MAAM,CAAA;IACZ,+EAA+E;IAC/E,SAAS,EAAE,MAAM,GAAG,IAAI,CAAA;CACzB;AAED,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,QAAQ,CAAA;IACd,kEAAkE;IAClE,MAAM,EAAE,MAAM,CAAA;IACd,wDAAwD;IACxD,MAAM,EAAE,MAAM,GAAG,IAAI,CAAA;IACrB;;;;OAIG;IACH,gBAAgB,EAAE,MAAM,CAAA;IACxB;;;OAGG;IACH,gBAAgB,EAAE,0BAA0B,GAAG,IAAI,CAAA;IACnD;;;;;;;;;;;;OAYG;IACH,eAAe,CAAC,EAAE,MAAM,CAAA;IACxB,kFAAkF;IAClF,IAAI,CAAC,EAAE,MAAM,CAAA;IACb;;;;;;;OAOG;IACH,mBAAmB,CAAC,EAAE,MAAM,CAAA;CAC7B;AAED,MAAM,WAAW,0BAA0B;IACzC,iEAAiE;IACjE,MAAM,EAAE,MAAM,CAAA;IACd,iEAAiE;IACjE,YAAY,EAAE,MAAM,CAAA;IACpB,kFAAkF;IAClF,IAAI,CAAC,EAAE,MAAM,CAAA;CACd;AAED,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;IACZ,qDAAqD;IACrD,eAAe,EAAE,MAAM,CAAA;IACvB,gFAAgF;IAChF,IAAI,CAAC,EAAE,MAAM,CAAA;CACd;AAED,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,UAAU,CAAA;IAChB,IAAI,EAAE,MAAM,CAAA;IACZ,+EAA+E;IAC/E,SAAS,EAAE,MAAM,CAAA;IACjB,yEAAyE;IACzE,IAAI,EAAE,MAAM,CAAA;IACZ,uEAAuE;IACvE,OAAO,EAAE,OAAO,CAAA;CACjB;AAED,MAAM,MAAM,mBAAmB,GAC3B,gBAAgB,GAChB,cAAc,GACd,YAAY,GACZ,gBAAgB,CAAA"}

package/dist/jsx-to-ir.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"jsx-to-ir.d.ts","sourceRoot":"","sources":["../src/jsx-to-ir.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,EACL,KAAK,MAAM,EAyBZ,MAAM,YAAY,CAAA;AACnB,OAAO,EAAE,KAAK,eAAe,EAA8C,MAAM,uBAAuB,CAAA;AA0gBxG,wBAAgB,OAAO,CAAC,QAAQ,EAAE,eAAe,GAAG,MAAM,GAAG,IAAI,CAkDhE"}
+{"version":3,"file":"jsx-to-ir.d.ts","sourceRoot":"","sources":["../src/jsx-to-ir.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,EACL,KAAK,MAAM,EAyBZ,MAAM,YAAY,CAAA;AACnB,OAAO,EAAE,KAAK,eAAe,EAA0E,MAAM,uBAAuB,CAAA;AAqnBpI,wBAAgB,OAAO,CAAC,QAAQ,EAAE,eAAe,GAAG,MAAM,GAAG,IAAI,CAIhE"}

package/dist/lowering-registry.d.ts

@@ -0,0 +1,122 @@
+/**
+ * Call-lowering plugin registry (#2057).
+ *
+ * The compiler core carries no bespoke per-API recognition branches. Instead, a
+ * lowering plugin *recognises* a call — by the import it comes from and its
+ * argument shape — and returns a **backend-neutral `LoweringNode`**. Each adapter
+ * renders that node in its own template syntax. This is a deliberate two-layer
+ * split:
+ *
+ *   - **Layer 1 (this module + plugins):** adapter-agnostic. A plugin matches a
+ *     call to a neutral node and never mentions Go/Perl/… syntax.
+ *   - **Layer 2 (adapters):** plugin-agnostic. Each adapter has ONE renderer per
+ *     node kind, so SSR/CSR parity is enforced once, not per plugin.
+ *
+ * Everything flows through this one seam — including first-party APIs. A
+ * userland package registers its plugin via {@link registerLoweringPlugin}, and
+ * a built-in like `queryHref` is registered by the compiler *as a default
+ * plugin* (see `builtin-lowering-plugins.ts`), not as an adapter branch. So an
+ * adapter can't tell a shipped API from a third-party one: both are just entries
+ * in this registry. That uniformity is the point — there is no "special" path to
+ * keep in sync.
+ *
+ * This is NOT the "output-rewriting hook" CLAUDE.md forbids: a plugin returns a
+ * structured IR node, never a rewritten output string, so the compiler's output
+ * stays determined by the compiler, not by whatever munges the emitted text.
+ */
+import type { ParsedExpr } from './expression-parser.ts';
+import type { IRMetadata } from './types.ts';
+/**
+ * A backend-neutral include triple for a {@link LoweringNode} `guard-list`.
+ * `guard` is the conditional test of a `key: cond ? v : <omit>` include, or null
+ * for a plain `key: v` (included purely on value-truthiness). An adapter renders
+ * the guard to decide inclusion; the *runtime helper* then applies the emptiness
+ * / array-append rules to the value. (Structurally identical to the query-href
+ * lowering's own triple, which the `queryHref` plugin passes through unchanged.)
+ */
+export interface LoweringTriple {
+    guard: ParsedExpr | null;
+    key: string;
+    value: ParsedExpr;
+}
+/**
+ * A backend-neutral lowering result. Adapters render each variant in their own
+ * template language; the shapes carry everything a renderer needs and nothing
+ * adapter-specific.
+ */
+export type LoweringNode = 
+/**
+ * A guard/key/value include list lowered to a query helper — the shape of
+ * `queryHref(base, { … })`. `helper` is the logical helper id (`'query'`),
+ * which each adapter maps to its own runtime helper (`bf_query` in go,
+ * `bf->query` in mojo, `$bf.query` in xslate). Each triple's `guard` controls
+ * inclusion; the runtime helper then applies the non-empty / array-append
+ * rules to the value (so an included-but-empty value is dropped and array
+ * members are appended), matching the client `queryHref` exactly. Adapters
+ * MUST switch on `helper` — a `guard-list` is not implicitly `query`.
+ */
+{
+    kind: 'guard-list';
+    helper: string;
+    base: ParsedExpr;
+    triples: LoweringTriple[];
+}
+/**
+ * A plain helper call `helper(...args)` — the general escape hatch for a pure
+ * builder that lowers to a single runtime-helper invocation. Unused today;
+ * present so the neutral vocabulary isn't single-purpose.
+ */
+ | {
+    kind: 'helper-call';
+    helper: string;
+    args: readonly ParsedExpr[];
+};
+/**
+ * A matcher bound to one component's metadata: given a parsed call's callee +
+ * args, returns a neutral node or null to decline. Produced by a plugin's
+ * {@link LoweringPlugin.prepare} so the per-component import-name resolution runs
+ * once (at adapter init), not on every emit.
+ */
+export type LoweringMatcher = (callee: ParsedExpr, args: readonly ParsedExpr[]) => LoweringNode | null;
+/**
+ * A lowering plugin. `prepare` resolves the local names its import is bound
+ * under in this component and returns a bound {@link LoweringMatcher}, or null
+ * when the component doesn't use it (so the adapter skips it entirely). A
+ * plugin never emits adapter syntax — only neutral nodes.
+ */
+export interface LoweringPlugin {
+    /** Stable id, for dedup/diagnostics (e.g. `'my-pkg-url'`). */
+    name: string;
+    prepare(metadata: IRMetadata): LoweringMatcher | null;
+}
+/**
+ * Register a lowering plugin. Idempotent by `name` — re-registering the same
+ * name replaces the prior plugin, so a double side-effect import can't stack
+ * duplicates. First-party packages call this at module load.
+ */
+export declare function registerLoweringPlugin(plugin: LoweringPlugin): void;
+/** The registered plugins, in registration order (a copy — mutating the result
+ *  can't reorder or corrupt the registry). */
+export declare function getLoweringPlugins(): readonly LoweringPlugin[];
+/**
+ * Bind every registered plugin to a component's metadata, returning the matchers
+ * that are active for it (import present). Adapters call this once at init and
+ * store the result, then try each matcher on the calls they lower — replacing a
+ * hardcoded per-API recognizer.
+ */
+export declare function prepareLoweringMatchers(metadata: IRMetadata): LoweringMatcher[];
+/**
+ * Convenience one-shot match against all registered plugins for a given
+ * metadata. Prefer {@link prepareLoweringMatchers} on a hot path (it resolves
+ * import names once); this re-resolves per call and is meant for tests / cold
+ * call sites.
+ */
+export declare function matchLoweringCall(callee: ParsedExpr, args: readonly ParsedExpr[], metadata: IRMetadata): LoweringNode | null;
+/**
+ * Test-only: replace the registry contents wholesale. The double-underscore
+ * prefix marks it as an internal seam — tests use it to restore global state in
+ * `afterEach` so a sample plugin can't leak into other suites. Never call from
+ * production code.
+ */
+export declare function __resetLoweringPluginsForTest(next?: readonly LoweringPlugin[]): void;
+//# sourceMappingURL=lowering-registry.d.ts.map

package/dist/lowering-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lowering-registry.d.ts","sourceRoot":"","sources":["../src/lowering-registry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAA;AACxD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAA;AAE5C;;;;;;;GAOG;AACH,MAAM,WAAW,cAAc;IAC7B,KAAK,EAAE,UAAU,GAAG,IAAI,CAAA;IACxB,GAAG,EAAE,MAAM,CAAA;IACX,KAAK,EAAE,UAAU,CAAA;CAClB;AAED;;;;GAIG;AACH,MAAM,MAAM,YAAY;AACtB;;;;;;;;;GASG;AACD;IAAE,IAAI,EAAE,YAAY,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,UAAU,CAAC;IAAC,OAAO,EAAE,cAAc,EAAE,CAAA;CAAE;AACrF;;;;GAIG;GACD;IAAE,IAAI,EAAE,aAAa,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,SAAS,UAAU,EAAE,CAAA;CAAE,CAAA;AAExE;;;;;GAKG;AACH,MAAM,MAAM,eAAe,GAAG,CAC5B,MAAM,EAAE,UAAU,EAClB,IAAI,EAAE,SAAS,UAAU,EAAE,KACxB,YAAY,GAAG,IAAI,CAAA;AAExB;;;;;GAKG;AACH,MAAM,WAAW,cAAc;IAC7B,8DAA8D;IAC9D,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,CAAC,QAAQ,EAAE,UAAU,GAAG,eAAe,GAAG,IAAI,CAAA;CACtD;AAID;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,cAAc,GAAG,IAAI,CAInE;AAED;8CAC8C;AAC9C,wBAAgB,kBAAkB,IAAI,SAAS,cAAc,EAAE,CAE9D;AAED;;;;;GAKG;AACH,wBAAgB,uBAAuB,CAAC,QAAQ,EAAE,UAAU,GAAG,eAAe,EAAE,CAO/E;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,UAAU,EAClB,IAAI,EAAE,SAAS,UAAU,EAAE,EAC3B,QAAQ,EAAE,UAAU,GACnB,YAAY,GAAG,IAAI,CAMrB;AAED;;;;;GAKG;AACH,wBAAgB,6BAA6B,CAAC,IAAI,GAAE,SAAS,cAAc,EAAO,GAAG,IAAI,CAGxF"}

package/dist/query-href-lowering.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Backend-neutral destructuring of a recognised `queryHref(base, { … })` call
+ * (#2042) into a base expression plus include triples, shared by the SSR
+ * adapters' query lowering.
+ *
+ * `queryHref` is the pure functional URL-query builder (the counterpart to
+ * `searchParams()`); its call + object literal are already structured IR, so an
+ * adapter lowers it to its query helper without any block-body recognition or
+ * re-parse. This module only does the structural match — turning the object
+ * literal's properties into `{ guard, key, value }` triples — leaving each
+ * adapter to format the include condition and the helper call in its own
+ * template language.
+ *
+ * Inclusion is truthy-omit over string values (matching the client `queryHref`'s
+ * `if (value)`): a plain `key: v` is included iff `v` is a non-empty string
+ * (`guard: null`); a conditional `key: cond ? a : <undefined|null|''>` is
+ * included iff `cond` AND `a` is non-empty (`guard: cond`, `value: a`).
+ */
+import type { ParsedExpr } from './expression-parser.ts';
+export interface QueryHrefTriple {
+    /**
+     * The conditional test of a `key: cond ? a : <omit>` include, or null for a
+     * plain `key: v` (which is included purely on value-truthiness). An adapter
+     * combines this with the value's non-emptiness to form the include condition.
+     */
+    guard: ParsedExpr | null;
+    /** The literal search-param key. */
+    key: string;
+    /** The value expression (the consequent for a conditional include). */
+    value: ParsedExpr;
+}
+export interface QueryHrefCall {
+    base: ParsedExpr;
+    triples: QueryHrefTriple[];
+}
+/**
+ * Match a `queryHref(base, { … })` call from its callee + args, returning the
+ * base and include triples, or null when it isn't a `queryHref` call with a
+ * plain object-literal second argument (→ the adapter falls back to its generic
+ * lowering). `localNames` are the bindings `queryHref` is imported under (from
+ * `queryHrefLocalNames`).
+ */
+export declare function matchQueryHrefCall(callee: ParsedExpr, args: readonly ParsedExpr[], localNames: ReadonlySet<string>): QueryHrefCall | null;
+/**
+ * Format a {@link QueryHrefCall} as the flat argument list for a guard-list
+ * query helper (`bf->query(base, guard, key, value, …)` in Mojo / `$bf.query(…)`
+ * in Xslate — the two adapters whose helper does the non-empty check itself).
+ * Each triple contributes a guard (`'1'` for a plain include, or the lowered
+ * condition for a conditional one), the key as a string literal, and the value —
+ * all lowered through the adapter's `emit`. The caller wraps the result in its
+ * own `<helper>(…)` call. (The go-template adapter folds the non-empty check
+ * into the include condition itself, so it formats its own form instead.)
+ *
+ * A conditional guard that is NOT already boolean-shaped (a bare value, a member
+ * access, `&&`/`||`) is JS *string* truthiness — `'0'` is a truthy string in JS
+ * but false under Perl's `unless`. To keep SSR byte-identical to the client (and
+ * to the go adapter, whose `lowerUrlGuard` does the same), such a guard is
+ * normalised to a `guard !== ''` test, emitted against a string literal so each
+ * adapter renders string `ne`, not numeric `!=`. Comparisons / `!x` / boolean
+ * literals already yield a real boolean and pass through unchanged.
+ */
+export declare function queryHrefArgs(q: QueryHrefCall, emit: (e: ParsedExpr) => string): string[];
+//# sourceMappingURL=query-href-lowering.d.ts.map

package/dist/query-href-lowering.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"query-href-lowering.d.ts","sourceRoot":"","sources":["../src/query-href-lowering.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAA;AAExD,MAAM,WAAW,eAAe;IAC9B;;;;OAIG;IACH,KAAK,EAAE,UAAU,GAAG,IAAI,CAAA;IACxB,oCAAoC;IACpC,GAAG,EAAE,MAAM,CAAA;IACX,uEAAuE;IACvE,KAAK,EAAE,UAAU,CAAA;CAClB;AAED,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,UAAU,CAAA;IAChB,OAAO,EAAE,eAAe,EAAE,CAAA;CAC3B;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,UAAU,EAClB,IAAI,EAAE,SAAS,UAAU,EAAE,EAC3B,UAAU,EAAE,WAAW,CAAC,MAAM,CAAC,GAC9B,aAAa,GAAG,IAAI,CAkBtB;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,aAAa,EAAE,IAAI,EAAE,CAAC,CAAC,EAAE,UAAU,KAAK,MAAM,GAAG,MAAM,EAAE,CAoBzF"}

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;AAkBD;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,GAAG,SAAS,CAmG/F"}
+{"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;AAkBD;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,GAAG,SAAS,CAuG/F"}

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

@@ -0,0 +1,84 @@
+/**
+ * Backend-neutral SSR seed plan — which signals/memos an adapter may seed
+ * in-template at SSR time, and from what scope.
+ *
+ * Design principle: the IR/analyzer side ANALYZES and attaches structured
+ * information; adapters only EMIT. The "is this binding derivable from names
+ * already in template scope" decision used to live (triplicated) in the
+ * template adapters' seed paths; this module computes it once, on the IR, so
+ * every adapter consumes the same plan and only supplies its own syntax.
+ *
+ * Ordering / acyclicity guarantee: `steps` lists the component's signals
+ * first, then its memos, each group in declaration order (matching
+ * `IRMetadata.signals` / `IRMetadata.memos`). A binding's name only enters
+ * the scope set AFTER its own step is decided, so a `derived` step's `frees`
+ * can only name `baseScope` entries or EARLIER steps — self- and
+ * forward-references are rejected by construction, and a consumer emitting
+ * the steps top-to-bottom never reads an undeclared local.
+ *
+ * Module-scope pure-string consts count as in-scope (they are part of
+ * `baseScope`) because every adapter compile-time-inlines them to their
+ * literal value — `collectModuleStringConsts` is the shared source of that
+ * set — so a reference to one is never a template-variable read.
+ *
+ * A `derived` step with EMPTY `frees` is a constant expression (e.g.
+ * `createSignal('b')`): the plan still classifies it as derived because the
+ * expression is fully analyzable; emit-side constant-skipping (adapters keep
+ * their existing ssr-defaults seeding for such inits) is an adapter concern,
+ * not a plan concern. Likewise the plan makes no backend-specific choices —
+ * no target-variable checks, no self-shadowing rules, no per-backend shape
+ * catalogs — those stay in the adapters.
+ */
+import { type EnvSignalReader } from './adapters/env-signal.ts';
+import { type ParsedExpr } from './expression-parser.ts';
+import type { IRMetadata } from './types.ts';
+/**
+ * One binding in component declaration order (signals first, then memos —
+ * matching `IRMetadata` order and the adapters' iteration).
+ *
+ * - `env-reader`: an env signal whose `envReader` key resolves in the shared
+ *   registry (`envSignalReaderFor`). The runtime provides the per-request
+ *   reader, so there is nothing to seed; the name still enters scope so a
+ *   later derived step may reference it. An `envReader` key UNKNOWN to the
+ *   registry falls through to the normal derived/opaque rules instead.
+ * - `derived`: the binding's value expression is a supported shape whose free
+ *   identifiers are all in scope at this point (baseScope + earlier steps) —
+ *   an adapter may seed it in-template by lowering `parsed`/`expr`.
+ * - `opaque`: not seedable this way (empty init, unsupported shape,
+ *   unanalyzable free set, out-of-scope reference, or a block-bodied memo).
+ *   The name still enters scope for later steps; adapters keep their static
+ *   ssr-defaults seeding for it.
+ */
+export type SsrSeedStep = {
+    kind: 'env-reader';
+    name: string;
+    reader: EnvSignalReader;
+} | {
+    kind: 'derived';
+    name: string;
+    origin: 'signal' | 'memo';
+    expr: string;
+    parsed: ParsedExpr;
+    frees: string[];
+} | {
+    kind: 'opaque';
+    name: string;
+    origin: 'signal' | 'memo';
+};
+export interface SsrSeedPlan {
+    /**
+     * Names in scope before any step: props params, the props-object name
+     * (when the component takes an undestructured props object), and module
+     * pure-string consts (compile-time inlined by every adapter).
+     */
+    baseScope: string[];
+    steps: SsrSeedStep[];
+}
+/**
+ * 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
+ * (`extractArrowBodyExpression` returns the body): a block-bodied memo is
+ * `opaque` even when the analyzer folded it to a `parsed` expression.
+ */
+export declare function computeSsrSeedPlan(metadata: IRMetadata): SsrSeedPlan;
+//# sourceMappingURL=ssr-seed-plan.d.ts.map

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

@@ -0,0 +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"}

package/dist/types.d.ts

@@ -3,7 +3,25 @@
  *
  * JSX-independent intermediate representation for multi-backend support.
  */
-import type { ParsedExpr, ParsedStatement, SortComparator } from './expression-parser.ts';
+import type { ParsedExpr, ParsedStatement } from './expression-parser.ts';
+import type { SsrSeedPlan } from './ssr-seed-plan.ts';
+/**
+ * Loop-hoisted sort comparator for the `.sort().map()` / `.toSorted().map()`
+ * pattern (#2018 P5). Carries the generic comparator `arrow` (params + body)
+ * that the SSR adapter serializes to the runtime evaluator (eval-first) or, for
+ * a `localeCompare` comparator the evaluator can't model, recovers a structured
+ * comparator from via `sortComparatorFromArrow`. The `paramA` / `paramB` / `raw`
+ * fields round-trip the comparator to native JS for the client / CSR path
+ * (`(paramA, paramB) => raw`), so the client is untouched.
+ */
+export type IRLoopSort = {
+    arrow: Extract<ParsedExpr, {
+        kind: 'arrow';
+    }>;
+    paramA: string;
+    paramB: string;
+    raw: string;
+};
 export interface Position {
     line: number;
     column: number;
@@ -201,6 +219,20 @@ export interface IRExpression {
     expr: string;
     /** Pre-transformed expr with destructured prop refs rewritten to _p.xxx (for client JS templates). */
     templateExpr?: string;
+    /**
+     * Structured parse of `expr` (`parseExpression(expr.trim())`), attached once
+     * during IR construction so SSR adapters emit from the tree instead of each
+     * re-parsing the string at emit time (and so a multi-adapter build parses it
+     * once, not per adapter). Plain serializable data.
+     *
+     * OPTIONAL by design — consumers MUST fall back to parsing `expr` when it is
+     * missing. It is absent for an empty/whitespace `expr`, and may also be
+     * absent for a node the IR-build walk doesn't reach (the walk is best-effort;
+     * under-coverage is a missed optimization, never a behavioural change). When
+     * present, an unparsable expression is a `{ kind: 'unsupported' }` node (the
+     * adapter's own support gate handles it).
+     */
+    parsed?: ParsedExpr;
     typeInfo: TypeInfo | null;
     reactive: boolean;
     slotId: string | null;
@@ -224,6 +256,13 @@ export interface IRConditional {
     condition: string;
     /** Pre-transformed condition with destructured prop refs rewritten to _p.xxx. */
     templateCondition?: string;
+    /**
+     * Structured parse of `condition` (`parseExpression(condition.trim())`),
+     * attached during IR construction so adapters lower the condition from the
+     * tree instead of re-parsing the string. Optional/best-effort — see
+     * `IRExpression.parsed`; consumers fall back to parsing `condition`.
+     */
+    parsedCondition?: ParsedExpr;
     conditionType: TypeInfo | null;
     reactive: boolean;
     whenTrue: IRNode;
@@ -275,6 +314,14 @@ export interface IRLoop {
      */
     method?: 'flatMap';
     array: string;
+    /**
+     * Structured parse of `array` (`parseExpression(array.trim())`), attached
+     * during IR construction so adapters lower the loop's array from the tree
+     * instead of re-parsing the string (e.g. the Go adapter's scalar-literal
+     * loop typing). Optional/best-effort — mirrors `IRExpression.parsed`;
+     * consumers fall back to parsing `array`.
+     */
+    arrayParsed?: ParsedExpr;
     /** Pre-transformed array expr with destructured prop refs rewritten to _p.xxx. */
     templateArray?: string;
     arrayType: TypeInfo | null;
@@ -336,14 +383,16 @@ export interface IRLoop {
      * When present, the loop renders with an if-condition wrapping each iteration.
      * Example: todos.filter(t => !t.done).map(...) stores { param: 't', predicate: ParsedExpr, raw: '!t.done' }
      *
-     * For block-body filters like:
+     * Block-body filters like
      *   filter(t => { const f = filter(); if (f === 'active') return !t.done; return true })
-     * The blockBody field contains the parsed statements.
+     * are normalized to a single boolean `predicate` expression at IR-build time
+     * (#2040, `foldBlockToExpr` + `predicateTernaryToLogical` in `jsx-to-ir`), so
+     * adapters only ever see the unified expression form — there is no separate
+     * block-statement shape to lower.
      */
     filterPredicate?: {
         param: string;
         predicate?: ParsedExpr;
-        blockBody?: ParsedStatement[];
         raw: string;
     };
     /**
@@ -351,14 +400,14 @@ export interface IRLoop {
      * When present, the loop array is sorted before iteration.
      * Example: todos.sort((a, b) => a.priority - b.priority).map(...)
      *
-     * The structured shape carries enough info for both adapters to
-     * emit the same `bf_sort` / `bf->sort` call (`SortComparator` is
-     * defined in `expression-parser.ts` because the standalone
-     * `array-method` IR variant uses the same type). The loop-hoist
-     * path lifts a comparator off a sibling `array-method` node
-     * during `jsx-to-ir.ts` chain detection — see `extractSortComparator`.
+     * The {@link IRLoopSort} struct carries the generic comparator `arrow`
+     * (params + body) the SSR adapter serializes to the runtime evaluator
+     * (eval-first; `sortComparatorFromArrow` fallback for `localeCompare`), plus
+     * the param names + raw body for the client JS round-trip. Lifted off the
+     * `.sort()` callback during `jsx-to-ir.ts` chain detection — see
+     * `extractSortComparator`. (#2018 P5)
      */
-    sortComparator?: SortComparator;
+    sortComparator?: IRLoopSort;
     /**
      * When both filter and sort are chained, indicates the order of operations.
      * 'filter-sort': filter first, then sort (e.g., filter().sort().map())
@@ -595,6 +644,13 @@ export interface IRIfStatement {
     condition: string;
     /** Pre-transformed condition with destructured prop refs rewritten to _p.xxx. */
     templateCondition?: string;
+    /**
+     * Structured parse of `condition` (`parseExpression(condition.trim())`),
+     * attached during IR construction so adapters lower the condition from the
+     * tree instead of re-parsing the string. Optional/best-effort — see
+     * `IRExpression.parsed`; consumers fall back to parsing `condition`.
+     */
+    parsedCondition?: ParsedExpr;
     /** The JSX return in the then branch */
     consequent: IRNode;
     /** The else branch: either another IRIfStatement (else if) or IRNode (final else) */
@@ -686,6 +742,14 @@ export interface ExpressionAttr {
     /** `expr` with destructured prop refs rewritten to `_p.xxx`, for SSR
      *  template inlining. Absent when no rewrite was needed. */
     templateExpr?: string;
+    /**
+     * Structured parse of `expr` (`parseExpression(expr.trim())`), attached
+     * during IR construction so adapters lower the attribute value from the tree
+     * instead of re-parsing the string (often several times per attribute).
+     * Optional/best-effort — see `IRExpression.parsed`; consumers fall back to
+     * parsing `expr`.
+     */
+    parsed?: ParsedExpr;
     /** Set when the producer peeled an `expr || undefined` boolean-presence
      *  pattern; adapters fold this back into `(expr) || undefined` at emit. */
     presenceOrUndefined?: boolean;
@@ -716,6 +780,16 @@ export interface SpreadAttr {
     kind: 'spread';
     expr: string;
     templateExpr?: string;
+    /**
+     * Structured parse of `expr` (`parseExpression(expr.trim())`), attached
+     * during IR construction so adapters lower the spread bag from the tree
+     * instead of re-parsing the string with `ts.createSourceFile`. Optional /
+     * best-effort — mirrors `ExpressionAttr.parsed`: it may be absent (a node the
+     * attach walk misses, or an empty `expr`), and parsing may yield
+     * `{ kind: 'unsupported' }`, which adapters treat as unlowerable and handle
+     * via their existing non-conditional spread paths (or BF101).
+     */
+    parsed?: ParsedExpr;
     /**
      * Component-scoped, stable slot ID assigned at IR-build time for
      * adapters that need to plumb the spread bag through a structured
@@ -837,6 +911,14 @@ export interface SignalInfo {
     getter: string;
     setter: string | null;
     initialValue: string;
+    /**
+     * `initialValue` parsed into a structured tree (Roadmap A). Attached
+     * best-effort by the analyzer so adapters can lower a literal initial value
+     * (e.g. `useState(['a', 'b'])`) from structure instead of re-parsing the
+     * string with `ts.createSourceFile`. Absent when the shape isn't supported;
+     * consumers fall back to parsing `initialValue`.
+     */
+    parsed?: ParsedExpr;
     /** Initial value with TypeScript type annotations preserved, for .tsx output */
     typedInitialValue?: string;
     type: TypeInfo;
@@ -873,12 +955,78 @@ export interface SignalInfo {
     isModule?: boolean;
     /** When true, the declaration carries an `export` keyword. */
     isExported?: boolean;
+    /**
+     * Request-scoped environment-signal key when this signal was produced by an
+     * env-signal factory (`createSearchParams()` → `'search'`), rather than by
+     * `createSignal`. Set structurally by the analyzer (#2057) — the getter is a
+     * normal reactive getter (so it lands in the fold purity oracle for free, no
+     * name allow-list), but its *value* is a request-scoped reader with methods
+     * (`.get(key)`), which adapters lower to their per-request reader object
+     * instead of a plain template field. This flag is how adapters recognise an
+     * env signal from structure instead of matching the import name.
+     */
+    envReader?: string;
+    /**
+     * For an env signal (`envReader` set), the exact callee text of its factory
+     * call as written — `'createSearchParams'`, an alias (`'csp'` for
+     * `import { createSearchParams as csp }`), or a namespace access
+     * (`'bf.createSearchParams'`). Backends that re-emit the declaration (client
+     * JS, JSX/Hono SSR) emit `<envFactory>()` so the call resolves to the binding
+     * actually in scope, not a hardcoded canonical name (#2057).
+     */
+    envFactory?: string;
 }
 export interface MemoInfo {
     name: string;
     computation: string;
     /** Computation with TypeScript type annotations preserved, for .tsx output */
     typedComputation?: string;
+    /**
+     * Structured parse of the memo's BODY as a single value expression, computed
+     * once at analysis time. Lets adapters pattern-match the memo's shape on the
+     * structured tree instead of re-parsing `computation` with their own AST walks
+     * / regexes.
+     *
+     * Set for an expression-bodied arrow (`() => <body>`) whose body
+     * `parseExpression` supports, AND — since #2040 — for a block-bodied memo
+     * (`() => { … }`) whose statements `foldBlockToExpr` can normalize to one
+     * expression (`let`-inline + value `if` / early `return` → ternary). A block
+     * the fold refuses (imperative residue) or a shape `parseExpression` can't
+     * represent leaves `parsed` undefined, so consumers must still fall back to
+     * `parsedBlock` / `computation` when it's missing. NOTE: a present `parsed`
+     * therefore no longer implies an expression-bodied arrow.
+     */
+    parsed?: ParsedExpr;
+    /**
+     * Whether the memo's effective body is a template literal (`() => `…`` or a
+     * block body whose first `return` is one), classified once at analysis time
+     * from the real arrow AST. Lets the Go adapter pick the `string` field type
+     * without re-parsing `computation` with `ts.createSourceFile`. A template
+     * literal — including a no-substitution `` `plain` `` — folds to a plain
+     * string `ParsedExpr` literal, losing the backtick distinction, so this is a
+     * dedicated flag rather than a `parsed.kind` check.
+     */
+    bodyIsTemplateLiteral?: boolean;
+    /**
+     * A block-bodied memo's statements, parsed best-effort (tolerant: a statement
+     * the parser can't represent is omitted). Lets the Go adapter pattern-match
+     * block-body memo shapes — e.g. the `const k = getter(); if (!k) return CONST`
+     * guard — on the structured statements instead of re-parsing `computation`
+     * with `ts.createSourceFile`. Absent for expression-bodied memos (those carry
+     * `parsed` instead) and when the arrow has no block body.
+     */
+    parsedBlock?: ParsedStatement[];
+    /**
+     * Whether {@link parsedBlock} represents EVERY statement of the block (true)
+     * or the tolerant parser omitted at least one it couldn't represent (false).
+     * A consumer that must reason about the whole block — e.g. one that bails on
+     * any statement it doesn't recognise (the template-literal memo lowering) —
+     * reads this and falls back when it's `false`, since omitted statements are
+     * otherwise invisible. Consumers that scan for a recognised prefix and ignore
+     * the rest (the guard-and-return-const lowering) can disregard it. Only set
+     * when `parsedBlock` is.
+     */
+    parsedBlockComplete?: boolean;
     type: TypeInfo;
     deps: string[];
     loc: SourceLocation;
@@ -1069,6 +1217,17 @@ export interface FunctionInfo {
 export interface ConstantInfo {
     name: string;
     value?: string;
+    /**
+     * `value` parsed into a structured tree (Roadmap A). Attached best-effort by
+     * the analyzer (parsed from the parenthesised value so a bare object literal
+     * — which TS reads as a block at statement position — resolves to an
+     * `object-literal` rather than failing). Lets adapters lower a constant value
+     * (e.g. a module-scope record's `{ … }`) from structure instead of
+     * re-parsing the string with `ts.createSourceFile`. Absent when the constant
+     * has no `value` string (e.g. an inlined-JSX const) or when the analyzer
+     * couldn't structure it (best-effort — consumers fall back to the string).
+     */
+    parsed?: ParsedExpr;
     /** Value with TypeScript type annotations preserved, for .tsx output */
     typedValue?: string;
     valueBranches?: string[];
@@ -1152,6 +1311,16 @@ export interface IRMetadata {
      * resolves the compiled module rather than the source `.tsx`.
      */
     clientSignalImportSources?: Set<string>;
+    /**
+     * Backend-neutral SSR seed plan: per-binding derived/opaque/env-reader
+     * classification in declaration order, plus the base scope, computed by
+     * `computeSsrSeedPlan` from this metadata. Attached by `buildMetadata` and
+     * serialized into IR JSON like the rest of the metadata; template adapters
+     * consume it instead of re-deriving scope/derivability themselves (their
+     * target-syntax choices — lowering, self-shadow rules, constant-emit
+     * guards — stay adapter-side).
+     */
+    ssrSeedPlan?: SsrSeedPlan;
 }
 /**
  * Where a reference appears in the emitted client JS. The emitter's rule