@real-router/core 0.51.0 → 0.53.0

package/dist/cjs/index-8oPDJBQc.d.ts

@@ -0,0 +1,306 @@
+import { t as Router$1 } from "./Router-CJihdrWA.js";
+import { DefaultDependencies, Params, Router, State } from "@real-router/types";
+
+//#region src/utils/createRequestScope.d.ts
+/**
+ * Subset of Node's `http.IncomingMessage` that `createRequestScope` relies on:
+ * a `"close"` event indicating that the client disconnected (or the response
+ * was fully sent) and the standard `removeListener` cleanup hook.
+ */
+interface IncomingMessageLike {
+  on: (event: "close", listener: () => void) => unknown;
+  removeListener?: (event: "close", listener: () => void) => unknown;
+}
+/**
+ * Web `Request`-shaped object — anything carrying an `AbortSignal`. Web
+ * runtimes (Bun, Cloudflare Workers, Vite RSC) surface client-disconnect via
+ * `request.signal` directly, so no listener attachment is needed.
+ */
+interface RequestLike {
+  signal: AbortSignal;
+}
+type RequestScopeSource = IncomingMessageLike | RequestLike;
+interface RequestScope<Dependencies extends DefaultDependencies = DefaultDependencies> extends AsyncDisposable {
+  /**
+   * Per-request router clone. Carries `abortSignal` injected into its
+   * dependencies — loaders can `getDep("abortSignal")` and pass it to fetch /
+   * `withTimeout` for cooperative cancellation when the client disconnects.
+   */
+  readonly router: Router$1<Dependencies>;
+  /**
+   * Aborts when the request closes (Node `IncomingMessage`'s `"close"` event)
+   * or when the upstream Web `Request.signal` aborts.
+   */
+  readonly signal: AbortSignal;
+  /**
+   * Detach the close listener (if attached to a Node `IncomingMessage`) and
+   * dispose the cloned router. Idempotent — safe to call multiple times or in
+   * combination with `Symbol.asyncDispose`.
+   */
+  dispose: () => Promise<void>;
+}
+/**
+ * Build a per-request router scope: clones `base`, attaches an `AbortSignal`
+ * tied to the request's lifetime, and exposes `dispose()` (plus
+ * `Symbol.asyncDispose` for `await using` declarations).
+ *
+ * Replaces the four-step boilerplate that every server entry repeats:
+ *
+ * 1. `new AbortController()` per request
+ * 2. `req.on("close", () => controller.abort())`
+ * 3. `cloneRouter(base, { ...deps, abortSignal: signal })`
+ * 4. `try { ... } finally { router.dispose() }`
+ *
+ * The signal is injected into the router clone under `abortSignal` so existing
+ * loaders that read `getDep("abortSignal")` keep working without changes.
+ *
+ * ## `await using` compatibility
+ *
+ * The scope implements `Symbol.asyncDispose`, so `await using scope = …` is
+ * supported on runtimes that ship the well-known `Symbol.asyncDispose`:
+ *
+ * - **Node.js 24+** (full support; partial in 20.4–20.17 only for `fs`/`stream`)
+ * - **Bun 1.0.23+**, **Deno 1.37+**
+ * - **Chrome / Edge 127+**, **Firefox 141+**
+ * - **Safari**: not yet supported (irrelevant in practice — this helper is
+ *   server-side only and never reaches the browser)
+ *
+ * On Node.js 22 LTS the well-known symbol is unavailable, so `await using`
+ * fails. **The bundled SSR examples therefore use the explicit
+ * `try/finally` + `await scope.dispose()` form**, which works on every
+ * runtime. Use `await using` only when you control the deployment target and
+ * know it ships the symbol.
+ *
+ * @example
+ * ```typescript
+ * // Explicit dispose — works on Node 18+, all browsers, every CI image
+ * export async function render(url: string, req: IncomingMessage) {
+ *   const scope = createRequestScope(req, baseRouter, { currentUser });
+ *   try {
+ *     scope.router.usePlugin(ssrDataPluginFactory(loaders));
+ *     return await renderShell(scope.router, url);
+ *   } finally {
+ *     await scope.dispose();
+ *   }
+ * }
+ *
+ * // `await using` — Node 24+, Bun, Deno, modern browsers
+ * export async function render(url: string, req: IncomingMessage) {
+ *   await using scope = createRequestScope(req, baseRouter, { currentUser });
+ *   scope.router.usePlugin(ssrDataPluginFactory(loaders));
+ *   return await renderShell(scope.router, url);
+ * }
+ *
+ * // Web runtime (signal already on the request)
+ * async function handler(request: Request) {
+ *   const scope = createRequestScope(request, baseRouter, { db });
+ *   try {
+ *     scope.router.usePlugin(rscServerPluginFactory(loaders));
+ *     return await render(scope.router, request.url);
+ *   } finally {
+ *     await scope.dispose();
+ *   }
+ * }
+ * ```
+ */
+declare function createRequestScope<Dependencies extends DefaultDependencies = DefaultDependencies>(request: RequestScopeSource, base: Router<Dependencies>, deps?: Partial<Dependencies>): RequestScope<Dependencies>;
+//#endregion
+//#region src/utils/getStaticPaths.d.ts
+type StaticPathEntries = Record<string, () => Promise<Record<string, string>[]>>;
+declare function getStaticPaths<Dependencies extends DefaultDependencies = DefaultDependencies>(router: Router<Dependencies>, entries?: StaticPathEntries): Promise<string[]>;
+//#endregion
+//#region src/utils/hydrateRouter.d.ts
+/**
+ * Custom deserializer signature for {@link hydrateRouter} (#606). Compatible
+ * with `JSON.parse` (default), `devalue.parse`, `superjson.parse`, or any
+ * user-supplied function.
+ */
+type Deserialize = (json: string) => unknown;
+interface HydrateRouterOptions {
+  /**
+   * Custom deserializer (e.g., `devalue.parse` / `superjson.parse`) for
+   * matching the `serialize` passed to {@link serializeRouterState}. Defaults
+   * to `JSON.parse`. Ignored when `source` is already an object.
+   *
+   * @default JSON.parse
+   *
+   * @example
+   * ```typescript
+   * import * as devalue from "devalue";
+   * await hydrateRouter(router, ssrJson, { deserialize: devalue.parse });
+   * ```
+   */
+  deserialize?: Deserialize;
+}
+/**
+ * Hydrate a fresh router from server-serialized State (#563, #596).
+ *
+ * Accepts either a JSON string (parsed via `JSON.parse` by default, or
+ * `options.deserialize` when provided) or a State-shaped object. Extracts
+ * `state.path` and delegates to `router.start(state.path)` — the canonical
+ * URL is the source of truth for the router on hydration.
+ *
+ * The full parsed state (incl. `state.context.<namespace>` payloads) is
+ * deposited into a one-shot scratchpad on `RouterInternals.hydrationState`
+ * before `start()` is invoked and cleared in the matching `finally`. SSR
+ * loader plugins (`@real-router/ssr-data-plugin`,
+ * `@real-router/rsc-server-plugin`) read this scratchpad to skip their loader
+ * call when the server-resolved namespace value is already present — avoiding
+ * the post-hydration loader re-run on first paint.
+ *
+ * Single-shot semantics: the scratchpad is consumed during the first `start()`
+ * triggered by `hydrateRouter` regardless of route mismatch; subsequent
+ * `start()` calls run loaders normally.
+ *
+ * @example
+ * ```typescript
+ * // Client
+ * const router = createAppRouter();
+ * router.usePlugin(browserPluginFactory());
+ * await hydrateRouter(router, window.__SSR_STATE__);
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // With non-JSON types (Date / Map / Set / RegExp / BigInt) via devalue (#606)
+ * import * as devalue from "devalue";
+ *
+ * await hydrateRouter(router, window.__SSR_STATE__, {
+ *   deserialize: devalue.parse,
+ * });
+ * ```
+ */
+declare function hydrateRouter(router: Router, source: string | {
+  path: string;
+}, options?: HydrateRouterOptions): Promise<State>;
+//#endregion
+//#region src/utils/serializeState.d.ts
+/**
+ * Custom serializer signature for {@link serializeState} (#606).
+ *
+ * Compatible with `JSON.stringify` (default) as well as `devalue.stringify`,
+ * `superjson.stringify`, or any user-supplied function that returns a JSON
+ * string. The output is run through XSS-safe character escapes regardless
+ * of which serializer produced it.
+ */
+type Serialize = (data: unknown) => string;
+interface SerializeStateOptions {
+  /**
+   * Custom serializer (e.g., `devalue.stringify` / `superjson.stringify`) to
+   * support non-JSON types (Date / Map / Set / RegExp / BigInt). Defaults to
+   * `JSON.stringify`. Output is still XSS-escaped.
+   *
+   * @default JSON.stringify
+   */
+  serialize?: Serialize;
+}
+/**
+ * XSS-safe JSON serialization for embedding data in HTML `<script>` tags.
+ *
+ * Escapes `<`, `>`, and `&` to their Unicode equivalents to prevent
+ * injection via `</script>` or HTML entities inside inline scripts.
+ *
+ * Pass `options.serialize` to use a custom serializer such as `devalue` or
+ * `superjson` for non-JSON types (Date/Map/Set/RegExp/BigInt). The serializer
+ * must return a string; XSS-escape is applied to its output.
+ *
+ * @example
+ * ```typescript
+ * const json = serializeState({ name: "home", path: "/" });
+ * const html = `<script>window.__STATE__=${json}</script>`;
+ * ```
+ *
+ * @example
+ * ```typescript
+ * import * as devalue from "devalue";
+ *
+ * const json = serializeState(
+ *   { date: new Date(), tags: new Set(["a", "b"]) },
+ *   { serialize: devalue.stringify },
+ * );
+ * ```
+ */
+declare function serializeState(data: unknown, options?: SerializeStateOptions): string;
+//#endregion
+//#region src/utils/serializeRouterState.d.ts
+/**
+ * Parsed shape produced by {@link serializeRouterState} (after `JSON.parse`).
+ *
+ * Identical to {@link State} minus `transition` (per-navigation `TransitionMeta`
+ * is meaningless after hydration; the client builds its own on commit). Used as
+ * the input shape for {@link hydrateRouter} and as the type of the one-shot
+ * hydration scratchpad consumed by SSR loader plugins.
+ */
+type SerializedRouterState<P extends Params = Params> = Omit<State<P>, "transition">;
+interface SerializeRouterStateOptions {
+  /**
+   * Plugin context namespaces to strip from the serialized output.
+   * Use when a plugin populates `state.context.<ns>` with non-JSON-serializable
+   * values (e.g., RSC payload: ReactNode trees containing functions/symbols).
+   *
+   * @default []
+   */
+  excludeContext?: readonly string[];
+  /**
+   * Custom serializer (e.g., `devalue.stringify` / `superjson.stringify`) to
+   * support non-JSON types in `state.params` and `state.context.<ns>` payloads
+   * (Date / Map / Set / RegExp / BigInt). Defaults to `JSON.stringify`.
+   *
+   * Pair with the matching `deserialize` on `hydrateRouter` to round-trip the
+   * extended types on the client.
+   *
+   * @default JSON.stringify
+   *
+   * @example
+   * ```typescript
+   * import * as devalue from "devalue";
+   *
+   * const json = serializeRouterState(state, { serialize: devalue.stringify });
+   * ```
+   */
+  serialize?: Serialize;
+}
+/**
+ * XSS-safe JSON serialization of router State for SSR → client transport (#563).
+ *
+ * Strips `state.transition` (per-navigation `TransitionMeta` — meaningless after
+ * hydration; the client's hydration commit produces its own `transition`).
+ * Keeps `name`, `params`, `path`, and `context` (plugin context namespaces are
+ * preserved as-is — server's `state.context.data` from `ssr-data-plugin` and
+ * any other plugin claims travel to the client untouched).
+ *
+ * Pass `options.excludeContext` to strip specific namespaces from the output —
+ * required for plugins that publish non-JSON-serializable values (e.g., RSC
+ * `ReactNode` trees from `@real-router/rsc-server-plugin`).
+ *
+ * @example
+ * ```typescript
+ * // Server
+ * const state = await router.start(req.url);
+ * const html = `<script>window.__SSR_STATE__=${serializeRouterState(state)}</script>`;
+ *
+ * // Client
+ * await hydrateRouter(router, window.__SSR_STATE__);
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // With RSC plugin: strip the "rsc" namespace before transport
+ * const state = await router.start(url);
+ * const json = serializeRouterState(state, { excludeContext: ["rsc"] });
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Non-JSON types (Date / Map / Set / RegExp / BigInt) via devalue (#606)
+ * import * as devalue from "devalue";
+ *
+ * const json = serializeRouterState(state, { serialize: devalue.stringify });
+ * // On the client:
+ * await hydrateRouter(router, json, { deserialize: devalue.parse });
+ * ```
+ */
+declare function serializeRouterState(state: State, options?: SerializeRouterStateOptions): string;
+//#endregion
+export { SerializeStateOptions as a, HydrateRouterOptions as c, getStaticPaths as d, IncomingMessageLike as f, createRequestScope as g, RequestScopeSource as h, Serialize as i, hydrateRouter as l, RequestScope as m, SerializedRouterState as n, serializeState as o, RequestLike as p, serializeRouterState as r, Deserialize as s, SerializeRouterStateOptions as t, StaticPathEntries as u };
+//# sourceMappingURL=index-8oPDJBQc.d.ts.map

package/dist/cjs/index-8oPDJBQc.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-8oPDJBQc.d.ts","names":[],"sources":["../../src/utils/createRequestScope.ts","../../src/utils/getStaticPaths.ts","../../src/utils/hydrateRouter.ts","../../src/utils/serializeState.ts","../../src/utils/serializeRouterState.ts"],"mappings":";;;;;;AAUA;;;UAAiB,mBAAA;EACf,EAAA,GAAK,KAAA,WAAgB,QAAA;EACrB,cAAA,IAAkB,KAAA,WAAgB,QAAA;AAAA;;;;;;UAQnB,WAAA;EACf,MAAA,EAAQ,WAAA;AAAA;AAAA,KAGE,kBAAA,GAAqB,mBAAA,GAAsB,WAAA;AAAA,UAEtC,YAAA,sBACM,mBAAA,GAAsB,mBAAA,UACnC,eAAA;EAJE;;;;;EAAA,SAUD,MAAA,EAAQ,QAAA,CAAY,YAAA;EARF;;;;EAAA,SAclB,MAAA,EAAQ,WAAA;EANA;;;;;EAajB,OAAA,QAAe,OAAA;AAAA;;;;;;;;;;;;;AA4EjB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACtHA;;;;;;;;;;;;;AAmBA;;;;;;;iBDmGgB,kBAAA,sBACO,mBAAA,GAAsB,mBAAA,CAAA,CAE3C,OAAA,EAAS,kBAAA,EACT,IAAA,EAAM,MAAA,CAAO,YAAA,GACb,IAAA,GAAO,OAAA,CAAQ,YAAA,IACd,YAAA,CAAa,YAAA;;;KC5HJ,iBAAA,GAAoB,MAAA,eAExB,OAAA,CAAQ,MAAA;AAAA,iBAiBM,cAAA,sBACC,mBAAA,GAAsB,mBAAA,CAAA,CAE3C,MAAA,EAAQ,MAAA,CAAO,YAAA,GACf,OAAA,GAAU,iBAAA,GACT,OAAA;;;;;;ADnBH;;KEAY,WAAA,IAAe,IAAA;AAAA,UAEV,oBAAA;EFDf;;;;;;;;AASF;;;;;EEME,WAAA,GAAc,WAAA;AAAA;;;;AFAhB;;;;;;;;;;;;;;;;;;;;;;;;;AAiGA;;;;;;;;;;iBExDsB,aAAA,CACpB,MAAA,EAAQ,MAAA,EACR,MAAA;EAAmB,IAAA;AAAA,GACnB,OAAA,GAAU,oBAAA,GACT,OAAA,CAAQ,KAAA;;;;;;;AF7DX;;;;KGFY,SAAA,IAAa,IAAA;AAAA,UAER,qBAAA;EHCM;;;;;;AASvB;EGFE,SAAA,GAAY,SAAA;AAAA;;;AHMd;;;;;AAEA;;;;;;;;;;;;;;;;;;;iBGqBgB,cAAA,CACd,IAAA,WACA,OAAA,GAAU,qBAAA;;;;;AHvCZ;;;;;;KIGY,qBAAA,WAAgC,MAAA,GAAS,MAAA,IAAU,IAAA,CAC7D,KAAA,CAAM,CAAA;AAAA,UAIS,2BAAA;EJNG;;;;AAQpB;;;EIME,cAAA;EJLmB;AAGrB;;;;;AAEA;;;;;;;;;;;EImBE,SAAA,GAAY,SAAA;AAAA;;;;;;;;;;;;;AJ8Ed;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBInCgB,oBAAA,CACd,KAAA,EAAO,KAAA,EACP,OAAA,GAAU,2BAAA"}

package/dist/cjs/{Router-DrBkBdZ5.d.ts → index-EwbhzRQw.d.ts}

@@ -1,5 +1,3 @@
-import { DefaultDependencies, EventMethodMap, GuardFnFactory, LeaveFn, LimitsConfig, NavigationOptions, Options, Params, PluginFactory, Route, RouteConfigUpdate, RouteTreeState, Router, State, SubscribeFn, Unsubscribe } from "@real-router/types";
-
 //#region ../path-matcher/dist/esm/index.d.mts
 //#region src/types.d.ts
 /**
@@ -232,7 +230,7 @@ type NumberFormat = "none" | "auto";
 /**
  * Options for search-params parsing and building.
  */
-interface Options$1 {
+interface Options {
   /** Array parameter encoding format. @default "none" */
   arrayFormat?: ArrayFormat;
   /** Boolean parameter encoding format. @default "auto" */
@@ -309,7 +307,7 @@ interface RouteTree {
  *
  * Controls how arrays, booleans, nulls, and numbers are serialized in query strings.
  */
-type QueryParamsConfig = Readonly<Options$1>;
+type QueryParamsConfig = Readonly<Options>;
 /**
  * Options for creating a path matcher.
  */
@@ -344,68 +342,5 @@ type Matcher = SegmentMatcher;
  * ```
  */
 //#endregion
-//#region src/types.d.ts
-/**
- * Immutable limits configuration type.
- */
-type Limits = Readonly<LimitsConfig>;
-/**
- * Extended build result that includes segments for path building.
- * Used internally to avoid duplicate getSegmentsByName calls.
- *
- * @param segments - Route segments from getSegmentsByName (typed as unknown[] for cross-package compatibility)
- * @internal
- */
-interface BuildStateResultWithSegments<P extends Params = Params> {
-  readonly state: RouteTreeState<P>;
-  readonly segments: readonly unknown[];
-}
-//#endregion
-//#region src/Router.d.ts
-/**
- * Router class with integrated namespace architecture.
- *
- * All functionality is provided by namespace classes:
- * - OptionsNamespace: getOptions (immutable)
- * - DependenciesStore: get/set/remove dependencies
- * - EventEmitter: subscribe
- * - StateNamespace: state storage (getState, setState, getPreviousState)
- * - RoutesNamespace: route tree operations
- * - RouteLifecycleNamespace: canActivate/canDeactivate guards
- * - PluginsNamespace: plugin lifecycle
- * - NavigationNamespace: navigate
- * - RouterLifecycleNamespace: start, stop, isStarted
- *
- * @internal This class implementation is internal. Use createRouter() instead.
- */
-declare class Router$1<Dependencies extends DefaultDependencies = DefaultDependencies> implements Router<Dependencies> {
-  #private;
-  [key: string]: unknown;
-  /**
-   * @param routes - Route definitions
-   * @param options - Router options
-   * @param dependencies - DI dependencies
-   */
-  constructor(routes?: Route<Dependencies>[], options?: Partial<Options>, dependencies?: Dependencies);
-  isActiveRoute(name: string, params?: Params, strictEquality?: boolean, ignoreQueryParams?: boolean): boolean;
-  buildPath(route: string, params?: Params): string;
-  getState<P extends Params = Params>(): State<P> | undefined;
-  getPreviousState(): State | undefined;
-  areStatesEqual(state1: State | undefined, state2: State | undefined, ignoreQueryParams?: boolean): boolean;
-  shouldUpdateNode(nodeName: string): (toState: State, fromState?: State) => boolean;
-  isActive(): boolean;
-  start(startPath: string): Promise<State>;
-  stop(): this;
-  dispose(): void;
-  canNavigateTo(name: string, params?: Params): boolean;
-  usePlugin(...plugins: (PluginFactory<Dependencies> | false | null | undefined)[]): Unsubscribe;
-  subscribe(listener: SubscribeFn): Unsubscribe;
-  subscribeLeave(listener: LeaveFn): Unsubscribe;
-  isLeaveApproved(): boolean;
-  navigate(routeName: string, routeParams?: Params, options?: NavigationOptions): Promise<State>;
-  navigateToDefault(options?: NavigationOptions): Promise<State>;
-  navigateToNotFound(path?: string): State;
-}
-//#endregion
-export { Limits as a, RouteConfigUpdate as c, RouteDefinition as d, RouteTree as f, GuardFnFactory as i, CreateMatcherOptions as l, BuildStateResultWithSegments as n, PluginFactory as o, EventMethodMap as r, Route as s, Router$1 as t, Matcher as u };
-//# sourceMappingURL=Router-DrBkBdZ5.d.ts.map
+export { RouteTree as i, Matcher as n, RouteDefinition as r, CreateMatcherOptions as t };
+//# sourceMappingURL=index-EwbhzRQw.d.ts.map

package/dist/cjs/index-EwbhzRQw.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-EwbhzRQw.d.ts","names":["ConstraintPattern","RegExp","pattern","constraint","ParamMeta","Record","Readonly","ReadonlyMap","urlParams","queryParams","spatParams","paramTypeMap","constraintPatterns","pathPattern","URLParamsEncodingType","MatcherInputNode","name","path","fullName","absolute","children","nonAbsoluteChildren","paramMeta","staticPath","CompiledRoute","ReadonlySet","BuildParamSlot","MatchResult","parent","depth","matchSegments","meta","declaredQueryParams","declaredQueryParamsSet","hasTrailingSlash","hasConstraints","buildStaticParts","buildParamSlots","buildParamNamesSet","cachedResult","forwardTo","defaultParams","paramName","encoder","value","isOptional","BuildPathOptions","queryParamsMode","trailingSlash","SegmentNode","staticChildren","hasChildren","paramChild","node","splatChild","route","slashChildRoute","segments","params","SegmentMatcherOptions","caseSensitive","strictTrailingSlash","strictQueryParams","urlParamsEncoding","parseQueryString","queryString","buildQueryString","ResolvedMatcherOptions","buildParamMeta","validateConstraints","encodeURIComponentExcludingSubDelims","segment","ENCODING_METHODS","param","DECODING_METHODS","encodeParam","encoding","isSpatParam","createSegmentNode","SegmentMatcher","private","options","constructor","registerTree","match","buildPath","getSegmentsByName","getMetaByName","hasRoute","setRootPath","rootPath","ArrayFormat","BooleanFormat","NullFormat","NumberFormat","Options","arrayFormat","booleanFormat","nullFormat","numberFormat","FinalOptions","QueryParamPrimitive","QueryParamValue","SearchParams","Record","OmitResponse","querystring","removedParams","KeepResponse","keptParams","DecodeResult","parse","path","opts","parseInto","queryString","target","build","params","omit","paramsToOmit","keep","paramsToKeep","DEFAULT_QUERY_PARAMS","ParamMeta","SegmentMatcher","URLParamsEncodingType","DEFAULT_QUERY_PARAMS","Options","RouteDefinition","key","name","path","children","RouteTree","ReadonlyMap","Record","Readonly","absolute","paramMeta","parent","nonAbsoluteChildren","fullName","staticPath","paramTypeMap","TreeBuildOptions","skipFreeze","QueryParamsMode","TrailingSlashMode","BasePathOptions","trailingSlashMode","queryParamsMode","queryParams","urlParamsEncoding","BuildOptions","ignoreConstraints","MatchOptions","strictTrailingSlash","strongMatching","ParamSource","ParamTypeMap","RouteTreeStateMeta","MatchResult","P","RouteParams","segments","params","meta","RouteTreeState","createRouteTree","routes","options","getSegmentsByName","tree","routeName","nodeToDefinition","node","routeTreeToDefinitions","QueryParamsConfig","CreateMatcherOptions","caseSensitive","strictQueryParams","Matcher","createMatcher","validateRoute","Set","Map","route","methodName","rootNode","parentName","seenNames","seenPathsByParent"],"sources":["../../../path-matcher/dist/esm/index.d.mts","../../../search-params/dist/esm/index.d.mts","../../../route-tree/dist/esm/index.d.mts"],"mappings":"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"}

package/dist/cjs/index.d.ts

@@ -1,6 +1,7 @@
-import { c as RouteConfigUpdate, f as RouteTree, i as GuardFnFactory, n as BuildStateResultWithSegments, o as PluginFactory, s as Route, t as Router } from "./Router-DrBkBdZ5.js";
-import { t as RouterValidator } from "./RouterValidator-DLy_W2du.js";
-import { Config, DefaultDependencies, DefaultDependencies as DefaultDependencies$1, ErrorCodeKeys, ErrorCodeToValueMap, ErrorCodeValues, EventToNameMap, GuardFn, Listener, NavigationOptions, Navigator, Navigator as Navigator$1, Options, Options as Options$1, Params, Plugin, Router as Router$1, SimpleState, State, State as State$1, SubscribeFn, SubscribeState, Subscription, Unsubscribe } from "@real-router/types";
+import { i as RouteTree } from "./index-EwbhzRQw.js";
+import { c as RouteConfigUpdate, i as GuardFnFactory, n as BuildStateResultWithSegments, o as PluginFactory, s as Route, t as Router } from "./Router-CJihdrWA.js";
+import { n as RouterValidator, t as RouterError } from "./RouterError-Bm9YnZ6e.js";
+import { Config, DefaultDependencies, DefaultDependencies as DefaultDependencies$1, ErrorCodeKeys, ErrorCodeToValueMap, ErrorCodeValues, EventToNameMap, GuardFn, Listener, NavigationOptions, Navigator, Navigator as Navigator$1, Options, Options as Options$1, Params, Plugin, Router as Router$1, SimpleState, State, SubscribeFn, SubscribeState, Subscription, Unsubscribe } from "@real-router/types";
 
 //#region src/constants.d.ts
 type ConstantsKeys = "UNKNOWN_ROUTE";
@@ -24,200 +25,6 @@ declare const constants: Constants;
  */
 declare const events: EventToNameMap;
 //#endregion
-//#region src/RouterError.d.ts
-declare class RouterError extends Error {
-  [key: string]: unknown;
-  readonly segment: string | undefined;
-  readonly path: string | undefined;
-  readonly redirect: State$1 | undefined;
-  code: string;
-  /**
-   * Creates a new RouterError instance.
-   *
-   * The options object accepts built-in fields (message, segment, path, redirect)
-   * and any additional custom fields, which will all be attached to the error instance.
-   *
-   * @param code - The error code (e.g., "ROUTE_NOT_FOUND", "CANNOT_ACTIVATE")
-   * @param options - Optional configuration object
-   * @param options.message - Custom error message (defaults to code if not provided)
-   * @param options.segment - The route segment where the error occurred
-   * @param options.path - The full path where the error occurred
-   * @param options.redirect - Optional redirect state for navigation errors
-   *
-   * @example
-   * ```typescript
-   * // Basic error
-   * const err1 = new RouterError("ROUTE_NOT_FOUND");
-   *
-   * // Error with custom message
-   * const err2 = new RouterError("ERR", { message: "Something went wrong" });
-   *
-   * // Error with context and custom fields
-   * const err3 = new RouterError("CANNOT_ACTIVATE", {
-   *   message: "Insufficient permissions",
-   *   segment: "admin",
-   *   path: "/admin/users",
-   *   userId: "123"  // custom field
-   * });
-   *
-   * // Error with redirect
-   * const err4 = new RouterError("TRANSITION_ERR", {
-   *   redirect: { name: "home", path: "/", params: {} }
-   * });
-   * ```
-   */
-  constructor(code: string, {
-    message,
-    segment,
-    path,
-    redirect,
-    ...rest
-  }?: {
-    [key: string]: unknown;
-    message?: string | undefined;
-    segment?: string | undefined;
-    path?: string | undefined;
-    redirect?: State$1 | undefined;
-  });
-  /**
-   * Updates the error code and conditionally updates the message.
-   *
-   * If the current message is one of the standard error code values
-   * (e.g., "ROUTE_NOT_FOUND", "SAME_STATES"), it will be replaced with the new code.
-   * This allows keeping error messages in sync with codes when using standard error codes.
-   *
-   * If the message is custom (not a standard error code), it will be preserved.
-   *
-   * @param newCode - The new error code to set
-   *
-   * @example
-   * // Message follows code (standard error code as message)
-   * const err = new RouterError("ROUTE_NOT_FOUND", { message: "ROUTE_NOT_FOUND" });
-   * err.setCode("CUSTOM_ERROR"); // message becomes "CUSTOM_ERROR"
-   *
-   * @example
-   * // Custom message is preserved
-   * const err = new RouterError("ERR", { message: "Custom error message" });
-   * err.setCode("NEW_CODE"); // message stays "Custom error message"
-   */
-  setCode(newCode: string): void;
-  /**
-   * Copies properties from another Error instance to this RouterError.
-   *
-   * This method updates the message, cause, and stack trace from the provided error.
-   * Useful for wrapping native errors while preserving error context.
-   *
-   * @param err - The Error instance to copy properties from
-   * @throws {TypeError} If err is null or undefined
-   *
-   * @example
-   * ```typescript
-   * const routerErr = new RouterError("TRANSITION_ERR");
-   * try {
-   *   // some operation that might fail
-   * } catch (nativeErr) {
-   *   routerErr.setErrorInstance(nativeErr);
-   *   throw routerErr;
-   * }
-   * ```
-   */
-  setErrorInstance(err: Error): void;
-  /**
-   * Adds custom fields to the error object.
-   *
-   * This method allows attaching arbitrary data to the error for debugging or logging purposes.
-   * All fields become accessible as properties on the error instance and are included in JSON serialization.
-   *
-   * Reserved method names (setCode, setErrorInstance, setAdditionalFields, hasField, getField, toJSON)
-   * are automatically filtered out to prevent accidental overwriting of class methods.
-   *
-   * @param fields - Object containing custom fields to add to the error
-   *
-   * @example
-   * ```typescript
-   * const err = new RouterError("CANNOT_ACTIVATE");
-   * err.setAdditionalFields({
-   *   userId: "123",
-   *   attemptedRoute: "/admin",
-   *   reason: "insufficient permissions"
-   * });
-   *
-   * console.log(err.userId); // "123"
-   * console.log(JSON.stringify(err)); // includes all custom fields
-   * ```
-   */
-  setAdditionalFields(fields: Record<string, unknown>): void;
-  /**
-   * Checks if a custom field exists on the error object.
-   *
-   * This method checks for both custom fields added via setAdditionalFields()
-   * and built-in fields (code, message, segment, etc.).
-   *
-   * @param key - The field name to check
-   * @returns `true` if the field exists, `false` otherwise
-   *
-   * @example
-   * ```typescript
-   * const err = new RouterError("ERR", { segment: "users" });
-   * err.setAdditionalFields({ userId: "123" });
-   *
-   * err.hasField("userId");  // true
-   * err.hasField("segment"); // true
-   * err.hasField("unknown"); // false
-   * ```
-   */
-  hasField(key: string): boolean;
-  /**
-   * Retrieves a custom field value from the error object.
-   *
-   * This method can access both custom fields and built-in fields.
-   * Returns `undefined` if the field doesn't exist.
-   *
-   * @param key - The field name to retrieve
-   * @returns The field value, or `undefined` if it doesn't exist
-   *
-   * @example
-   * ```typescript
-   * const err = new RouterError("ERR");
-   * err.setAdditionalFields({ userId: "123", role: "admin" });
-   *
-   * err.getField("userId"); // "123"
-   * err.getField("role");   // "admin"
-   * err.getField("code");   // "ERR" (built-in field)
-   * err.getField("unknown"); // undefined
-   * ```
-   */
-  getField(key: string): unknown;
-  /**
-   * Serializes the error to a JSON-compatible object.
-   *
-   * This method is automatically called by JSON.stringify() and includes:
-   * - Built-in fields: code, message, segment (if set), path (if set), redirect (if set)
-   * - All custom fields added via setAdditionalFields() or constructor
-   * - Excludes: stack trace (for security/cleanliness)
-   *
-   * @returns A plain object representation of the error, suitable for JSON serialization
-   *
-   * @example
-   * ```typescript
-   * const err = new RouterError("ROUTE_NOT_FOUND", {
-   *   message: "Route not found",
-   *   path: "/admin/users/123"
-   * });
-   * err.setAdditionalFields({ userId: "123" });
-   *
-   * JSON.stringify(err);
-   * // {
-   * //   "code": "ROUTE_NOT_FOUND",
-   * //   "message": "Route not found",
-   * //   "path": "/admin/users/123",
-   * //   "userId": "123"
-   * // }
-   * ```
-   */
-  toJSON(): Record<string, unknown>;
-}
-//#endregion
 //#region src/createRouter.d.ts
 /**
  * Creates a new router instance.

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/constants.ts","../../src/RouterError.ts","../../src/createRouter.ts","../../src/getNavigator.ts","../../src/namespaces/RoutesNamespace/forwardChain.ts"],"mappings":";;;;;KAWY,aAAA;AAAA,KAEA,SAAA,GAAY,MAAA,CAAO,aAAA;AAAA,KAMnB,UAAA,GAAa,MAAA,CAAO,aAAA,EAAe,eAAA;;AAR/C;;;;cAea,UAAA,EAAY,mBAAA;AAbzB;;;;AAAA,cAgCa,aAAA;AAAA,cAEA,SAAA,EAAW,SAAA;;;;;cAsBX,MAAA,EAAQ,cAAA;;;cC7CR,WAAA,SAAoB,KAAA;EAAA,CAC9B,GAAA;EAAA,SAIQ,OAAA;EAAA,SACA,IAAA;EAAA,SACA,QAAA,EAAU,OAAA;EAInB,IAAA;;;;ADtBF;;;;;AAMA;;;;;;;;;;;;;AAOA;;;;;AAmBA;;;;;AAEA;;;;cC0BI,IAAA;IAEE,OAAA;IACA,OAAA;IACA,IAAA;IACA,QAAA;IAAA,GACG;EAAA;IAAA,CAEF,GAAA;IACD,OAAA;IACA,OAAA;IACA,IAAA;IACA,QAAA,GAAW,OAAA;EAAA;;;AA7DjB;;;;;;;;;;;;;;;;;;;EA4GE,OAAA,CAAQ,OAAA;EArGW;;;;;;;;;;;;;;;;;;;;EAkInB,gBAAA,CAAiB,GAAA,EAAK,KAAA;EAAtB;;;;;;;;;;;;;;;;;AC1IF;;;;;;;ED+KE,mBAAA,CAAoB,MAAA,EAAQ,MAAA;EC3KnB;;;;;;;;;;;;;;;;;;;ED6MT,QAAA,CAAS,GAAA;EC3MW;;;;ACrBtB;;;;;;;;;;;;;;;;EFwPE,QAAA,CAAS,GAAA;EEnOV;;;;;AC3BD;;;;;;;;;;;;;;;;;;;;;;EH6RE,MAAA,CAAA,GAAU,MAAA;AAAA;;;;;ADpRZ;;;;;AAEA;;;;;AAMA;;;;cEIa,YAAA,wBACU,qBAAA,GAAsB,qBAAA,EAE3C,MAAA,GAAQ,KAAA,CAAM,YAAA,KACd,OAAA,GAAS,OAAA,CAAQ,SAAA,GACjB,YAAA,GAAc,YAAA,KACb,MAAA,CAAO,YAAA;;;cCrBG,YAAA,wBACU,qBAAA,GAAsB,qBAAA,EAE3C,MAAA,EAAQ,QAAA,CAAO,YAAA,MACd,WAAA;;;iBCVa,mBAAA,CACd,UAAA,UACA,UAAA,EAAY,MAAA,kBACZ,QAAA"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/constants.ts","../../src/createRouter.ts","../../src/getNavigator.ts","../../src/namespaces/RoutesNamespace/forwardChain.ts"],"mappings":";;;;;;KAWY,aAAA;AAAA,KAEA,SAAA,GAAY,MAAA,CAAO,aAAA;AAAA,KAMnB,UAAA,GAAa,MAAA,CAAO,aAAA,EAAe,eAAA;;;AAR/C;;;cAea,UAAA,EAAY,mBAAA;;AAbzB;;;cAgCa,aAAA;AAAA,cAEA,SAAA,EAAW,SAAA;;;;;cAsBX,MAAA,EAAQ,cAAA;;;;;;AA1DrB;;;;;AAEA;;;;;AAMA;;;cCIa,YAAA,wBACU,qBAAA,GAAsB,qBAAA,EAE3C,MAAA,GAAQ,KAAA,CAAM,YAAA,KACd,OAAA,GAAS,OAAA,CAAQ,SAAA,GACjB,YAAA,GAAc,YAAA,KACb,MAAA,CAAO,YAAA;;;cCrBG,YAAA,wBACU,qBAAA,GAAsB,qBAAA,EAE3C,MAAA,EAAQ,QAAA,CAAO,YAAA,MACd,WAAA;;;iBCVa,mBAAA,CACd,UAAA,UACA,UAAA,EAAY,MAAA,kBACZ,QAAA"}

package/dist/cjs/index.js

@@ -1,2 +1,2 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./Router-CmI2Uw9u.js`),t=require(`./RouterError-BmvAyBlx.js`),n=(t=[],n={},r={})=>new e.t(t,n,r),r=new WeakMap,i=e=>{let t=r.get(e);return t||(t=Object.freeze({navigate:e.navigate,getState:e.getState,isActiveRoute:e.isActiveRoute,canNavigateTo:e.canNavigateTo,subscribe:e.subscribe,subscribeLeave:e.subscribeLeave,isLeaveApproved:e.isLeaveApproved}),r.set(e,t)),t};exports.Router=e.t,exports.RouterError=t.t,exports.UNKNOWN_ROUTE=t.c,exports.constants=t.l,exports.createRouter=n,exports.errorCodes=t.u,exports.events=t.d,exports.getNavigator=i,exports.resolveForwardChain=e.a;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./Router-DlmLM8Yo.js`),t=(t=[],n={},r={})=>new e.t(t,n,r),n=new WeakMap,r=e=>{let t=n.get(e);return t||(t=Object.freeze({navigate:e.navigate,getState:e.getState,isActiveRoute:e.isActiveRoute,canNavigateTo:e.canNavigateTo,subscribe:e.subscribe,subscribeLeave:e.subscribeLeave,isLeaveApproved:e.isLeaveApproved}),n.set(e,t)),t};exports.Router=e.t,exports.RouterError=e.n,exports.UNKNOWN_ROUTE=e.f,exports.constants=e.p,exports.createRouter=t,exports.errorCodes=e.m,exports.events=e.h,exports.getNavigator=r,exports.resolveForwardChain=e.o;
 //# sourceMappingURL=index.js.map

package/dist/cjs/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":["Router"],"sources":["../../src/createRouter.ts","../../src/getNavigator.ts"],"sourcesContent":["// packages/core/src/createRouter.ts\n\nimport { Router } from \"./Router\";\n\nimport type { Route } from \"./types\";\nimport type { DefaultDependencies, Options } from \"@real-router/types\";\n\n/**\n * Creates a new router instance.\n *\n * @param routes - Array of route definitions\n * @param options - Router configuration options\n * @param dependencies - Dependencies to inject into the router\n * @returns A new Router instance\n *\n * @example\n * const router = createRouter([\n *   { name: 'home', path: '/' },\n *   { name: 'users', path: '/users' },\n * ]);\n *\n * router.start('/');\n */\nexport const createRouter = <\n  Dependencies extends DefaultDependencies = DefaultDependencies,\n>(\n  routes: Route<Dependencies>[] = [],\n  options: Partial<Options> = {},\n  dependencies: Dependencies = {} as Dependencies,\n): Router<Dependencies> => {\n  return new Router<Dependencies>(routes, options, dependencies);\n};\n","import type {\n  Navigator,\n  DefaultDependencies,\n  Router,\n} from \"@real-router/types\";\n\nconst cache = new WeakMap<Router, Navigator>();\n\nexport const getNavigator = <\n  Dependencies extends DefaultDependencies = DefaultDependencies,\n>(\n  router: Router<Dependencies>,\n): Navigator => {\n  let nav = cache.get(router);\n\n  if (!nav) {\n    nav = Object.freeze({\n      navigate: router.navigate,\n      getState: router.getState,\n      isActiveRoute: router.isActiveRoute,\n      canNavigateTo: router.canNavigateTo,\n      subscribe: router.subscribe,\n      subscribeLeave: router.subscribeLeave,\n      isLeaveApproved: router.isLeaveApproved,\n    } as Navigator);\n    cache.set(router, nav);\n  }\n\n  return nav;\n};\n"],"mappings":"kJAuBa,GAGX,EAAgC,EAAE,CAClC,EAA4B,EAAE,CAC9B,EAA6B,EAAE,GAExB,IAAIA,EAAAA,EAAqB,EAAQ,EAAS,EAAa,CCxB1D,EAAQ,IAAI,QAEL,EAGX,GACc,CACd,IAAI,EAAM,EAAM,IAAI,EAAO,CAe3B,OAbK,IACH,EAAM,OAAO,OAAO,CAClB,SAAU,EAAO,SACjB,SAAU,EAAO,SACjB,cAAe,EAAO,cACtB,cAAe,EAAO,cACtB,UAAW,EAAO,UAClB,eAAgB,EAAO,eACvB,gBAAiB,EAAO,gBACzB,CAAc,CACf,EAAM,IAAI,EAAQ,EAAI,EAGjB"}
+{"version":3,"file":"index.js","names":["Router"],"sources":["../../src/createRouter.ts","../../src/getNavigator.ts"],"sourcesContent":["// packages/core/src/createRouter.ts\n\nimport { Router } from \"./Router\";\n\nimport type { Route } from \"./types\";\nimport type { DefaultDependencies, Options } from \"@real-router/types\";\n\n/**\n * Creates a new router instance.\n *\n * @param routes - Array of route definitions\n * @param options - Router configuration options\n * @param dependencies - Dependencies to inject into the router\n * @returns A new Router instance\n *\n * @example\n * const router = createRouter([\n *   { name: 'home', path: '/' },\n *   { name: 'users', path: '/users' },\n * ]);\n *\n * router.start('/');\n */\nexport const createRouter = <\n  Dependencies extends DefaultDependencies = DefaultDependencies,\n>(\n  routes: Route<Dependencies>[] = [],\n  options: Partial<Options> = {},\n  dependencies: Dependencies = {} as Dependencies,\n): Router<Dependencies> => {\n  return new Router<Dependencies>(routes, options, dependencies);\n};\n","import type {\n  Navigator,\n  DefaultDependencies,\n  Router,\n} from \"@real-router/types\";\n\nconst cache = new WeakMap<Router, Navigator>();\n\nexport const getNavigator = <\n  Dependencies extends DefaultDependencies = DefaultDependencies,\n>(\n  router: Router<Dependencies>,\n): Navigator => {\n  let nav = cache.get(router);\n\n  if (!nav) {\n    nav = Object.freeze({\n      navigate: router.navigate,\n      getState: router.getState,\n      isActiveRoute: router.isActiveRoute,\n      canNavigateTo: router.canNavigateTo,\n      subscribe: router.subscribe,\n      subscribeLeave: router.subscribeLeave,\n      isLeaveApproved: router.isLeaveApproved,\n    } as Navigator);\n    cache.set(router, nav);\n  }\n\n  return nav;\n};\n"],"mappings":"2GAuBa,GAGX,EAAgC,EAAE,CAClC,EAA4B,EAAE,CAC9B,EAA6B,EAAE,GAExB,IAAIA,EAAAA,EAAqB,EAAQ,EAAS,EAAa,CCxB1D,EAAQ,IAAI,QAEL,EAGX,GACc,CACd,IAAI,EAAM,EAAM,IAAI,EAAO,CAe3B,OAbK,IACH,EAAM,OAAO,OAAO,CAClB,SAAU,EAAO,SACjB,SAAU,EAAO,SACjB,cAAe,EAAO,cACtB,cAAe,EAAO,cACtB,UAAW,EAAO,UAClB,eAAgB,EAAO,eACvB,gBAAiB,EAAO,gBACzB,CAAc,CACf,EAAM,IAAI,EAAQ,EAAI,EAGjB"}

package/dist/cjs/{internals-na15rxo_.js → internals-CM6oaz9n.js}

@@ -1,2 +1,2 @@
 const e=new WeakMap;function t(t){let n=e.get(t);if(!n)throw TypeError(`[real-router] Invalid router instance — not found in internals registry`);return n}function n(t,n){e.set(t,n)}function r(e,t,n){let r=t;for(let t of e){let e=r;r=(...n)=>t(e,...n)}return r(...n)}function i(e,t,n){return((...i)=>{let a=n.get(e);return!a||a.length===0?t(...i):r(a,t,i)})}function a(e,t,n){return(i,a)=>{let o=n.get(e);return!o||o.length===0?t(i,a):r(o,t,[i,a])}}Object.defineProperty(exports,`i`,{enumerable:!0,get:function(){return n}}),Object.defineProperty(exports,`n`,{enumerable:!0,get:function(){return a}}),Object.defineProperty(exports,`r`,{enumerable:!0,get:function(){return t}}),Object.defineProperty(exports,`t`,{enumerable:!0,get:function(){return i}});
-//# sourceMappingURL=internals-na15rxo_.js.map
+//# sourceMappingURL=internals-CM6oaz9n.js.map