diff --git a/deno.json b/deno.json
index 6af1b42e71..8abeaae28d 100644
--- a/deno.json
+++ b/deno.json
@@ -1,6 +1,6 @@
 {
   "name": "veryfront",
-  "version": "0.1.993",
+  "version": "0.1.994",
   "license": "Apache-2.0",
   "nodeModulesDir": "auto",
   "minimumDependencyAge": {
diff --git a/src/html/html-injection.test.ts b/src/html/html-injection.test.ts
index 7727ecb6a4..3fa21138ab 100644
--- a/src/html/html-injection.test.ts
+++ b/src/html/html-injection.test.ts
@@ -108,6 +108,66 @@ describe("html/html-injection", () => {
       assertEquals(hydrationData.clientModuleStrategy, "rsc-module");
     });
 
+    it("seeds route params into client-page hydration data (issue #2741)", () => {
+      const html = injectHTMLContent(
+        baseTemplate,
+        "<p>content</p>",
+        minMeta,
+        {
+          mode: "production",
+          slug: "docs/guides/intro",
+          pagePath: "/app/page.tsx",
+          isClientPage: true,
+          params: { slug: ["guides", "intro"] },
+        },
+      );
+
+      const hydrationData = extractHydrationData(html);
+      // Catch-all arrays are preserved in the payload; the client runtime joins
+      // them when seeding the router (issue #2742).
+      assertEquals(hydrationData.params, { slug: ["guides", "intro"] });
+    });
+
+    it("escapes </script> in route params so the hydration payload cannot break out (XSS)", () => {
+      const payload = "</script><script>globalThis.pwned=1</script>";
+      const html = injectHTMLContent(
+        baseTemplate,
+        "<p>content</p>",
+        minMeta,
+        {
+          mode: "production",
+          slug: "test",
+          pagePath: "/app/page.tsx",
+          isClientPage: true,
+          params: { slug: [payload] },
+        },
+      );
+
+      // The literal breakout sequence must not appear anywhere in the output;
+      // jsonForInlineScript encodes `<` as \\u003c inside the JSON value.
+      assertEquals(html.includes("<script>globalThis.pwned=1</script>"), false);
+      // Round-trips losslessly: if the payload had broken out of the tag, the
+      // extractor's non-greedy `</script>` match would truncate the JSON and
+      // JSON.parse would throw here.
+      assertEquals(extractHydrationData(html).params, { slug: [payload] });
+    });
+
+    it("defaults client-page hydration params to an empty object when unset", () => {
+      const html = injectHTMLContent(
+        baseTemplate,
+        "<p>content</p>",
+        minMeta,
+        {
+          mode: "production",
+          slug: "test",
+          pagePath: "/app/page.tsx",
+          isClientPage: true,
+        },
+      );
+
+      assertEquals(extractHydrationData(html).params, {});
+    });
+
     it("keeps production client-page injection on the RSC client boot script", () => {
       const html = injectHTMLContent(
         baseTemplate,
diff --git a/src/html/html-injection.ts b/src/html/html-injection.ts
index 2b018e1b12..a59cc60044 100644
--- a/src/html/html-injection.ts
+++ b/src/html/html-injection.ts
@@ -8,6 +8,7 @@ import {
   generateStyleTags,
 } from "./tag-generators.ts";
 import { buildNonceAttribute } from "./html-escape.ts";
+import { jsonForInlineScript } from "#veryfront/security/client/html-sanitizer.ts";
 import {
   getDevScripts,
   getDevStyles,
@@ -26,6 +27,13 @@ export interface InjectHTMLContentOptions {
   projectDir?: string;
   /** Whether the page has 'use client' directive */
   isClientPage?: boolean;
+  /**
+   * Route params from the initial match, seeded into the 'use client' hydration
+   * payload so full-HTML-document client pages hydrate with their params
+   * instead of an empty object (issue #2741). Catch-all arrays are preserved;
+   * the client runtime joins them (issue #2742).
+   */
+  params?: Record<string, string | string[]>;
   /** Whether page is embedded in Studio iframe */
   studioEmbed?: boolean;
   /** Project ID for Studio communication */
@@ -114,10 +122,15 @@ export function injectHTMLContent(
 
   // Inject hydration data for 'use client' pages (before scripts, so client.js can find it)
   if (options.pagePath && options.isClientPage && hasBodyClose) {
-    const hydrationData = JSON.stringify({
+    // Serialize with jsonForInlineScript, not raw JSON.stringify: route params
+    // (and slug) are URL-derived and decoded, so a segment like `%3C/script%3E`
+    // would otherwise break out of the <script> tag (reflected XSS). This escapes
+    // `<`, `>`, `&`, and line separators, matching the main shell hydration path.
+    const hydrationData = jsonForInlineScript({
       pagePath: toProjectRelativePath(options.pagePath, options.projectDir),
       slug: options.slug,
       isClientPage: true,
+      params: options.params ?? {},
       clientModuleStrategy: determineClientModuleStrategy({
         isLocalProject: options.isLocalProject ?? options.mode === "development",
         environment: options.environment,
diff --git a/src/html/hydration-script-builder/templates/renderer.test.ts b/src/html/hydration-script-builder/templates/renderer.test.ts
index f468ca7028..3940d333e8 100644
--- a/src/html/hydration-script-builder/templates/renderer.test.ts
+++ b/src/html/hydration-script-builder/templates/renderer.test.ts
@@ -72,8 +72,10 @@ describe("hydration-script-builder/templates/renderer", () => {
       assertIncludes(getRendererScript(), "pageModule.default || pageModule");
     });
 
-    it("should merge props with params", () => {
-      assertIncludes(getRendererScript(), "...(data.props || {}), params: data.params || {}");
+    it("should merge props with normalized params", () => {
+      const result = getRendererScript();
+      assertIncludes(result, "const normalizedParams = normalizeRouteParams(data.params)");
+      assertIncludes(result, "...(data.props || {}), params: normalizedParams");
     });
 
     it("should wrap with layouts from innermost to outermost", () => {
@@ -108,7 +110,7 @@ describe("hydration-script-builder/templates/renderer", () => {
       const result = getRendererScript();
       assertIncludes(result, "slug: data.slug");
       assertIncludes(result, "path: data.pagePath");
-      assertIncludes(result, "params: data.params");
+      assertIncludes(result, "params: normalizedParams");
       assertIncludes(result, "frontmatter: data.frontmatter");
       assertIncludes(result, "headings,");
     });
diff --git a/src/html/hydration-script-builder/templates/renderer.ts b/src/html/hydration-script-builder/templates/renderer.ts
index 03bd596349..4b22a27436 100644
--- a/src/html/hydration-script-builder/templates/renderer.ts
+++ b/src/html/hydration-script-builder/templates/renderer.ts
@@ -112,7 +112,11 @@ export const getRendererScript = () => `
           return;
         }
 
-        const pageProps = { ...(data.props || {}), params: data.params || {} };
+        // Normalize catch-all params (arrays -> joined strings) so the hydrated
+        // props and page context match the server render. normalizeRouteParams
+        // is defined in router.ts, which loads first (issue #2742).
+        const normalizedParams = normalizeRouteParams(data.params);
+        const pageProps = { ...(data.props || {}), params: normalizedParams };
         let tree = React.createElement(PageComponent, pageProps);
 
         const layouts = data.layouts;
@@ -143,7 +147,7 @@ export const getRendererScript = () => `
         const pageContext = {
           slug: data.slug || '',
           path: data.pagePath || resolvedPathname,
-          params: data.params || {},
+          params: normalizedParams,
           query: Object.fromEntries(new URLSearchParams(window.location.search)),
           frontmatter: data.frontmatter || {},
           headings,
diff --git a/src/html/hydration-script-builder/templates/router.test.ts b/src/html/hydration-script-builder/templates/router.test.ts
index 68bc18403d..313d36b0c7 100644
--- a/src/html/hydration-script-builder/templates/router.test.ts
+++ b/src/html/hydration-script-builder/templates/router.test.ts
@@ -317,6 +317,24 @@ describe("hydration-script-builder/templates/router", () => {
       assertIncludes(getRouterScript(), "window.__veryfrontRouter = router");
     });
 
+    it("should normalize route params joining catch-all segments", () => {
+      const result = getRouterScript();
+      assertIncludes(result, "function normalizeRouteParams(raw)");
+      assertIncludes(result, "Array.isArray(value) ? value.join('/') : value");
+    });
+
+    it("should refresh router params during SPA and popstate navigation", () => {
+      const result = getRouterScript();
+      assertIncludes(
+        result,
+        "window.__veryfrontRouter.params = normalizeRouteParams(pageData.params);",
+      );
+      assertIncludes(
+        result,
+        "window.__veryfrontRouter.params = normalizeRouteParams(e.state.pageData.params);",
+      );
+    });
+
     it("should handle popstate events for browser back/forward", () => {
       assertIncludes(getRouterScript(), "addEventListener('popstate'");
     });
@@ -376,4 +394,250 @@ describe("hydration-script-builder/templates/router", () => {
       assertIncludes(getRouterScript(), "document.title = pageData.frontmatter.title");
     });
   });
+
+  // Executable coverage: evaluate the generated browser runtime in a stubbed
+  // DOM so a future edit can't keep the string tokens while breaking the actual
+  // hydration-data parsing, param normalization, or SPA/popstate param updates.
+  describe("generated router runtime (executable)", () => {
+    interface RuntimeLocation {
+      origin: string;
+      pathname: string;
+      search: string;
+      readonly href: string;
+    }
+    interface RuntimeRouter {
+      params: Record<string, string>;
+      pathname: string;
+      query: Record<string, string>;
+      navigate(path: string): Promise<void>;
+      push(path: string): void;
+    }
+    interface RuntimeWindow {
+      location: RuntimeLocation;
+      history: { pushState(): void; back(): void; forward(): void };
+      addEventListener(type: string, fn: (e: unknown) => void): void;
+      dispatchEvent(): boolean;
+      scrollTo(): void;
+      scrollY: number;
+      __veryfrontRouter?: RuntimeRouter;
+      __veryfrontHydrationComplete?: () => void;
+    }
+    interface RuntimeHandle {
+      router: RuntimeRouter;
+      navigateSPA: (href: string, pushState?: boolean, restoreScroll?: boolean) => Promise<void>;
+      win: RuntimeWindow;
+      listeners: Record<string, Array<(e: unknown) => void>>;
+      setNextPageData: (data: unknown) => void;
+      // The router.params snapshot captured the moment renderPageFromData built
+      // the RouterProvider element — i.e. what the new page renders with. This is
+      // what the ordering bug (mutating params after render) would get wrong.
+      getRenderedParams: () => Record<string, string> | null;
+      // The `params` prop handed to the page component during render — must be
+      // normalized (joined) so it matches the server render.
+      getRenderedPageParams: () => Record<string, string> | null;
+    }
+
+    function evaluateRouterRuntime(
+      opts: {
+        pathname?: string;
+        search?: string;
+        hydrationParams?: Record<string, string | string[]>;
+      } = {},
+    ): RuntimeHandle {
+      const hydrationJson = JSON.stringify({ params: opts.hydrationParams ?? {} });
+      const listeners: Record<string, Array<(e: unknown) => void>> = {};
+      const addEventListener = (type: string, fn: (e: unknown) => void) => {
+        (listeners[type] ??= []).push(fn);
+      };
+
+      const makeEl = () => ({
+        style: {} as Record<string, unknown>,
+        id: "",
+        textContent: "",
+        setAttribute() {},
+        getAttribute() {
+          return null;
+        },
+        prepend() {},
+        remove() {},
+        appendChild() {},
+      });
+
+      const rootEl = { __reactRoot: { render() {} } };
+      const doc = {
+        readyState: "complete",
+        body: { prepend() {}, setAttribute() {}, removeAttribute() {}, appendChild() {} },
+        head: { appendChild() {} },
+        createElement: () => makeEl(),
+        querySelector: () => null,
+        querySelectorAll: () => [] as unknown[],
+        getElementById: (id: string) => {
+          if (id === "veryfront-hydration-data") return { textContent: hydrationJson };
+          if (id === "root") return rootEl;
+          return null;
+        },
+        addEventListener,
+      };
+
+      const win: RuntimeWindow = {
+        location: {
+          origin: "https://veryfront.test",
+          pathname: opts.pathname ?? "/",
+          search: opts.search ?? "",
+          get href() {
+            return "https://veryfront.test" + this.pathname + this.search;
+          },
+        },
+        history: { pushState() {}, back() {}, forward() {} },
+        addEventListener,
+        dispatchEvent() {
+          return true;
+        },
+        scrollTo() {},
+        scrollY: 0,
+      };
+
+      let nextPageData: unknown = { pagePath: "page", params: {} };
+      const fetchStub = () =>
+        Promise.resolve({
+          ok: true,
+          status: 200,
+          url: "/_veryfront/page-data/page.json",
+          headers: { get: () => null },
+          json: () => Promise.resolve(nextPageData),
+        });
+
+      const RouterProvider = () => ({});
+      const PageContextProvider = () => ({});
+      // Capture params exactly when the generated render builds elements, so the
+      // test reflects what the new page renders with (not the value the router
+      // settles on afterwards). renderedRouterParams = what RouterProvider sees;
+      // renderedPageParams = what the page component receives as its `params`
+      // prop (must be normalized so it matches the server render, issue #2742).
+      let renderedRouterParams: Record<string, string> | null = null;
+      let renderedPageParams: Record<string, string> | null = null;
+      const React = {
+        createElement: (
+          type: unknown,
+          props?: { router?: RuntimeRouter; params?: Record<string, string> },
+        ) => {
+          if (type === RouterProvider && props?.router) {
+            renderedRouterParams = { ...props.router.params };
+          } else if (props && "params" in props && renderedPageParams === null) {
+            renderedPageParams = { ...(props.params ?? {}) };
+          }
+          return {};
+        },
+      };
+      const loadComponent = () => Promise.resolve(() => null);
+
+      const factory = new Function(
+        "window",
+        "document",
+        "fetch",
+        "React",
+        "RouterProvider",
+        "PageContextProvider",
+        "loadComponent",
+        "setTimeout",
+        "clearTimeout",
+        getRouterScript() + "\nreturn { router, navigateSPA };",
+      );
+
+      const handle = factory(
+        win,
+        doc,
+        fetchStub,
+        React,
+        RouterProvider,
+        PageContextProvider,
+        loadComponent,
+        () => 0,
+        () => {},
+      ) as { router: RuntimeRouter; navigateSPA: RuntimeHandle["navigateSPA"] };
+
+      return {
+        router: handle.router,
+        navigateSPA: handle.navigateSPA,
+        win,
+        listeners,
+        setNextPageData: (data: unknown) => {
+          nextPageData = data;
+        },
+        getRenderedParams: () => renderedRouterParams,
+        getRenderedPageParams: () => renderedPageParams,
+      };
+    }
+
+    it("seeds router params from hydration data, joining catch-all segments", () => {
+      const { router } = evaluateRouterRuntime({
+        pathname: "/docs/guides/intro",
+        hydrationParams: { slug: ["guides", "intro"], lang: "en" },
+      });
+      assertEquals(router.params, { slug: "guides/intro", lang: "en" });
+    });
+
+    it("replaces stale params with new page data on SPA navigation", async () => {
+      const runtime = evaluateRouterRuntime({
+        pathname: "/posts/42",
+        hydrationParams: { id: "42" },
+      });
+      runtime.win.__veryfrontHydrationComplete?.();
+
+      runtime.setNextPageData({ pagePath: "page", params: { id: "99" } });
+      runtime.win.location.pathname = "/posts/99";
+      await runtime.navigateSPA("/posts/99", true);
+
+      assertEquals(runtime.router.params, { id: "99" });
+      assertEquals(runtime.router.pathname, "/posts/99");
+      // The new page must render with the fresh params — not the previous
+      // route's — which only holds if params are updated before render.
+      assertEquals(runtime.getRenderedParams(), { id: "99" });
+    });
+
+    it("normalizes catch-all params for both router and page props on SPA nav", () => {
+      const runtime = evaluateRouterRuntime({ pathname: "/", hydrationParams: {} });
+      runtime.win.__veryfrontHydrationComplete?.();
+
+      // Page data carries a raw catch-all array, as route matching produces it.
+      runtime.setNextPageData({ pagePath: "page", params: { slug: ["guides", "intro"] } });
+      return runtime.navigateSPA("/docs/guides/intro", true).then(() => {
+        // Both the router snapshot and the page component's `params` prop must
+        // be joined strings so client and server render identically (#2742).
+        assertEquals(runtime.router.params, { slug: "guides/intro" });
+        assertEquals(runtime.getRenderedParams(), { slug: "guides/intro" });
+        assertEquals(runtime.getRenderedPageParams(), { slug: "guides/intro" });
+      });
+    });
+
+    it("clears params when navigating to a static route", async () => {
+      const runtime = evaluateRouterRuntime({
+        pathname: "/posts/42",
+        hydrationParams: { id: "42" },
+      });
+      runtime.win.__veryfrontHydrationComplete?.();
+
+      runtime.setNextPageData({ pagePath: "page", params: {} });
+      await runtime.navigateSPA("/about", true);
+
+      assertEquals(runtime.router.params, {});
+      assertEquals(runtime.getRenderedParams(), {});
+    });
+
+    it("refreshes params from history state on popstate navigation", async () => {
+      const runtime = evaluateRouterRuntime({
+        pathname: "/posts/42",
+        hydrationParams: { id: "42" },
+      });
+      runtime.win.__veryfrontHydrationComplete?.();
+
+      runtime.win.location.pathname = "/posts/7";
+      const popstate = runtime.listeners.popstate?.[0];
+      if (!popstate) throw new Error("popstate handler was not registered");
+      await popstate({ state: { pageData: { pagePath: "page", params: { id: "7" } } } });
+
+      assertEquals(runtime.router.params, { id: "7" });
+      assertEquals(runtime.getRenderedParams(), { id: "7" });
+    });
+  });
 });
diff --git a/src/html/hydration-script-builder/templates/router.ts b/src/html/hydration-script-builder/templates/router.ts
index d0f724ee54..8943092952 100644
--- a/src/html/hydration-script-builder/templates/router.ts
+++ b/src/html/hydration-script-builder/templates/router.ts
@@ -604,13 +604,18 @@ export const getRouterScript = () => `
           window.history.pushState({ pageData, scrollY: 0 }, '', href);
         }
 
-        perfStart('nav:render:' + href);
-        await renderPageFromData(pageData, targetPath);
-        perfEnd('nav:render:' + href);
-
+        // Update the shared router snapshot BEFORE rendering. RouterProvider
+        // reads router.params during render, so mutating after renderPageFromData
+        // would leave the new page's first render with the previous route's
+        // params (issue #2741). pathname/query move up for the same reason.
         currentPath = targetPath;
         window.__veryfrontRouter.pathname = targetPath;
         window.__veryfrontRouter.query = Object.fromEntries(new URLSearchParams(window.location.search));
+        window.__veryfrontRouter.params = normalizeRouteParams(pageData.params);
+
+        perfStart('nav:render:' + href);
+        await renderPageFromData(pageData, targetPath);
+        perfEnd('nav:render:' + href);
 
         if (restoreScroll) {
           restoreScrollPosition(targetPath);
@@ -708,9 +713,15 @@ export const getRouterScript = () => `
         }
       }
 
+      // Normalize catch-all params (arrays -> joined strings) so page props and
+      // page context match the server render exactly. SSR emits joined strings
+      // via flattenRouteParams; without this the client would hand raw arrays to
+      // props and usePageContext() after navigation (issue #2742).
+      const normalizedParams = normalizeRouteParams(pageData.params);
+
       let tree = React.createElement(PageComponent, {
         ...pageData.props,
-        params: pageData.params
+        params: normalizedParams
       });
 
       if (pageData.layouts?.length) {
@@ -733,7 +744,7 @@ export const getRouterScript = () => `
       const pageContext = {
         slug: pageData.slug || '',
         path: pageData.pagePath || targetPath,
-        params: pageData.params || {},
+        params: normalizedParams,
         query: Object.fromEntries(new URLSearchParams(window.location.search)),
         frontmatter: pageData.frontmatter || {},
         headings: headingsArray,
@@ -951,6 +962,22 @@ export const getRouterScript = () => `
       }, IDLE_PREFETCH_DELAY_MS);
     }
 
+    // ============================================
+    // Route params normalization
+    // ============================================
+    // Catch-all segments arrive as arrays and are joined so no path info is
+    // lost, matching the server flattenRouteParams + RSC hydration normalizer.
+    function normalizeRouteParams(raw) {
+      const out = {};
+      if (!raw) return out;
+      for (const key in raw) {
+        const value = raw[key];
+        if (value === undefined) continue;
+        out[key] = Array.isArray(value) ? value.join('/') : value;
+      }
+      return out;
+    }
+
     // ============================================
     // Router object
     // ============================================
@@ -974,7 +1001,17 @@ export const getRouterScript = () => `
       },
       pathname: window.location.pathname,
       query: Object.fromEntries(new URLSearchParams(window.location.search)),
-      params: {},
+      // Seed route params from the hydration data (issue #2741). Catch-all
+      // segments arrive as arrays and are joined so no path info is lost.
+      params: (function () {
+        try {
+          const el = document.getElementById('veryfront-hydration-data');
+          const raw = (JSON.parse(el && el.textContent ? el.textContent : '{}') || {}).params || {};
+          return normalizeRouteParams(raw);
+        } catch (_) {
+          return {};
+        }
+      })(),
       isPreview: false,
       isMounted: true,
       navigate: (path) => navigateSPA(path, true),
@@ -999,10 +1036,14 @@ export const getRouterScript = () => `
 
       showNavigationProgress();
       try {
-        await renderPageFromData(e.state.pageData, path);
+        // Update the router snapshot before rendering so RouterProvider reads
+        // this route's params, not the previous route's (issue #2741).
         currentPath = path;
         window.__veryfrontRouter.pathname = path;
         window.__veryfrontRouter.query = Object.fromEntries(new URLSearchParams(window.location.search));
+        window.__veryfrontRouter.params = normalizeRouteParams(e.state.pageData.params);
+
+        await renderPageFromData(e.state.pageData, path);
 
         restoreScrollPosition(path);
         hideNavigationProgress();
diff --git a/src/rendering/layouts/layout-applicator.test.ts b/src/rendering/layouts/layout-applicator.test.ts
index 33dd8fc419..064c265a27 100644
--- a/src/rendering/layouts/layout-applicator.test.ts
+++ b/src/rendering/layouts/layout-applicator.test.ts
@@ -1,6 +1,7 @@
 import "#veryfront/schemas/_test-setup.ts";
 import { assertEquals } from "#veryfront/testing/assert.ts";
 import { describe, it } from "#veryfront/testing/bdd.ts";
+import { flattenRouteParams } from "#veryfront/routing";
 import type { LayoutApplicationOptions } from "./layout-applicator.ts";
 
 function isDotPath(pageFilePath: string): boolean {
@@ -27,13 +28,9 @@ function buildSSRRouter(
   replace: () => void;
   reload: () => void;
 } {
-  const flatParams = params
-    ? Object.fromEntries(
-      Object.entries(params)
-        .map(([key, value]) => [key, Array.isArray(value) ? value[0] : value])
-        .filter((entry): entry is [string, string] => entry[1] !== undefined),
-    )
-    : {};
+  // Mirror production: reuse the shared helper so this test can't drift back
+  // to the old first-segment-only contract (issue #2742).
+  const flatParams = flattenRouteParams(params);
 
   return {
     domain: requestUrl?.origin ?? "",
@@ -123,12 +120,12 @@ describe("LayoutApplicator helpers", () => {
       assertEquals(router.query, {});
     });
 
-    it("should flatten params into string values", () => {
-      const url = new URL("https://example.com/blog/123");
-      const router = buildSSRRouter(url, "/pages/blog/[id].tsx", "blog/123", {
-        id: ["123", "ignored"],
+    it("should join catch-all params instead of dropping segments", () => {
+      const url = new URL("https://example.com/blog/123/extra");
+      const router = buildSSRRouter(url, "/pages/blog/[...id].tsx", "blog/123/extra", {
+        id: ["123", "extra"],
       });
-      assertEquals(router.params, { id: "123" });
+      assertEquals(router.params, { id: "123/extra" });
     });
 
     it("should handle URL with multiple search params", () => {
diff --git a/src/rendering/layouts/layout-applicator.ts b/src/rendering/layouts/layout-applicator.ts
index 06075ff35f..3a7af2de77 100644
--- a/src/rendering/layouts/layout-applicator.ts
+++ b/src/rendering/layouts/layout-applicator.ts
@@ -1,5 +1,6 @@
 import { dirname, join } from "#veryfront/compat/path";
 import { rendererLogger } from "#veryfront/utils";
+import { flattenRouteParams } from "#veryfront/routing";
 import * as BundledReact from "react";
 import type { RuntimeAdapter } from "#veryfront/platform/adapters/base.ts";
 import type { LayoutItem, MdxBundle, MDXComponents } from "#veryfront/types";
@@ -119,13 +120,7 @@ export class LayoutApplicator {
         const React = await getProjectReact();
 
         const headingsArray = this.headings ?? [];
-        const flatParams = this.params
-          ? Object.fromEntries(
-            Object.entries(this.params)
-              .map(([key, value]) => [key, Array.isArray(value) ? value[0] : value])
-              .filter((entry): entry is [string, string] => entry[1] !== undefined),
-          )
-          : {};
+        const flatParams = flattenRouteParams(this.params);
         const query = this.requestUrl ? Object.fromEntries(this.requestUrl.searchParams) : {};
         const pageContext = {
           slug: pageInfo.entity.slug || "",
diff --git a/src/rendering/orchestrator/html.ts b/src/rendering/orchestrator/html.ts
index c72de922dd..f7abca4d4b 100644
--- a/src/rendering/orchestrator/html.ts
+++ b/src/rendering/orchestrator/html.ts
@@ -275,6 +275,7 @@ export class HTMLGenerator {
       pagePath,
       projectDir: this.config.projectDir,
       isClientPage,
+      params: context.options?.params,
       environment: context.options?.environment,
       isLocalProject: this.config.mode === "development",
       nonce: context.options?.nonce,
diff --git a/src/rendering/page-rendering.ts b/src/rendering/page-rendering.ts
index fec73ef161..a45eb9366c 100644
--- a/src/rendering/page-rendering.ts
+++ b/src/rendering/page-rendering.ts
@@ -6,6 +6,7 @@ import type { EntityInfo, MdxBundle, MDXComponents, MDXModule, PageBundle } from
 import { mdxRenderer } from "#veryfront/transforms/mdx/index.ts";
 import { clearMdxEsmCacheNamespace } from "#veryfront/transforms/mdx/esm-module-loader/index.ts";
 import { getProjectReact } from "#veryfront/react";
+import { flattenRouteParams } from "#veryfront/routing";
 import { compileContent } from "#veryfront/transforms/mdx/compiler/index.ts";
 import { ensureError, getErrorMessage } from "#veryfront/errors/veryfront-error.ts";
 import { withSpan } from "#veryfront/observability/tracing/otlp-setup.ts";
@@ -177,13 +178,7 @@ export function handleMDXPage(
 
         if (typeof mod.generateMetadata === "function") {
           try {
-            const params = options?.params
-              ? (Object.fromEntries(
-                Object.entries(options.params)
-                  .map(([k, v]) => [k, Array.isArray(v) ? v[0] : v])
-                  .filter((entry): entry is [string, string] => entry[1] !== undefined),
-              ) as Record<string, string>)
-              : {};
+            const params = flattenRouteParams(options?.params);
             const query = options?.url ? Object.fromEntries(options.url.searchParams) : {};
 
             const gen = await mod.generateMetadata({
diff --git a/src/rendering/script-page-handling.test.ts b/src/rendering/script-page-handling.test.ts
index c24f3a64a6..909b67f12d 100644
--- a/src/rendering/script-page-handling.test.ts
+++ b/src/rendering/script-page-handling.test.ts
@@ -2,6 +2,7 @@ import "#veryfront/schemas/_test-setup.ts";
 import { assertEquals, assertThrows } from "#veryfront/testing/assert.ts";
 import { describe, it } from "#veryfront/testing/bdd.ts";
 import { handleScriptPage } from "./script-page-handling.ts";
+import { flattenRouteParams } from "#veryfront/routing";
 import type { RuntimeAdapter } from "#veryfront/platform/adapters/base.ts";
 
 type ScriptModuleOutput =
@@ -47,13 +48,9 @@ function buildPageContext(
   params?: Record<string, string | string[]>,
   url?: URL,
 ): PageContext {
-  const flatParams: Record<string, string> = params
-    ? Object.fromEntries(
-      Object.entries(params)
-        .map(([k, v]) => [k, Array.isArray(v) ? v[0] : v])
-        .filter((entry): entry is [string, string] => entry[1] !== undefined),
-    )
-    : {};
+  // Mirror production: reuse the shared helper so this test can't drift back
+  // to the old first-segment-only contract (issue #2742).
+  const flatParams = flattenRouteParams(params);
 
   return {
     params: flatParams,
@@ -165,9 +162,9 @@ describe("script-page-handling helpers", () => {
       assertEquals(ctx.frontmatter, { title: "About" });
     });
 
-    it("should flatten array params to first element", () => {
+    it("should join catch-all array params instead of dropping segments", () => {
       const ctx = buildPageContext(mockPageInfo, "blog", { tags: ["a", "b"] });
-      assertEquals(ctx.params, { tags: "a" });
+      assertEquals(ctx.params, { tags: "a/b" });
     });
 
     it("should handle empty params", () => {
diff --git a/src/rendering/script-page-handling.ts b/src/rendering/script-page-handling.ts
index 59cf864dae..a3e56277dc 100644
--- a/src/rendering/script-page-handling.ts
+++ b/src/rendering/script-page-handling.ts
@@ -10,6 +10,7 @@ import { rewriteNpmImports } from "#veryfront/transforms/npm-import-rewrites.ts"
 import { dirname, join } from "#veryfront/compat/path/index.ts";
 import { cwd } from "#veryfront/platform/compat/process.ts";
 import { RENDER_ERROR } from "#veryfront/errors/error-registry.ts";
+import { flattenRouteParams } from "#veryfront/routing";
 import { createError, toError } from "#veryfront/errors/veryfront-error.ts";
 import type {
   ComponentProps,
@@ -128,13 +129,7 @@ function buildPageContext(
   params?: Record<string, string | string[]>,
   url?: URL,
 ): PageContext {
-  const flatParams: Record<string, string> = params
-    ? Object.fromEntries(
-      Object.entries(params)
-        .map(([k, v]) => [k, Array.isArray(v) ? v[0] : v])
-        .filter((entry): entry is [string, string] => entry[1] !== undefined),
-    )
-    : {};
+  const flatParams = flattenRouteParams(params);
 
   return {
     params: flatParams,
diff --git a/src/routing/api/context-builder.ts b/src/routing/api/context-builder.ts
index 30dc28bb05..02e6285055 100644
--- a/src/routing/api/context-builder.ts
+++ b/src/routing/api/context-builder.ts
@@ -1,6 +1,7 @@
 import type { RouteMatch } from "./api-route-matcher.ts";
 import type { FileSystemAdapter } from "#veryfront/platform/adapters/base.ts";
 import { parseCookies } from "#veryfront/utils/cookie-utils.ts";
+import { flattenRouteParams } from "../flatten-route-params.ts";
 
 export { parseCookies };
 
@@ -57,14 +58,12 @@ export function createContext(
   };
 }
 
+/**
+ * @deprecated Use {@link flattenRouteParams} directly. Kept as a thin alias so
+ * the routing barrel exposes a single flattener implementation (issue #2742).
+ */
 export function normalizeParams(
   params: Record<string, string | string[]>,
 ): Record<string, string> {
-  const out: Record<string, string> = {};
-
-  for (const [key, value] of Object.entries(params)) {
-    out[key] = Array.isArray(value) ? value.join("/") : value;
-  }
-
-  return out;
+  return flattenRouteParams(params);
 }
diff --git a/src/routing/flatten-route-params.test.ts b/src/routing/flatten-route-params.test.ts
new file mode 100644
index 0000000000..bf68d9885f
--- /dev/null
+++ b/src/routing/flatten-route-params.test.ts
@@ -0,0 +1,32 @@
+import { assertEquals } from "#veryfront/testing/assert.ts";
+import { describe, it } from "#veryfront/testing/bdd.ts";
+import { flattenRouteParams } from "./flatten-route-params.ts";
+
+describe("routing/flattenRouteParams", () => {
+  it("keeps a single dynamic segment as-is", () => {
+    assertEquals(flattenRouteParams({ id: "42" }), { id: "42" });
+  });
+
+  it("joins catch-all array segments instead of dropping them (issue #2742)", () => {
+    // Regression: the SSR flatteners used `value[0]`, truncating to "guides".
+    assertEquals(flattenRouteParams({ slug: ["guides", "intro"] }), { slug: "guides/intro" });
+  });
+
+  it("handles mixed params and skips undefined values", () => {
+    assertEquals(
+      flattenRouteParams({ id: "7", rest: ["a", "b", "c"], missing: undefined as never }),
+      { id: "7", rest: "a/b/c" },
+    );
+  });
+
+  it("returns an empty object for no params", () => {
+    assertEquals(flattenRouteParams(undefined), {});
+  });
+
+  it("maps an empty optional catch-all array to an empty string, keeping the key", () => {
+    // `[[...slug]]` matched at its base yields `{ slug: [] }`. Joining gives
+    // `""` (key retained) rather than dropping the key, matching the RSC/API/
+    // client normalizers so server and client agree on index routes.
+    assertEquals(flattenRouteParams({ slug: [] }), { slug: "" });
+  });
+});
diff --git a/src/routing/flatten-route-params.ts b/src/routing/flatten-route-params.ts
new file mode 100644
index 0000000000..7bfcc62f2d
--- /dev/null
+++ b/src/routing/flatten-route-params.ts
@@ -0,0 +1,20 @@
+/**
+ * Flattens matched route params (which may be arrays for catch-all `[...slug]`
+ * segments) into the `Record<string, string>` shape the router value exposes.
+ *
+ * Catch-all segments are **joined with `/`** so no path information is lost —
+ * `/docs/guides/intro` -> `{ slug: "guides/intro" }`, not `{ slug: "guides" }`.
+ * This matches the client SPA normalizer and the RSC hydration normalizer, so
+ * server and client agree.
+ */
+export function flattenRouteParams(
+  params?: Record<string, string | string[]>,
+): Record<string, string> {
+  if (!params) return {};
+  const flat: Record<string, string> = {};
+  for (const [key, value] of Object.entries(params)) {
+    if (value === undefined) continue;
+    flat[key] = Array.isArray(value) ? value.join("/") : value;
+  }
+  return flat;
+}
diff --git a/src/routing/index.ts b/src/routing/index.ts
index 8f3856cb8f..3f14d09ab3 100644
--- a/src/routing/index.ts
+++ b/src/routing/index.ts
@@ -6,6 +6,7 @@
  */
 
 export type { Route, RouteMatch } from "./matchers/index.ts";
+export { flattenRouteParams } from "./flatten-route-params.ts";
 export {
   getSpecificityScore,
   matchRoute,
diff --git a/src/utils/version-constant.ts b/src/utils/version-constant.ts
index 4b7d87ac10..8ad7058335 100644
--- a/src/utils/version-constant.ts
+++ b/src/utils/version-constant.ts
@@ -1,4 +1,4 @@
 // Keep in sync with deno.json version.
 // scripts/release.ts updates this constant during releases.
 /** Shared version value. */
-export const VERSION = "0.1.993";
+export const VERSION = "0.1.994";