@mindees/router 0.1.0

package/dist/errors.js

@@ -0,0 +1,18 @@
+//#region src/errors.ts
+/** An error thrown by the Quantum router. */
+var RouterError = class extends Error {
+	/** Machine-readable error code. */
+	code;
+	/** Standard Schema issues, present only for `VALIDATE_SEARCH`. */
+	issues;
+	constructor(code, message, issues) {
+		super(message);
+		this.name = "RouterError";
+		this.code = code;
+		if (issues !== void 0) this.issues = issues;
+	}
+};
+//#endregion
+export { RouterError };
+
+//# sourceMappingURL=errors.js.map

package/dist/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.js","names":[],"sources":["../src/errors.ts"],"sourcesContent":["/**\n * Router error types. A single {@link RouterError} carries a machine-readable\n * `code` (so callers can branch without string-matching messages) and, for\n * search-validation failures, the Standard Schema issues that caused it.\n *\n * @module\n */\n\nimport type { StandardSchemaV1 } from './standard-schema'\n\n/** Machine-readable router error codes. */\nexport type RouterErrorCode =\n  /** A path pattern was malformed (e.g. a catch-all that is not the last segment). */\n  | 'INVALID_PATTERN'\n  /** {@link buildPath} was called without a value for a required param. */\n  | 'MISSING_PARAM'\n  /** Search-param validation failed against the route's schema. */\n  | 'VALIDATE_SEARCH'\n  /**\n   * A Standard Schema returned a `Promise`. Navigation-time parsing must be\n   * synchronous, so async schemas are rejected.\n   */\n  | 'ASYNC_SCHEMA'\n\n/** An error thrown by the Quantum router. */\nexport class RouterError extends Error {\n  /** Machine-readable error code. */\n  readonly code: RouterErrorCode\n  /** Standard Schema issues, present only for `VALIDATE_SEARCH`. */\n  readonly issues?: ReadonlyArray<StandardSchemaV1.Issue>\n\n  constructor(\n    code: RouterErrorCode,\n    message: string,\n    issues?: ReadonlyArray<StandardSchemaV1.Issue>,\n  ) {\n    super(message)\n    this.name = 'RouterError'\n    this.code = code\n    if (issues !== undefined) this.issues = issues\n  }\n}\n"],"mappings":";;AAyBA,IAAa,cAAb,cAAiC,MAAM;;CAErC;;CAEA;CAEA,YACE,MACA,SACA,QACA;EACA,MAAM,OAAO;EACb,KAAK,OAAO;EACZ,KAAK,OAAO;EACZ,IAAI,WAAW,KAAA,GAAW,KAAK,SAAS;CAC1C;AACF"}

package/dist/history.d.ts

@@ -0,0 +1,75 @@
+//#region src/history.d.ts
+/**
+ * History — the navigation capability the router is built on.
+ *
+ * {@link RouterHistory} is a tiny observable over a location. Two adapters ship:
+ * {@link createMemoryHistory} (in-memory, the primary tested path — no DOM, so
+ * the whole router is deterministically testable headless) and
+ * {@link createBrowserHistory} (binds `window.history` + `popstate`).
+ *
+ * @module
+ */
+/** A parsed location: pathname plus the raw search and hash strings. */
+interface RouterLocation {
+  /** Path portion, always starting with `/` (e.g. `/posts/42`). */
+  readonly pathname: string;
+  /** Raw search string including the leading `?` (e.g. `?page=2`), or `''`. */
+  readonly search: string;
+  /** Raw hash including the leading `#`, or `''`. */
+  readonly hash: string;
+}
+/** A listener notified on every location change. */
+type HistoryListener = (location: RouterLocation) => void;
+/** The navigation capability: read the location, navigate, and subscribe. */
+interface RouterHistory {
+  /** The current location. */
+  location(): RouterLocation;
+  /** Push a new entry (forward history is discarded). Notifies synchronously. */
+  push(to: string): void;
+  /** Replace the current entry in place. Notifies synchronously. */
+  replace(to: string): void;
+  /**
+   * Move within the stack by a relative delta.
+   *
+   * Timing differs by adapter: {@link createMemoryHistory} updates and notifies
+   * **synchronously**, whereas {@link createBrowserHistory} delegates to
+   * `window.history` and the location change is observed **asynchronously** via
+   * the `popstate` event — so reading `location()` immediately after `go()` may
+   * still return the previous location in a browser.
+   */
+  go(delta: number): void;
+  /** Shorthand for `go(-1)`. See {@link RouterHistory.go} for timing caveats. */
+  back(): void;
+  /** Shorthand for `go(1)`. See {@link RouterHistory.go} for timing caveats. */
+  forward(): void;
+  /** Subscribe to location changes; returns an unsubscribe function. */
+  subscribe(listener: HistoryListener): () => void;
+}
+/** Parse an href string into a {@link RouterLocation} (no base required). */
+declare function parseHref(href: string): RouterLocation;
+/** Serialize a {@link RouterLocation} back into an href string. */
+declare function createHref(location: RouterLocation): string;
+/** Options for {@link createMemoryHistory}. */
+interface MemoryHistoryOptions {
+  /** Initial entries (hrefs). Defaults to `['/']`. */
+  initialEntries?: readonly string[];
+  /** Initial index into `initialEntries`. Defaults to the last entry. */
+  initialIndex?: number;
+}
+/**
+ * Create an in-memory history. Deterministic and DOM-free — the primary tested
+ * path and the right adapter for SSR, tests, and non-browser hosts.
+ */
+declare function createMemoryHistory(options?: MemoryHistoryOptions): RouterHistory;
+/**
+ * Create a history bound to the browser's `window.history`. `push`/`replace` use
+ * the History API; `popstate` (back/forward) is observed and forwarded to
+ * subscribers. The `popstate` listener is attached lazily while there is at
+ * least one subscriber and removed when the last one unsubscribes.
+ *
+ * Requires a DOM (`window`). Use {@link createMemoryHistory} elsewhere.
+ */
+declare function createBrowserHistory(): RouterHistory;
+//#endregion
+export { HistoryListener, MemoryHistoryOptions, RouterHistory, RouterLocation, createBrowserHistory, createHref, createMemoryHistory, parseHref };
+//# sourceMappingURL=history.d.ts.map

package/dist/history.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"history.d.ts","names":[],"sources":["../src/history.ts"],"mappings":";;AAYA;;;;;;;;AAMe;AAIf;AAAA,UAViB,cAAA;;WAEN,QAAA;EAQ4C;EAAA,SAN5C,MAAA;EASmB;EAAA,SAPnB,IAAA;AAAA;;KAIC,eAAA,IAAmB,QAAwB,EAAd,cAAc;;UAGtC,aAAA;EAMf;EAJA,QAAA,IAAY,cAAA;EAcZ;EAZA,IAAA,CAAK,EAAA;EAcL;EAZA,OAAA,CAAQ,EAAA;EAgBR;;;;AAAmC;AAMrC;;;;EAZE,EAAA,CAAG,KAAA;EAgCW;EA9Bd,IAAA;;EAEA,OAAA;EA4BiD;EA1BjD,SAAA,CAAU,QAAA,EAAU,eAAe;AAAA;;iBAMrB,SAAA,CAAU,IAAA,WAAe,cAAc;AA6BzC;AAAA,iBATE,UAAA,CAAW,QAAwB,EAAd,cAAc;;UAKlC,oBAAA;EAgBqE;EAdpF,cAAA;EAckC;EAZlC,YAAY;AAAA;AAYwE;AAoDtF;;;AApDsF,iBAAtE,mBAAA,CAAoB,OAAA,GAAS,oBAAA,GAA4B,aAAa;AAoDjC;;;;;;;;AAAA,iBAArC,oBAAA,IAAwB,aAAa"}

package/dist/history.js

@@ -0,0 +1,125 @@
+//#region src/history.ts
+const ROOT = {
+	pathname: "/",
+	search: "",
+	hash: ""
+};
+/** Parse an href string into a {@link RouterLocation} (no base required). */
+function parseHref(href) {
+	let rest = href;
+	let hash = "";
+	const hashIndex = rest.indexOf("#");
+	if (hashIndex !== -1) {
+		hash = rest.slice(hashIndex);
+		rest = rest.slice(0, hashIndex);
+	}
+	let search = "";
+	const queryIndex = rest.indexOf("?");
+	if (queryIndex !== -1) {
+		search = rest.slice(queryIndex);
+		rest = rest.slice(0, queryIndex);
+	}
+	return {
+		pathname: rest.length === 0 ? "/" : rest.startsWith("/") ? rest : `/${rest}`,
+		search,
+		hash
+	};
+}
+/** Serialize a {@link RouterLocation} back into an href string. */
+function createHref(location) {
+	return `${location.pathname}${location.search}${location.hash}`;
+}
+/** Clamp `n` to the inclusive range `[min, max]`. */
+function clamp(n, min, max) {
+	return Math.min(max, Math.max(min, n));
+}
+/**
+* Create an in-memory history. Deterministic and DOM-free — the primary tested
+* path and the right adapter for SSR, tests, and non-browser hosts.
+*/
+function createMemoryHistory(options = {}) {
+	const entries = (options.initialEntries && options.initialEntries.length > 0 ? options.initialEntries : ["/"]).map(parseHref);
+	let index = clamp(options.initialIndex ?? entries.length - 1, 0, entries.length - 1);
+	const listeners = /* @__PURE__ */ new Set();
+	const current = () => entries[index] ?? ROOT;
+	const notify = () => {
+		const location = current();
+		for (const listener of listeners) listener(location);
+	};
+	const go = (delta) => {
+		const next = clamp(index + delta, 0, entries.length - 1);
+		if (next !== index) {
+			index = next;
+			notify();
+		}
+	};
+	return {
+		location: current,
+		push(to) {
+			entries.splice(index + 1);
+			entries.push(parseHref(to));
+			index = entries.length - 1;
+			notify();
+		},
+		replace(to) {
+			entries[index] = parseHref(to);
+			notify();
+		},
+		go,
+		back: () => go(-1),
+		forward: () => go(1),
+		subscribe(listener) {
+			listeners.add(listener);
+			return () => {
+				listeners.delete(listener);
+			};
+		}
+	};
+}
+/**
+* Create a history bound to the browser's `window.history`. `push`/`replace` use
+* the History API; `popstate` (back/forward) is observed and forwarded to
+* subscribers. The `popstate` listener is attached lazily while there is at
+* least one subscriber and removed when the last one unsubscribes.
+*
+* Requires a DOM (`window`). Use {@link createMemoryHistory} elsewhere.
+*/
+function createBrowserHistory() {
+	const listeners = /* @__PURE__ */ new Set();
+	const current = () => ({
+		pathname: window.location.pathname,
+		search: window.location.search,
+		hash: window.location.hash
+	});
+	const notify = () => {
+		const location = current();
+		for (const listener of listeners) listener(location);
+	};
+	const onPopState = () => notify();
+	return {
+		location: current,
+		push(to) {
+			window.history.pushState(null, "", createHref(parseHref(to)));
+			notify();
+		},
+		replace(to) {
+			window.history.replaceState(null, "", createHref(parseHref(to)));
+			notify();
+		},
+		go: (delta) => window.history.go(delta),
+		back: () => window.history.back(),
+		forward: () => window.history.forward(),
+		subscribe(listener) {
+			if (listeners.size === 0) window.addEventListener("popstate", onPopState);
+			listeners.add(listener);
+			return () => {
+				listeners.delete(listener);
+				if (listeners.size === 0) window.removeEventListener("popstate", onPopState);
+			};
+		}
+	};
+}
+//#endregion
+export { createBrowserHistory, createHref, createMemoryHistory, parseHref };
+
+//# sourceMappingURL=history.js.map

package/dist/history.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"history.js","names":[],"sources":["../src/history.ts"],"sourcesContent":["/**\n * History — the navigation capability the router is built on.\n *\n * {@link RouterHistory} is a tiny observable over a location. Two adapters ship:\n * {@link createMemoryHistory} (in-memory, the primary tested path — no DOM, so\n * the whole router is deterministically testable headless) and\n * {@link createBrowserHistory} (binds `window.history` + `popstate`).\n *\n * @module\n */\n\n/** A parsed location: pathname plus the raw search and hash strings. */\nexport interface RouterLocation {\n  /** Path portion, always starting with `/` (e.g. `/posts/42`). */\n  readonly pathname: string\n  /** Raw search string including the leading `?` (e.g. `?page=2`), or `''`. */\n  readonly search: string\n  /** Raw hash including the leading `#`, or `''`. */\n  readonly hash: string\n}\n\n/** A listener notified on every location change. */\nexport type HistoryListener = (location: RouterLocation) => void\n\n/** The navigation capability: read the location, navigate, and subscribe. */\nexport interface RouterHistory {\n  /** The current location. */\n  location(): RouterLocation\n  /** Push a new entry (forward history is discarded). Notifies synchronously. */\n  push(to: string): void\n  /** Replace the current entry in place. Notifies synchronously. */\n  replace(to: string): void\n  /**\n   * Move within the stack by a relative delta.\n   *\n   * Timing differs by adapter: {@link createMemoryHistory} updates and notifies\n   * **synchronously**, whereas {@link createBrowserHistory} delegates to\n   * `window.history` and the location change is observed **asynchronously** via\n   * the `popstate` event — so reading `location()` immediately after `go()` may\n   * still return the previous location in a browser.\n   */\n  go(delta: number): void\n  /** Shorthand for `go(-1)`. See {@link RouterHistory.go} for timing caveats. */\n  back(): void\n  /** Shorthand for `go(1)`. See {@link RouterHistory.go} for timing caveats. */\n  forward(): void\n  /** Subscribe to location changes; returns an unsubscribe function. */\n  subscribe(listener: HistoryListener): () => void\n}\n\nconst ROOT: RouterLocation = { pathname: '/', search: '', hash: '' }\n\n/** Parse an href string into a {@link RouterLocation} (no base required). */\nexport function parseHref(href: string): RouterLocation {\n  let rest = href\n  let hash = ''\n  const hashIndex = rest.indexOf('#')\n  if (hashIndex !== -1) {\n    hash = rest.slice(hashIndex)\n    rest = rest.slice(0, hashIndex)\n  }\n  let search = ''\n  const queryIndex = rest.indexOf('?')\n  if (queryIndex !== -1) {\n    search = rest.slice(queryIndex)\n    rest = rest.slice(0, queryIndex)\n  }\n  // Guarantee the documented invariant: pathname always starts with '/'.\n  const pathname = rest.length === 0 ? '/' : rest.startsWith('/') ? rest : `/${rest}`\n  return { pathname, search, hash }\n}\n\n/** Serialize a {@link RouterLocation} back into an href string. */\nexport function createHref(location: RouterLocation): string {\n  return `${location.pathname}${location.search}${location.hash}`\n}\n\n/** Options for {@link createMemoryHistory}. */\nexport interface MemoryHistoryOptions {\n  /** Initial entries (hrefs). Defaults to `['/']`. */\n  initialEntries?: readonly string[]\n  /** Initial index into `initialEntries`. Defaults to the last entry. */\n  initialIndex?: number\n}\n\n/** Clamp `n` to the inclusive range `[min, max]`. */\nfunction clamp(n: number, min: number, max: number): number {\n  return Math.min(max, Math.max(min, n))\n}\n\n/**\n * Create an in-memory history. Deterministic and DOM-free — the primary tested\n * path and the right adapter for SSR, tests, and non-browser hosts.\n */\nexport function createMemoryHistory(options: MemoryHistoryOptions = {}): RouterHistory {\n  const initial =\n    options.initialEntries && options.initialEntries.length > 0 ? options.initialEntries : ['/']\n  const entries: RouterLocation[] = initial.map(parseHref)\n  let index = clamp(options.initialIndex ?? entries.length - 1, 0, entries.length - 1)\n  const listeners = new Set<HistoryListener>()\n\n  const current = (): RouterLocation => entries[index] ?? ROOT\n  const notify = (): void => {\n    const location = current()\n    for (const listener of listeners) listener(location)\n  }\n  const go = (delta: number): void => {\n    const next = clamp(index + delta, 0, entries.length - 1)\n    if (next !== index) {\n      index = next\n      notify()\n    }\n  }\n\n  return {\n    location: current,\n    push(to) {\n      entries.splice(index + 1)\n      entries.push(parseHref(to))\n      index = entries.length - 1\n      notify()\n    },\n    replace(to) {\n      entries[index] = parseHref(to)\n      notify()\n    },\n    go,\n    back: () => go(-1),\n    forward: () => go(1),\n    subscribe(listener) {\n      listeners.add(listener)\n      return () => {\n        listeners.delete(listener)\n      }\n    },\n  }\n}\n\n/**\n * Create a history bound to the browser's `window.history`. `push`/`replace` use\n * the History API; `popstate` (back/forward) is observed and forwarded to\n * subscribers. The `popstate` listener is attached lazily while there is at\n * least one subscriber and removed when the last one unsubscribes.\n *\n * Requires a DOM (`window`). Use {@link createMemoryHistory} elsewhere.\n */\nexport function createBrowserHistory(): RouterHistory {\n  const listeners = new Set<HistoryListener>()\n  const current = (): RouterLocation => ({\n    pathname: window.location.pathname,\n    search: window.location.search,\n    hash: window.location.hash,\n  })\n  const notify = (): void => {\n    const location = current()\n    for (const listener of listeners) listener(location)\n  }\n  const onPopState = (): void => notify()\n\n  return {\n    location: current,\n    push(to) {\n      // Normalize via parseHref so the browser adapter treats `to` as an href\n      // (not browser-relative), matching createMemoryHistory exactly. Router\n      // navigation already passes absolute hrefs; this only affects direct calls.\n      window.history.pushState(null, '', createHref(parseHref(to)))\n      notify()\n    },\n    replace(to) {\n      window.history.replaceState(null, '', createHref(parseHref(to)))\n      notify()\n    },\n    go: (delta) => window.history.go(delta),\n    back: () => window.history.back(),\n    forward: () => window.history.forward(),\n    subscribe(listener) {\n      if (listeners.size === 0) window.addEventListener('popstate', onPopState)\n      listeners.add(listener)\n      return () => {\n        listeners.delete(listener)\n        if (listeners.size === 0) window.removeEventListener('popstate', onPopState)\n      }\n    },\n  }\n}\n"],"mappings":"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"}

package/dist/index.d.ts

@@ -0,0 +1,28 @@
+import { HistoryListener, MemoryHistoryOptions, RouterHistory, RouterLocation, createBrowserHistory, createHref, createMemoryHistory, parseHref } from "./history.js";
+import { LoaderContext, LoaderData, LoaderDepsFn, LoaderFn, LoaderStatus } from "./data.js";
+import { HasPathParams, PathParams, buildPath, compareSpecificity, matchPattern, parsePattern } from "./pattern.js";
+import { StandardSchemaV1 } from "./standard-schema.js";
+import { QueryValue, ValidationResult, parseQuery, safeValidateSearch, stringifyQuery, validateSearch } from "./search.js";
+import { BeforeNavigate, CreateRouterOptions, NavTarget, NavigateOptions, RouteComponentProps, RouteMatch, RouteRecord, Router, RouterState, createRouter, resolvePath } from "./router.js";
+import { LinkComponent, LinkOptions, LinkProps, RouterViewOptions, createLink, createRouterView } from "./components.js";
+import { RouterError, RouterErrorCode } from "./errors.js";
+import { Maturity, NotImplementedError, PackageInfo, notImplemented } from "@mindees/core";
+
+//#region src/index.d.ts
+/** The npm package name. */
+declare const name = "@mindees/router";
+/** The package version. All `@mindees/*` packages share one locked version line. */
+declare const VERSION = "0.1.0";
+/**
+ * Current maturity. Router I (typed params, Standard-Schema search, history, the
+ * signals-native router, selector-isolated state, typed + relative navigation)
+ * and Router II (nested rendering, typed links, SWR loaders, navigation guards,
+ * view transitions) are implemented and tested. The global typed route registry
+ * and file-based route scanning are a later phase — see `STATUS.md`.
+ */
+declare const maturity: Maturity;
+/** Static identity + maturity metadata for this package. */
+declare const info: PackageInfo;
+//#endregion
+export { type BeforeNavigate, type CreateRouterOptions, type HasPathParams, type HistoryListener, type LinkComponent, type LinkOptions, type LinkProps, type LoaderContext, type LoaderData, type LoaderDepsFn, type LoaderFn, type LoaderStatus, type Maturity, type MemoryHistoryOptions, type NavTarget, type NavigateOptions, NotImplementedError, type PackageInfo, type PathParams, type QueryValue, type RouteComponentProps, type RouteMatch, type RouteRecord, type Router, RouterError, type RouterErrorCode, type RouterHistory, type RouterLocation, type RouterState, type RouterViewOptions, type StandardSchemaV1, VERSION, type ValidationResult, buildPath, compareSpecificity, createBrowserHistory, createHref, createLink, createMemoryHistory, createRouter, createRouterView, info, matchPattern, maturity, name, notImplemented, parseHref, parsePattern, parseQuery, resolvePath, safeValidateSearch, stringifyQuery, validateSearch };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/index.ts"],"mappings":";;;;;;;;;;;;cAyFa,IAAA;;cAGA,OAAA;;;;;;;;cASA,QAAA,EAAU,QAAyB;;cAGnC,IAAA,EAAM,WAAkD"}

package/dist/index.js

@@ -0,0 +1,30 @@
+import { RouterError } from "./errors.js";
+import { buildPath, compareSpecificity, matchPattern, parsePattern } from "./pattern.js";
+import { parseQuery, safeValidateSearch, stringifyQuery, validateSearch } from "./search.js";
+import { createLink, createRouterView } from "./components.js";
+import { createBrowserHistory, createHref, createMemoryHistory, parseHref } from "./history.js";
+import { createRouter, resolvePath } from "./router.js";
+import { NotImplementedError, notImplemented } from "@mindees/core";
+//#region src/index.ts
+/** The npm package name. */
+const name = "@mindees/router";
+/** The package version. All `@mindees/*` packages share one locked version line. */
+const VERSION = "0.1.0";
+/**
+* Current maturity. Router I (typed params, Standard-Schema search, history, the
+* signals-native router, selector-isolated state, typed + relative navigation)
+* and Router II (nested rendering, typed links, SWR loaders, navigation guards,
+* view transitions) are implemented and tested. The global typed route registry
+* and file-based route scanning are a later phase — see `STATUS.md`.
+*/
+const maturity = "experimental";
+/** Static identity + maturity metadata for this package. */
+const info = {
+	name,
+	version: VERSION,
+	maturity
+};
+//#endregion
+export { NotImplementedError, RouterError, VERSION, buildPath, compareSpecificity, createBrowserHistory, createHref, createLink, createMemoryHistory, createRouter, createRouterView, info, matchPattern, maturity, name, notImplemented, parseHref, parsePattern, parseQuery, resolvePath, safeValidateSearch, stringifyQuery, validateSearch };
+
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../src/index.ts"],"sourcesContent":["/**\n * `@mindees/router` — **Quantum**, the typed router for MindeesNative.\n *\n * Router I (Phase 6): codegen-free typed path params ({@link PathParams}),\n * Standard-Schema validated search params, a signals-native router with typed +\n * relative navigation and selector-isolated state, and an injectable history\n * (memory + browser). See ADR-0003.\n *\n * Router II (Phase 7): render integration — {@link createRouterView} (nested,\n * fine-grained, layout-preserving) and typed {@link createLink} — plus SWR data\n * loaders (with `AbortSignal`, {@link Router.invalidate}/{@link Router.preload}),\n * navigation guards ({@link BeforeNavigate} cancel/redirect + idempotent\n * navigation), and web view transitions. See ADR-0004 and ADR-0005.\n *\n * Still a later phase (not exported): the global typed route registry and\n * file-based route scanning + bundler plugin. See `STATUS.md`.\n *\n * @module\n */\n\nimport type { Maturity, PackageInfo } from '@mindees/core'\nimport { NotImplementedError, notImplemented } from '@mindees/core'\n\n/** Render integration: nested view + typed links (Router II). */\nexport {\n  createLink,\n  createRouterView,\n  type LinkComponent,\n  type LinkOptions,\n  type LinkProps,\n  type RouterViewOptions,\n} from './components'\n/** Loaders + data (SWR). */\nexport type {\n  LoaderContext,\n  LoaderData,\n  LoaderDepsFn,\n  LoaderFn,\n  LoaderStatus,\n} from './data'\n/** Errors. */\nexport { RouterError, type RouterErrorCode } from './errors'\n/** History capability. */\nexport {\n  createBrowserHistory,\n  createHref,\n  createMemoryHistory,\n  type HistoryListener,\n  type MemoryHistoryOptions,\n  parseHref,\n  type RouterHistory,\n  type RouterLocation,\n} from './history'\n/** Route patterns + codegen-free typed params. */\nexport {\n  buildPath,\n  compareSpecificity,\n  type HasPathParams,\n  matchPattern,\n  type PathParams,\n  parsePattern,\n} from './pattern'\n/** Router. */\nexport {\n  type BeforeNavigate,\n  type CreateRouterOptions,\n  createRouter,\n  type NavigateOptions,\n  type NavTarget,\n  type RouteComponentProps,\n  type RouteMatch,\n  type RouteRecord,\n  type Router,\n  type RouterState,\n  resolvePath,\n} from './router'\n/** Search (query) params. */\nexport {\n  parseQuery,\n  type QueryValue,\n  safeValidateSearch,\n  stringifyQuery,\n  type ValidationResult,\n  validateSearch,\n} from './search'\n/** Standard Schema — the validator-agnostic interface (vendored, types only). */\nexport type { StandardSchemaV1 } from './standard-schema'\n\n/** The npm package name. */\nexport const name = '@mindees/router'\n\n/** The package version. All `@mindees/*` packages share one locked version line. */\nexport const VERSION = '0.1.0'\n\n/**\n * Current maturity. Router I (typed params, Standard-Schema search, history, the\n * signals-native router, selector-isolated state, typed + relative navigation)\n * and Router II (nested rendering, typed links, SWR loaders, navigation guards,\n * view transitions) are implemented and tested. The global typed route registry\n * and file-based route scanning are a later phase — see `STATUS.md`.\n */\nexport const maturity: Maturity = 'experimental'\n\n/** Static identity + maturity metadata for this package. */\nexport const info: PackageInfo = { name, version: VERSION, maturity }\n\nexport type { Maturity, PackageInfo }\nexport { NotImplementedError, notImplemented }\n"],"mappings":";;;;;;;;;AAyFA,MAAa,OAAO;;AAGpB,MAAa,UAAU;;;;;;;;AASvB,MAAa,WAAqB;;AAGlC,MAAa,OAAoB;CAAE;CAAM,SAAS;CAAS;AAAS"}

package/dist/pattern.d.ts

@@ -0,0 +1,81 @@
+//#region src/pattern.d.ts
+/**
+ * Route patterns — matching, building, and **codegen-free** typed params.
+ *
+ * A pattern is a `/`-separated path where each segment is one of:
+ * - a **static** segment (`posts`) — matches itself literally;
+ * - a **dynamic** segment (`:postId`) — matches exactly one non-empty segment;
+ * - a **catch-all** segment (`:rest*`) — must be last; matches the remaining
+ *   segments (zero or more), joined with `/`.
+ *
+ * This mirrors the manifest paths emitted by `@mindees/compiler`
+ * (`buildRouteManifest`: `[param]` → `:param`, `[...rest]` → `:rest*`).
+ *
+ * The headline win over Expo Router / React Router: params are typed by parsing
+ * the pattern string with **template-literal types** ({@link PathParams}) — no
+ * generated `.d.ts`, no dev server, and required params are typed as *required*
+ * (not optional). See ADR-0003.
+ *
+ * @module
+ */
+/** Flatten an intersection of object types into a single readable object type. */
+type Prettify<T> = { [K in keyof T]: T[K] } & {};
+/** The param contributed by a single pattern segment. */
+type SegmentParam<Seg extends string> = Seg extends `:${infer Name}*` ? { [K in Name]: string } : Seg extends `:${infer Name}` ? { [K in Name]: string } : {};
+/** Split a pattern on `/` into a tuple of segments. */
+type SplitSegments<P extends string> = P extends `${infer Head}/${infer Tail}` ? [Head, ...SplitSegments<Tail>] : [P];
+/** Intersect the param contributions of every segment. */
+type MergeSegments<Segs extends readonly string[]> = Segs extends [infer Head extends string, ...infer Tail extends string[]] ? SegmentParam<Head> & MergeSegments<Tail> : {};
+/**
+ * The params object for a pattern, inferred at the type level.
+ *
+ * @example
+ * type A = PathParams<'/posts/:postId'>       // { postId: string }
+ * type B = PathParams<'/files/:rest*'>        // { rest: string }
+ * type C = PathParams<'/about'>               // {}
+ * type D = PathParams<'/u/:userId/p/:postId'> // { userId: string; postId: string }
+ */
+type PathParams<P extends string> = Prettify<MergeSegments<SplitSegments<P>>>;
+/** Whether a pattern has any dynamic params (used to make params required vs optional). */
+type HasPathParams<P extends string> = keyof PathParams<P> extends never ? false : true;
+interface Segment {
+  readonly kind: 'static' | 'param' | 'catchAll';
+  /** Static text, or the param name. */
+  readonly value: string;
+}
+/**
+ * Parse a pattern into segments, validating it. Throws {@link RouterError}
+ * (`INVALID_PATTERN`) if a catch-all is not the final segment, or a param name
+ * is empty.
+ */
+declare function parsePattern(pattern: string): Segment[];
+/**
+ * Match a `pathname` against a `pattern`. Returns the extracted params, or
+ * `null` if it does not match. Param values are URI-decoded.
+ *
+ * @example
+ * matchPattern('/posts/:id', '/posts/42')   // { id: '42' }
+ * matchPattern('/files/:rest*', '/files/a/b') // { rest: 'a/b' }
+ * matchPattern('/about', '/contact')        // null
+ */
+declare function matchPattern(pattern: string, pathname: string): Record<string, string> | null;
+/**
+ * Build a pathname from a `pattern` and `params`. Param values are URI-encoded.
+ * Throws {@link RouterError} (`MISSING_PARAM`) if a required dynamic param is
+ * absent. A missing/empty catch-all simply contributes nothing.
+ *
+ * @example
+ * buildPath('/posts/:id', { id: '42' })       // '/posts/42'
+ * buildPath('/files/:rest*', { rest: 'a/b' }) // '/files/a/b'
+ * buildPath('/about', {})                     // '/about'
+ */
+declare function buildPath(pattern: string, params?: Record<string, string | number>): string;
+/**
+ * Compare two patterns by specificity. Returns a negative number if `a` is more
+ * specific than `b` (so `routes.sort(compareSpecificity)` puts the most specific
+ * first), positive if less specific, 0 if equal.
+ */
+declare function compareSpecificity(a: string, b: string): number;
+//#endregion
+export { HasPathParams, PathParams, buildPath, compareSpecificity, matchPattern, parsePattern };
+//# sourceMappingURL=pattern.d.ts.map

package/dist/pattern.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pattern.d.ts","names":[],"sources":["../src/pattern.ts"],"mappings":";;;;;;;;;;;;;;;;AA2BwC;AAAA;;;;KAAnC,QAAA,oBAA4B,CAAA,GAAI,CAAA,CAAE,CAAA;;KAGlC,YAAA,uBAAmC,GAAA,qCAC5B,IAAA,cACR,GAAA,oCACU,IAAA;;KAKT,aAAA,qBAAkC,CAAA,0CAClC,IAAA,KAAS,aAAA,CAAc,IAAA,MACvB,CAAA;;KAGA,aAAA,mCAAgD,IAAA,uEAIjD,YAAA,CAAa,IAAA,IAAQ,aAAA,CAAc,IAAA;AAdrB;;;;;;;;;AAAA,KA2BN,UAAA,qBAA+B,QAAA,CAAS,aAAA,CAAc,aAAA,CAAc,CAAA;;KAGpE,aAAA,2BAAwC,UAAU,CAAC,CAAA;AAAA,UAMrD,OAAA;EAAA,SACC,IAAA;EA/BN;EAAA,SAiCM,KAAK;AAAA;;;AAhCV;AAAA;;iBAqDU,YAAA,CAAa,OAAA,WAAkB,OAAO;;;;;;;;;;iBA8BtC,YAAA,CAAa,OAAA,UAAiB,QAAA,WAAmB,MAAM;;;;;;;AA5E5B;AAa3C;;;iBA+GgB,SAAA,CAAU,OAAA,UAAiB,MAAA,GAAQ,MAAM;;;;;;iBA0DzC,kBAAA,CAAmB,CAAA,UAAW,CAAS"}

package/dist/pattern.js

@@ -0,0 +1,156 @@
+import { RouterError } from "./errors.js";
+//#region src/pattern.ts
+/**
+* Route patterns — matching, building, and **codegen-free** typed params.
+*
+* A pattern is a `/`-separated path where each segment is one of:
+* - a **static** segment (`posts`) — matches itself literally;
+* - a **dynamic** segment (`:postId`) — matches exactly one non-empty segment;
+* - a **catch-all** segment (`:rest*`) — must be last; matches the remaining
+*   segments (zero or more), joined with `/`.
+*
+* This mirrors the manifest paths emitted by `@mindees/compiler`
+* (`buildRouteManifest`: `[param]` → `:param`, `[...rest]` → `:rest*`).
+*
+* The headline win over Expo Router / React Router: params are typed by parsing
+* the pattern string with **template-literal types** ({@link PathParams}) — no
+* generated `.d.ts`, no dev server, and required params are typed as *required*
+* (not optional). See ADR-0003.
+*
+* @module
+*/
+/** Split a pathname into non-empty segments (tolerates leading/trailing slashes). */
+function splitPath(path) {
+	return path.split("/").filter((s) => s.length > 0);
+}
+/** Reject an empty param name (`/:` or `/:*`) so downstream never sees `params['']`. */
+function requireName(name, pattern) {
+	if (name.length === 0) throw new RouterError("INVALID_PATTERN", `Param name cannot be empty in pattern "${pattern}".`);
+	return name;
+}
+/**
+* Parse a pattern into segments, validating it. Throws {@link RouterError}
+* (`INVALID_PATTERN`) if a catch-all is not the final segment, or a param name
+* is empty.
+*/
+function parsePattern(pattern) {
+	const segments = splitPath(pattern).map((s) => {
+		if (s.startsWith(":") && s.endsWith("*")) return {
+			kind: "catchAll",
+			value: requireName(s.slice(1, -1), pattern)
+		};
+		if (s.startsWith(":")) return {
+			kind: "param",
+			value: requireName(s.slice(1), pattern)
+		};
+		return {
+			kind: "static",
+			value: s
+		};
+	});
+	const catchAllIndex = segments.findIndex((s) => s.kind === "catchAll");
+	if (catchAllIndex !== -1 && catchAllIndex !== segments.length - 1) throw new RouterError("INVALID_PATTERN", `Catch-all segment must be last in pattern "${pattern}".`);
+	return segments;
+}
+/**
+* Match a `pathname` against a `pattern`. Returns the extracted params, or
+* `null` if it does not match. Param values are URI-decoded.
+*
+* @example
+* matchPattern('/posts/:id', '/posts/42')   // { id: '42' }
+* matchPattern('/files/:rest*', '/files/a/b') // { rest: 'a/b' }
+* matchPattern('/about', '/contact')        // null
+*/
+function matchPattern(pattern, pathname) {
+	const segments = parsePattern(pattern);
+	const parts = splitPath(pathname);
+	const params = {};
+	for (let i = 0; i < segments.length; i++) {
+		const seg = segments[i];
+		if (seg === void 0) return null;
+		if (seg.kind === "catchAll") {
+			params[seg.value] = parts.slice(i).map((p) => safeDecode(p)).join("/");
+			return params;
+		}
+		const part = parts[i];
+		if (part === void 0) return null;
+		if (seg.kind === "static") {
+			if (part !== seg.value) return null;
+		} else params[seg.value] = safeDecode(part);
+	}
+	return parts.length === segments.length ? params : null;
+}
+/** Decode a URI segment, falling back to the raw value on malformed input. */
+function safeDecode(value) {
+	try {
+		return decodeURIComponent(value);
+	} catch {
+		return value;
+	}
+}
+/**
+* Build a pathname from a `pattern` and `params`. Param values are URI-encoded.
+* Throws {@link RouterError} (`MISSING_PARAM`) if a required dynamic param is
+* absent. A missing/empty catch-all simply contributes nothing.
+*
+* @example
+* buildPath('/posts/:id', { id: '42' })       // '/posts/42'
+* buildPath('/files/:rest*', { rest: 'a/b' }) // '/files/a/b'
+* buildPath('/about', {})                     // '/about'
+*/
+function buildPath(pattern, params = {}) {
+	const segments = parsePattern(pattern);
+	const out = [];
+	for (const seg of segments) {
+		if (seg.kind === "static") {
+			out.push(seg.value);
+			continue;
+		}
+		const value = params[seg.value];
+		if (seg.kind === "param") {
+			if (value === void 0 || value === "") throw new RouterError("MISSING_PARAM", `Missing value for required param ":${seg.value}" in pattern "${pattern}".`);
+			out.push(encodeURIComponent(String(value)));
+		} else if (value !== void 0 && value !== "") out.push(String(value).split("/").filter((s) => s.length > 0).map((s) => encodeURIComponent(s)).join("/"));
+	}
+	return `/${out.join("/")}`;
+}
+/** Per-segment specificity weights: static > param > (end of pattern) > catch-all. */
+const SEGMENT_WEIGHT = {
+	static: 4,
+	param: 3,
+	catchAll: 1
+};
+/**
+* Weight for a "missing" segment slot (the pattern ended). It outranks a
+* catch-all (so the root `/` beats a bare `/:rest*`) but loses to a static or
+* dynamic segment (so a longer, more specific pattern still wins).
+*/
+const END_WEIGHT = 2;
+/**
+* Specificity score for a pattern: a per-segment weight tuple. Static segments
+* outrank dynamic, which outrank a pattern's end, which outranks a catch-all.
+* Used to sort routes so the most specific match wins.
+*/
+function score(pattern) {
+	return parsePattern(pattern).map((s) => SEGMENT_WEIGHT[s.kind]);
+}
+/**
+* Compare two patterns by specificity. Returns a negative number if `a` is more
+* specific than `b` (so `routes.sort(compareSpecificity)` puts the most specific
+* first), positive if less specific, 0 if equal.
+*/
+function compareSpecificity(a, b) {
+	const sa = score(a);
+	const sb = score(b);
+	const len = Math.max(sa.length, sb.length);
+	for (let i = 0; i < len; i++) {
+		const wa = sa[i] ?? END_WEIGHT;
+		const wb = sb[i] ?? END_WEIGHT;
+		if (wa !== wb) return wb - wa;
+	}
+	return 0;
+}
+//#endregion
+export { buildPath, compareSpecificity, matchPattern, parsePattern };
+
+//# sourceMappingURL=pattern.js.map

package/dist/pattern.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pattern.js","names":[],"sources":["../src/pattern.ts"],"sourcesContent":["/**\n * Route patterns — matching, building, and **codegen-free** typed params.\n *\n * A pattern is a `/`-separated path where each segment is one of:\n * - a **static** segment (`posts`) — matches itself literally;\n * - a **dynamic** segment (`:postId`) — matches exactly one non-empty segment;\n * - a **catch-all** segment (`:rest*`) — must be last; matches the remaining\n *   segments (zero or more), joined with `/`.\n *\n * This mirrors the manifest paths emitted by `@mindees/compiler`\n * (`buildRouteManifest`: `[param]` → `:param`, `[...rest]` → `:rest*`).\n *\n * The headline win over Expo Router / React Router: params are typed by parsing\n * the pattern string with **template-literal types** ({@link PathParams}) — no\n * generated `.d.ts`, no dev server, and required params are typed as *required*\n * (not optional). See ADR-0003.\n *\n * @module\n */\n\nimport { RouterError } from './errors'\n\n// ---------------------------------------------------------------------------\n// Type-level: infer params from a pattern string\n// ---------------------------------------------------------------------------\n\n/** Flatten an intersection of object types into a single readable object type. */\ntype Prettify<T> = { [K in keyof T]: T[K] } & {}\n\n/** The param contributed by a single pattern segment. */\ntype SegmentParam<Seg extends string> = Seg extends `:${infer Name}*`\n  ? { [K in Name]: string }\n  : Seg extends `:${infer Name}`\n    ? { [K in Name]: string }\n    : // biome-ignore lint/complexity/noBannedTypes: empty object = \"this segment adds no params\"\n      {}\n\n/** Split a pattern on `/` into a tuple of segments. */\ntype SplitSegments<P extends string> = P extends `${infer Head}/${infer Tail}`\n  ? [Head, ...SplitSegments<Tail>]\n  : [P]\n\n/** Intersect the param contributions of every segment. */\ntype MergeSegments<Segs extends readonly string[]> = Segs extends [\n  infer Head extends string,\n  ...infer Tail extends string[],\n]\n  ? SegmentParam<Head> & MergeSegments<Tail>\n  : // biome-ignore lint/complexity/noBannedTypes: base case = no params\n    {}\n\n/**\n * The params object for a pattern, inferred at the type level.\n *\n * @example\n * type A = PathParams<'/posts/:postId'>       // { postId: string }\n * type B = PathParams<'/files/:rest*'>        // { rest: string }\n * type C = PathParams<'/about'>               // {}\n * type D = PathParams<'/u/:userId/p/:postId'> // { userId: string; postId: string }\n */\nexport type PathParams<P extends string> = Prettify<MergeSegments<SplitSegments<P>>>\n\n/** Whether a pattern has any dynamic params (used to make params required vs optional). */\nexport type HasPathParams<P extends string> = keyof PathParams<P> extends never ? false : true\n\n// ---------------------------------------------------------------------------\n// Runtime: parse, match, build\n// ---------------------------------------------------------------------------\n\ninterface Segment {\n  readonly kind: 'static' | 'param' | 'catchAll'\n  /** Static text, or the param name. */\n  readonly value: string\n}\n\n/** Split a pathname into non-empty segments (tolerates leading/trailing slashes). */\nfunction splitPath(path: string): string[] {\n  return path.split('/').filter((s) => s.length > 0)\n}\n\n/** Reject an empty param name (`/:` or `/:*`) so downstream never sees `params['']`. */\nfunction requireName(name: string, pattern: string): string {\n  if (name.length === 0) {\n    throw new RouterError('INVALID_PATTERN', `Param name cannot be empty in pattern \"${pattern}\".`)\n  }\n  return name\n}\n\n/**\n * Parse a pattern into segments, validating it. Throws {@link RouterError}\n * (`INVALID_PATTERN`) if a catch-all is not the final segment, or a param name\n * is empty.\n */\nexport function parsePattern(pattern: string): Segment[] {\n  const raw = splitPath(pattern)\n  const segments: Segment[] = raw.map((s) => {\n    if (s.startsWith(':') && s.endsWith('*')) {\n      return { kind: 'catchAll', value: requireName(s.slice(1, -1), pattern) }\n    }\n    if (s.startsWith(':')) {\n      return { kind: 'param', value: requireName(s.slice(1), pattern) }\n    }\n    return { kind: 'static', value: s }\n  })\n  const catchAllIndex = segments.findIndex((s) => s.kind === 'catchAll')\n  if (catchAllIndex !== -1 && catchAllIndex !== segments.length - 1) {\n    throw new RouterError(\n      'INVALID_PATTERN',\n      `Catch-all segment must be last in pattern \"${pattern}\".`,\n    )\n  }\n  return segments\n}\n\n/**\n * Match a `pathname` against a `pattern`. Returns the extracted params, or\n * `null` if it does not match. Param values are URI-decoded.\n *\n * @example\n * matchPattern('/posts/:id', '/posts/42')   // { id: '42' }\n * matchPattern('/files/:rest*', '/files/a/b') // { rest: 'a/b' }\n * matchPattern('/about', '/contact')        // null\n */\nexport function matchPattern(pattern: string, pathname: string): Record<string, string> | null {\n  const segments = parsePattern(pattern)\n  const parts = splitPath(pathname)\n  const params: Record<string, string> = {}\n\n  for (let i = 0; i < segments.length; i++) {\n    const seg = segments[i]\n    // `seg` is always defined for i < length; the cast satisfies noUncheckedIndexedAccess.\n    if (seg === undefined) return null\n    if (seg.kind === 'catchAll') {\n      params[seg.value] = parts\n        .slice(i)\n        .map((p) => safeDecode(p))\n        .join('/')\n      return params\n    }\n    const part = parts[i]\n    if (part === undefined) return null\n    if (seg.kind === 'static') {\n      if (part !== seg.value) return null\n    } else {\n      params[seg.value] = safeDecode(part)\n    }\n  }\n\n  // No catch-all consumed the tail: lengths must match exactly.\n  return parts.length === segments.length ? params : null\n}\n\n/** Decode a URI segment, falling back to the raw value on malformed input. */\nfunction safeDecode(value: string): string {\n  try {\n    return decodeURIComponent(value)\n  } catch {\n    return value\n  }\n}\n\n/**\n * Build a pathname from a `pattern` and `params`. Param values are URI-encoded.\n * Throws {@link RouterError} (`MISSING_PARAM`) if a required dynamic param is\n * absent. A missing/empty catch-all simply contributes nothing.\n *\n * @example\n * buildPath('/posts/:id', { id: '42' })       // '/posts/42'\n * buildPath('/files/:rest*', { rest: 'a/b' }) // '/files/a/b'\n * buildPath('/about', {})                     // '/about'\n */\nexport function buildPath(pattern: string, params: Record<string, string | number> = {}): string {\n  const segments = parsePattern(pattern)\n  const out: string[] = []\n\n  for (const seg of segments) {\n    if (seg.kind === 'static') {\n      out.push(seg.value)\n      continue\n    }\n    const value = params[seg.value]\n    if (seg.kind === 'param') {\n      if (value === undefined || value === '') {\n        throw new RouterError(\n          'MISSING_PARAM',\n          `Missing value for required param \":${seg.value}\" in pattern \"${pattern}\".`,\n        )\n      }\n      out.push(encodeURIComponent(String(value)))\n    } else {\n      // catch-all: optional; encode each sub-segment so '/' stays a separator.\n      if (value !== undefined && value !== '') {\n        out.push(\n          String(value)\n            .split('/')\n            .filter((s) => s.length > 0)\n            .map((s) => encodeURIComponent(s))\n            .join('/'),\n        )\n      }\n    }\n  }\n\n  return `/${out.join('/')}`\n}\n\n/** Per-segment specificity weights: static > param > (end of pattern) > catch-all. */\nconst SEGMENT_WEIGHT = { static: 4, param: 3, catchAll: 1 } as const\n/**\n * Weight for a \"missing\" segment slot (the pattern ended). It outranks a\n * catch-all (so the root `/` beats a bare `/:rest*`) but loses to a static or\n * dynamic segment (so a longer, more specific pattern still wins).\n */\nconst END_WEIGHT = 2\n\n/**\n * Specificity score for a pattern: a per-segment weight tuple. Static segments\n * outrank dynamic, which outrank a pattern's end, which outranks a catch-all.\n * Used to sort routes so the most specific match wins.\n */\nfunction score(pattern: string): number[] {\n  return parsePattern(pattern).map((s) => SEGMENT_WEIGHT[s.kind])\n}\n\n/**\n * Compare two patterns by specificity. Returns a negative number if `a` is more\n * specific than `b` (so `routes.sort(compareSpecificity)` puts the most specific\n * first), positive if less specific, 0 if equal.\n */\nexport function compareSpecificity(a: string, b: string): number {\n  const sa = score(a)\n  const sb = score(b)\n  const len = Math.max(sa.length, sb.length)\n  for (let i = 0; i < len; i++) {\n    const wa = sa[i] ?? END_WEIGHT\n    const wb = sb[i] ?? END_WEIGHT\n    if (wa !== wb) return wb - wa\n  }\n  return 0\n}\n"],"mappings":"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"}