@jay-framework/jay-stack-cli 0.24.7 → 0.25.1

package/agent-kit-template/contracts/GUIDE.md

@@ -60,11 +60,11 @@ See [syntax.md](syntax.md) for the full YAML format: tag types, phases, data typ
 
 Start with the simplest example that matches your use case, then add complexity as needed:
 
-| Example                                                | Complexity     | Key patterns                                                |
-| ------------------------------------------------------ | -------------- | ----------------------------------------------------------- |
-| [mini-cart](examples/mini-cart.md)                     | Trivial        | Variant + interactive refs                                  |
-| [cart-indicator](examples/cart-indicator.md)           | Simple         | Flat data, variants, phase choices                          |
-| [category-list](examples/category-list.md)             | Medium         | Props, repeated sub-contracts                               |
-| [product-card](examples/product-card.md)               | Medium-complex | Linked sub-contracts, variants, multiple ref types          |
-| [product-page](examples/product-page.md)               | Complex        | Params, nested repeated sub-contracts, linked sub-contracts |
-| [composing-contracts](examples/composing-contracts.md) | Pattern        | How contracts link together into a hierarchy                |
+| Example                                                                                                                                                         | Complexity     | Key patterns                                                |
+| --------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------- | ----------------------------------------------------------- |
+| [mini-cart](https://github.com/jay-framework/jay/blob/main/packages/jay-stack/stack-cli/agent-kit-template/contracts/examples/mini-cart.md)                     | Trivial        | Variant + interactive refs                                  |
+| [cart-indicator](https://github.com/jay-framework/jay/blob/main/packages/jay-stack/stack-cli/agent-kit-template/contracts/examples/cart-indicator.md)           | Simple         | Flat data, variants, phase choices                          |
+| [category-list](https://github.com/jay-framework/jay/blob/main/packages/jay-stack/stack-cli/agent-kit-template/contracts/examples/category-list.md)             | Medium         | Props, repeated sub-contracts                               |
+| [product-card](https://github.com/jay-framework/jay/blob/main/packages/jay-stack/stack-cli/agent-kit-template/contracts/examples/product-card.md)               | Medium-complex | Linked sub-contracts, variants, multiple ref types          |
+| [product-page](https://github.com/jay-framework/jay/blob/main/packages/jay-stack/stack-cli/agent-kit-template/contracts/examples/product-page.md)               | Complex        | Params, nested repeated sub-contracts, linked sub-contracts |
+| [composing-contracts](https://github.com/jay-framework/jay/blob/main/packages/jay-stack/stack-cli/agent-kit-template/contracts/examples/composing-contracts.md) | Pattern        | How contracts link together into a hierarchy                |

package/agent-kit-template/contracts/linked-contracts.md

@@ -72,4 +72,4 @@ The linked contract must have a tag matching the `trackBy` field.
 
 ## See Also
 
-- [composing-contracts example](examples/composing-contracts.md) — Real-world composition hierarchy from wix-stores
+- [composing-contracts example](https://github.com/jay-framework/jay/blob/main/packages/jay-stack/stack-cli/agent-kit-template/contracts/examples/composing-contracts.md) — Real-world composition hierarchy from wix-stores

package/agent-kit-template/designer/cli-commands.md

@@ -69,8 +69,15 @@ jay-stack validate -v
 
 # JSON output
 jay-stack validate --json
+
+# Tier 2: deeper checks against an existing build (needs `jay-stack build` first)
+jay-stack validate --tier-2
 ```
 
+The default run is **Tier 1** (fast, template-only). `--tier-2` adds deep checks against a build's output
+(dynamic-slug links, rendered-content links, per-instance meta) — see
+[validation-tier-2-guide.md](validation-tier-2-guide.md).
+
 Example output:
 
 ```

package/agent-kit-template/designer/contracts-and-plugins.md

@@ -327,4 +327,4 @@ For repeated lists, add a **boolean variant** (e.g. `hasItems`, `hasCategories`)
 <div if="hasCategories" forEach="categories" trackBy="_id">...</div>
 ```
 
-Alternatively, expose a **number** data tag (`itemCount`) and use numeric comparison: `if="itemCount===0"`. See [jay-html-template-syntax.md](jay-html-template-syntax.md#expression-limits-important) and [contracts/examples/category-list.md](../contracts/examples/category-list.md).
+Alternatively, expose a **number** data tag (`itemCount`) and use numeric comparison: `if="itemCount===0"`. See [jay-html-template-syntax.md](jay-html-template-syntax.md#expression-limits-important) and [contracts/examples/category-list.md](https://github.com/jay-framework/jay/blob/main/packages/jay-stack/stack-cli/agent-kit-template/contracts/examples/category-list.md).

package/agent-kit-template/designer/design-system-guide.md

@@ -148,8 +148,8 @@ component's **own** tags, and an optional `<style>` of **plain component CSS**.
 ```
 
 > **Author plain CSS here, not `@scope`.** In the template you write ordinary class rules
-> (`.ds-card { … }`). When a page flattens the element, `sync` copies this CSS into the page and rewrites it
-> into the canonical `@scope (.<ref>)` / `:scope` form for you — that scoped shape is a _page-side_ concern
+> (`.ds-card { … }`). When a page flattens the element, `sync` copies these rules into the page verbatim and
+> wraps them in a canonical `@scope (.<ref>)` block for you — that scoped wrapper is a _page-side_ concern
 > (see [The shape of a region's CSS](#the-shape-of-a-regions-css)); you don't write it in the template.
 
 ### 4. Choose the right axis of variation
@@ -217,7 +217,7 @@ the page's `<style>`, `@scope`-wrapped by the region's `ref`:
 
 ```html
 <jay:card ref="promo" heading="{title}">
-  <div class="card promo">
+  <div class="card">
     <h3 class="card-heading">{heading}</h3>
     <p class="card-body">Default body</p>
   </div>
@@ -226,7 +226,7 @@ the page's `<style>`, `@scope`-wrapped by the region's `ref`:
 
 ```css
 @scope (.promo) {
-  :scope {
+  .card {
     border: 1px solid #ccc;
     padding: 16px;
   }
@@ -236,8 +236,9 @@ the page's `<style>`, `@scope`-wrapped by the region's `ref`:
 }
 ```
 
-Note two things sync did to the CSS — both required for the styles to actually apply. **Write region CSS in
-this shape yourself**; the rules are below in [The shape of a region's CSS](#the-shape-of-a-regions-css).
+The flattened body is the template body **verbatim** — no synthetic class on the root — and the CSS is the
+component's own plain rules wrapped in one `@scope (.<ref>)` block. **Write region CSS in this shape
+yourself**; the rules are below in [The shape of a region's CSS](#the-shape-of-a-regions-css).
 
 > A bare `<jay:X>` with **no** flattened body is a hard error at build time — flatten it with `jay-stack
 sync` (first-fill is just the no-edits case of sync; there is no separate `add` command).
@@ -292,9 +293,9 @@ the second import its own region tag with `as=`:
 
 ## The shape of a region's CSS
 
-A region's CSS is the component's own CSS, copied into the page `<style>` and rewritten into a canonical
-form. `sync` produces this form and `validate` enforces it — but when you **hand-write or edit** a region's
-CSS, write it this way directly:
+A region's CSS is the component's own CSS, copied into the page `<style>` and wrapped in one `@scope` block.
+`sync` produces this form and `validate` enforces it — but when you **hand-write or edit** a region's CSS,
+write it this way directly:
 
 ### 1. Wrap the component's rules in `@scope (.<ref>)`
 
@@ -302,52 +303,47 @@ All of a region's rules live inside one `@scope` block keyed by the region's `re
 
 ```css
 @scope (.promo) {
-  /* …the card's rules… */
+  /* …the card's rules, as plain class selectors… */
 }
 ```
 
 This isolates the component's styles to that region — rules inside never leak out, and page rules outside
 never bleed in.
 
-### 2. The `ref` is a real class on the region root (scope-anchor)
-
-A jay `ref` is not emitted to the DOM, so `@scope (.promo)` would have nothing to match. The region root
-therefore carries the ref **as an actual class** — `<div class="card promo">` above. Keep that class on the
-root when you edit markup; it is what anchors the scope. (validate's drift check ignores this synthetic
-class, so it never shows up as drift.)
+### 2. Write plain class selectors — the ref is _not_ a class on your markup
 
-### 3. The component's own root rule targets `:scope`, not its block class
+A jay `ref` is not emitted to the DOM, so `@scope (.promo)` would have nothing to match. The compiler
+therefore synthesizes a `<div class="promo" style="display: contents">` **scope-anchor wrapper** around the
+region body at build time (DL#206). It is layout-transparent (`display:contents` generates no box) and you
+**never write it, see it in source, or style it** — it exists only so `.promo` has a real element to root at.
 
-This is the one that trips people up. **Inside `@scope (.<ref>) { … }`, a scoped selector matches
-_descendants_ of the scope root only — the scope root element itself is reachable solely through `:scope`.**
-So a rule for the region's own root element must be written as `:scope`, _not_ as the root's class:
+Because the wrapper is the scope root, your real roots are ordinary **descendants** of it. So every rule —
+including the component's own root element — is a **plain class selector**, exactly as authored in the
+template. Keep the template's classes on your markup unchanged; add **no** ref class:
 
 ```css
 @scope (.promo) {
-  :scope {
-    border: 1px solid #ccc;
-  } /* ✅ styles the region root (<div class="card promo">) */
   .card {
     border: 1px solid #ccc;
-  } /* ❌ never matches — .card IS the scope root, not a descendant */
+  } /* ✅ the region root — a plain class selector, matched as a descendant of the wrapper */
   .card-heading {
     color: black;
-  } /* ✅ descendant — plain class selector is correct */
+  } /* ✅ descendant — also a plain class selector */
 }
 ```
 
-Rule of thumb: the component's **root block class** → `:scope`; keep compounds and descendants on that
-class (`.card.active` → `:scope.active`, `.card .card-heading` → `:scope .card-heading`), and leave every
-**descendant/element** selector as its ordinary class.
+> **No `:scope` rewrite.** In the old model the root rule was rewritten to `:scope` and the ref was stamped
+> onto the root as a class. DL#206 removed both: page region CSS is now byte-for-byte the template's plain
+> rules, just wrapped in `@scope (.<ref>)`. `:scope` would now refer to the invisible wrapper — don't use it.
 
-### 4. Instances of the same component coalesce into one block
+### 3. Instances of the same component coalesce into one block
 
 When a page holds several regions flattened from the _same_ template, they share one `@scope` block with a
 selector list — never one duplicated block per `ref`:
 
 ```css
 @scope (.cardStarter, .cardPro) {
-  :scope {
+  .card {
     border: 1px solid #ccc;
   }
   .card-heading {
@@ -359,6 +355,21 @@ selector list — never one duplicated block per `ref`:
 Regions from _different_ templates stay in separate blocks. If you add a second instance by hand, fold its
 ref into the existing block's selector list rather than copying the block.
 
+### 4. A CSS-shipping region must have a `ref` (error)
+
+The `@scope (.<ref>)` anchor is derived from the region's `ref=`. A region whose `template=` ships CSS but
+whose `<jay:X>` tag has **no `ref`** has nothing to scope to — the materialiser cannot wrap the CSS and
+`jay-stack sync` silently drops it. `validate` catches this as a **hard error** (`REGION-CSS-NO-REF`, DL#209):
+
+```
+<jay:card> flattens template="./components/card/card.jay-html" which ships CSS, but the region has no ref=
+— so its CSS cannot be scoped and `jay-stack sync` will silently drop it.
+  → Add a ref= to the <jay:card> so sync can scope its CSS as an @scope (.<ref>) block and preserve it.
+```
+
+Fix it by adding a `ref` — there is no suppression, because the alternative (keeping the CSS unscoped) would
+leak the region's styles across the whole page.
+
 ## Drift: what `jay-stack validate` tells you
 
 Because the copy has a known source (its `template=`), `jay-stack validate` diffs the two and reports each
@@ -490,7 +501,8 @@ CSS reconciles the same way as markup — drift is overwritten, marked facets ar
   never rewritten.
 - A block that **diverges without any pragma** is unmarked CSS drift: `sync` overwrites it back to the
   canonical form, exactly as it re-flattens unmarked markup. (This is what lets `sync` _migrate_ a page to a
-  new canonical form — e.g. an older `.card { … }` root rule is rewritten to `:scope { … }`.)
+  new canonical form — e.g. an older `:scope { … }` / ref-on-root block is rewritten to the DL#206 form:
+  plain class rules wrapped in `@scope (.<ref>)`.)
 
 So after one `sync` a page's CSS is in canonical form, and a `validate`-clean page is one `sync` leaves
 unchanged. To keep a hand-edit through `sync`, mark it with a `jay:override` pragma.

package/agent-kit-template/designer/jay-html-styling.md

@@ -19,12 +19,13 @@ Add `<style>` blocks in `<head>`:
 </head>
 ```
 
-## Styling a design-system region (`@scope` + `:scope`)
+## Styling a design-system region (`@scope`)
 
 CSS for a `<jay:X>` **design-system element** (a region with `template=` provenance) is not written as plain
-page rules — it lives in an `@scope (.<ref>)` block, and the component's own root rule must target `:scope`,
-not its block class (inside `@scope`, a class selector matches descendants of the scope root only). This has
-its own rules and is covered in full in
+page rules — it lives in an `@scope (.<ref>)` block keyed by the region's `ref`. Inside that block you write
+the component's **plain class rules** exactly as authored in the template (`.ds-card { … }`); the compiler
+synthesizes a `display:contents` scope-anchor so `.<ref>` has something to match — you never write it or use
+`:scope`. This has its own rules and is covered in full in
 [design-system-guide.md → The shape of a region's CSS](design-system-guide.md#the-shape-of-a-regions-css).
 The plain-`<style>` patterns on this page apply to ordinary page markup.
 

package/agent-kit-template/designer/jay-html-template-syntax.md

@@ -240,7 +240,7 @@ Jay-html expressions resolve **contract or page tag names only**. They are **not
 | Empty list hint | `hasItems: boolean` variant  | `if="!hasItems"`     |
 | Count-based UI  | `itemCount: number` data tag | `if="itemCount===0"` |
 
-See [contracts/examples/category-list.md](../contracts/examples/category-list.md) (`hasCategories`).
+See [contracts/examples/category-list.md](https://github.com/jay-framework/jay/blob/main/packages/jay-stack/stack-cli/agent-kit-template/contracts/examples/category-list.md) (`hasCategories`).
 
 ### Common Errors
 

package/agent-kit-template/designer/validation-guide.md

@@ -27,6 +27,18 @@ So a warning about an `<img>` might come from a full-stack component's template,
 - **Errors** block the build. They must be fixed — there is no way to suppress them.
 - **Warnings** must be either fixed or explicitly suppressed. Do not ignore warnings — each one has a clear resolution path (add the missing attribute, or suppress via `<script type="application/jay-validations">`).
 
+**Broken internal links are errors** (DL#210). `validate` resolves every `<a href>` against the project's
+**static routes + public assets**. An href that resolves to nothing is an error: a placeholder (`href="#"` or
+empty), a typo, or a link to a page/asset that does not exist. Links that match a **dynamic** route pattern
+(e.g. `/blog/[slug]`) are **not** checked here — the concrete slug list isn't known at validate time — so they
+never false-error. External URLs, `mailto:`/`tel:`, in-page `#fragments`, and `{binding}` hrefs are skipped.
+Fix the path, use `<button>` for JS-driven anchors, or suppress per-page (see the `jay-stack` table below).
+
+One design-system rule is a **hard error**, not a warning: `REGION-CSS-NO-REF` (DL#209) — a `<jay:X>` region
+whose `template=` ships CSS but which has no `ref=`. Without a `ref` the CSS has no scope anchor, so `sync`
+silently drops it; the fix is to add a `ref` (see `design-system-guide.md` → _The shape of a region's CSS_).
+It is unsuppressible because the alternative would leak the region's styles across the whole page.
+
 ## How to Read Warnings
 
 Each warning has:
@@ -121,6 +133,7 @@ The core `jay-stack validate` emits four warnings that nudge you to reuse UI thr
 | `REGION-OVERRIDE-NON-CONTENT` | `jay-validations="REGION-OVERRIDE-NON-CONTENT"` on the import                                                                   |
 | `COMPONENT-NO-TEMPLATE`       | `jay-stack: allow-no-template: [Contract]`                                                                                      |
 | `NO-DESIGN-SYSTEM`            | `jay-stack: allow-no-design-system: true`                                                                                       |
+| Broken internal link (DL#210) | `jay-stack: allow-broken-links: true` (per-page — skips all link checks for that page)                                          |
 
 ```html
 <script type="application/jay-validations">
@@ -135,11 +148,55 @@ The core `jay-stack validate` emits four warnings that nudge you to reuse UI thr
 
 If a warning comes from dynamic content (`{post.content}`) or a generated file, you can't suppress it in the template. This is a validator limitation — the warning is a false positive. Don't loop trying to fix it.
 
+## Design-system scorecard (metrics to optimize)
+
+Below the warnings, `validate` prints a **report-only scorecard** (DL#207). It is **never** a pass/fail — it
+emits no warnings and never affects the exit code. It turns "prefer design-system elements" from a nudge into
+two numbers you can deliberately raise:
+
+- **Tag coverage** — of every contract tag/ref a page's regions _could_ bind, how many it actually binds.
+- **Design-system coverage %** — what share of a page's DOM elements come from `template=`-backed
+  design-system regions (vs. hand-authored markup). Higher = more of the page is built from the design system.
+- **Reuse** — how many catalogued templates are used **more than once** across the project. A design system
+  whose templates are each used once isn't really a design system.
+
+The healthy target: **most of each page is composed of design-system elements, and each template is reused
+more than once.** When building a page, prefer linking an existing template (raising coverage and reuse) over
+hand-authoring markup.
+
+By default the scorecard prints **one-line totals** for the whole project:
+
+```
+📦 Tag coverage: 100% (43/43 tags used across 10 page(s))
+📊 Design-system scorecard: 80% element coverage (74/92), 2 of 5 catalogued templates reused > 1
+   Run validate -v for per-page details.
+```
+
+Run with `-v` / `--verbose` to expand the **per-page** breakdown (coverage per file, which tags are unused,
+per-template reuse counts, and `⚠ low` flags on pages under 50% coverage).
+
+## Two validation tiers
+
+Validation comes in two tiers. This guide covers **Tier 1**, the always-on gate.
+
+**Tier 1 — always on (`jay-stack validate`)** is the fast, template-only gate. It reads your `.jay-html` files and
+route scan only — **no build needed** — so it's cheap enough for the hot agent loop and runs on every `validate`.
+Everything described in this guide is Tier 1. For links, Tier 1 (DL#210) resolves every hand-authored `<a href>`
+against the project's static routes + public assets and **errors** on broken internal links (typos, missing
+pages), degenerate `#` / empty placeholder links, and self-links. Links matching a **dynamic** route pattern
+(`/design-log/[...slug]`) are deferred — the concrete slug set isn't known without a build.
+
+**Tier 2 — opt-in, against a build (`jay-stack validate --tier-2`)** adds deeper checks that need a build:
+dynamic-slug links, broken links in rendered content, and per-instance meta/SEO. It's documented separately to
+keep this guide focused — see **`validation-tier-2-guide.md`**. Run it pre-deploy / in CI.
+
 ## Running Validation
 
 ```bash
-jay-stack validate              # validate all pages
-jay-stack validate --strict     # treat warnings as errors
+jay-stack validate                     # Tier 1: all pages (+ one-line scorecard totals)
+jay-stack validate -v                  # add per-page tag coverage + scorecard detail
+jay-stack validate --strict            # treat warnings as errors
+jay-stack validate --tier-2            # also run Tier 2 — see validation-tier-2-guide.md
 ```
 
 Validation runs automatically during `jay-stack build`. Warnings don't block the build; errors do (with `--strict`).

package/agent-kit-template/designer/validation-tier-2-guide.md

@@ -0,0 +1,64 @@
+# Tier 2 Validation — Deep Checks Against a Build
+
+`jay-stack validate` runs **Tier 1**: the fast, template-only gate (links, placeholders, coverage) that needs no
+build. See `validation-guide.md` for Tier 1.
+
+**Tier 2** (`jay-stack validate --tier-2`) adds deeper checks that are only possible once a build exists. This
+guide covers Tier 2 end to end.
+
+## What Tier 2 is
+
+Deep validation against an **existing build's output** (DL#211). It reads
+`build/v<version>/backend/route-manifest.json` plus the per-instance `*.cache.json` slow-render results. It does
+**not** run any render, so it's cheap — but it **requires a prior `jay-stack build`**. If no build is found, Tier 2
+reports a single actionable error (run `jay-stack build` first, or drop `--tier-2`).
+
+Run it **pre-deploy / in CI**, not in the hot authoring loop.
+
+```bash
+jay-stack validate --tier-2                      # validate against the highest build/v* output
+jay-stack validate --t2                          # short alias
+jay-stack validate --tier-2 --build-dir <dir>    # point at a specific build backend dir or build root
+```
+
+Tier 2 findings print under their own `📦 Tier 2 — build-output validation (--tier-2)` section, separate from the
+Tier 1 `📦 jay-stack (core)` section.
+
+## The three checks
+
+All run against the concrete URLs the build actually produced (routes × instances).
+
+1. **Deferred dynamic-slug links** (ERROR) — the template links Tier 1 could only defer (because they matched a
+   dynamic pattern like `/design-log/[...slug]`) are resolved against the real URL set. A link to a dynamic route
+   with a slug the build never generated (e.g. `/design-log/wix/index`) is caught here.
+
+2. **Broken links in rendered content** (WARNING) — `<a href>` found _inside_ the slow-rendered ViewState
+   (markdown bodies, descriptions) that resolve to a URL the build does not produce. Relative hrefs are resolved
+   against the instance's own URL. These are **warnings**, not errors, because content often doubles as repo/GitHub
+   docs where repo-relative links like `../pkg/foo.ts` are legitimately correct.
+
+3. **Per-instance meta/SEO** (mostly WARNING) — resolves each route's `headMeta` template against each instance's
+   slow ViewState and validates the concrete `<title>` / `<meta name="description">`:
+   - Empty title/description, a title > 60 chars, or a description > 160 chars → **warning**.
+   - A leftover unresolved `{binding}` (a field never produced at any phase) → **error**.
+   - Note (DL#189): a field bound to the fast/interactive phase is legitimately empty at slow render, so
+     **emptiness is only ever a warning, never an error**.
+
+If the build is older than your current source files, a **staleness warning** is emitted ("validated against a
+build from &lt;timestamp&gt;; source has changed since") suggesting a rebuild.
+
+## Suppressing Tier 2 findings
+
+Per-page, via the same `<script type="application/jay-validations">` block used for Tier 1, under the `jay-stack:`
+key:
+
+- `allow-broken-links: true` — suppresses link findings (both template and rendered-content links) for that page.
+- `allow-meta-issues: true` — suppresses meta/SEO findings for that page.
+
+```html
+<script type="application/jay-validations">
+  jay-stack:
+    allow-broken-links: true
+    allow-meta-issues: true
+</script>
+```

package/dist/{index-l6QVpvnY.js → index-BQbkAEhi.js}

@@ -411,6 +411,102 @@ function buildPagePartsConfig(pageParts, pageServerModule, pageExportName, build
     }))
   };
 }
+function crossProductParams(parts) {
+  if (parts.length === 0) return [];
+  if (parts.length === 1) return parts[0].values;
+  const logger = getLogger();
+  for (let i = 0; i < parts.length; i++) {
+    for (let j = i + 1; j < parts.length; j++) {
+      for (const key of parts[i].keys) {
+        if (parts[j].keys.has(key)) {
+          logger.warn(
+            `[Build] Multiple loadParams provide key "${key}" — using first provider`
+          );
+        }
+      }
+    }
+  }
+  let result = parts[0].values;
+  for (let i = 1; i < parts.length; i++) {
+    const next = parts[i].values;
+    const combined = [];
+    for (const a of result) {
+      for (const b of next) {
+        combined.push({ ...a, ...b });
+      }
+    }
+    result = combined;
+  }
+  return result;
+}
+function paramsMatchInferred(params, inferredParams, optionalSegments) {
+  return Object.entries(inferredParams).every(([k, v]) => {
+    if (optionalSegments?.has(k)) return true;
+    return params[k] === v;
+  });
+}
+function computeSpecificity(route) {
+  const dynamicCount = (route.rawRoute.match(/\[/g) || []).length;
+  const inferredCount = route.inferredParams ? Object.keys(route.inferredParams).length : 0;
+  const unresolvedCount = Math.max(0, dynamicCount - inferredCount);
+  return 0 - unresolvedCount;
+}
+function buildUrl(route, params) {
+  return route.rawRoute.replace(/\[\[(\w+)\]\]/g, (_, name) => {
+    const value = params[name];
+    if (!value) return "";
+    if (route.inferredParams?.[name] === value) return "";
+    return value;
+  }).replace(/\[(\w+)\]/g, (_, name) => params[name] || "").replace(/\/\/+/g, "/").replace(/\/$/, "") || "/";
+}
+function materializeRouteParams(routes, loadParamsResults) {
+  const entries = [];
+  for (const route of routes) {
+    const specificity = computeSpecificity(route);
+    if (!route.hasDynamicParams) {
+      const params = route.inferredParams || {};
+      entries.push({ route, params, url: route.rawRoute, specificity });
+      continue;
+    }
+    const allParams = loadParamsResults.get(route) || [];
+    for (const params of allParams) {
+      if (route.inferredParams && !paramsMatchInferred(params, route.inferredParams, route.optionalSegments)) {
+        continue;
+      }
+      let mergedParams = params;
+      if (route.inferredParams) {
+        mergedParams = { ...params };
+        for (const [k, v] of Object.entries(route.inferredParams)) {
+          if (!(k in mergedParams)) {
+            mergedParams[k] = v;
+          }
+        }
+      }
+      const url = buildUrl(route, mergedParams);
+      entries.push({ route, params: mergedParams, url, specificity });
+    }
+  }
+  return entries;
+}
+function dedupeByUrl(entries) {
+  const logger = getLogger();
+  const byUrl = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const existing = byUrl.get(entry.url);
+    if (!existing) {
+      byUrl.set(entry.url, entry);
+    } else if (entry.specificity > existing.specificity) {
+      byUrl.set(entry.url, entry);
+    }
+  }
+  const deduped = [...byUrl.values()];
+  if (deduped.length < entries.length) {
+    logger.info(
+      `[Build] Deduplication: ${entries.length} materialized → ${deduped.length} unique URLs`
+    );
+  }
+  return deduped;
+}
 function hashParams(params, suffix) {
   const sorted = Object.keys(params).sort().reduce(
     (acc, key) => {
@@ -472,10 +568,11 @@ async function buildInstance(route, params, pageModule, ctx, routeServerElementP
   );
   await fs.writeFile(pagePartsConfigPath, JSON.stringify(config, null, 2));
   logger.info(`[Build] Page parts config: ${routeDir}/page-parts.json`);
+  const pageUrl = buildUrl(route, params);
   const slowPhase = new DevSlowlyChangingPhase();
   const slowResult = await slowPhase.runSlowlyForPage(
     params,
-    { params },
+    { language: "en", url: pageUrl },
     pageParts.parts,
     pageParts.discoveredInstances,
     pageParts.headlessInstanceComponents,
@@ -501,7 +598,7 @@ async function buildInstance(route, params, pageModule, ctx, routeServerElementP
       {
         pageViewState: slowViewState,
         pageParams: params,
-        pageProps: { language: "en", url: "" }
+        pageProps: { language: "en", url: pageUrl }
       }
     );
     if (slowResult2) {
@@ -764,7 +861,12 @@ async function compileServerElement(jayHtmlContent, jayHtmlFilename, jayHtmlDir,
     cssFile = cssFilename;
   }
   getLogger().info(`[Build] Compiled server element: ${path__default.basename(outputPath)}`);
-  return { cssFile, cssImports, headMeta: parsedJayFile.headMeta };
+  return {
+    cssFile,
+    cssImports,
+    headMeta: parsedJayFile.headMeta,
+    scripts: parsedJayFile.scripts
+  };
 }
 async function compileRouteServerElement(jayHtmlPath, outputPath, projectRoot, tsConfigFilePath, minifyCss = true) {
   const jayHtmlContent = await fs.readFile(jayHtmlPath, "utf-8");
@@ -974,102 +1076,6 @@ async function buildInstanceClient(hydrateEntryPath, instanceId, outputDir, proj
   logger.info(`[Build] Client bundle: ${result.jsFile}`);
   return result;
 }
-function crossProductParams(parts) {
-  if (parts.length === 0) return [];
-  if (parts.length === 1) return parts[0].values;
-  const logger = getLogger();
-  for (let i = 0; i < parts.length; i++) {
-    for (let j = i + 1; j < parts.length; j++) {
-      for (const key of parts[i].keys) {
-        if (parts[j].keys.has(key)) {
-          logger.warn(
-            `[Build] Multiple loadParams provide key "${key}" — using first provider`
-          );
-        }
-      }
-    }
-  }
-  let result = parts[0].values;
-  for (let i = 1; i < parts.length; i++) {
-    const next = parts[i].values;
-    const combined = [];
-    for (const a of result) {
-      for (const b of next) {
-        combined.push({ ...a, ...b });
-      }
-    }
-    result = combined;
-  }
-  return result;
-}
-function paramsMatchInferred(params, inferredParams, optionalSegments) {
-  return Object.entries(inferredParams).every(([k, v]) => {
-    if (optionalSegments?.has(k)) return true;
-    return params[k] === v;
-  });
-}
-function computeSpecificity(route) {
-  const dynamicCount = (route.rawRoute.match(/\[/g) || []).length;
-  const inferredCount = route.inferredParams ? Object.keys(route.inferredParams).length : 0;
-  const unresolvedCount = Math.max(0, dynamicCount - inferredCount);
-  return 0 - unresolvedCount;
-}
-function buildUrl(route, params) {
-  return route.rawRoute.replace(/\[\[(\w+)\]\]/g, (_, name) => {
-    const value = params[name];
-    if (!value) return "";
-    if (route.inferredParams?.[name] === value) return "";
-    return value;
-  }).replace(/\[(\w+)\]/g, (_, name) => params[name] || "").replace(/\/\/+/g, "/").replace(/\/$/, "") || "/";
-}
-function materializeRouteParams(routes, loadParamsResults) {
-  const entries = [];
-  for (const route of routes) {
-    const specificity = computeSpecificity(route);
-    if (!route.hasDynamicParams) {
-      const params = route.inferredParams || {};
-      entries.push({ route, params, url: route.rawRoute, specificity });
-      continue;
-    }
-    const allParams = loadParamsResults.get(route) || [];
-    for (const params of allParams) {
-      if (route.inferredParams && !paramsMatchInferred(params, route.inferredParams, route.optionalSegments)) {
-        continue;
-      }
-      let mergedParams = params;
-      if (route.inferredParams) {
-        mergedParams = { ...params };
-        for (const [k, v] of Object.entries(route.inferredParams)) {
-          if (!(k in mergedParams)) {
-            mergedParams[k] = v;
-          }
-        }
-      }
-      const url = buildUrl(route, mergedParams);
-      entries.push({ route, params: mergedParams, url, specificity });
-    }
-  }
-  return entries;
-}
-function dedupeByUrl(entries) {
-  const logger = getLogger();
-  const byUrl = /* @__PURE__ */ new Map();
-  for (const entry of entries) {
-    const existing = byUrl.get(entry.url);
-    if (!existing) {
-      byUrl.set(entry.url, entry);
-    } else if (entry.specificity > existing.specificity) {
-      byUrl.set(entry.url, entry);
-    }
-  }
-  const deduped = [...byUrl.values()];
-  if (deduped.length < entries.length) {
-    logger.info(
-      `[Build] Deduplication: ${entries.length} materialized → ${deduped.length} unique URLs`
-    );
-  }
-  return deduped;
-}
 async function discoverPluginClientPackages(projectRoot) {
   const projectRequire = createRequire(path__default.join(projectRoot, "package.json"));
   const seen = /* @__PURE__ */ new Set();
@@ -1404,6 +1410,9 @@ async function buildVersion(options) {
           entry.noIndex = true;
         }
       }
+      if (seResult.scripts?.length) {
+        entry.scripts = seResult.scripts;
+      }
       logger.important(`[Build] Route server element: ${routeDir}`);
     } catch (err) {
       logger.error(`[Build] Route server element FAILED ${route.rawRoute}: ${err.message}`);