@mindees/router 0.1.0

package/LICENSE

@@ -0,0 +1,31 @@
+# License
+
+MindeesNative is dual-licensed under either of:
+
+- **Apache License, Version 2.0** ([LICENSE-APACHE](./LICENSE-APACHE) or
+  <https://www.apache.org/licenses/LICENSE-2.0>)
+- **MIT license** ([LICENSE-MIT](./LICENSE-MIT) or
+  <https://opensource.org/licenses/MIT>)
+
+at your option.
+
+This `MIT OR Apache-2.0` dual-license is the same model used by the Rust
+ecosystem and many modern open-source projects. It gives downstream users
+maximum flexibility: the MIT option is short and permissive, while the Apache
+option adds an explicit patent grant.
+
+## SPDX identifier
+
+```
+SPDX-License-Identifier: MIT OR Apache-2.0
+```
+
+## Contribution
+
+Unless you explicitly state otherwise, any contribution intentionally
+submitted for inclusion in the work by you, as defined in the Apache-2.0
+license, shall be dual-licensed as above, without any additional terms or
+conditions.
+
+Contributions are accepted under the **Developer Certificate of Origin (DCO)**.
+See [CONTRIBUTING.md](./CONTRIBUTING.md) for details on signing off your commits.

package/README.md

@@ -0,0 +1,196 @@
+# @mindees/router
+
+**Quantum** — the typed, signals-native router for MindeesNative. **Codegen-free
+typed path params**, **typed + runtime-validated search params** (bring any
+Zod / Valibot / ArkType schema), and **fine-grained reactive route state** with
+selector-based re-render isolation. A modern, type-safe alternative to Expo
+Router and React Router for TypeScript cross-platform apps.
+
+> **Status: 🧪 Experimental (Phase 6 — Router I + Phase 7 — Router II).** The
+> typed routing core (typed params, Standard Schema search validation, the
+> signals-native router, typed + relative navigation, dynamic reconfiguration,
+> memory + browser history), **render integration** (`createRouterView` —
+> fine-grained, layout-preserving nested rendering; typed `createLink`), and
+> **data/guards/transitions** (SWR loaders + `preload`/`invalidate`, navigation
+> guards, web view transitions) are implemented and tested. The global typed
+> route registry and file-based route scanning are a later phase — see
+> [ROADMAP](../../ROADMAP.md).
+
+## Why Quantum?
+
+| | **Quantum** | Expo Router v6 | React Router v7 |
+| --- | --- | --- | --- |
+| Typed path params | ✅ template-literal types, **no codegen** | ⚠️ codegen; required params typed as *optional* | ✅ codegen (`.react-router/types`) |
+| Typed **search** params | ✅ via Standard Schema | ❌ not typed | ❌ raw `URLSearchParams` |
+| Validation lock-in | ✅ none — any Standard Schema (Zod/Valibot/ArkType) | — | — |
+| Reactivity | ✅ fine-grained signals; select a slice, re-run on *that* change | ⚠️ global-vs-local re-render footgun | React renders |
+| Build/dev-server required for types | ❌ pure TypeScript inference | ✅ dev server | ✅ typegen step |
+
+Relative navigation (`navigate('./edit')`, `'../'`) and `#fragment` targets are
+supported via href strings (resolved against the current location); the typed
+structured form (`navigate({ to, params })`) builds absolute paths.
+
+## Quick start
+
+```ts
+import { createRouter, createMemoryHistory } from '@mindees/router'
+import { z } from 'zod' // or valibot, arktype — any Standard Schema validator
+
+const router = createRouter({
+  routes: [
+    { path: '/' },
+    { path: '/posts/:postId' },
+    { path: '/search', searchSchema: z.object({ q: z.string(), page: z.coerce.number() }) },
+    { path: '/files/:rest*' }, // catch-all
+  ],
+  history: createMemoryHistory({ initialEntries: ['/'] }), // or createBrowserHistory()
+})
+
+// Typed navigation — params are required iff the pattern has them (inferred, no codegen):
+router.navigate({ to: '/posts/:postId', params: { postId: '42' }, search: { ref: 'home' } })
+// router.navigate({ to: '/posts/:postId' })            // ✗ type error: params required
+// router.navigate({ to: '/', params: { x: '1' } })     // ✗ type error: no params allowed
+router.navigate('./edit')                               // ✓ relative navigation (href string)
+
+// Re-render isolation — re-runs ONLY when the selected slice changes:
+const postId = router.select((s) => s.params.postId)
+const matched = router.match() // { route, params, search, searchRaw, issues? }
+```
+
+## Typed, validated search params
+
+Search params are first-class typed state. Reads are validated against the route's
+schema and fully typed — the capability Expo Router and React Router lack:
+
+```ts
+import { validateSearch } from '@mindees/router'
+
+const schema = z.object({ page: z.coerce.number(), q: z.string() })
+const search = validateSearch(schema, { page: '2', q: 'router' })
+//    ^? { page: number; q: string }
+```
+
+Invalid params never crash navigation — the match exposes `issues` (Standard
+Schema diagnostics) and falls back to the raw parse. Repeated keys
+(`?tag=a&tag=b`) become arrays; coercion is delegated to your schema.
+
+## Render integration — nested routes that actually render
+
+`createRouterView` renders the matched route **chain**; a layout renders its
+`children` (the outlet). Navigation is **fine-grained and layout-preserving** —
+switching between sibling pages keeps the parent layout (and its state) mounted,
+and a same-route param change (`/posts/1` → `/posts/2`) re-mounts *nothing*; only
+the bindings that read the changed param update.
+
+```ts
+import { createElement } from '@mindees/core'
+import { render, createDomBackend } from '@mindees/renderer'
+import { createRouter, createRouterView, createLink, type RouteComponentProps } from '@mindees/router'
+
+function DashLayout(props: RouteComponentProps) {
+  return createElement('view', null,
+    createElement('nav', null, 'sidebar'),
+    props.children, // ← the outlet: the matched child route renders here
+  )
+}
+const Settings = () => createElement('text', null, 'settings')
+
+const router = createRouter({
+  routes: [{ path: '/dash', component: DashLayout, children: [
+    { path: '', component: () => createElement('text', null, 'home') },
+    { path: 'settings', component: Settings },
+  ] }],
+})
+
+const Link = createLink(router)
+render(createRouterView(router, { notFound: () => createElement('text', null, '404') }),
+  createDomBackend(), document.getElementById('app')!)
+
+// Typed link — params required iff the pattern has them:
+Link({ to: '/dash/settings', children: 'Settings' })
+```
+
+Components built on `@mindees/core`'s `createElement` — the renderer just renders
+the tree, so `@mindees/router` keeps **zero renderer runtime dependency**.
+
+## Codegen-free typed params
+
+```ts
+import type { PathParams } from '@mindees/router'
+
+type A = PathParams<'/posts/:postId'>        // { postId: string }
+type B = PathParams<'/u/:userId/p/:postId'>  // { userId: string; postId: string }
+type C = PathParams<'/files/:rest*'>         // { rest: string }
+type D = PathParams<'/about'>                // {}
+```
+
+No generated `.d.ts`, no dev server, no stale type files — just TypeScript.
+
+## Data, guards & transitions
+
+```ts
+const router = createRouter({
+  routes: [
+    {
+      path: '/posts/:postId',
+      // SWR loader: cached, revalidated, abortable; result flows to props.data()
+      loader: async ({ params, signal }) => fetch(`/api/posts/${params.postId}`, { signal }).then((r) => r.json()),
+      loaderDeps: ({ search }) => search.page, // re-load when ?page changes
+      staleTime: 30_000,
+    },
+  ],
+  // Guard: cancel (false) or redirect (string); idempotent nav is automatic
+  beforeNavigate: (to) => (isLoggedIn() ? undefined : '/login'),
+  viewTransitions: true, // wrap navigations in document.startViewTransition (web)
+})
+
+router.preload('/posts/42')   // intent prefetch — runs the loader, no navigation
+router.invalidate()           // re-run the current chain's loaders
+
+function Post(props: RouteComponentProps) {
+  const d = props.data()      // reactive: { status, data?, error? } — updates in place
+  // ...
+}
+```
+
+Loaders run for every route in the matched chain, cache by route + params +
+`loaderDeps` (stale-while-revalidate), abort superseded loads via `AbortSignal`,
+and surface results reactively — a resolved load updates the component's data
+binding **without re-mounting** it. View transitions are feature-detected and a
+transparent no-op outside a DOM (SSR / native).
+
+## API surface
+
+- **Render (Router II)** — `createRouterView`, `createLink`, `RouterViewOptions`,
+  `LinkProps`, `LinkComponent`, `LinkOptions`, `RouteComponentProps`.
+- **Data / guards / transitions** — route `loader` / `loaderDeps` / `staleTime`,
+  `router.loaderData` / `invalidate` / `preload`, `LoaderContext`, `LoaderData`,
+  `LoaderFn`, `LoaderStatus`; `BeforeNavigate`, `NavigateOptions` (`force`,
+  `viewTransition`), `CreateRouterOptions` (`beforeNavigate`, `viewTransitions`).
+- **Router** — `createRouter`, `Router`, `RouteRecord` (with `children` for
+  nesting), `RouteMatch`, `RouterState` (with `matches` chain), `NavTarget`,
+  `NavigateOptions`, `resolvePath`.
+- **Patterns** — `matchPattern`, `buildPath`, `parsePattern`,
+  `compareSpecificity`, `PathParams`, `HasPathParams`.
+- **Search** — `parseQuery`, `stringifyQuery`, `validateSearch`,
+  `safeValidateSearch`, `QueryValue`, `ValidationResult`.
+- **History** — `createMemoryHistory`, `createBrowserHistory`, `parseHref`,
+  `createHref`, `RouterHistory`, `RouterLocation`.
+- **Validation** — `StandardSchemaV1` (vendored, zero runtime dependency).
+- **Errors** — `RouterError`, `RouterErrorCode`.
+
+## Design
+
+Route state (location, params, search, matched route) is modeled as the
+fine-grained **signal graph** from [`@mindees/core`](../core) — no monolithic
+state object, no over-subscription. `select()` applies the same
+selector-isolation technique as core's Phase 2 `createProvider` (a `computed`
+memo over an `equals:false` source). History is an **injected capability**, so the
+whole router is deterministically testable headless. Validation rides on
+[**Standard Schema**](https://standardschema.dev) — vendored as types only, so
+Quantum adds **zero runtime dependencies** while accepting any compliant
+validator. See [ADR-0003](../../docs/adr/0003-router-architecture.md).
+
+## License
+
+Dual-licensed under **MIT OR Apache-2.0**.

package/dist/components.d.ts

@@ -0,0 +1,50 @@
+import { NavTarget, Router } from "./router.js";
+import { Component, MindeesElement, MindeesNode } from "@mindees/core";
+
+//#region src/components.d.ts
+/** Options for {@link createRouterView}. */
+interface RouterViewOptions {
+  /** Rendered when no route matches the current location. */
+  notFound?: Component;
+}
+/**
+ * Create the router's view: a node that renders the matched route **chain**
+ * top-down, nesting each child into its parent's `children` (the outlet). Render
+ * it with the Helix renderer (`render(createRouterView(router), backend, root)`);
+ * it re-renders fine-grainedly as navigation changes the matched routes.
+ *
+ * @example
+ * const view = createRouterView(router, { notFound: NotFound })
+ * render(view, backend, root)
+ */
+declare function createRouterView(router: Router, options?: RouterViewOptions): MindeesNode;
+/** Extra (non-target) props accepted by a {@link LinkComponent}. */
+interface LinkOptions {
+  /** Replace the current history entry instead of pushing. */
+  replace?: boolean;
+  /** Host tag to render. Defaults to `'a'` (web). Use e.g. `'view'` on native. */
+  as?: string;
+  /** Class applied (in addition to `class`) when the link's path is the current pathname. */
+  activeClass?: string;
+  /** Static class. */
+  class?: string;
+  /** Link content. */
+  children?: MindeesNode;
+}
+/** Props for a typed link: a {@link NavTarget} plus {@link LinkOptions}. */
+type LinkProps<P extends string> = NavTarget<P> & LinkOptions;
+/** A typed link component — params are required iff the pattern has them. */
+type LinkComponent = <P extends string>(props: LinkProps<P>) => MindeesElement;
+/**
+ * Create a typed `Link` bound to `router`. Calling it returns an element that
+ * navigates on activation (default tag `'a'` with `href` + an `onClick` that
+ * honors modifier/middle clicks). Params are required iff the pattern has them.
+ *
+ * @example
+ * const Link = createLink(router)
+ * Link({ to: '/posts/:postId', params: { postId: '42' }, children: 'Open' })
+ */
+declare function createLink(router: Router): LinkComponent;
+//#endregion
+export { LinkComponent, LinkOptions, LinkProps, RouterViewOptions, createLink, createRouterView };
+//# sourceMappingURL=components.d.ts.map

package/dist/components.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"components.d.ts","names":[],"sources":["../src/components.ts"],"mappings":";;;;;UA6BiB,iBAAA;EAegB;EAb/B,QAAA,GAAW,SAAS;AAAA;;;AAawE;AA2C9F;;;;;;;iBA3CgB,gBAAA,CAAiB,MAAA,EAAQ,MAAA,EAAQ,OAAA,GAAS,iBAAA,GAAyB,WAAA;;UA2ClE,WAAA;EAUO;EARtB,OAAA;EAYU;EAVV,EAAA;EAUmB;EARnB,WAAA;EAQwC;EANxC,KAAA;EAMkE;EAJlE,QAAA,GAAW,WAAW;AAAA;;KAIZ,SAAA,qBAA8B,SAAA,CAAU,CAAA,IAAK,WAAA;;KAG7C,aAAA,sBAAmC,KAAA,EAAO,SAAA,CAAU,CAAA,MAAO,cAAA;AAHH;AAGpE;;;;;;;;AAHoE,iBA2DpD,UAAA,CAAW,MAAA,EAAQ,MAAA,GAAS,aAAa"}

package/dist/components.js

@@ -0,0 +1,94 @@
+import { buildPath } from "./pattern.js";
+import { stringifyQuery } from "./search.js";
+import { createElement } from "@mindees/core";
+//#region src/components.ts
+/**
+* Render integration — `createRouterView` (renders the matched route chain) and
+* `createLink` (typed navigation links). Built on `@mindees/core`'s
+* `createElement` + signals; the renderer turns the returned function nodes into
+* fine-grained reactive regions. See ADR-0004.
+*
+* Nesting uses **explicit composition** (no ambient context): each matched route
+* component receives the next route in the chain as `children` (the outlet), and
+* the router exposes the chain as the reactive `matches` array. Each depth is a
+* reactive region keyed on that depth's route identity, so navigating a leaf
+* re-mounts only the leaf — parent layouts (and their state) are preserved.
+*
+* @module
+*/
+/** Shared idle loader state for routes without a loader. */
+const IDLE_LOADER_DATA = Object.freeze({ status: "idle" });
+/**
+* Create the router's view: a node that renders the matched route **chain**
+* top-down, nesting each child into its parent's `children` (the outlet). Render
+* it with the Helix renderer (`render(createRouterView(router), backend, root)`);
+* it re-renders fine-grainedly as navigation changes the matched routes.
+*
+* @example
+* const view = createRouterView(router, { notFound: NotFound })
+* render(view, backend, root)
+*/
+function createRouterView(router, options = {}) {
+	const outletAt = (depth) => () => {
+		const route = router.select((s) => s.matches[depth]?.route ?? null)();
+		if (route === null) return depth === 0 && options.notFound ? createElement(options.notFound, {}) : null;
+		const child = outletAt(depth + 1);
+		const component = route.component;
+		if (component === void 0) return child;
+		return createElement(component, {
+			router,
+			params: router.params,
+			search: router.search,
+			data: () => {
+				const match = router.matches()[depth];
+				return match ? router.loaderData(match) : IDLE_LOADER_DATA;
+			},
+			children: child
+		});
+	};
+	return outletAt(0);
+}
+/** Should a click be left for the browser (modifier/middle-click, already handled)? */
+function isModifiedClick(event) {
+	return event.defaultPrevented === true || event.button !== void 0 && event.button !== 0 || event.metaKey === true || event.ctrlKey === true || event.shiftKey === true || event.altKey === true;
+}
+/** Assemble an href (path + query + hash) from a link target. */
+function hrefFor(props) {
+	const path = buildPath(props.to, props.params ?? {});
+	const query = props.search ? stringifyQuery(props.search) : "";
+	let hash = props.hash ?? "";
+	if (hash.length > 0 && !hash.startsWith("#")) hash = `#${hash}`;
+	return `${path}${query ? `?${query}` : ""}${hash}`;
+}
+/**
+* Create a typed `Link` bound to `router`. Calling it returns an element that
+* navigates on activation (default tag `'a'` with `href` + an `onClick` that
+* honors modifier/middle clicks). Params are required iff the pattern has them.
+*
+* @example
+* const Link = createLink(router)
+* Link({ to: '/posts/:postId', params: { postId: '42' }, children: 'Open' })
+*/
+function createLink(router) {
+	const Link = (props) => {
+		const tag = props.as ?? "a";
+		const href = hrefFor(props);
+		const onClick = (event) => {
+			if (event && isModifiedClick(event)) return;
+			event?.preventDefault?.();
+			router.navigate(href, { replace: props.replace === true });
+		};
+		const elementProps = { onClick };
+		if (tag === "a") elementProps.href = href;
+		if (props.activeClass !== void 0) {
+			const here = buildPath(props.to, props.params ?? {});
+			elementProps.class = () => [props.class, router.location().pathname === here ? props.activeClass : void 0].filter((c) => typeof c === "string" && c.length > 0).join(" ");
+		} else if (props.class !== void 0) elementProps.class = props.class;
+		return createElement(tag, elementProps, props.children);
+	};
+	return Link;
+}
+//#endregion
+export { createLink, createRouterView };
+
+//# sourceMappingURL=components.js.map

package/dist/components.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"components.js","names":[],"sources":["../src/components.ts"],"sourcesContent":["/**\n * Render integration — `createRouterView` (renders the matched route chain) and\n * `createLink` (typed navigation links). Built on `@mindees/core`'s\n * `createElement` + signals; the renderer turns the returned function nodes into\n * fine-grained reactive regions. See ADR-0004.\n *\n * Nesting uses **explicit composition** (no ambient context): each matched route\n * component receives the next route in the chain as `children` (the outlet), and\n * the router exposes the chain as the reactive `matches` array. Each depth is a\n * reactive region keyed on that depth's route identity, so navigating a leaf\n * re-mounts only the leaf — parent layouts (and their state) are preserved.\n *\n * @module\n */\n\nimport { type Component, createElement, type MindeesElement, type MindeesNode } from '@mindees/core'\nimport type { LoaderData } from './data'\nimport { buildPath } from './pattern'\nimport type { NavTarget, Router } from './router'\nimport { type QueryValue, stringifyQuery } from './search'\n\n/** Shared idle loader state for routes without a loader. */\nconst IDLE_LOADER_DATA: LoaderData = Object.freeze({ status: 'idle' })\n\n// ---------------------------------------------------------------------------\n// RouterView — render the matched route chain\n// ---------------------------------------------------------------------------\n\n/** Options for {@link createRouterView}. */\nexport interface RouterViewOptions {\n  /** Rendered when no route matches the current location. */\n  notFound?: Component\n}\n\n/**\n * Create the router's view: a node that renders the matched route **chain**\n * top-down, nesting each child into its parent's `children` (the outlet). Render\n * it with the Helix renderer (`render(createRouterView(router), backend, root)`);\n * it re-renders fine-grainedly as navigation changes the matched routes.\n *\n * @example\n * const view = createRouterView(router, { notFound: NotFound })\n * render(view, backend, root)\n */\nexport function createRouterView(router: Router, options: RouterViewOptions = {}): MindeesNode {\n  // Each depth is its own reactive region (a function node). A region depends\n  // only on a memo of its depth's matched route identity (`Object.is`), so a\n  // navigation that doesn't change a given depth's route does NOT re-run that\n  // region — parent layouts (and their state) stay mounted.\n  //\n  // The route memo is created FRESH on every region run, on purpose: a memo\n  // cached across runs would be owned by — and disposed with — this region's\n  // effect when it re-runs, leaving a dead source (the region would react once\n  // and then freeze). A fresh memo each run is always live; the `Object.is`\n  // equality on the memo is what still gates re-runs (the memo only re-runs the\n  // region when the route at this depth actually changes).\n  const outletAt =\n    (depth: number): (() => MindeesNode) =>\n    (): MindeesNode => {\n      const route = router.select((s) => s.matches[depth]?.route ?? null)()\n      if (route === null) {\n        return depth === 0 && options.notFound ? createElement(options.notFound, {}) : null\n      }\n      const child = outletAt(depth + 1)\n      const component = route.component\n      // A component-less (layout/pathless) route passes its child through.\n      if (component === undefined) return child\n      return createElement(component, {\n        router,\n        params: router.params,\n        search: router.search,\n        data: () => {\n          const match = router.matches()[depth]\n          return match ? router.loaderData(match) : IDLE_LOADER_DATA\n        },\n        children: child,\n      })\n    }\n\n  return outletAt(0)\n}\n\n// ---------------------------------------------------------------------------\n// Link — typed navigation links\n// ---------------------------------------------------------------------------\n\n/** Extra (non-target) props accepted by a {@link LinkComponent}. */\nexport interface LinkOptions {\n  /** Replace the current history entry instead of pushing. */\n  replace?: boolean\n  /** Host tag to render. Defaults to `'a'` (web). Use e.g. `'view'` on native. */\n  as?: string\n  /** Class applied (in addition to `class`) when the link's path is the current pathname. */\n  activeClass?: string\n  /** Static class. */\n  class?: string\n  /** Link content. */\n  children?: MindeesNode\n}\n\n/** Props for a typed link: a {@link NavTarget} plus {@link LinkOptions}. */\nexport type LinkProps<P extends string> = NavTarget<P> & LinkOptions\n\n/** A typed link component — params are required iff the pattern has them. */\nexport type LinkComponent = <P extends string>(props: LinkProps<P>) => MindeesElement\n\n/** The broad runtime shape the Link impl accepts (typed surface is {@link LinkProps}). */\ninterface LinkInput {\n  to: string\n  params?: Record<string, string | number>\n  search?: Record<string, QueryValue>\n  hash?: string\n  replace?: boolean\n  as?: string\n  activeClass?: string\n  class?: string\n  children?: MindeesNode\n}\n\n/** A minimal click-event shape (DOM `MouseEvent` satisfies it; tests can omit it). */\ninterface ClickEventLike {\n  preventDefault?: () => void\n  defaultPrevented?: boolean\n  button?: number\n  metaKey?: boolean\n  ctrlKey?: boolean\n  shiftKey?: boolean\n  altKey?: boolean\n}\n\n/** Should a click be left for the browser (modifier/middle-click, already handled)? */\nfunction isModifiedClick(event: ClickEventLike): boolean {\n  return (\n    event.defaultPrevented === true ||\n    (event.button !== undefined && event.button !== 0) ||\n    event.metaKey === true ||\n    event.ctrlKey === true ||\n    event.shiftKey === true ||\n    event.altKey === true\n  )\n}\n\n/** Assemble an href (path + query + hash) from a link target. */\nfunction hrefFor(props: LinkInput): string {\n  const path = buildPath(props.to, props.params ?? {})\n  const query = props.search ? stringifyQuery(props.search) : ''\n  let hash = props.hash ?? ''\n  if (hash.length > 0 && !hash.startsWith('#')) hash = `#${hash}`\n  return `${path}${query ? `?${query}` : ''}${hash}`\n}\n\n/**\n * Create a typed `Link` bound to `router`. Calling it returns an element that\n * navigates on activation (default tag `'a'` with `href` + an `onClick` that\n * honors modifier/middle clicks). Params are required iff the pattern has them.\n *\n * @example\n * const Link = createLink(router)\n * Link({ to: '/posts/:postId', params: { postId: '42' }, children: 'Open' })\n */\nexport function createLink(router: Router): LinkComponent {\n  const Link = (props: LinkInput): MindeesElement => {\n    const tag = props.as ?? 'a'\n    const href = hrefFor(props)\n    const onClick = (event?: ClickEventLike): void => {\n      if (event && isModifiedClick(event)) return\n      event?.preventDefault?.()\n      // `href` is an absolute path; navigate by string (resolveHref no-ops on absolutes).\n      router.navigate(href, { replace: props.replace === true })\n    }\n\n    const elementProps: Record<string, unknown> = { onClick }\n    if (tag === 'a') elementProps.href = href\n\n    if (props.activeClass !== undefined) {\n      const here = buildPath(props.to, props.params ?? {})\n      elementProps.class = (): string =>\n        [props.class, router.location().pathname === here ? props.activeClass : undefined]\n          .filter((c): c is string => typeof c === 'string' && c.length > 0)\n          .join(' ')\n    } else if (props.class !== undefined) {\n      elementProps.class = props.class\n    }\n\n    return createElement(tag, elementProps, props.children)\n  }\n  return Link as LinkComponent\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAsBA,MAAM,mBAA+B,OAAO,OAAO,EAAE,QAAQ,OAAO,CAAC;;;;;;;;;;;AAsBrE,SAAgB,iBAAiB,QAAgB,UAA6B,CAAC,GAAgB;CAY7F,MAAM,YACH,gBACkB;EACjB,MAAM,QAAQ,OAAO,QAAQ,MAAM,EAAE,QAAQ,QAAQ,SAAS,IAAI,EAAE;EACpE,IAAI,UAAU,MACZ,OAAO,UAAU,KAAK,QAAQ,WAAW,cAAc,QAAQ,UAAU,CAAC,CAAC,IAAI;EAEjF,MAAM,QAAQ,SAAS,QAAQ,CAAC;EAChC,MAAM,YAAY,MAAM;EAExB,IAAI,cAAc,KAAA,GAAW,OAAO;EACpC,OAAO,cAAc,WAAW;GAC9B;GACA,QAAQ,OAAO;GACf,QAAQ,OAAO;GACf,YAAY;IACV,MAAM,QAAQ,OAAO,QAAQ,EAAE;IAC/B,OAAO,QAAQ,OAAO,WAAW,KAAK,IAAI;GAC5C;GACA,UAAU;EACZ,CAAC;CACH;CAEF,OAAO,SAAS,CAAC;AACnB;;AAmDA,SAAS,gBAAgB,OAAgC;CACvD,OACE,MAAM,qBAAqB,QAC1B,MAAM,WAAW,KAAA,KAAa,MAAM,WAAW,KAChD,MAAM,YAAY,QAClB,MAAM,YAAY,QAClB,MAAM,aAAa,QACnB,MAAM,WAAW;AAErB;;AAGA,SAAS,QAAQ,OAA0B;CACzC,MAAM,OAAO,UAAU,MAAM,IAAI,MAAM,UAAU,CAAC,CAAC;CACnD,MAAM,QAAQ,MAAM,SAAS,eAAe,MAAM,MAAM,IAAI;CAC5D,IAAI,OAAO,MAAM,QAAQ;CACzB,IAAI,KAAK,SAAS,KAAK,CAAC,KAAK,WAAW,GAAG,GAAG,OAAO,IAAI;CACzD,OAAO,GAAG,OAAO,QAAQ,IAAI,UAAU,KAAK;AAC9C;;;;;;;;;;AAWA,SAAgB,WAAW,QAA+B;CACxD,MAAM,QAAQ,UAAqC;EACjD,MAAM,MAAM,MAAM,MAAM;EACxB,MAAM,OAAO,QAAQ,KAAK;EAC1B,MAAM,WAAW,UAAiC;GAChD,IAAI,SAAS,gBAAgB,KAAK,GAAG;GACrC,OAAO,iBAAiB;GAExB,OAAO,SAAS,MAAM,EAAE,SAAS,MAAM,YAAY,KAAK,CAAC;EAC3D;EAEA,MAAM,eAAwC,EAAE,QAAQ;EACxD,IAAI,QAAQ,KAAK,aAAa,OAAO;EAErC,IAAI,MAAM,gBAAgB,KAAA,GAAW;GACnC,MAAM,OAAO,UAAU,MAAM,IAAI,MAAM,UAAU,CAAC,CAAC;GACnD,aAAa,cACX,CAAC,MAAM,OAAO,OAAO,SAAS,EAAE,aAAa,OAAO,MAAM,cAAc,KAAA,CAAS,EAC9E,QAAQ,MAAmB,OAAO,MAAM,YAAY,EAAE,SAAS,CAAC,EAChE,KAAK,GAAG;EACf,OAAO,IAAI,MAAM,UAAU,KAAA,GACzB,aAAa,QAAQ,MAAM;EAG7B,OAAO,cAAc,KAAK,cAAc,MAAM,QAAQ;CACxD;CACA,OAAO;AACT"}

package/dist/data.d.ts

@@ -0,0 +1,38 @@
+import { RouterLocation } from "./history.js";
+//#region src/data.d.ts
+/** Context passed to a route `loader`. */
+interface LoaderContext {
+  /** The matched path params. */
+  params: Record<string, string>;
+  /** The (validated) search params. */
+  search: Record<string, unknown>;
+  /** The current location. */
+  location: RouterLocation;
+  /** Aborted when this load is superseded (navigated away, or re-keyed). */
+  signal: AbortSignal;
+}
+/** A route data loader. May be sync or async. */
+type LoaderFn = (ctx: LoaderContext) => unknown | Promise<unknown>;
+/**
+ * Declares which inputs key a route's loader cache (e.g. specific search params).
+ * The returned value keys the SWR cache via `JSON.stringify`, so it must be
+ * JSON-serializable (and ideally have stable property order). A non-serializable
+ * value degrades to a params-only cache key rather than throwing.
+ */
+type LoaderDepsFn = (args: {
+  search: Record<string, unknown>;
+}) => unknown;
+/** Loader lifecycle status. */
+type LoaderStatus = 'idle' | 'pending' | 'success' | 'error';
+/** The reactive state of a route's loader. */
+interface LoaderData<T = unknown> {
+  /** `idle` when the route has no loader or hasn't started. */
+  status: LoaderStatus;
+  /** The loaded value (also present while `pending` if a stale value exists). */
+  data?: T;
+  /** The error, when `status === 'error'`. */
+  error?: unknown;
+}
+//#endregion
+export { LoaderContext, LoaderData, LoaderDepsFn, LoaderFn, LoaderStatus };
+//# sourceMappingURL=data.d.ts.map

package/dist/data.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"data.d.ts","names":[],"sources":["../src/data.ts"],"mappings":";;;UAiBiB,aAAA;EAIP;EAFR,MAAA,EAAQ,MAAA;EAIE;EAFV,MAAA,EAAQ,MAAA;EAIA;EAFR,QAAA,EAAU,cAAA;EAES;EAAnB,MAAA,EAAQ,WAAA;AAAA;;KAIE,QAAA,IAAY,GAAA,EAAK,aAAA,eAA4B,OAAO;;;;;AAAA;AAQhE;KAAY,YAAA,IAAgB,IAAA;EAAQ,MAAA,EAAQ,MAAM;AAAA;;KAGtC,YAAA;;UAGK,UAAA;EANoD;EAQnE,MAAA,EAAQ,YAAA;EALc;EAOtB,IAAA,GAAO,CAAC;EAPc;EAStB,KAAA;AAAA"}

package/dist/data.js

@@ -0,0 +1,151 @@
+//#region src/data.ts
+const IDLE = Object.freeze({ status: "idle" });
+/** Create a loader manager. */
+function createLoaderManager(options) {
+	const now = options.now ?? Date.now;
+	let cache = /* @__PURE__ */ new WeakMap();
+	const inFlight = /* @__PURE__ */ new Map();
+	const ids = /* @__PURE__ */ new WeakMap();
+	let nextId = 0;
+	let disposed = false;
+	const MAX_ENTRIES_PER_ROUTE = 64;
+	const idOf = (route) => {
+		let id = ids.get(route);
+		if (id === void 0) {
+			id = nextId++;
+			ids.set(route, id);
+		}
+		return id;
+	};
+	const innerKey = (route, match) => {
+		try {
+			const deps = route.loaderDeps ? route.loaderDeps({ search: match.search }) : null;
+			return JSON.stringify({
+				p: match.params,
+				d: deps
+			});
+		} catch {
+			return `${JSON.stringify({ p: match.params })}::unserializable-deps`;
+		}
+	};
+	const getEntry = (route, key) => cache.get(route)?.get(key);
+	const setEntry = (route, key, entry) => {
+		let m = cache.get(route);
+		if (!m) {
+			m = /* @__PURE__ */ new Map();
+			cache.set(route, m);
+		}
+		m.delete(key);
+		m.set(key, entry);
+		if (m.size > MAX_ENTRIES_PER_ROUTE) for (const [k, e] of m) {
+			if (m.size <= MAX_ENTRIES_PER_ROUTE) break;
+			if (e.status !== "pending") m.delete(k);
+		}
+	};
+	const ensure = (match) => {
+		if (disposed) return;
+		const route = match.route;
+		const loader = route.loader;
+		if (!loader) return;
+		const key = innerKey(route, match);
+		const gkey = `${idOf(route)}:${key}`;
+		const existing = getEntry(route, key);
+		const staleTime = route.staleTime ?? 0;
+		if (existing?.status === "success" && now() - existing.loadedAt < staleTime) return;
+		if (inFlight.has(gkey)) return;
+		const controller = new AbortController();
+		inFlight.set(gkey, controller);
+		const pendingEntry = {
+			status: "pending",
+			loadedAt: existing?.loadedAt ?? 0,
+			controller
+		};
+		if (existing?.data !== void 0) pendingEntry.data = existing.data;
+		setEntry(route, key, pendingEntry);
+		options.onChange();
+		const ctx = {
+			params: match.params,
+			search: match.search,
+			location: options.location(),
+			signal: controller.signal
+		};
+		const settle = (settled) => {
+			if (inFlight.get(gkey) === controller) inFlight.delete(gkey);
+			if (getEntry(route, key) !== pendingEntry) return;
+			setEntry(route, key, settled);
+			if (!controller.signal.aborted) options.onChange();
+		};
+		Promise.resolve().then(() => loader(ctx)).then((data) => settle({
+			status: "success",
+			data,
+			loadedAt: now()
+		}), (error) => {
+			const errored = {
+				status: "error",
+				error,
+				loadedAt: now()
+			};
+			if (existing?.data !== void 0) errored.data = existing.data;
+			settle(errored);
+		});
+	};
+	const currentGlobalKeys = (matches) => {
+		const keys = /* @__PURE__ */ new Set();
+		for (const m of matches) if (m.route.loader) keys.add(`${idOf(m.route)}:${innerKey(m.route, m)}`);
+		return keys;
+	};
+	const ensureSafe = (match) => {
+		try {
+			ensure(match);
+		} catch {}
+	};
+	return {
+		sync(matches) {
+			for (const m of matches) ensureSafe(m);
+			const keep = currentGlobalKeys(matches);
+			for (const [gkey, controller] of inFlight) if (!keep.has(gkey)) {
+				controller.abort();
+				inFlight.delete(gkey);
+			}
+		},
+		preload(matches) {
+			for (const m of matches) ensureSafe(m);
+		},
+		read(match) {
+			options.track();
+			const route = match.route;
+			if (!route.loader) return IDLE;
+			const entry = getEntry(route, innerKey(route, match));
+			if (!entry) return IDLE;
+			const out = { status: entry.status };
+			if (entry.data !== void 0) out.data = entry.data;
+			if (entry.error !== void 0) out.error = entry.error;
+			return out;
+		},
+		invalidate(matches) {
+			for (const m of matches) {
+				if (!m.route.loader) continue;
+				const key = innerKey(m.route, m);
+				const entry = getEntry(m.route, key);
+				if (entry) entry.loadedAt = 0;
+				const gkey = `${idOf(m.route)}:${key}`;
+				const controller = inFlight.get(gkey);
+				if (controller) {
+					controller.abort();
+					inFlight.delete(gkey);
+				}
+			}
+			this.sync(matches);
+		},
+		dispose() {
+			disposed = true;
+			for (const controller of inFlight.values()) controller.abort();
+			inFlight.clear();
+			cache = /* @__PURE__ */ new WeakMap();
+		}
+	};
+}
+//#endregion
+export { createLoaderManager };
+
+//# sourceMappingURL=data.js.map

package/dist/data.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"data.js","names":[],"sources":["../src/data.ts"],"sourcesContent":["/**\n * Loaders + data — a stale-while-revalidate (SWR) cache for route loaders.\n *\n * A route may declare a `loader`. The manager runs loaders for the matched\n * chain, caches results (keyed by route identity + params + `loaderDeps`),\n * serves stale data while revalidating, aborts superseded loads via\n * `AbortSignal`, and exposes results **reactively** so a component's data binding\n * updates when its load resolves — without re-mounting the component. See\n * ADR-0005.\n *\n * @module\n */\n\nimport type { RouterLocation } from './history'\nimport type { RouteMatch, RouteRecord } from './router'\n\n/** Context passed to a route `loader`. */\nexport interface LoaderContext {\n  /** The matched path params. */\n  params: Record<string, string>\n  /** The (validated) search params. */\n  search: Record<string, unknown>\n  /** The current location. */\n  location: RouterLocation\n  /** Aborted when this load is superseded (navigated away, or re-keyed). */\n  signal: AbortSignal\n}\n\n/** A route data loader. May be sync or async. */\nexport type LoaderFn = (ctx: LoaderContext) => unknown | Promise<unknown>\n\n/**\n * Declares which inputs key a route's loader cache (e.g. specific search params).\n * The returned value keys the SWR cache via `JSON.stringify`, so it must be\n * JSON-serializable (and ideally have stable property order). A non-serializable\n * value degrades to a params-only cache key rather than throwing.\n */\nexport type LoaderDepsFn = (args: { search: Record<string, unknown> }) => unknown\n\n/** Loader lifecycle status. */\nexport type LoaderStatus = 'idle' | 'pending' | 'success' | 'error'\n\n/** The reactive state of a route's loader. */\nexport interface LoaderData<T = unknown> {\n  /** `idle` when the route has no loader or hasn't started. */\n  status: LoaderStatus\n  /** The loaded value (also present while `pending` if a stale value exists). */\n  data?: T\n  /** The error, when `status === 'error'`. */\n  error?: unknown\n}\n\nconst IDLE: LoaderData = Object.freeze({ status: 'idle' })\n\ninterface CacheEntry {\n  status: LoaderStatus\n  data?: unknown\n  error?: unknown\n  loadedAt: number\n  controller?: AbortController\n}\n\n/** Options for {@link createLoaderManager}. */\nexport interface LoaderManagerOptions {\n  /** The current location (for the loader context). */\n  location: () => RouterLocation\n  /** Called whenever cached data changes (bump the reactive data version). */\n  onChange: () => void\n  /** Subscribe the current reactive scope to data changes (read the version signal). */\n  track: () => void\n  /** Wall-clock now (injectable for tests). Defaults to `Date.now`. */\n  now?: () => number\n}\n\n/** Manages route loaders + their SWR cache. */\nexport interface LoaderManager {\n  /** Ensure loads for the matched chain and abort loads for routes no longer matched. */\n  sync(matches: readonly RouteMatch[]): void\n  /** Ensure loads for `matches` WITHOUT aborting others (used by `preload`). */\n  preload(matches: readonly RouteMatch[]): void\n  /** Reactively read a match's loader state. */\n  read(match: RouteMatch): LoaderData\n  /** Mark the given chain's entries stale and reload them. */\n  invalidate(matches: readonly RouteMatch[]): void\n  /** Abort all in-flight loads. */\n  dispose(): void\n}\n\n/** Create a loader manager. */\nexport function createLoaderManager(options: LoaderManagerOptions): LoaderManager {\n  const now = options.now ?? Date.now\n  // Per-route SWR cache. The outer WeakMap lets a route's entries be reclaimed\n  // when its RouteRecord is dropped; the inner Map is bounded (see setEntry) so a\n  // high-cardinality dynamic route (e.g. `/posts/:id` visited thousands of times)\n  // can't grow it without limit. `let` so dispose() can drop it wholesale.\n  let cache = new WeakMap<RouteRecord, Map<string, CacheEntry>>()\n  const inFlight = new Map<string, AbortController>()\n  const ids = new WeakMap<RouteRecord, number>()\n  let nextId = 0\n  let disposed = false\n\n  // Max distinct (params, loaderDeps) entries retained per route before the oldest\n  // non-pending entries are evicted (LRU by last write). Bounds memory growth.\n  const MAX_ENTRIES_PER_ROUTE = 64\n\n  const idOf = (route: RouteRecord): number => {\n    let id = ids.get(route)\n    if (id === undefined) {\n      id = nextId++\n      ids.set(route, id)\n    }\n    return id\n  }\n\n  const innerKey = (route: RouteRecord, match: RouteMatch): string => {\n    try {\n      const deps = route.loaderDeps ? route.loaderDeps({ search: match.search }) : null\n      return JSON.stringify({ p: match.params, d: deps })\n    } catch {\n      // A throwing or non-serializable loaderDeps (BigInt/circular): degrade to a\n      // params-only key rather than throwing out of navigation. `params` is\n      // always a Record<string, string>, so this is total. (loaderDeps should be\n      // pure and JSON-serializable — see LoaderDepsFn.) innerKey is also called\n      // from currentGlobalKeys/read/invalidate, so it must never throw.\n      return `${JSON.stringify({ p: match.params })}::unserializable-deps`\n    }\n  }\n\n  const getEntry = (route: RouteRecord, key: string): CacheEntry | undefined =>\n    cache.get(route)?.get(key)\n\n  const setEntry = (route: RouteRecord, key: string, entry: CacheEntry): void => {\n    let m = cache.get(route)\n    if (!m) {\n      m = new Map()\n      cache.set(route, m)\n    }\n    // Re-insert so Map iteration order is least-recently-written first.\n    m.delete(key)\n    m.set(key, entry)\n    // Bound the cache: evict the oldest entries that aren't currently loading.\n    if (m.size > MAX_ENTRIES_PER_ROUTE) {\n      for (const [k, e] of m) {\n        if (m.size <= MAX_ENTRIES_PER_ROUTE) break\n        if (e.status !== 'pending') m.delete(k)\n      }\n    }\n  }\n\n  const ensure = (match: RouteMatch): void => {\n    if (disposed) return\n    const route = match.route\n    const loader = route.loader\n    if (!loader) return\n\n    const key = innerKey(route, match)\n    const gkey = `${idOf(route)}:${key}`\n    const existing = getEntry(route, key)\n    const staleTime = route.staleTime ?? 0\n\n    if (existing?.status === 'success' && now() - existing.loadedAt < staleTime) return\n    if (inFlight.has(gkey)) return // a load for this exact key is already running\n\n    const controller = new AbortController()\n    inFlight.set(gkey, controller)\n    // Keep any prior data visible while revalidating (stale-while-revalidate).\n    const pendingEntry: CacheEntry = {\n      status: 'pending',\n      loadedAt: existing?.loadedAt ?? 0,\n      controller,\n    }\n    if (existing?.data !== undefined) pendingEntry.data = existing.data\n    setEntry(route, key, pendingEntry)\n    options.onChange()\n\n    const ctx: LoaderContext = {\n      params: match.params,\n      search: match.search,\n      location: options.location(),\n      signal: controller.signal,\n    }\n\n    // Settle the load. Even an aborted load (e.g. a preload superseded by a\n    // navigation) still warms the cache for the route's next visit — but only if\n    // our pending entry hasn't already been replaced by a newer load, and we\n    // notify observers only when we weren't aborted. This also guarantees an\n    // aborted preload never leaves a permanently `pending` cache entry.\n    const settle = (settled: CacheEntry): void => {\n      if (inFlight.get(gkey) === controller) inFlight.delete(gkey)\n      if (getEntry(route, key) !== pendingEntry) return // a newer load superseded us\n      setEntry(route, key, settled)\n      if (!controller.signal.aborted) options.onChange()\n    }\n\n    Promise.resolve()\n      .then(() => loader(ctx))\n      .then(\n        (data) => settle({ status: 'success', data, loadedAt: now() }),\n        (error: unknown) => {\n          const errored: CacheEntry = { status: 'error', error, loadedAt: now() }\n          if (existing?.data !== undefined) errored.data = existing.data\n          settle(errored)\n        },\n      )\n  }\n\n  const currentGlobalKeys = (matches: readonly RouteMatch[]): Set<string> => {\n    const keys = new Set<string>()\n    for (const m of matches) {\n      if (m.route.loader) keys.add(`${idOf(m.route)}:${innerKey(m.route, m)}`)\n    }\n    return keys\n  }\n\n  // Run ensure() for one match, isolating failures so a single route can never\n  // abort the whole pass (and so nothing escapes navigation).\n  const ensureSafe = (match: RouteMatch): void => {\n    try {\n      ensure(match)\n    } catch {\n      // A route's key/loader-start failure must not break sibling/child loads.\n    }\n  }\n\n  return {\n    sync(matches) {\n      for (const m of matches) ensureSafe(m)\n      // Abort in-flight loads for routes no longer in the matched chain.\n      const keep = currentGlobalKeys(matches)\n      for (const [gkey, controller] of inFlight) {\n        if (!keep.has(gkey)) {\n          controller.abort()\n          inFlight.delete(gkey)\n        }\n      }\n    },\n    preload(matches) {\n      for (const m of matches) ensureSafe(m)\n    },\n    read(match) {\n      options.track()\n      const route = match.route\n      if (!route.loader) return IDLE\n      const entry = getEntry(route, innerKey(route, match))\n      if (!entry) return IDLE\n      const out: LoaderData = { status: entry.status }\n      if (entry.data !== undefined) out.data = entry.data\n      if (entry.error !== undefined) out.error = entry.error\n      return out\n    },\n    invalidate(matches) {\n      for (const m of matches) {\n        if (!m.route.loader) continue\n        const key = innerKey(m.route, m)\n        const entry = getEntry(m.route, key)\n        if (entry) entry.loadedAt = 0 // force stale\n        // If a load is already in flight for this key, abort it so the sync below\n        // starts a FRESH load — otherwise ensure() bails on the in-flight guard\n        // and the pre-invalidate (possibly stale) result is served, with the\n        // staleness mark silently overwritten when it resolves.\n        const gkey = `${idOf(m.route)}:${key}`\n        const controller = inFlight.get(gkey)\n        if (controller) {\n          controller.abort()\n          inFlight.delete(gkey)\n        }\n      }\n      this.sync(matches)\n    },\n    dispose() {\n      disposed = true\n      for (const controller of inFlight.values()) controller.abort()\n      inFlight.clear()\n      // Drop all cached loader data so a disposed (but still-referenced) manager\n      // doesn't retain payloads; a fresh WeakMap lets the inner Maps be GC'd.\n      cache = new WeakMap()\n    },\n  }\n}\n"],"mappings":"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"}

package/dist/errors.d.ts

@@ -0,0 +1,21 @@
+import { StandardSchemaV1 } from "./standard-schema.js";
+
+//#region src/errors.d.ts
+/** Machine-readable router error codes. */
+type RouterErrorCode = /** A path pattern was malformed (e.g. a catch-all that is not the last segment). */'INVALID_PATTERN' /** {@link buildPath} was called without a value for a required param. */ | 'MISSING_PARAM' /** Search-param validation failed against the route's schema. */ | 'VALIDATE_SEARCH'
+/**
+ * A Standard Schema returned a `Promise`. Navigation-time parsing must be
+ * synchronous, so async schemas are rejected.
+ */
+| 'ASYNC_SCHEMA';
+/** An error thrown by the Quantum router. */
+declare class RouterError extends Error {
+  /** Machine-readable error code. */
+  readonly code: RouterErrorCode;
+  /** Standard Schema issues, present only for `VALIDATE_SEARCH`. */
+  readonly issues?: ReadonlyArray<StandardSchemaV1.Issue>;
+  constructor(code: RouterErrorCode, message: string, issues?: ReadonlyArray<StandardSchemaV1.Issue>);
+}
+//#endregion
+export { RouterError, RouterErrorCode };
+//# sourceMappingURL=errors.d.ts.map

package/dist/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","names":[],"sources":["../src/errors.ts"],"mappings":";;;AAyBA;AAAA,KAdY,eAAA;;;;;;;cAcC,WAAA,SAAoB,KAAA;EAItB;EAAA,SAFA,IAAA,EAAM,eAAA;EAEiB;EAAA,SAAvB,MAAA,GAAS,aAAA,CAAc,gBAAA,CAAiB,KAAA;cAG/C,IAAA,EAAM,eAAA,EACN,OAAA,UACA,MAAA,GAAS,aAAA,CAAc,gBAAA,CAAiB,KAAA;AAAA"}