@real-router/solid 0.11.1 → 0.13.0

package/dist/types/dom-utils/scroll-restore.d.ts

@@ -1,4 +1,4 @@
-import type { Router } from "@real-router/core";
+import type { Router, State } from "@real-router/core";
 export type ScrollRestorationMode = "restore" | "top" | "native";
 export interface ScrollRestorationOptions {
     mode?: ScrollRestorationMode | undefined;
@@ -29,4 +29,41 @@ export interface ScrollRestorationOptions {
 export declare function createScrollRestoration(router: Router, options?: ScrollRestorationOptions): {
     destroy: () => void;
 };
+export declare function keyOf(state: State): string;
+/**
+ * Stable JSON serializer with sorted object keys.
+ *
+ * **Exported for testing only — not part of the public API** (intentionally
+ * excluded from `index.ts` barrel). Adapter property tests import it via
+ * the direct path to lock the key-order-insensitive property
+ * (`canonicalJson({a:1,b:2}) === canonicalJson({b:2,a:1})`).
+ *
+ * ## Divergence from `@real-router/sources/canonicalJson` — by design
+ *
+ * Two independent implementations live in the monorepo:
+ *
+ * - **`shared/dom-utils/scroll-restore.canonicalJson`** (this file) — scroll
+ *   cache key builder. Uses `localeCompare` and a plain-object accumulator;
+ *   tolerates `__proto__`-keyed inputs only insofar as `JSON.stringify`'s
+ *   replacer happens to sort them; relies on `JSON.stringify`'s native cycle
+ *   detector. Designed to be cheap on the navigation hot path. The
+ *   surrounding [[safeKeyOf]] wrapper catches the two crash inputs (`BigInt`,
+ *   cyclic) and skips the offending capture/restore.
+ *
+ * - **`@real-router/sources/canonicalJson`** — sources cache key builder.
+ *   Uses byte-order compare (`< / >`) for locale-independence, a
+ *   `Object.create(null)` accumulator to prevent prototype pollution, and a
+ *   bespoke path-based cycle detector (the native one cannot see the cloned
+ *   graph). Throws eagerly on `Map`/`Set`/`RegExp`/cycles — the caller falls
+ *   back to a non-cached source.
+ *
+ * **They are intentionally NOT interchangeable.** Aligning them would either
+ * regress scroll-restore performance (byte-order + recursive clone is heavier
+ * per call) or weaken the sources cache (locale dependence breaks
+ * deterministic cache keys across machines). No cross-package equivalence
+ * test exists or should be added; the relationship is "different invariants,
+ * different costs, different consumers." Audit-2 / audit-2026-05-17 §2
+ * documents the choice.
+ */
+export declare function canonicalJson(value: unknown): string;
 //# sourceMappingURL=scroll-restore.d.ts.map

package/dist/types/dom-utils/scroll-restore.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"scroll-restore.d.ts","sourceRoot":"","sources":["../../../src/dom-utils/scroll-restore.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAS,MAAM,mBAAmB,CAAC;AAUvD,MAAM,MAAM,qBAAqB,GAAG,SAAS,GAAG,KAAK,GAAG,QAAQ,CAAC;AAEjE,MAAM,WAAW,wBAAwB;IACvC,IAAI,CAAC,EAAE,qBAAqB,GAAG,SAAS,CAAC;IACzC,eAAe,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;IACtC,eAAe,CAAC,EAAE,CAAC,MAAM,WAAW,GAAG,IAAI,CAAC,GAAG,SAAS,CAAC;IACzD;;;;;;;;;;;OAWG;IACH,QAAQ,CAAC,EAAE,cAAc,GAAG,SAAS,CAAC;IACtC;;;;;;OAMG;IACH,UAAU,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CACjC;AAOD,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,MAAM,EACd,OAAO,CAAC,EAAE,wBAAwB,GACjC;IAAE,OAAO,EAAE,MAAM,IAAI,CAAA;CAAE,CAkMzB"}
+{"version":3,"file":"scroll-restore.d.ts","sourceRoot":"","sources":["../../../src/dom-utils/scroll-restore.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAC;AAUvD,MAAM,MAAM,qBAAqB,GAAG,SAAS,GAAG,KAAK,GAAG,QAAQ,CAAC;AAEjE,MAAM,WAAW,wBAAwB;IACvC,IAAI,CAAC,EAAE,qBAAqB,GAAG,SAAS,CAAC;IACzC,eAAe,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;IACtC,eAAe,CAAC,EAAE,CAAC,MAAM,WAAW,GAAG,IAAI,CAAC,GAAG,SAAS,CAAC;IACzD;;;;;;;;;;;OAWG;IACH,QAAQ,CAAC,EAAE,cAAc,GAAG,SAAS,CAAC;IACtC;;;;;;OAMG;IACH,UAAU,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CACjC;AAOD,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,MAAM,EACd,OAAO,CAAC,EAAE,wBAAwB,GACjC;IAAE,OAAO,EAAE,MAAM,IAAI,CAAA;CAAE,CAgQzB;AA2BD,wBAAgB,KAAK,CAAC,KAAK,EAAE,KAAK,GAAG,MAAM,CAY1C;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAEpD"}

package/dist/types/hooks/useDeferred.d.ts

@@ -0,0 +1,16 @@
+import type { Accessor } from "solid-js";
+/**
+ * Read a deferred promise published by `defer({ deferred: { <key>: Promise } })`
+ * inside an SSR data loader.
+ *
+ * Returns a Solid `Accessor<Promise<T>>` so the value tracks the active route
+ * — re-reading on navigation picks up the new state's deferred map. Wrap with
+ * `<Await name="key">{(value) => …}</Await>` (this package), which builds on
+ * `createResource` + `<Suspense>` for native Solid streaming.
+ *
+ * Returns a forever-pending promise when the key is missing — surfaces
+ * loader/consumer key drift as a visible Suspense fallback rather than a
+ * silent runtime error.
+ */
+export declare function useDeferred<T = unknown>(key: string): Accessor<Promise<T>>;
+//# sourceMappingURL=useDeferred.d.ts.map

package/dist/types/hooks/useDeferred.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDeferred.d.ts","sourceRoot":"","sources":["../../../src/hooks/useDeferred.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AAWzC;;;;;;;;;;;;GAYG;AACH,wBAAgB,WAAW,CAAC,CAAC,GAAG,OAAO,EAAE,GAAG,EAAE,MAAM,GAAG,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAS1E"}

package/dist/types/hooks/useNavigator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useNavigator.d.ts","sourceRoot":"","sources":["../../../src/hooks/useNavigator.tsx"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAEnD,eAAO,MAAM,YAAY,QAAO,SAQ/B,CAAC"}
+{"version":3,"file":"useNavigator.d.ts","sourceRoot":"","sources":["../../../src/hooks/useNavigator.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAEnD,eAAO,MAAM,YAAY,QAAO,SACoB,CAAC"}

package/dist/types/hooks/useRouteUtils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useRouteUtils.d.ts","sourceRoot":"","sources":["../../../src/hooks/useRouteUtils.tsx"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AAE3D,eAAO,MAAM,aAAa,QAAO,UAIhC,CAAC"}
+{"version":3,"file":"useRouteUtils.d.ts","sourceRoot":"","sources":["../../../src/hooks/useRouteUtils.tsx"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AA4B3D,eAAO,MAAM,aAAa,QAAO,UAehC,CAAC"}

package/dist/types/hooks/useRouter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useRouter.d.ts","sourceRoot":"","sources":["../../../src/hooks/useRouter.tsx"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAEhD,eAAO,MAAM,SAAS,QAAO,MAQ5B,CAAC"}
+{"version":3,"file":"useRouter.d.ts","sourceRoot":"","sources":["../../../src/hooks/useRouter.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAEhD,eAAO,MAAM,SAAS,QAAO,MACiB,CAAC"}

package/dist/types/index.d.ts

@@ -14,6 +14,7 @@ export { useRouteExit } from "./hooks/useRouteExit";
 export { useRouteEnter } from "./hooks/useRouteEnter";
 export { RouterProvider } from "./RouterProvider";
 export { RouterContext, RouteContext } from "./context";
+export type { RouterContextValue } from "./context";
 export { createSignalFromSource } from "./createSignalFromSource";
 export { createStoreFromSource } from "./createStoreFromSource";
 export type { LinkProps, RouteState } from "./types";

package/dist/types/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AAEnD,OAAO,EAAE,IAAI,EAAE,MAAM,mBAAmB,CAAC;AAEzC,OAAO,EAAE,mBAAmB,EAAE,MAAM,kCAAkC,CAAC;AAEvE,OAAO,EAAE,IAAI,EAAE,MAAM,mBAAmB,CAAC;AAEzC,OAAO,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAE9C,OAAO,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAEpD,OAAO,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAEtD,OAAO,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAE5C,OAAO,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAEpD,OAAO,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAEtD,OAAO,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAE9D,OAAO,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAC;AAElE,OAAO,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAEpD,OAAO,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAEtD,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAElD,OAAO,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAExD,OAAO,EAAE,sBAAsB,EAAE,MAAM,0BAA0B,CAAC;AAElE,OAAO,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAC;AAEhE,YAAY,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAErD,YAAY,EAAE,wBAAwB,EAAE,MAAM,kCAAkC,CAAC;AAEjF,YAAY,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AAE9D,YAAY,EACV,cAAc,EACd,mBAAmB,EACnB,kBAAkB,EAClB,sBAAsB,GACvB,MAAM,wBAAwB,CAAC;AAEhC,YAAY,EACV,gBAAgB,EAChB,gBAAgB,EAChB,mBAAmB,GACpB,MAAM,sBAAsB,CAAC;AAE9B,YAAY,EACV,iBAAiB,EACjB,iBAAiB,EACjB,oBAAoB,GACrB,MAAM,uBAAuB,CAAC;AAE/B,YAAY,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAEnD,YAAY,EAAE,wBAAwB,EAAE,MAAM,sBAAsB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AAEnD,OAAO,EAAE,IAAI,EAAE,MAAM,mBAAmB,CAAC;AAEzC,OAAO,EAAE,mBAAmB,EAAE,MAAM,kCAAkC,CAAC;AAEvE,OAAO,EAAE,IAAI,EAAE,MAAM,mBAAmB,CAAC;AAEzC,OAAO,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAE9C,OAAO,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAEpD,OAAO,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAEtD,OAAO,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAE5C,OAAO,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAEpD,OAAO,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAEtD,OAAO,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAE9D,OAAO,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAC;AAElE,OAAO,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAEpD,OAAO,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAEtD,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAElD,OAAO,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAExD,YAAY,EAAE,kBAAkB,EAAE,MAAM,WAAW,CAAC;AAEpD,OAAO,EAAE,sBAAsB,EAAE,MAAM,0BAA0B,CAAC;AAElE,OAAO,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAC;AAEhE,YAAY,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAErD,YAAY,EAAE,wBAAwB,EAAE,MAAM,kCAAkC,CAAC;AAEjF,YAAY,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AAE9D,YAAY,EACV,cAAc,EACd,mBAAmB,EACnB,kBAAkB,EAClB,sBAAsB,GACvB,MAAM,wBAAwB,CAAC;AAEhC,YAAY,EACV,gBAAgB,EAChB,gBAAgB,EAChB,mBAAmB,GACpB,MAAM,sBAAsB,CAAC;AAE9B,YAAY,EACV,iBAAiB,EACjB,iBAAiB,EACjB,oBAAoB,GACrB,MAAM,uBAAuB,CAAC;AAE/B,YAAY,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAEnD,YAAY,EAAE,wBAAwB,EAAE,MAAM,sBAAsB,CAAC"}

package/dist/types/ssr.d.ts

@@ -0,0 +1,16 @@
+export { ClientOnly } from "./components/ClientOnly";
+export { ServerOnly } from "./components/ServerOnly";
+export { Await } from "./components/Await";
+export { Streamed } from "./components/Streamed";
+export { HttpStatusCode } from "./components/HttpStatusCode";
+export { HttpStatusProvider } from "./components/HttpStatusProvider";
+export { useDeferred } from "./hooks/useDeferred";
+export { createHttpStatusSink } from "./utils/createHttpStatusSink";
+export type { ClientOnlyProps } from "./components/ClientOnly";
+export type { ServerOnlyProps } from "./components/ServerOnly";
+export type { AwaitProps } from "./components/Await";
+export type { StreamedProps } from "./components/Streamed";
+export type { HttpStatusCodeProps } from "./components/HttpStatusCode";
+export type { HttpStatusProviderProps } from "./components/HttpStatusProvider";
+export type { HttpStatusSink } from "./utils/createHttpStatusSink";
+//# sourceMappingURL=ssr.d.ts.map

package/dist/types/ssr.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ssr.d.ts","sourceRoot":"","sources":["../../src/ssr.tsx"],"names":[],"mappings":"AAOA,OAAO,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AAErD,OAAO,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AAErD,OAAO,EAAE,KAAK,EAAE,MAAM,oBAAoB,CAAC;AAE3C,OAAO,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAEjD,OAAO,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAC;AAE7D,OAAO,EAAE,kBAAkB,EAAE,MAAM,iCAAiC,CAAC;AAGrE,OAAO,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAGlD,OAAO,EAAE,oBAAoB,EAAE,MAAM,8BAA8B,CAAC;AAGpE,YAAY,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAE/D,YAAY,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAE/D,YAAY,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAErD,YAAY,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAE3D,YAAY,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAC;AAEvE,YAAY,EAAE,uBAAuB,EAAE,MAAM,iCAAiC,CAAC;AAE/E,YAAY,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC"}

package/dist/types/utils/createHttpStatusSink.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Render-scoped HTTP status sink. Created per request on the server, passed to
+ * `<HttpStatusProvider sink={...}>`, and read after `renderToString` /
+ * `renderToStream` to apply the value to the HTTP response.
+ *
+ * Last write wins: if the rendered tree mounts more than one
+ * `<HttpStatusCode />`, the value reflects the last component that ran during
+ * the render pass.
+ *
+ * No-op on the client — `<HttpStatusCode />` reads the optional context and
+ * skips the write when no provider is mounted, so the same component tree can
+ * be hydrated without changing behaviour.
+ *
+ * Constraints:
+ * - **Per-request only.** Don't share a sink across requests; the rendered
+ *   tree mutates `code` in place. Module-level singletons leak status
+ *   between concurrent requests.
+ * - **Don't `Object.freeze` the sink.** The component writes to `.code`;
+ *   freezing makes the assignment throw under ESM strict mode.
+ * - **Hydration symmetry:** mount `<HttpStatusProvider>` on both server and
+ *   client (with a throwaway client sink). Solid emits `data-hk` markers
+ *   per component boundary; an extra provider on one side desyncs the
+ *   counter and breaks the hydration walker.
+ */
+export interface HttpStatusSink {
+    code: number | undefined;
+}
+export declare function createHttpStatusSink(): HttpStatusSink;
+//# sourceMappingURL=createHttpStatusSink.d.ts.map

package/dist/types/utils/createHttpStatusSink.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createHttpStatusSink.d.ts","sourceRoot":"","sources":["../../../src/utils/createHttpStatusSink.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,GAAG,SAAS,CAAC;CAC1B;AAED,wBAAgB,oBAAoB,IAAI,cAAc,CAErD"}

package/dist/types/utils/createMountedSignal.d.ts

@@ -0,0 +1,16 @@
+import type { Accessor } from "solid-js";
+/**
+ * Returns a boolean accessor that is `false` during initial render (SSR
+ * and the first client paint) and flips to `true` once the component
+ * has mounted in the browser.
+ *
+ * Solid guarantees that `onMount` does NOT fire during `renderToString` /
+ * `renderToStream`, so the accessor stays `false` server-side — this is
+ * the building block for SSR boundary components (`<ClientOnly>` /
+ * `<ServerOnly>`).
+ *
+ * Consolidates the identical `createSignal(false) + onMount(setMounted)`
+ * pattern across the two boundary components (§8a Q15).
+ */
+export declare function createMountedSignal(): Accessor<boolean>;
+//# sourceMappingURL=createMountedSignal.d.ts.map

package/dist/types/utils/createMountedSignal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createMountedSignal.d.ts","sourceRoot":"","sources":["../../../src/utils/createMountedSignal.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AAEzC;;;;;;;;;;;;GAYG;AACH,wBAAgB,mBAAmB,IAAI,QAAQ,CAAC,OAAO,CAAC,CAQvD"}

package/package.json

@@ -1,11 +1,18 @@
 {
   "name": "@real-router/solid",
-  "version": "0.11.1",
+  "version": "0.13.0",
   "type": "commonjs",
   "description": "Solid.js integration for Real-Router",
   "main": "./dist/cjs/index.js",
   "module": "./dist/esm/index.mjs",
   "types": "./dist/cjs/index.d.ts",
+  "typesVersions": {
+    "*": {
+      "ssr": [
+        "./dist/cjs/ssr.d.ts"
+      ]
+    }
+  },
   "exports": {
     ".": {
       "@real-router/internal-source": "./src/index.tsx",
@@ -15,6 +22,15 @@
       },
       "import": "./dist/esm/index.mjs",
       "require": "./dist/cjs/index.js"
+    },
+    "./ssr": {
+      "@real-router/internal-source": "./src/ssr.tsx",
+      "types": {
+        "import": "./dist/esm/ssr.d.mts",
+        "require": "./dist/cjs/ssr.d.ts"
+      },
+      "import": "./dist/esm/ssr.mjs",
+      "require": "./dist/cjs/ssr.js"
     }
   },
   "files": [
@@ -51,9 +67,9 @@
   "license": "MIT",
   "sideEffects": false,
   "dependencies": {
-    "@real-router/core": "^0.52.0",
+    "@real-router/core": "^0.54.1",
     "@real-router/route-utils": "^0.2.2",
-    "@real-router/sources": "^0.8.1"
+    "@real-router/sources": "^0.8.3"
   },
   "devDependencies": {
     "@babel/core": "7.29.0",
@@ -70,8 +86,8 @@
     "rollup-plugin-dts": "6.4.1",
     "solid-js": "1.9.12",
     "vite-plugin-solid": "2.11.11",
-    "vitest": "4.1.0",
-    "@real-router/browser-plugin": "^0.17.1"
+    "vitest": "4.1.6",
+    "@real-router/browser-plugin": "^0.17.4"
   },
   "peerDependencies": {
     "solid-js": ">=1.7.0"

package/src/RouterProvider.tsx

@@ -31,54 +31,60 @@ export function isRouteActive(
   );
 }
 
-export function RouterProvider(
-  props: ParentProps<RouteProviderProps>,
-): JSX.Element {
+// §8.1 audit fix (LOW) — collapse three identical onMount lifecycle blocks
+// into a single helper. Each opt-in feature has the same shape:
+//   `if (!enabled) return; const handle = create(...); onCleanup(handle.destroy)`.
+// Routing setup through this helper keeps the props.<feature> check + mount
+// side-effect + cleanup wiring in one place.
+function mountFeature(
+  enabled: unknown,
+  factory: () => { destroy: () => void },
+): void {
   onMount(() => {
-    if (!props.announceNavigation) {
+    if (!enabled) {
       return;
     }
 
-    const announcer = createRouteAnnouncer(props.router);
+    const handle = factory();
 
     onCleanup(() => {
-      announcer.destroy();
-    });
-  });
-
-  onMount(() => {
-    if (!props.scrollRestoration) {
-      return;
-    }
-
-    const sr = createScrollRestoration(props.router, props.scrollRestoration);
-
-    onCleanup(() => {
-      sr.destroy();
-    });
-  });
-
-  onMount(() => {
-    if (!props.viewTransitions) {
-      return;
-    }
-
-    const vt = createViewTransitions(props.router);
-
-    onCleanup(() => {
-      vt.destroy();
+      handle.destroy();
     });
   });
+}
 
+export function RouterProvider(
+  props: ParentProps<RouteProviderProps>,
+): JSX.Element {
+  // Setup vars FIRST (§8.1 audit fix LOW #2 — semantic ordering): the router
+  // subscription wiring is the core of the provider, the opt-in features
+  // below ride on top of it.
   const navigator = getNavigator(props.router);
   const routeSource = createRouteSource(props.router);
   const routeSignal = createSignalFromSource(routeSource);
 
   const routeSelector = createSelector(
+    // The empty-string sentinel guarantees no Link is "active" while the
+    // router has no route (unstarted / stopped) — `isRouteActive` short-
+    // circuits because no real route name equals or starts with `""` +
+    // dot boundary. Without the sentinel, `routeSignal().route?.name`
+    // would be `undefined` and the selector would compare against
+    // `undefined`, defeating Solid's identity-based change detection.
     () => routeSignal().route?.name ?? "",
     isRouteActive,
   );
 
+  // Opt-in features wired through the shared mountFeature helper.
+  mountFeature(props.announceNavigation, () =>
+    createRouteAnnouncer(props.router),
+  );
+  mountFeature(props.scrollRestoration, () =>
+    createScrollRestoration(props.router, props.scrollRestoration),
+  );
+  mountFeature(props.viewTransitions, () =>
+    createViewTransitions(props.router),
+  );
+
   return (
     <RouterContext.Provider
       value={{ router: props.router, navigator, routeSelector }}

package/src/components/Await.tsx

@@ -0,0 +1,56 @@
+import { createResource } from "solid-js";
+
+import { useDeferred } from "../hooks/useDeferred";
+
+import type { JSX } from "solid-js";
+
+export interface AwaitProps<T> {
+  /** Deferred key declared in the loader's `defer({ deferred: { <name>: ... } })`. */
+  readonly name: string;
+  /** Render the resolved value. Surrounding `<Suspense>` shows fallback while
+   * pending; rejection bubbles through Solid's `<ErrorBoundary>`. */
+  readonly children: (value: T) => JSX.Element;
+}
+
+/**
+ * Reads `useDeferred(name)` and hands the resolved value to the render-prop.
+ * Wraps the deferred promise in `createResource` so Solid's reactivity tracks
+ * resolution and `<Suspense>` gets the standard suspend signal.
+ *
+ * ```tsx
+ * <Streamed fallback={<Spinner />}>
+ *   <Await<Review[]> name="reviews">
+ *     {(reviews) => <ReviewList items={reviews} />}
+ *   </Await>
+ * </Streamed>
+ * ```
+ *
+ * Implementation: returns a Solid accessor (function child) that reads
+ * `resource()` — this both (a) triggers `<Suspense>` suspension while pending
+ * and (b) re-throws on `errored` for the nearest `<ErrorBoundary>` to catch.
+ * The render-prop is gated on `resource.state === "ready"` rather than on
+ * truthiness so falsy resolved values (`0`, `false`, `null`, `""`) still
+ * reach `props.children`.
+ */
+export function Await<T = unknown>(props: AwaitProps<T>): JSX.Element {
+  const promiseAccessor = useDeferred<T>(props.name);
+  const [resource] = createResource(promiseAccessor, (promise) => promise);
+
+  // The double cast `as unknown as JSX.Element` (audit-2026-05-17 §8a) is
+  // load-bearing: this returns a Solid accessor *function*, not an element
+  // node. `JSX.Element` in Solid is a union that includes function-as-child
+  // for reactive bindings, but the type machinery can't narrow the bare
+  // arrow's signature to that union — going through `unknown` is the
+  // standard escape hatch used elsewhere in solid-router-style adapters.
+  // Removing either cast yields a "Type '() => unknown' is not assignable
+  // to type 'JSX.Element'" error.
+  return (() => {
+    const value = resource();
+
+    if (resource.state !== "ready") {
+      return;
+    }
+
+    return props.children(value as T);
+  }) as unknown as JSX.Element;
+}

package/src/components/ClientOnly.tsx

@@ -0,0 +1,20 @@
+import { Show } from "solid-js";
+
+import { createMountedSignal } from "../utils/createMountedSignal";
+
+import type { JSX } from "solid-js";
+
+export interface ClientOnlyProps {
+  readonly children: JSX.Element;
+  readonly fallback?: JSX.Element;
+}
+
+export function ClientOnly(props: ClientOnlyProps): JSX.Element {
+  const mounted = createMountedSignal();
+
+  return (
+    <Show when={mounted()} fallback={props.fallback}>
+      {props.children}
+    </Show>
+  );
+}

package/src/components/HttpStatusCode.tsx

@@ -0,0 +1,65 @@
+import { useContext } from "solid-js";
+
+import { HttpStatusContext } from "./HttpStatusProvider";
+
+import type { JSX } from "solid-js";
+
+export interface HttpStatusCodeProps {
+  /** HTTP status to apply to the response. Common values: 404, 410, 451, 503. */
+  readonly code: number;
+}
+
+/**
+ * Render-time HTTP status declaration. Mount inside a route component (typical
+ * use case: a glob `*` route's NotFound page) when the status is decided by
+ * the rendered tree rather than a loader.
+ *
+ * Writes `code` to the nearest `<HttpStatusProvider>`'s sink during render and
+ * returns `null`. With no provider mounted (the standard client-side case)
+ * the component is a silent no-op — same component tree hydrates without
+ * touching the DOM or warning about mismatches.
+ *
+ * Loader-driven errors (`LoaderNotFound` → 404, `LoaderRedirect` → 30x) keep
+ * working as before; this component covers render-time decisions only.
+ *
+ * Last write wins when several `<HttpStatusCode />` instances mount in the
+ * same render pass — sink reflects the last component that ran.
+ *
+ * ```tsx
+ * // entry-server.tsx
+ * import { renderToString } from "solid-js/web";
+ * import { createHttpStatusSink, HttpStatusProvider } from "@real-router/solid/ssr";
+ *
+ * const sink = createHttpStatusSink();
+ * const html = renderToString(() => (
+ *   <HttpStatusProvider sink={sink}>
+ *     <RouterProvider router={router}>
+ *       <App />
+ *     </RouterProvider>
+ *   </HttpStatusProvider>
+ * ));
+ * response.status(sink.code ?? 200).send(html);
+ * ```
+ *
+ * **Streaming SSR (`renderToStream`):** the response status MUST be sent
+ * before the first body byte flushes. If `<HttpStatusCode />` is mounted
+ * inside a late-resolving `<Suspense>` boundary, the sink write may happen
+ * AFTER the headers are already on the wire — the override is then lost.
+ * Mount the component in the shell (above every `<Suspense>` that could
+ * delay it), or use `renderToStringAsync` (single-shot, awaits all Suspense
+ * before returning HTML).
+ *
+ * **Valid `code` range:** Node's `res.end()` throws `Invalid status code` on
+ * `NaN`, `0`, negative values, or values `> 999` — this surfaces as a 5xx /
+ * dropped connection, not silent corruption. Pass a real HTTP status integer
+ * (commonly 4xx/5xx; 100-999 is what Node accepts).
+ */
+export function HttpStatusCode(props: HttpStatusCodeProps): JSX.Element {
+  const sink = useContext(HttpStatusContext);
+
+  if (sink) {
+    sink.code = props.code;
+  }
+
+  return null;
+}

package/src/components/HttpStatusProvider.tsx

@@ -0,0 +1,21 @@
+import { createContext } from "solid-js";
+
+import type { HttpStatusSink } from "../utils/createHttpStatusSink";
+import type { JSX } from "solid-js";
+
+export const HttpStatusContext = createContext<HttpStatusSink | null>(null);
+
+export interface HttpStatusProviderProps {
+  readonly sink: HttpStatusSink;
+  readonly children: JSX.Element;
+}
+
+export function HttpStatusProvider(
+  props: HttpStatusProviderProps,
+): JSX.Element {
+  return (
+    <HttpStatusContext.Provider value={props.sink}>
+      {props.children}
+    </HttpStatusContext.Provider>
+  );
+}

package/src/components/Link.tsx

@@ -1,8 +1,8 @@
 import { createActiveRouteSource } from "@real-router/sources";
-import { createMemo, mergeProps, splitProps, useContext } from "solid-js";
+import { createMemo, mergeProps, splitProps } from "solid-js";
 
 import { EMPTY_PARAMS, EMPTY_OPTIONS } from "../constants";
-import { RouterContext } from "../context";
+import { useRequiredRouterContext } from "../context";
 import { createSignalFromSource } from "../createSignalFromSource";
 import {
   shouldNavigate,
@@ -43,23 +43,24 @@ export function Link<P extends Params = Params>(
     "children",
   ]);
 
-  const ctx = useContext(RouterContext);
-
-  if (!ctx) {
-    throw new Error("Link must be used within a RouterProvider");
-  }
-
+  const ctx = useRequiredRouterContext("Link");
   const router = ctx.router;
 
   // Hash-aware active state (#532). `routeSelector` (the O(1) shared selector)
   // doesn't know about hash — when `hash` prop is set, fall back to the slow
   // path so the source's hash comparison kicks in. Tab-style UI is opt-in via
   // the prop, so the fast path stays open for the typical Link case.
+  //
+  // §8.1 audit fix: read `props.routeParams === undefined` directly instead of
+  // `local.routeParams === EMPTY_PARAMS`. The latter went through `mergeProps`
+  // proxy and relied on a hidden contract (mergeProps preserves the default
+  // sentinel identity when consumer omits the field). The new check is
+  // explicit: "fast path kicks in when consumer did not supply routeParams".
   const useFastPath =
     local.hash === undefined &&
     !local.activeStrict &&
     local.ignoreQueryParams &&
-    local.routeParams === EMPTY_PARAMS;
+    props.routeParams === undefined;
 
   const buildActiveOptions = () => {
     const base = {
@@ -85,13 +86,18 @@ export function Link<P extends Params = Params>(
         ),
       );
 
+  // Separate memo for the hash-options object so the `{ hash }` literal
+  // is allocated only when `local.hash` actually changes (instead of on
+  // every `href` memo evaluation). For static `<Link hash="foo">` this
+  // produces ONE allocation total; for dynamic hash through `<Show keyed>`
+  // workaround the allocation cost scales with hash changes, not with
+  // routeName/routeParams changes (§8c A4 audit fix).
+  const hashOpts = createMemo(() =>
+    local.hash === undefined ? undefined : { hash: local.hash },
+  );
+
   const href = createMemo(() =>
-    buildHref(
-      router,
-      local.routeName,
-      local.routeParams,
-      local.hash === undefined ? undefined : { hash: local.hash },
-    ),
+    buildHref(router, local.routeName, local.routeParams, hashOpts()),
   );
 
   const handleClick = (evt: MouseEvent) => {

package/src/components/RouteView/RouteView.tsx

@@ -1,4 +1,4 @@
-import { children as resolveChildren, createMemo } from "solid-js";
+import { children as resolveChildren, createMemo, For, Show } from "solid-js";
 
 import { Match, NotFound, Self } from "./components";
 import { buildRenderList, collectElements } from "./helpers";
@@ -21,24 +21,25 @@ function RouteViewRoot(props: Readonly<RouteViewProps>): JSX.Element {
     return arr;
   });
 
+  // Idiomatic Solid: `<Show>` gates on the route presence, `<For>` iterates
+  // the build-render-list output. `<Show when={...} keyed>` re-runs the
+  // child callback only when route identity changes; `<For>` adds/removes
+  // exactly the changed elements without re-running the rest.
+  // (§8a Q4 audit fix — replaced an IIFE-in-JSX with idiomatic primitives.)
+  const renderList = createMemo<JSX.Element[]>(() => {
+    const state = routeState();
+
+    if (!state.route) {
+      return [];
+    }
+
+    return buildRenderList(elements(), state.route.name, props.nodeName);
+  });
+
   return (
-    <>
-      {(() => {
-        const state = routeState();
-
-        if (!state.route) {
-          return null;
-        }
-
-        const rendered = buildRenderList(
-          elements(),
-          state.route.name,
-          props.nodeName,
-        );
-
-        return rendered.length > 0 ? rendered : null;
-      })()}
-    </>
+    <Show when={renderList().length > 0}>
+      <For each={renderList()}>{(node) => node}</For>
+    </Show>
   );
 }