@real-router/core 0.79.1 → 0.80.0

package/dist/cjs/index.d.ts

@@ -1,6 +1,6 @@
 import { RouteTree } from "./engine/builder/types.js";
 import { QueryParamsMode, QueryParamsOptions, RouteParams, RouteTreeState } from "./types/route-node-types.js";
-import { Params, SimpleState, State, StateMetaInput, TransitionMeta, TransitionPhase, TransitionReason, Unsubscribe } from "./types/base.js";
+import { Params, SerializedRouterState, SimpleState, State, StateMetaInput, TransitionMeta, TransitionPhase, TransitionReason, Unsubscribe } from "./types/base.js";
 import { LimitsConfig } from "./types/limits.js";
 import { DefaultDependencies, DefaultParamsCallback, DefaultRouteCallback, ForwardToCallback, GuardFn, GuardFnFactory, LeaveFn, LeaveState, Listener, LogCallback, LogLevel, LogLevelConfig, LoggerConfig, Navigator, Options, Plugin, PluginFactory, Route, RouteConfigUpdate, RouterLogger, SubscribeFn, SubscribeState, Subscription } from "./types/router.js";
 import { ErrorCodeKeys, ErrorCodeToValueMap, ErrorCodeValues, EventMethodMap, EventName, EventToNameMap, EventToPluginMap, EventsKeys, PluginMethod } from "./types/constants.js";
@@ -14,4 +14,4 @@ import { RouterError } from "./RouterError.js";
 import { createRouter } from "./createRouter.js";
 import { getNavigator } from "./getNavigator.js";
 import { resolveForwardChain } from "./namespaces/RoutesNamespace/forwardChain.js";
-export { type Constants, type ContextNamespaceClaim, type DefaultDependencies, type DefaultParamsCallback, type DefaultRouteCallback, type DependenciesApi, type ErrorCodeKeys, type ErrorCodeToValueMap, type ErrorCodeValues, type ErrorCodes, type EventMethodMap, type EventName, type EventToNameMap, type EventToPluginMap, type EventsKeys, type ForwardToCallback, type GuardFn, type GuardFnFactory, type InterceptableMethodMap, type InterceptorFn, type LeaveFn, type LeaveState, type LifecycleApi, type LimitsConfig, type Listener, type LogCallback, type LogLevel, type LogLevelConfig, type LoggerConfig, type NavigationOptions, type Navigator, type Options, type Params, type Plugin, type PluginApi, type PluginFactory, type PluginMethod, type QueryParamsMode, type QueryParamsOptions, type Route, type RouteConfigUpdate, type RouteParams, type RouteTree, type RouteTreeState, Router, RouterError, type RouterLogger, type RouterValidator, type RoutesApi, type SimpleState, type State, type StateContext, type StateMetaInput, type SubscribeFn, type SubscribeState, type Subscription, type TransitionMeta, type TransitionPhase, type TransitionReason, type TreeChangedAdd, type TreeChangedClear, type TreeChangedEvent, type TreeChangedRemove, type TreeChangedReplace, type TreeChangedUpdate, type TreeStructuralPatch, UNKNOWN_ROUTE, type Unsubscribe, constants, createRouter, errorCodes, events, getNavigator, resolveForwardChain };
+export { type Constants, type ContextNamespaceClaim, type DefaultDependencies, type DefaultParamsCallback, type DefaultRouteCallback, type DependenciesApi, type ErrorCodeKeys, type ErrorCodeToValueMap, type ErrorCodeValues, type ErrorCodes, type EventMethodMap, type EventName, type EventToNameMap, type EventToPluginMap, type EventsKeys, type ForwardToCallback, type GuardFn, type GuardFnFactory, type InterceptableMethodMap, type InterceptorFn, type LeaveFn, type LeaveState, type LifecycleApi, type LimitsConfig, type Listener, type LogCallback, type LogLevel, type LogLevelConfig, type LoggerConfig, type NavigationOptions, type Navigator, type Options, type Params, type Plugin, type PluginApi, type PluginFactory, type PluginMethod, type QueryParamsMode, type QueryParamsOptions, type Route, type RouteConfigUpdate, type RouteParams, type RouteTree, type RouteTreeState, Router, RouterError, type RouterLogger, type RouterValidator, type RoutesApi, type SerializedRouterState, type SimpleState, type State, type StateContext, type StateMetaInput, type SubscribeFn, type SubscribeState, type Subscription, type TransitionMeta, type TransitionPhase, type TransitionReason, type TreeChangedAdd, type TreeChangedClear, type TreeChangedEvent, type TreeChangedRemove, type TreeChangedReplace, type TreeChangedUpdate, type TreeStructuralPatch, UNKNOWN_ROUTE, type Unsubscribe, constants, createRouter, errorCodes, events, getNavigator, resolveForwardChain };

package/dist/cjs/index.js

@@ -1,2 +1 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require("./Router-DGUed2F4.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.C,exports.constants=e.w,exports.createRouter=t,exports.errorCodes=e.T,exports.events=e.E,exports.getNavigator=r,exports.resolveForwardChain=e.g;
-//# sourceMappingURL=index.js.map
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require("./constants.js"),t=require("./namespaces/RoutesNamespace/forwardChain.js"),n=require("./RouterError.js"),r=require("./Router.js"),i=require("./createRouter.js"),a=require("./getNavigator.js");exports.Router=r.Router,exports.RouterError=n.RouterError,exports.UNKNOWN_ROUTE=e.UNKNOWN_ROUTE,exports.constants=e.constants,exports.createRouter=i.createRouter,exports.errorCodes=e.errorCodes,exports.events=e.events,exports.getNavigator=a.getNavigator,exports.resolveForwardChain=t.resolveForwardChain;

package/dist/cjs/internals.d.ts

@@ -1,12 +1,11 @@
 import { RouteTree } from "./engine/builder/types.js";
 import { RouteTreeState } from "./types/route-node-types.js";
-import { Params, SimpleState, State, Unsubscribe } from "./types/base.js";
+import { Params, SerializedRouterState, SimpleState, State, Unsubscribe } from "./types/base.js";
 import { DefaultDependencies, LoggerConfig, Options, Plugin, PluginFactory, Router, RouterLogger } from "./types/router.js";
 import { EventMethodMap, EventName } from "./types/constants.js";
 import { TreeChangedEvent } from "./types/tree-changed.js";
 import { NavigationOptions } from "./types.js";
 import { RouterValidator } from "./types/RouterValidator.js";
-import { SerializedRouterState } from "./utils/serializeRouterState.js";
 import { DependenciesStore } from "./namespaces/DependenciesNamespace/dependenciesStore.js";
 import { RoutesStore } from "./namespaces/RoutesNamespace/routesStore.js";
 //#region src/internals.d.ts

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

@@ -1 +1 @@
-{"version":3,"file":"internals.d.ts","names":[],"sources":["../../src/internals.ts"],"mappings":";;;;;;;;;;;;UAyBiB,gBACf,UAAU,sBAAsB;WAEvB,YAAY,UAAU,SAAS,QACtC,cACA,SAAS,GACT,eACA,OAAO,eAAe,qCACnB,MAAM;WAEF,eAAe,UAAU,SAAS,QACzC,mBACA,aAAa,MACV,YAAY;WAER,qBACP,sBACA,gBAAgB,WACb;WAEI,YAAY,UAAU,SAAS,QACtC,cACA,UAAU,YACP,MAAM;WAEF,kBAAkB;WAElB,mBAAmB,UAAU,WACpC,WAAW,GACX,IAAI,OAAO,eAAe,QACvB;;;;;;;;WASI;aACE,OAAO,OAAO;aACd,YACP,UAAU,OAAO,8BACd;aACI;;;;;aAKA;;WAGF,YAAY,eAAe,SAAS;WAEpC,sBAAsB,OAAO;;;;;;;WAQ7B,wBACP,SAAS,OACT,WAAW,mBACX,OAAO;;;;;;;;WAUA,qBAAqB,iBAAiB;WAEtC,QAAQ,iBAAiB,QAAQ;;;;;;;WAQjC,kBACP,OAAO,OACP,UAAU,sBACP,QAAQ;WAGJ,cAAc,cAEnB,UAAU,wBAAwB;WAI7B,cAAc;WACd;WAEA,eAAe;WAEf;EAET,WAAW;WAQF,QAAQ;WAGR,4BAA4B,kBAAkB;WAM9C;IACP,SAAS;IACT,cAAc;IACd,iBAAiB,cAAc;IAK/B,cAAc;;WAIP,qBAAqB,YAAY;WAGjC;WACA;WACA;WACA,WAAW,OAAO;WAClB;IAAoB;;WACpB,qBAAqB;;;;;;;;;;EAW9B,gBAAgB;;iBAMF,aAAa,UAAU,qBACrC,QAAQ,OAAgB,KACvB,gBAAgB"}
+{"version":3,"file":"internals.d.ts","names":[],"sources":["../../src/internals.ts"],"mappings":";;;;;;;;;;;UAyBiB,gBACf,UAAU,sBAAsB;WAEvB,YAAY,UAAU,SAAS,QACtC,cACA,SAAS,GACT,eACA,OAAO,eAAe,qCACnB,MAAM;WAEF,eAAe,UAAU,SAAS,QACzC,mBACA,aAAa,MACV,YAAY;WAER,qBACP,sBACA,gBAAgB,WACb;WAEI,YAAY,UAAU,SAAS,QACtC,cACA,UAAU,YACP,MAAM;WAEF,kBAAkB;WAElB,mBAAmB,UAAU,WACpC,WAAW,GACX,IAAI,OAAO,eAAe,QACvB;;;;;;;;WASI;aACE,OAAO,OAAO;aACd,YACP,UAAU,OAAO,8BACd;aACI;;;;;aAKA;;WAGF,YAAY,eAAe,SAAS;WAEpC,sBAAsB,OAAO;;;;;;;WAQ7B,wBACP,SAAS,OACT,WAAW,mBACX,OAAO;;;;;;;;WAUA,qBAAqB,iBAAiB;WAEtC,QAAQ,iBAAiB,QAAQ;;;;;;;WAQjC,kBACP,OAAO,OACP,UAAU,sBACP,QAAQ;WAGJ,cAAc,cAEnB,UAAU,wBAAwB;WAI7B,cAAc;WACd;WAEA,eAAe;WAEf;EAET,WAAW;WAQF,QAAQ;WAGR,4BAA4B,kBAAkB;WAM9C;IACP,SAAS;IACT,cAAc;IACd,iBAAiB,cAAc;IAK/B,cAAc;;WAIP,qBAAqB,YAAY;WAGjC;WACA;WACA;WACA,WAAW,OAAO;WAClB;IAAoB;;WACpB,qBAAqB;;;;;;;;;;EAW9B,gBAAgB;;iBAMF,aAAa,UAAU,qBACrC,QAAQ,OAAgB,KACvB,gBAAgB"}

package/dist/cjs/internals.js.map

@@ -1 +1 @@
-{"version":3,"file":"internals.js","names":[],"sources":["../../src/internals.ts"],"sourcesContent":["import type { RouteTree } from \"./engine\";\nimport type { DependenciesStore } from \"./namespaces\";\nimport type { RoutesStore } from \"./namespaces/RoutesNamespace\";\nimport type { Router as RouterClass } from \"./Router\";\nimport type {\n  DefaultDependencies,\n  EventName,\n  LoggerConfig,\n  NavigationOptions,\n  Options,\n  Params,\n  Plugin,\n  Router as RouterInterface,\n  RouterLogger,\n  RouteTreeState,\n  SimpleState,\n  State,\n  TreeChangedEvent,\n  Unsubscribe,\n  EventMethodMap,\n  PluginFactory,\n} from \"./types\";\nimport type { RouterValidator } from \"./types/RouterValidator\";\nimport type { SerializedRouterState } from \"./utils\";\n\nexport interface RouterInternals<\n  D extends DefaultDependencies = DefaultDependencies,\n> {\n  readonly makeState: <P extends Params = Params>(\n    name: string,\n    params?: P,\n    path?: string,\n    meta?: Record<string, Record<string, \"url\" | \"query\">>,\n  ) => State<P>;\n\n  readonly forwardState: <P extends Params = Params>(\n    routeName: string,\n    routeParams: P,\n  ) => SimpleState<P>;\n\n  readonly buildStateResolved: (\n    resolvedName: string,\n    resolvedParams: Params,\n  ) => RouteTreeState | undefined;\n\n  readonly matchPath: <P extends Params = Params>(\n    path: string,\n    options?: Options,\n  ) => State<P> | undefined;\n\n  readonly getOptions: () => Options;\n\n  readonly addEventListener: <E extends EventName>(\n    eventName: E,\n    cb: Plugin[EventMethodMap[E]],\n  ) => Unsubscribe;\n\n  /**\n   * Route-tree mutation channel — internal access for the `getRoutesApi`\n   * wrapper. A dedicated bridge is required because the public\n   * `addEventListener<E extends EventName>` structurally rejects\n   * `\"TREE_CHANGED\"` (it is not in the public `EventName` union), is strict on\n   * duplicates, and exposes neither `emit` nor `listenerCount`.\n   */\n  readonly treeChanged: {\n    readonly emit: (event: TreeChangedEvent) => void;\n    readonly subscribe: (\n      handler: (event: TreeChangedEvent) => void,\n    ) => Unsubscribe;\n    readonly listenerCount: () => number;\n    /**\n     * True while a `TREE_CHANGED` emit is on the stack — `getRoutesApi` reads it\n     * to reject reentrant route-CRUD from a `subscribeChanges` handler (#1032).\n     */\n    readonly isEmitting: () => boolean;\n  };\n\n  readonly buildPath: (route: string, params?: Params) => string;\n\n  readonly emitTransitionError: (error: Error) => void;\n\n  /**\n   * Emits `TRANSITION_SUCCESS` directly (no FSM transition) — used by\n   * `getRoutesApi().replace()` to notify `router.subscribe` listeners when a\n   * structural replace revalidates the active state (#950). Mirrors the success\n   * emission `completeTransition` / `navigateToNotFound` perform.\n   */\n  readonly emitTransitionSuccess: (\n    toState: State,\n    fromState: State | undefined,\n    opts?: NavigationOptions,\n  ) => void;\n\n  /**\n   * Commits the not-found (`UNKNOWN_ROUTE`) state for `path` and emits\n   * `TRANSITION_SUCCESS` — the `NavigationNamespace.navigateToNotFound`\n   * primitive. `replace()` uses it when a structural replace drops the active\n   * route, so subscribers are notified instead of the state silently clearing\n   * (#950).\n   */\n  readonly navigateToNotFound: (path: string) => State;\n\n  readonly start: (path: string) => Promise<State>;\n\n  /**\n   * Plugin-only navigation entry point — delegates to\n   * `NavigationNamespace.navigateToState` (`getPluginApi(router).navigateToState`).\n   * Hidden from `Router`/`Navigator` to keep the userland surface minimal;\n   * see `core-types/src/api.ts` for usage docs.\n   */\n  readonly navigateToState: (\n    state: State,\n    options?: NavigationOptions,\n  ) => Promise<State>;\n\n  /* eslint-disable @typescript-eslint/no-explicit-any -- heterogeneous map: stores different InterceptorFn<M> types under different keys */\n  readonly interceptors: Map<\n    string,\n    ((next: (...args: any[]) => any, ...args: any[]) => any)[]\n  >;\n  /* eslint-enable @typescript-eslint/no-explicit-any */\n\n  readonly setRootPath: (rootPath: string) => void;\n  readonly getRootPath: () => string;\n\n  readonly getTree: () => RouteTree;\n\n  readonly isDisposed: () => boolean;\n\n  validator: RouterValidator | null;\n\n  // Per-router logger instance (built from `options.logger` in the Router\n  // constructor). The facade reads it as `getInternals(this).logger`; namespaces\n  // receive it via their deps at wiring; plugins reach it through\n  // `getPluginApi(router).logger`. Replaces the former process-global singleton\n  // from the standalone `@real-router/logger` package (now folded into\n  // `foundation/logger`), whose `configure()` leaked across routers (#724).\n  readonly logger: RouterLogger;\n\n  // Dependencies (issue #172)\n  readonly dependenciesGetStore: () => DependenciesStore<D>;\n\n  // Clone support (issue #173, consolidated #964). One accessor for the\n  // source-side snapshot a clone carries over besides the route store, so a new\n  // clone-relevant subsystem is wired in a single place instead of being spread\n  // across separate methods.\n  readonly getCloneState: () => {\n    options: Options;\n    dependencies: Record<string, unknown>;\n    pluginFactories: PluginFactory<D>[];\n    // Resolved logger config of the base router, so a clone can build its OWN\n    // logger inheriting the base's level/callback. Frozen `options` do NOT carry\n    // `logger` (stripped in the constructor), so `options` above can't convey it;\n    // cloneRouter merges a per-request override (traceId) over this snapshot.\n    loggerConfig: LoggerConfig;\n  };\n\n  // Consolidated route data store (issue #174 Phase 2)\n  readonly routeGetStore: () => RoutesStore<D>;\n\n  // Cross-namespace state (issue #174)\n  readonly getStateName: () => string | undefined;\n  readonly isTransitioning: () => boolean;\n  readonly clearState: () => void;\n  readonly setState: (state: State) => void;\n  readonly routerExtensions: { keys: string[] }[];\n  readonly contextClaimRecords: Set<string>;\n\n  /**\n   * One-shot hydration scratchpad populated by `hydrateRouter` immediately\n   * before delegating to `router.start(parsed.path)` and cleared in the\n   * matching `finally`. SSR loader plugins read this slot directly via\n   * `getInternals(router).hydrationState` to short-circuit their own loader\n   * call when the server-resolved namespace value is already present in the\n   * parsed state (#596). `null` outside of an active `hydrateRouter`\n   * invocation.\n   */\n  hydrationState: SerializedRouterState | null;\n}\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any -- existential type: stores RouterInternals for all Dependencies types\nconst internals = new WeakMap<object, RouterInternals<any>>();\n\nexport function getInternals<D extends DefaultDependencies>(\n  router: RouterInterface<D>,\n): RouterInternals<D> {\n  const ctx = internals.get(router);\n\n  if (!ctx) {\n    throw new TypeError(\n      \"[real-router] Invalid router instance — not found in internals registry\",\n    );\n  }\n\n  return ctx as RouterInternals<D>;\n}\n\nexport function registerInternals<D extends DefaultDependencies>(\n  router: RouterClass<D>,\n  ctx: RouterInternals<D>,\n): void {\n  internals.set(router, ctx);\n}\n\n/* eslint-disable @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-argument -- internal chain execution: type safety enforced at public API boundary (PluginApi.addInterceptor) */\nfunction executeInterceptorChain<T>(\n  interceptors: ((next: (...args: any[]) => any, ...args: any[]) => any)[],\n  original: (...args: any[]) => T,\n  args: any[],\n): T {\n  let chain = original as (...args: any[]) => any;\n\n  for (const interceptor of interceptors) {\n    const prev = chain;\n\n    chain = (...chainArgs: any[]) => interceptor(prev, ...chainArgs);\n  }\n\n  return chain(...args) as T;\n}\n\n/**\n * Variadic interceptor wrapper — wraps a function of any arity, returning the\n * same callable type `T`. Use {@link createBinaryInterceptable} instead when the\n * wrapped method takes exactly two args and the caller needs the precise\n * `(a, b) => r` signature preserved (the variadic form widens args to `any[]`).\n */\nexport function createInterceptable<T extends (...args: any[]) => any>(\n  name: string,\n  original: T,\n  interceptors: Map<\n    string,\n    ((next: (...args: any[]) => any, ...args: any[]) => any)[]\n  >,\n): T {\n  return ((...args: any[]) => {\n    const chain = interceptors.get(name);\n\n    if (!chain || chain.length === 0) {\n      return original(...args);\n    }\n\n    return executeInterceptorChain(chain, original, args);\n  }) as T;\n}\n\n/**\n * Two-argument interceptor wrapper — preserves the exact `(a: A, b: B) => R`\n * signature, which the variadic {@link createInterceptable} cannot express\n * (it widens args to `any[]`). Used for the binary interceptable methods\n * `forwardState(routeName, routeParams)` and `buildPath(route, params)`.\n */\nexport function createBinaryInterceptable<A, B, R>(\n  name: string,\n  original: (a: A, b: B) => R,\n  interceptors: Map<\n    string,\n    ((next: (...args: any[]) => any, ...args: any[]) => any)[]\n  >,\n): (a: A, b: B) => R {\n  return (arg1: A, arg2: B) => {\n    const chain = interceptors.get(name);\n\n    if (!chain || chain.length === 0) {\n      return original(arg1, arg2);\n    }\n\n    return executeInterceptorChain(chain, original, [arg1, arg2]);\n  };\n}\n/* eslint-enable @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-argument */\n"],"mappings":"AAqLA,MAAM,EAAY,IAAI,QAEtB,SAAgB,EACd,EACoB,CACpB,IAAM,EAAM,EAAU,IAAI,CAAM,EAEhC,GAAI,CAAC,EACH,MAAU,UACR,yEACF,EAGF,OAAO,CACT,CAEA,SAAgB,EACd,EACA,EACM,CACN,EAAU,IAAI,EAAQ,CAAG,CAC3B,CAGA,SAAS,EACP,EACA,EACA,EACG,CACH,IAAI,EAAQ,EAEZ,IAAK,IAAM,KAAe,EAAc,CACtC,IAAM,EAAO,EAEb,GAAS,GAAG,IAAqB,EAAY,EAAM,GAAG,CAAS,CACjE,CAEA,OAAO,EAAM,GAAG,CAAI,CACtB,CAQA,SAAgB,EACd,EACA,EACA,EAIG,CACH,QAAS,GAAG,IAAgB,CAC1B,IAAM,EAAQ,EAAa,IAAI,CAAI,EAMnC,MAJI,CAAC,GAAS,EAAM,SAAW,EACtB,EAAS,GAAG,CAAI,EAGlB,EAAwB,EAAO,EAAU,CAAI,CACtD,EACF,CAQA,SAAgB,EACd,EACA,EACA,EAImB,CACnB,OAAQ,EAAS,IAAY,CAC3B,IAAM,EAAQ,EAAa,IAAI,CAAI,EAMnC,MAJI,CAAC,GAAS,EAAM,SAAW,EACtB,EAAS,EAAM,CAAI,EAGrB,EAAwB,EAAO,EAAU,CAAC,EAAM,CAAI,CAAC,CAC9D,CACF"}
+{"version":3,"file":"internals.js","names":[],"sources":["../../src/internals.ts"],"sourcesContent":["import type { RouteTree } from \"./engine\";\nimport type { DependenciesStore } from \"./namespaces\";\nimport type { RoutesStore } from \"./namespaces/RoutesNamespace\";\nimport type { Router as RouterClass } from \"./Router\";\nimport type {\n  DefaultDependencies,\n  EventName,\n  LoggerConfig,\n  NavigationOptions,\n  Options,\n  Params,\n  Plugin,\n  Router as RouterInterface,\n  RouterLogger,\n  RouteTreeState,\n  SerializedRouterState,\n  SimpleState,\n  State,\n  TreeChangedEvent,\n  Unsubscribe,\n  EventMethodMap,\n  PluginFactory,\n} from \"./types\";\nimport type { RouterValidator } from \"./types/RouterValidator\";\n\nexport interface RouterInternals<\n  D extends DefaultDependencies = DefaultDependencies,\n> {\n  readonly makeState: <P extends Params = Params>(\n    name: string,\n    params?: P,\n    path?: string,\n    meta?: Record<string, Record<string, \"url\" | \"query\">>,\n  ) => State<P>;\n\n  readonly forwardState: <P extends Params = Params>(\n    routeName: string,\n    routeParams: P,\n  ) => SimpleState<P>;\n\n  readonly buildStateResolved: (\n    resolvedName: string,\n    resolvedParams: Params,\n  ) => RouteTreeState | undefined;\n\n  readonly matchPath: <P extends Params = Params>(\n    path: string,\n    options?: Options,\n  ) => State<P> | undefined;\n\n  readonly getOptions: () => Options;\n\n  readonly addEventListener: <E extends EventName>(\n    eventName: E,\n    cb: Plugin[EventMethodMap[E]],\n  ) => Unsubscribe;\n\n  /**\n   * Route-tree mutation channel — internal access for the `getRoutesApi`\n   * wrapper. A dedicated bridge is required because the public\n   * `addEventListener<E extends EventName>` structurally rejects\n   * `\"TREE_CHANGED\"` (it is not in the public `EventName` union), is strict on\n   * duplicates, and exposes neither `emit` nor `listenerCount`.\n   */\n  readonly treeChanged: {\n    readonly emit: (event: TreeChangedEvent) => void;\n    readonly subscribe: (\n      handler: (event: TreeChangedEvent) => void,\n    ) => Unsubscribe;\n    readonly listenerCount: () => number;\n    /**\n     * True while a `TREE_CHANGED` emit is on the stack — `getRoutesApi` reads it\n     * to reject reentrant route-CRUD from a `subscribeChanges` handler (#1032).\n     */\n    readonly isEmitting: () => boolean;\n  };\n\n  readonly buildPath: (route: string, params?: Params) => string;\n\n  readonly emitTransitionError: (error: Error) => void;\n\n  /**\n   * Emits `TRANSITION_SUCCESS` directly (no FSM transition) — used by\n   * `getRoutesApi().replace()` to notify `router.subscribe` listeners when a\n   * structural replace revalidates the active state (#950). Mirrors the success\n   * emission `completeTransition` / `navigateToNotFound` perform.\n   */\n  readonly emitTransitionSuccess: (\n    toState: State,\n    fromState: State | undefined,\n    opts?: NavigationOptions,\n  ) => void;\n\n  /**\n   * Commits the not-found (`UNKNOWN_ROUTE`) state for `path` and emits\n   * `TRANSITION_SUCCESS` — the `NavigationNamespace.navigateToNotFound`\n   * primitive. `replace()` uses it when a structural replace drops the active\n   * route, so subscribers are notified instead of the state silently clearing\n   * (#950).\n   */\n  readonly navigateToNotFound: (path: string) => State;\n\n  readonly start: (path: string) => Promise<State>;\n\n  /**\n   * Plugin-only navigation entry point — delegates to\n   * `NavigationNamespace.navigateToState` (`getPluginApi(router).navigateToState`).\n   * Hidden from `Router`/`Navigator` to keep the userland surface minimal;\n   * see `core-types/src/api.ts` for usage docs.\n   */\n  readonly navigateToState: (\n    state: State,\n    options?: NavigationOptions,\n  ) => Promise<State>;\n\n  /* eslint-disable @typescript-eslint/no-explicit-any -- heterogeneous map: stores different InterceptorFn<M> types under different keys */\n  readonly interceptors: Map<\n    string,\n    ((next: (...args: any[]) => any, ...args: any[]) => any)[]\n  >;\n  /* eslint-enable @typescript-eslint/no-explicit-any */\n\n  readonly setRootPath: (rootPath: string) => void;\n  readonly getRootPath: () => string;\n\n  readonly getTree: () => RouteTree;\n\n  readonly isDisposed: () => boolean;\n\n  validator: RouterValidator | null;\n\n  // Per-router logger instance (built from `options.logger` in the Router\n  // constructor). The facade reads it as `getInternals(this).logger`; namespaces\n  // receive it via their deps at wiring; plugins reach it through\n  // `getPluginApi(router).logger`. Replaces the former process-global singleton\n  // from the standalone `@real-router/logger` package (now folded into\n  // `foundation/logger`), whose `configure()` leaked across routers (#724).\n  readonly logger: RouterLogger;\n\n  // Dependencies (issue #172)\n  readonly dependenciesGetStore: () => DependenciesStore<D>;\n\n  // Clone support (issue #173, consolidated #964). One accessor for the\n  // source-side snapshot a clone carries over besides the route store, so a new\n  // clone-relevant subsystem is wired in a single place instead of being spread\n  // across separate methods.\n  readonly getCloneState: () => {\n    options: Options;\n    dependencies: Record<string, unknown>;\n    pluginFactories: PluginFactory<D>[];\n    // Resolved logger config of the base router, so a clone can build its OWN\n    // logger inheriting the base's level/callback. Frozen `options` do NOT carry\n    // `logger` (stripped in the constructor), so `options` above can't convey it;\n    // cloneRouter merges a per-request override (traceId) over this snapshot.\n    loggerConfig: LoggerConfig;\n  };\n\n  // Consolidated route data store (issue #174 Phase 2)\n  readonly routeGetStore: () => RoutesStore<D>;\n\n  // Cross-namespace state (issue #174)\n  readonly getStateName: () => string | undefined;\n  readonly isTransitioning: () => boolean;\n  readonly clearState: () => void;\n  readonly setState: (state: State) => void;\n  readonly routerExtensions: { keys: string[] }[];\n  readonly contextClaimRecords: Set<string>;\n\n  /**\n   * One-shot hydration scratchpad populated by `hydrateRouter` immediately\n   * before delegating to `router.start(parsed.path)` and cleared in the\n   * matching `finally`. SSR loader plugins read this slot directly via\n   * `getInternals(router).hydrationState` to short-circuit their own loader\n   * call when the server-resolved namespace value is already present in the\n   * parsed state (#596). `null` outside of an active `hydrateRouter`\n   * invocation.\n   */\n  hydrationState: SerializedRouterState | null;\n}\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any -- existential type: stores RouterInternals for all Dependencies types\nconst internals = new WeakMap<object, RouterInternals<any>>();\n\nexport function getInternals<D extends DefaultDependencies>(\n  router: RouterInterface<D>,\n): RouterInternals<D> {\n  const ctx = internals.get(router);\n\n  if (!ctx) {\n    throw new TypeError(\n      \"[real-router] Invalid router instance — not found in internals registry\",\n    );\n  }\n\n  return ctx as RouterInternals<D>;\n}\n\nexport function registerInternals<D extends DefaultDependencies>(\n  router: RouterClass<D>,\n  ctx: RouterInternals<D>,\n): void {\n  internals.set(router, ctx);\n}\n\n/* eslint-disable @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-argument -- internal chain execution: type safety enforced at public API boundary (PluginApi.addInterceptor) */\nfunction executeInterceptorChain<T>(\n  interceptors: ((next: (...args: any[]) => any, ...args: any[]) => any)[],\n  original: (...args: any[]) => T,\n  args: any[],\n): T {\n  let chain = original as (...args: any[]) => any;\n\n  for (const interceptor of interceptors) {\n    const prev = chain;\n\n    chain = (...chainArgs: any[]) => interceptor(prev, ...chainArgs);\n  }\n\n  return chain(...args) as T;\n}\n\n/**\n * Variadic interceptor wrapper — wraps a function of any arity, returning the\n * same callable type `T`. Use {@link createBinaryInterceptable} instead when the\n * wrapped method takes exactly two args and the caller needs the precise\n * `(a, b) => r` signature preserved (the variadic form widens args to `any[]`).\n */\nexport function createInterceptable<T extends (...args: any[]) => any>(\n  name: string,\n  original: T,\n  interceptors: Map<\n    string,\n    ((next: (...args: any[]) => any, ...args: any[]) => any)[]\n  >,\n): T {\n  return ((...args: any[]) => {\n    const chain = interceptors.get(name);\n\n    if (!chain || chain.length === 0) {\n      return original(...args);\n    }\n\n    return executeInterceptorChain(chain, original, args);\n  }) as T;\n}\n\n/**\n * Two-argument interceptor wrapper — preserves the exact `(a: A, b: B) => R`\n * signature, which the variadic {@link createInterceptable} cannot express\n * (it widens args to `any[]`). Used for the binary interceptable methods\n * `forwardState(routeName, routeParams)` and `buildPath(route, params)`.\n */\nexport function createBinaryInterceptable<A, B, R>(\n  name: string,\n  original: (a: A, b: B) => R,\n  interceptors: Map<\n    string,\n    ((next: (...args: any[]) => any, ...args: any[]) => any)[]\n  >,\n): (a: A, b: B) => R {\n  return (arg1: A, arg2: B) => {\n    const chain = interceptors.get(name);\n\n    if (!chain || chain.length === 0) {\n      return original(arg1, arg2);\n    }\n\n    return executeInterceptorChain(chain, original, [arg1, arg2]);\n  };\n}\n/* eslint-enable @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-argument */\n"],"mappings":"AAqLA,MAAM,EAAY,IAAI,QAEtB,SAAgB,EACd,EACoB,CACpB,IAAM,EAAM,EAAU,IAAI,CAAM,EAEhC,GAAI,CAAC,EACH,MAAU,UACR,yEACF,EAGF,OAAO,CACT,CAEA,SAAgB,EACd,EACA,EACM,CACN,EAAU,IAAI,EAAQ,CAAG,CAC3B,CAGA,SAAS,EACP,EACA,EACA,EACG,CACH,IAAI,EAAQ,EAEZ,IAAK,IAAM,KAAe,EAAc,CACtC,IAAM,EAAO,EAEb,GAAS,GAAG,IAAqB,EAAY,EAAM,GAAG,CAAS,CACjE,CAEA,OAAO,EAAM,GAAG,CAAI,CACtB,CAQA,SAAgB,EACd,EACA,EACA,EAIG,CACH,QAAS,GAAG,IAAgB,CAC1B,IAAM,EAAQ,EAAa,IAAI,CAAI,EAMnC,MAJI,CAAC,GAAS,EAAM,SAAW,EACtB,EAAS,GAAG,CAAI,EAGlB,EAAwB,EAAO,EAAU,CAAI,CACtD,EACF,CAQA,SAAgB,EACd,EACA,EACA,EAImB,CACnB,OAAQ,EAAS,IAAY,CAC3B,IAAM,EAAQ,EAAa,IAAI,CAAI,EAMnC,MAJI,CAAC,GAAS,EAAM,SAAW,EACtB,EAAS,EAAM,CAAI,EAGrB,EAAwB,EAAO,EAAU,CAAC,EAAM,CAAI,CAAC,CAC9D,CACF"}

package/dist/cjs/types/base.d.ts

@@ -60,6 +60,15 @@ interface State<P extends Params = Params> {
 interface StateMetaInput<P extends Params = Params> {
   params: P;
 }
+/**
+ * Parsed shape produced by `serializeRouterState()` (`@real-router/ssr-utils`,
+ * after `JSON.parse`). Identical to {@link State} minus `transition`
+ * (per-navigation `TransitionMeta` is meaningless after hydration; the client
+ * builds its own on commit). Defined here (not in `ssr-utils`) because core's
+ * own hydration scratchpad (`RouterInternals.hydrationState`) is typed against
+ * it — see `internals.ts`.
+ */
+type SerializedRouterState<P extends Params = Params> = Omit<State<P>, "transition">;
 /**
  * RouterError interface describing the public API of the RouterError class.
  * The actual class implementation is in the real-router package.
@@ -82,5 +91,5 @@ interface Params {
   [key: string]: string | string[] | number | number[] | boolean | boolean[] | Params | Params[] | Record<string, string | number | boolean> | null | undefined;
 }
 //#endregion
-export { Params, RouterError, SimpleState, State, StateMetaInput, TransitionMeta, TransitionPhase, TransitionReason, Unsubscribe };
+export { Params, RouterError, SerializedRouterState, SimpleState, State, StateMetaInput, TransitionMeta, TransitionPhase, TransitionReason, Unsubscribe };
 //# sourceMappingURL=base.d.ts.map

package/dist/cjs/types/base.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"base.d.ts","names":[],"sources":["../../../src/types/base.ts"],"mappings":";;;;;;;;;;;KAmBY;UAEK,YAAY,UAAU,SAAS;EAC9C;EACA,QAAQ;;KAGE;KAEA;UAEK;EACf,OAAO;EACP,QAAQ;EACR;EACA;EACA;EACA;EACA;EACA;IACE;IACA;IACA;;;UAIa,MAAM,UAAU,SAAS;EACxC;EACA,QAAQ;EACR;EACA,YAAY;;;;;;;;;;;;;;;;;;;;;EAqBZ,SAAS,eAAe;;UAGT,eAAe,UAAU,SAAS;EACjD,QAAQ;;;;;;;;UASO,oBAAoB;GAClC;WACQ;WACA;WACA;EACT,UAAU;EACV,mBAAmB,KAAK;EACxB,sBAAsB,QAAQ;EAC9B,WAAW;EACX,WAAW;EACX,cAAc;;UAGC;GACd,4EAOG,SACA,WACA"}
+{"version":3,"file":"base.d.ts","names":[],"sources":["../../../src/types/base.ts"],"mappings":";;;;;;;;;;;KAmBY;UAEK,YAAY,UAAU,SAAS;EAC9C;EACA,QAAQ;;KAGE;KAEA;UAEK;EACf,OAAO;EACP,QAAQ;EACR;EACA;EACA;EACA;EACA;EACA;IACE;IACA;IACA;;;UAIa,MAAM,UAAU,SAAS;EACxC;EACA,QAAQ;EACR;EACA,YAAY;;;;;;;;;;;;;;;;;;;;;EAqBZ,SAAS,eAAe;;UAGT,eAAe,UAAU,SAAS;EACjD,QAAQ;;;;;;;;;;KAWE,sBAAsB,UAAU,SAAS,UAAU,KAC7D,MAAM;;;;;;;UAUS,oBAAoB;GAClC;WACQ;WACA;WACA;EACT,UAAU;EACV,mBAAmB,KAAK;EACxB,sBAAsB,QAAQ;EAC9B,WAAW;EACX,WAAW;EACX,cAAc;;UAGC;GACd,4EAOG,SACA,WACA"}

package/dist/cjs/types.d.ts

@@ -1,5 +1,5 @@
 import { QueryParamsMode, QueryParamsOptions, RouteParams, RouteTreeState } from "./types/route-node-types.js";
-import { Params, RouterError, SimpleState, State, StateMetaInput, TransitionMeta, TransitionPhase, TransitionReason, Unsubscribe } from "./types/base.js";
+import { Params, RouterError, SerializedRouterState, SimpleState, State, StateMetaInput, TransitionMeta, TransitionPhase, TransitionReason, Unsubscribe } from "./types/base.js";
 import { LimitsConfig } from "./types/limits.js";
 import { DefaultDependencies, DefaultParamsCallback, DefaultRouteCallback, ForwardToCallback, GuardFn, GuardFnFactory, LeaveFn, LeaveState, Listener, LogCallback, LogLevel, LogLevelConfig, LoggerConfig, Navigator, Options, Plugin, PluginFactory, Route, RouteConfigUpdate, Router, RouterLogger, SubscribeFn, SubscribeState, Subscription } from "./types/router.js";
 import { ErrorCodeKeys, ErrorCodeToValueMap, ErrorCodeValues, EventMethodMap, EventName, EventToNameMap, EventToPluginMap, EventsKeys, PluginMethod } from "./types/constants.js";
@@ -204,5 +204,5 @@ interface NavigationOptions {
   signal?: AbortSignal | undefined;
 }
 //#endregion
-export { type ContextNamespaceClaim, type DefaultDependencies, type DefaultParamsCallback, type DefaultRouteCallback, type DependenciesApi, type ErrorCodeKeys, type ErrorCodeToValueMap, type ErrorCodeValues, type EventMethodMap, type EventName, type EventToNameMap, type EventToPluginMap, type EventsKeys, type ForwardToCallback, type GuardFn, type GuardFnFactory, type InterceptableMethodMap, type InterceptorFn, type LeaveFn, type LeaveState, type LifecycleApi, type LimitsConfig, type Listener, type LogCallback, type LogLevel, type LogLevelConfig, type LoggerConfig, NavigationOptions, type Navigator, type Options, type Params, type Plugin, type PluginApi, type PluginFactory, type PluginMethod, type QueryParamsMode, type QueryParamsOptions, type Route, type RouteConfigUpdate, type RouteParams, type RouteTreeState, type Router, type RouterError, type RouterLogger, type RoutesApi, type SimpleState, type State, StateContext, type StateMetaInput, type SubscribeFn, type SubscribeState, type Subscription, type TransitionMeta, type TransitionPhase, type TransitionReason, type TreeChangedAdd, type TreeChangedClear, type TreeChangedEvent, type TreeChangedRemove, type TreeChangedReplace, type TreeChangedUpdate, type TreeStructuralPatch, type Unsubscribe };
+export { type ContextNamespaceClaim, type DefaultDependencies, type DefaultParamsCallback, type DefaultRouteCallback, type DependenciesApi, type ErrorCodeKeys, type ErrorCodeToValueMap, type ErrorCodeValues, type EventMethodMap, type EventName, type EventToNameMap, type EventToPluginMap, type EventsKeys, type ForwardToCallback, type GuardFn, type GuardFnFactory, type InterceptableMethodMap, type InterceptorFn, type LeaveFn, type LeaveState, type LifecycleApi, type LimitsConfig, type Listener, type LogCallback, type LogLevel, type LogLevelConfig, type LoggerConfig, NavigationOptions, type Navigator, type Options, type Params, type Plugin, type PluginApi, type PluginFactory, type PluginMethod, type QueryParamsMode, type QueryParamsOptions, type Route, type RouteConfigUpdate, type RouteParams, type RouteTreeState, type Router, type RouterError, type RouterLogger, type RoutesApi, type SerializedRouterState, type SimpleState, type State, StateContext, type StateMetaInput, type SubscribeFn, type SubscribeState, type Subscription, type TransitionMeta, type TransitionPhase, type TransitionReason, type TreeChangedAdd, type TreeChangedClear, type TreeChangedEvent, type TreeChangedRemove, type TreeChangedReplace, type TreeChangedUpdate, type TreeStructuralPatch, type Unsubscribe };
 //# sourceMappingURL=types.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","names":[],"sources":["../../src/types/index.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UA0DiB;;;;;;;;;;;;;;UAeA;;;;;;;;;;;;;;;;;EAiBf;;;;;;;;;;;;;;;EAgBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmCA;;;;;;;;;;;;;;;;;;;;;;;;;;EA2BA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkCA;;;;;;;;;;;;;;;;;;;;;;;EAwBA;;;;;;;;;;;EAYA,SAAS"}
+{"version":3,"file":"types.d.ts","names":[],"sources":["../../src/types/index.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UA2DiB;;;;;;;;;;;;;;UAeA;;;;;;;;;;;;;;;;;EAiBf;;;;;;;;;;;;;;;EAgBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmCA;;;;;;;;;;;;;;;;;;;;;;;;;;EA2BA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkCA;;;;;;;;;;;;;;;;;;;;;;;EAwBA;;;;;;;;;;;EAYA,SAAS"}

package/dist/cjs/validation.js

@@ -1,2 +1 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require("./buildParamMeta-DniluAIV.js");function t(e,t){return TypeError(`[router.${e}] ${t}`)}function n(e,n,r,i){let a=new Set;for(let o of e){if(a.has(o))throw t(r,`Invalid path for route "${n}": duplicate parameter name ':${o}' in "${i}" (a param name must be unique within a route — the second binding would overwrite the first)`);a.add(o)}}function r(n,r,i,a,o){let s=new Set(n);for(let n of r){if(e.n.test(n))throw t(a,`Invalid path for route "${i}": invalid query-param name "${n}" in "${o}" (a query-param name cannot contain '<' or '>' — it would never round-trip; rename the query param)`);if(s.has(n))throw t(a,`Invalid path for route "${i}": "${n}" is declared as both a path param and a query param in "${o}" — buildPath would emit its value twice (rename one)`)}}function i(e){let t=!0,n=!1;for(let r of e){if(r===`/`){t=!0;continue}if(t&&=(n=r===`:`||r===`*`,!1),!n&&r.codePointAt(0)>=128)return!0}return!1}function a(e,t,n){switch(e){case`name-less`:case`trailing-marker`:return`Invalid path for route "${t}": parameter marker (':' or '*') without a name in "${n}"`;case`fused-marker`:return`Invalid path for route "${t}": parameter marker (':' or '*') must begin a segment, but "${n}" fuses one to a static prefix (use a boundary marker like "/a/:b")`}}function o(e,t){return e.code===`optional-removed`?`Invalid path for route "${t}": optional params are not supported — "${e.segment}". Declare two sibling routes instead: "${e.withoutSegment}" and "${e.requiredForm}" (the route hierarchy already expresses optionality)`:`Invalid path for route "${t}": regex constraints are not supported — '<' and '>' are reserved in path segments ("${e.segment}"). Match the segment as a plain string and validate the value in a guard (canActivate) or app code`}function s(s,c,l,u){if(typeof s!=`string`){let e;throw e=s===null?`null`:Array.isArray(s)?`array`:typeof s,t(l,`Route path must be a string, got ${e}`)}if(s===``)return;if(/\s/.test(s))throw t(l,`Invalid path for route "${c}": whitespace not allowed in "${s}"`);if(!/^([/?~]|[^/]+$)/.test(s))throw t(l,`Route "${c}" has invalid path format: "${s}". Path should start with '/', '~', '?' or be a relative segment.`);if(s.includes(`//`))throw t(l,`Invalid path for route "${c}": double slashes not allowed in "${s}"`);let{pathPattern:d,urlParams:f,queryParams:p}=e.r(s);n(f,c,l,s),r(f,p,c,l,s);let m=e.i(d);if(m!==void 0)throw t(l,o(m,c));let h=e.a(d);if(h!==void 0)throw t(l,a(h,c,s));if(i(d))throw t(l,`Invalid path for route "${c}": non-ASCII static segment in "${s}" — match compares static segments raw and rejects non-ASCII input, so this route would never match. Percent-encode it (e.g. '/caf%C3%A9') or use a param`);let g=u&&u.paramMeta.urlParams.length>0;if(s.startsWith(`~`)&&g)throw t(l,`Absolute path "${s}" cannot be used under parent route with URL parameters`)}const c=/^[A-Z_a-z][\w-]*$/,l=/\S/,u=1e4;function d(e){if(e===null)return`null`;if(typeof e==`object`){try{let t=e.constructor;if(typeof t==`function`&&t.name!==`Object`)return t.name||`object`}catch{}return`object`}return typeof e}function f(e){for(let t of Object.keys(e)){let n=Object.getOwnPropertyDescriptor(e,t);if(n&&(n.get||n.set))return!0}return!1}function p(e,t){if(!e||typeof e!=`object`)throw TypeError(`[router.${t}] Route must be an object, got ${d(e)}`);let n=Object.getPrototypeOf(e);if(n!==Object.prototype&&n!==null)throw TypeError(`[router.${t}] Route must be a plain object, got ${d(e)}`);if(f(e))throw TypeError(`[router.${t}] Route must not have getters or setters`)}function m(e,t){if(e.encodeParams!==void 0&&typeof e.encodeParams!=`function`)throw TypeError(`[router.${t}] Route "${String(e.name)}" encodeParams must be a function`)}function h(e,t){if(e.decodeParams!==void 0&&typeof e.decodeParams!=`function`)throw TypeError(`[router.${t}] Route "${String(e.name)}" decodeParams must be a function`)}function g(e,t){if(typeof e.name!=`string`)throw TypeError(`[router.${t}] Route name must be a string, got ${d(e.name)}`);let n=e.name;if(n===``)throw TypeError(`[router.${t}] Route name cannot be empty`);if(!l.test(n))throw TypeError(`[router.${t}] Route name cannot contain only whitespace`);if(n.length>u)throw TypeError(`[router.${t}] Route name exceeds maximum length of ${u} characters`);if(!n.startsWith(`@@`)){if(n.includes(`.`))throw TypeError(`[router.${t}] Route name "${n}" cannot contain dots. Use children array or { parent } option in addRoute() instead.`);if(!c.test(n))throw TypeError(`[router.${t}] Invalid route name "${n}". Name must start with a letter or underscore, followed by letters, numbers, underscores, or hyphens.`)}}function _(e,t){if(!t.includes(`.`))return e.children.get(t);let n=e;for(let e of t.split(`.`))if(n=n.children.get(e),!n)return;return n}function v(e,t,n){if(_(e,t))throw Error(`[router.${n}] Route "${t}" already exists`)}function y(e,t,n){if(e.has(t))throw Error(`[router.${n}] Duplicate route "${t}" in batch`);e.add(t)}function b(e,t,n,r){let i=t===``?e:_(e,t);if(i){for(let e of i.children.values())if(e.path===n)throw Error(`[router.${r}] Path "${n}" is already defined`)}}function x(e,t,n,r){let i=e.get(t);if(i?.has(n))throw Error(`[router.${r}] Path "${n}" is already defined`);i?i.add(n):e.set(t,new Set([n]))}function S(e,t,n,r=``,i,a){p(e,t);let o=e;g(o,t),s(o.path,o.name,t,n),m(o,t),h(o,t);let c=o.name,l=r?`${r}.${c}`:c;n&&l&&v(n,l,t),i&&y(i,l,t);let u=o.path,f=r;if(n&&b(n,f,u,t),a&&x(a,f,u,t),o.children!==void 0){if(!Array.isArray(o.children))throw TypeError(`[router.${t}] Route "${c}" children must be an array, got ${d(o.children)}`);for(let e of o.children)S(e,t,n,l,i,a)}}exports.getInternals=e.u,exports.validateRoute=S;
-//# sourceMappingURL=validation.js.map
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require("./internals.js"),t=require("./engine/validation/route-batch.js");exports.getInternals=e.getInternals,exports.validateRoute=t.validateRoute;

package/dist/esm/api/cloneRouter.d.mts

@@ -77,7 +77,7 @@ interface CloneOptions {
  * // clone.deps.currentUser          ✓ unique per request
  * ```
  *
- * @see createRequestScope — `@real-router/core/utils` SSR helper that
+ * @see createRequestScope — `@real-router/ssr-utils` SSR helper that
  *   wraps this function and injects `abortSignal` automatically.
  */
 declare function cloneRouter<Dependencies extends DefaultDependencies = DefaultDependencies>(router: Router<Dependencies>, dependencies?: Dependencies, opts?: CloneOptions): Router$1<Dependencies>;

package/dist/esm/api.mjs

@@ -1,2 +1,2 @@
-import{S as e,a as t,b as n,c as r,d as i,f as a,h as o,i as s,l as c,m as l,o as u,p as d,r as f,s as p,u as m,v as h,y as g}from"./Router-Bk6PfSE8.mjs";import{u as _}from"./buildParamMeta-bOLhLF9h.mjs";import{a as v,i as y,n as b,r as x,t as S}from"./cloneRouter-D4rnqmi9.mjs";function C(e,t,n,r){if(t){let n=t===e,i=t.startsWith(`${e}.`);if(n||i){let i=n?``:` (current: "${t}")`;return r.warn(`router.removeRoute`,`Cannot remove route "${e}" — it is currently active${i}. Navigate away first.`),!1}}return n&&r.warn(`router.removeRoute`,`Route "${e}" removed while navigation is in progress. This may cause unexpected behavior.`),!0}function w(e,t){return e?(t.error(`router.clearRoutes`,`Cannot clear routes while navigation is in progress. Wait for navigation to complete.`),!1):!0}const T=Object.freeze({replace:!0,revalidate:!0});function E(e,t,n,r){let i=t=>t===e||t.startsWith(`${e}.`);h(t.decoders,i),h(t.encoders,i),h(t.defaultParams,i),h(t.forwardMap,i),h(t.forwardFnMap,i),h(n,i),h(t.forwardMap,e=>i(t.forwardMap[e]));let[a,o]=r.getFactories();for(let e of Object.keys(o))i(e)&&r.clearCanActivate(e,`both`);for(let e of Object.keys(a))i(e)&&r.clearCanDeactivate(e,`both`)}function D(e,t,n,r){let i=n.forwardFnMap[t],a=n.forwardMap[t];i===void 0?a!==void 0&&(e.forwardTo=a):e.forwardTo=i,t in n.defaultParams&&(e.defaultParams=n.defaultParams[t]),t in n.decoders&&(e.decodeParams=n.decoders[t]),t in n.encoders&&(e.encodeParams=n.encoders[t]);let[o,s]=r;return t in s&&(e.canActivate=s[t]),t in o&&(e.canDeactivate=o[t]),e}function O(e,t,n,r){let i={name:e.name,path:e.path};return D(i,t,n,r),e.children&&(i.children=e.children.map(e=>O(e,`${t}.${e.name}`,n,r))),i}function k(e,t,n,r){let i={name:e,path:t};return D(i,e,n,r),Object.freeze(i)}function A(e,t){let n=new Map,r=e.lifecycleNamespace.getFactories(),i=(a,o)=>{for(let s of a){let a=o?`${o}.${s.name}`:s.name;t(a)&&n.set(a,k(a,s.path,e.config,r)),s.children&&i(s.children,a)}};return i(e.definitions,``),n}function j(e,t){let n=`${t}.`,r=A(e,e=>e===t||e.startsWith(n));return Object.freeze([...r.values()])}function M(e,t,n){let r=n.lifecycleNamespace.getFactories(),i=[],a=(e,t)=>{for(let o of e){let e=t?`${t}.${o.name}`:o.name;i.push(k(e,o.path,n.config,r)),o.children&&a(o.children,e)}};return a(e,t??``),Object.freeze(i)}function N(e,t){let n=[],r=[];for(let[r,i]of e)t.has(r)||n.push(i);for(let[n,i]of t)e.has(n)||r.push(i);return{removed:Object.freeze(n),added:Object.freeze(r)}}function P(e){let t={};return e.forwardTo!==void 0&&(t.forwardTo=e.forwardTo),e.defaultParams!==void 0&&(t.defaultParams=e.defaultParams),e.encodeParams!==void 0&&(t.encodeParams=e.encodeParams),e.decodeParams!==void 0&&(t.decodeParams=e.decodeParams),Object.freeze(t)}function F(e,n,r,i){t(e,n,r);let a=m(e,n,r,i);e.lifecycleNamespace.preflightHandlerLimit(a.pendingCanActivate.keys(),a.pendingCanDeactivate.keys(),!1),s(e,a)}function I(e,t,n){e.setState(t),e.emitTransitionSuccess(t,n,T)}function L(e,t,n,a,o){r(t,`addRoute`),u(t,``,`addRoute`),p(t,``,`addRoute`);let c=i(t,e.rootPath,e.matcherOptions,n.logger);e.lifecycleNamespace.preflightHandlerLimit(c.pendingCanActivate.keys(),c.pendingCanDeactivate.keys(),!0);let d=l(c,e.depsStore);if(e.lifecycleNamespace.clearDefinitionGuards(),s(e,c,d),o?.(),a!==void 0){let t=n.matchPath(a.path,n.getOptions());if(t)if(t.name===a.name)I(n,{...t,context:a.context,transition:a.transition},a);else{let{toDeactivate:r,toActivate:i}=f(t,a);e.lifecycleNamespace.canNavigateTo(r,i,t,a)?I(n,{...t,transition:a.transition},a):n.navigateToNotFound(a.path)}else n.navigateToNotFound(a.path)}}function R(e,t){let n=e.definitions;return g(n,t)?(E(t,e.config,e.routeCustomFields,e.lifecycleNamespace),d(e,n),!0):!1}function z(e,t){let r=e.matcher.getSegmentsByName(t);if(!r)return;let i=n(r.at(-1)),a=e.lifecycleNamespace.getFactories();return O(i,t,e.config,a)}const B=new WeakMap;function V(t){let n=B.get(t);if(n)return n;let r=_(t),i=r.routeGetStore(),s=e=>{r.treeChanged.emit(e)},l={add:(t,n)=>{y(r.isDisposed),v(r.treeChanged.isEmitting);let a=Array.isArray(t)?t:[t],o=n?.parent;if(e(a,r.validator),o!==void 0&&r.validator?.routes.validateParentOption(o,i.tree),r.validator?.routes.throwIfInternalRouteInArray(a,`addRoute`),r.validator?.routes.validateAddRouteArgs(a),r.validator?.routes.validateRoutes(a,i,o),F(i,a,o,r.logger),r.treeChanged.listenerCount()>0){let e=M(a,o,i);s(o===void 0?{op:`add`,added:e}:{op:`add`,added:e,parent:o})}},remove:e=>{if(y(r.isDisposed),v(r.treeChanged.isEmitting),r.validator?.routes.validateRemoveRouteArgs(e),r.validator?.routes.throwIfInternalRoute(e,`removeRoute`),c(e,`removeRoute`),!C(e,r.getStateName(),r.isTransitioning(),r.logger))return;let t=r.treeChanged.listenerCount()>0?j(i,e):void 0;if(!R(i,e)){r.logger.warn(`router.removeRoute`,`Route "${e}" not found. No changes made.`);return}t!==void 0&&s({op:`remove`,name:e,removedSubtree:t})},update:(e,t)=>{if(y(r.isDisposed),v(r.treeChanged.isEmitting),r.validator?.routes.validateUpdateRouteBasicArgs(e,t),r.validator?.routes.throwIfInternalRoute(e,`updateRoute`),c(e,`updateRoute`),r.validator?.routes.validateUpdateRoutePropertyTypes(e,t),r.isTransitioning()&&r.logger.error(`router.updateRoute`,`Updating route "${e}" while navigation is in progress. This may cause unexpected behavior.`),r.validator?.routes.validateUpdateRoute(e,t,i),!i.matcher.hasRoute(e))return;let n=i.lifecycleNamespace,o=a(i,n,e,t);if(r.treeChanged.listenerCount()>0){let t=P(o);Object.keys(t).length>0&&s({op:`update`,name:e,patch:t})}},clear:()=>{if(y(r.isDisposed),v(r.treeChanged.isEmitting),!w(r.isTransitioning(),r.logger))return;let e=r.treeChanged.listenerCount()>0?Object.freeze([...A(i,()=>!0).values()]):void 0;o(i),i.lifecycleNamespace.clearAll(),r.clearState(),e!==void 0&&s({op:`clear`,removed:e})},has:e=>(r.validator?.routes.validateRouteName(e,`hasRoute`),i.matcher.hasRoute(e)),get:e=>(r.validator?.routes.validateRouteName(e,`getRoute`),z(i,e)),replace:n=>{y(r.isDisposed),v(r.treeChanged.isEmitting);let a=Array.isArray(n)?n:[n];if(!w(r.isTransitioning(),r.logger))return;e(a,r.validator),r.validator?.routes.throwIfInternalRouteInArray(a,`replaceRoutes`),r.validator?.routes.validateAddRouteArgs(a),r.validator?.routes.validateRoutes(a,i);let o=t.getState(),c=r.treeChanged.listenerCount()>0?A(i,()=>!0):void 0;L(i,a,r,o,c===void 0?void 0:()=>{let e=A(i,()=>!0),{removed:t,added:n}=N(c,e);s({op:`replace`,removed:t,added:n})})},subscribeChanges:e=>r.treeChanged.subscribe(e)};return B.set(t,l),l}function H(e,t,n,r){if(n!==void 0){if(!Object.hasOwn(e.dependencies,t))r?.dependencies.validateDependencyCount(e,`setDependency`);else{let i=e.dependencies[t];i!==n&&!(Number.isNaN(i)&&Number.isNaN(n))&&r?.dependencies.warnOverwrite(t,`setDependency`)}e.dependencies[t]=n}}function U(e,t,n){let r=[];for(let i in t)t[i]!==void 0&&(Object.hasOwn(e.dependencies,i)?r.push(i):n?.dependencies.validateDependencyCount(e,`setDependencies`),e.dependencies[i]=t[i]);r.length>0&&n?.dependencies.warnBatchOverwrite(r,`setDependencies`)}function W(e){let t=_(e);return{get:e=>{t.validator?.dependencies.validateDependencyName(e,`getDependency`);let n=t.dependenciesGetStore(),r=n.dependencies[e];return t.validator?.dependencies.validateDependencyExists(e,n),r},getAll:()=>({...t.dependenciesGetStore().dependencies}),set:(e,n)=>{y(t.isDisposed),t.validator?.dependencies.validateSetDependencyArgs(e,n,`setDependency`),H(t.dependenciesGetStore(),e,n,t.validator)},setAll:e=>{y(t.isDisposed);let n=t.dependenciesGetStore();t.validator?.dependencies.validateDependenciesObject(e,`setDependencies`),U(n,e,t.validator)},remove:e=>{y(t.isDisposed),t.validator?.dependencies.validateDependencyName(e,`removeDependency`);let n=t.dependenciesGetStore();Object.hasOwn(n.dependencies,e)||t.validator?.dependencies.warnRemoveNonExistent(e),delete n.dependencies[e]},reset:()=>{y(t.isDisposed);let e=t.dependenciesGetStore();e.dependencies=Object.create(null)},has:e=>(t.validator?.dependencies.validateDependencyName(e,`hasDependency`),Object.hasOwn(t.dependenciesGetStore().dependencies,e))}}export{S as cloneRouter,W as getDependenciesApi,b as getLifecycleApi,x as getPluginApi,V as getRoutesApi};
+import{S as e,T as t,_ as n,a as r,b as i,c as a,d as o,f as s,h as c,i as l,l as u,m as d,n as f,o as p,p as m,r as h,s as g,t as _,u as v,v as y,x as b,y as x}from"./Router-Bk6PfSE8.mjs";import{u as S}from"./buildParamMeta-bOLhLF9h.mjs";function C(e){if(e())throw new f(t.ROUTER_DISPOSED)}function w(e){if(e())throw new f(t.REENTRANT_TREE_MUTATION)}const T=new WeakMap;function E(e){let n=T.get(e);if(n)return n;let r=S(e),i={makeState:(e,t,n,i)=>(r.validator?.state.validateMakeStateArgs(e,t,n),r.makeState(e,t,n,i?.params)),buildState:(e,t)=>{r.validator?.routes.validateStateBuilderArgs(e,t,`buildState`);let{name:n,params:i}=r.forwardState(e,t);return r.buildStateResolved(n,i)},forwardState:(e,t)=>(r.validator?.routes.validateStateBuilderArgs(e,t,`forwardState`),r.forwardState(e,t)),matchPath:e=>(r.validator?.routes.validateMatchPathArgs(e),r.matchPath(e,r.getOptions())),navigateToState:(e,t)=>(C(r.isDisposed),r.validator?.navigation.validateNavigateToStateArgs(e),t!==void 0&&r.validator?.navigation.validateNavigationOptions(t,`navigateToState`),r.navigateToState(e,t)),setRootPath:e=>{C(r.isDisposed),r.validator?.routes.validateSetRootPathArgs(e),r.setRootPath(e)},getRootPath:r.getRootPath,addEventListener:(e,t)=>(C(r.isDisposed),r.validator?.eventBus.validateListenerArgs(e,t),r.addEventListener(e,t)),buildNavigationState:(e,t={})=>{r.validator?.routes.validateStateBuilderArgs(e,t,`buildNavigationState`);let{name:n,params:i}=r.forwardState(e,t),a=r.buildStateResolved(n,i);if(a)return r.makeState(a.name,a.params,r.buildPath(a.name,a.params),a.meta)},getOptions:r.getOptions,getTree:r.getTree,addInterceptor:(e,t)=>{C(r.isDisposed),r.validator?.plugins.validateAddInterceptorArgs(e,t);let n=r.interceptors.get(e);n||(n=[],r.interceptors.set(e,n)),n.push(t);let i=!1;return()=>{i||(i=!0,n.splice(n.indexOf(t),1))}},getRouteConfig:e=>{let t=r.routeGetStore();if(t.matcher.hasRoute(e))return t.routeCustomFields[e]},extendRouter:n=>{C(r.isDisposed);let i=Object.keys(n);for(let n of i)if(n in e)throw new f(t.PLUGIN_CONFLICT,{message:`Cannot extend router: property "${n}" already exists`});for(let t of i)e[t]=n[t];let a={keys:i};r.routerExtensions.push(a);let o=!1;return()=>{if(o)return;o=!0;for(let t of a.keys)delete e[t];let t=r.routerExtensions.indexOf(a);t!==-1&&r.routerExtensions.splice(t,1)}},emitTransitionError:e=>{C(r.isDisposed),r.emitTransitionError(e)},claimContextNamespace:e=>{if(C(r.isDisposed),typeof e!=`string`||e===``)throw TypeError(`[claimContextNamespace] namespace must be a non-empty string, got ${typeof e==`string`?`an empty string`:typeof e}`);if(r.contextClaimRecords.has(e))throw new f(t.CONTEXT_NAMESPACE_ALREADY_CLAIMED,{message:`Cannot claim context namespace: "${e}" is already claimed by another plugin`});return r.contextClaimRecords.add(e),{write(t,n){e===`__proto__`?Object.defineProperty(t.context,e,{value:n,writable:!0,enumerable:!0,configurable:!0}):t.context[e]=n},release(){r.contextClaimRecords.delete(e)}}}};return T.set(e,i),i}function D(e,t,n,r){if(t){let n=t===e,i=t.startsWith(`${e}.`);if(n||i){let i=n?``:` (current: "${t}")`;return r.warn(`router.removeRoute`,`Cannot remove route "${e}" — it is currently active${i}. Navigate away first.`),!1}}return n&&r.warn(`router.removeRoute`,`Route "${e}" removed while navigation is in progress. This may cause unexpected behavior.`),!0}function O(e,t){return e?(t.error(`router.clearRoutes`,`Cannot clear routes while navigation is in progress. Wait for navigation to complete.`),!1):!0}const k=Object.freeze({replace:!0,revalidate:!0});function A(e,t,n,r){let i=t=>t===e||t.startsWith(`${e}.`);y(t.decoders,i),y(t.encoders,i),y(t.defaultParams,i),y(t.forwardMap,i),y(t.forwardFnMap,i),y(n,i),y(t.forwardMap,e=>i(t.forwardMap[e]));let[a,o]=r.getFactories();for(let e of Object.keys(o))i(e)&&r.clearCanActivate(e,`both`);for(let e of Object.keys(a))i(e)&&r.clearCanDeactivate(e,`both`)}function j(e,t,n,r){let i=n.forwardFnMap[t],a=n.forwardMap[t];i===void 0?a!==void 0&&(e.forwardTo=a):e.forwardTo=i,t in n.defaultParams&&(e.defaultParams=n.defaultParams[t]),t in n.decoders&&(e.decodeParams=n.decoders[t]),t in n.encoders&&(e.encodeParams=n.encoders[t]);let[o,s]=r;return t in s&&(e.canActivate=s[t]),t in o&&(e.canDeactivate=o[t]),e}function M(e,t,n,r){let i={name:e.name,path:e.path};return j(i,t,n,r),e.children&&(i.children=e.children.map(e=>M(e,`${t}.${e.name}`,n,r))),i}function N(e,t,n,r){let i={name:e,path:t};return j(i,e,n,r),Object.freeze(i)}function P(e,t){let n=new Map,r=e.lifecycleNamespace.getFactories(),i=(a,o)=>{for(let s of a){let a=o?`${o}.${s.name}`:s.name;t(a)&&n.set(a,N(a,s.path,e.config,r)),s.children&&i(s.children,a)}};return i(e.definitions,``),n}function F(e,t){let n=`${t}.`,r=P(e,e=>e===t||e.startsWith(n));return Object.freeze([...r.values()])}function I(e,t,n){let r=n.lifecycleNamespace.getFactories(),i=[],a=(e,t)=>{for(let o of e){let e=t?`${t}.${o.name}`:o.name;i.push(N(e,o.path,n.config,r)),o.children&&a(o.children,e)}};return a(e,t??``),Object.freeze(i)}function L(e,t){let n=[],r=[];for(let[r,i]of e)t.has(r)||n.push(i);for(let[n,i]of t)e.has(n)||r.push(i);return{removed:Object.freeze(n),added:Object.freeze(r)}}function R(e){let t={};return e.forwardTo!==void 0&&(t.forwardTo=e.forwardTo),e.defaultParams!==void 0&&(t.defaultParams=e.defaultParams),e.encodeParams!==void 0&&(t.encodeParams=e.encodeParams),e.decodeParams!==void 0&&(t.decodeParams=e.decodeParams),Object.freeze(t)}function z(e,t,n,i){r(e,t,n);let a=v(e,t,n,i);e.lifecycleNamespace.preflightHandlerLimit(a.pendingCanActivate.keys(),a.pendingCanDeactivate.keys(),!1),l(e,a)}function B(e,t,n){e.setState(t),e.emitTransitionSuccess(t,n,k)}function V(e,t,n,r,i){a(t,`addRoute`),p(t,``,`addRoute`),g(t,``,`addRoute`);let s=o(t,e.rootPath,e.matcherOptions,n.logger);e.lifecycleNamespace.preflightHandlerLimit(s.pendingCanActivate.keys(),s.pendingCanDeactivate.keys(),!0);let c=d(s,e.depsStore);if(e.lifecycleNamespace.clearDefinitionGuards(),l(e,s,c),i?.(),r!==void 0){let t=n.matchPath(r.path,n.getOptions());if(t)if(t.name===r.name)B(n,{...t,context:r.context,transition:r.transition},r);else{let{toDeactivate:i,toActivate:a}=h(t,r);e.lifecycleNamespace.canNavigateTo(i,a,t,r)?B(n,{...t,transition:r.transition},r):n.navigateToNotFound(r.path)}else n.navigateToNotFound(r.path)}}function H(e,t){let n=e.definitions;return x(n,t)?(A(t,e.config,e.routeCustomFields,e.lifecycleNamespace),m(e,n),!0):!1}function U(e,t){let n=e.matcher.getSegmentsByName(t);if(!n)return;let r=i(n.at(-1)),a=e.lifecycleNamespace.getFactories();return M(r,t,e.config,a)}const W=new WeakMap;function G(t){let n=W.get(t);if(n)return n;let r=S(t),i=r.routeGetStore(),a=e=>{r.treeChanged.emit(e)},o={add:(t,n)=>{C(r.isDisposed),w(r.treeChanged.isEmitting);let o=Array.isArray(t)?t:[t],s=n?.parent;if(e(o,r.validator),s!==void 0&&r.validator?.routes.validateParentOption(s,i.tree),r.validator?.routes.throwIfInternalRouteInArray(o,`addRoute`),r.validator?.routes.validateAddRouteArgs(o),r.validator?.routes.validateRoutes(o,i,s),z(i,o,s,r.logger),r.treeChanged.listenerCount()>0){let e=I(o,s,i);a(s===void 0?{op:`add`,added:e}:{op:`add`,added:e,parent:s})}},remove:e=>{if(C(r.isDisposed),w(r.treeChanged.isEmitting),r.validator?.routes.validateRemoveRouteArgs(e),r.validator?.routes.throwIfInternalRoute(e,`removeRoute`),u(e,`removeRoute`),!D(e,r.getStateName(),r.isTransitioning(),r.logger))return;let t=r.treeChanged.listenerCount()>0?F(i,e):void 0;if(!H(i,e)){r.logger.warn(`router.removeRoute`,`Route "${e}" not found. No changes made.`);return}t!==void 0&&a({op:`remove`,name:e,removedSubtree:t})},update:(e,t)=>{if(C(r.isDisposed),w(r.treeChanged.isEmitting),r.validator?.routes.validateUpdateRouteBasicArgs(e,t),r.validator?.routes.throwIfInternalRoute(e,`updateRoute`),u(e,`updateRoute`),r.validator?.routes.validateUpdateRoutePropertyTypes(e,t),r.isTransitioning()&&r.logger.error(`router.updateRoute`,`Updating route "${e}" while navigation is in progress. This may cause unexpected behavior.`),r.validator?.routes.validateUpdateRoute(e,t,i),!i.matcher.hasRoute(e))return;let n=i.lifecycleNamespace,o=s(i,n,e,t);if(r.treeChanged.listenerCount()>0){let t=R(o);Object.keys(t).length>0&&a({op:`update`,name:e,patch:t})}},clear:()=>{if(C(r.isDisposed),w(r.treeChanged.isEmitting),!O(r.isTransitioning(),r.logger))return;let e=r.treeChanged.listenerCount()>0?Object.freeze([...P(i,()=>!0).values()]):void 0;c(i),i.lifecycleNamespace.clearAll(),r.clearState(),e!==void 0&&a({op:`clear`,removed:e})},has:e=>(r.validator?.routes.validateRouteName(e,`hasRoute`),i.matcher.hasRoute(e)),get:e=>(r.validator?.routes.validateRouteName(e,`getRoute`),U(i,e)),replace:n=>{C(r.isDisposed),w(r.treeChanged.isEmitting);let o=Array.isArray(n)?n:[n];if(!O(r.isTransitioning(),r.logger))return;e(o,r.validator),r.validator?.routes.throwIfInternalRouteInArray(o,`replaceRoutes`),r.validator?.routes.validateAddRouteArgs(o),r.validator?.routes.validateRoutes(o,i);let s=t.getState(),c=r.treeChanged.listenerCount()>0?P(i,()=>!0):void 0;V(i,o,r,s,c===void 0?void 0:()=>{let e=P(i,()=>!0),{removed:t,added:n}=L(c,e);a({op:`replace`,removed:t,added:n})})},subscribeChanges:e=>r.treeChanged.subscribe(e)};return W.set(t,o),o}function K(e,t,n,r){if(n!==void 0){if(!Object.hasOwn(e.dependencies,t))r?.dependencies.validateDependencyCount(e,`setDependency`);else{let i=e.dependencies[t];i!==n&&!(Number.isNaN(i)&&Number.isNaN(n))&&r?.dependencies.warnOverwrite(t,`setDependency`)}e.dependencies[t]=n}}function q(e,t,n){let r=[];for(let i in t)t[i]!==void 0&&(Object.hasOwn(e.dependencies,i)?r.push(i):n?.dependencies.validateDependencyCount(e,`setDependencies`),e.dependencies[i]=t[i]);r.length>0&&n?.dependencies.warnBatchOverwrite(r,`setDependencies`)}function J(e){let t=S(e);return{get:e=>{t.validator?.dependencies.validateDependencyName(e,`getDependency`);let n=t.dependenciesGetStore(),r=n.dependencies[e];return t.validator?.dependencies.validateDependencyExists(e,n),r},getAll:()=>({...t.dependenciesGetStore().dependencies}),set:(e,n)=>{C(t.isDisposed),t.validator?.dependencies.validateSetDependencyArgs(e,n,`setDependency`),K(t.dependenciesGetStore(),e,n,t.validator)},setAll:e=>{C(t.isDisposed);let n=t.dependenciesGetStore();t.validator?.dependencies.validateDependenciesObject(e,`setDependencies`),q(n,e,t.validator)},remove:e=>{C(t.isDisposed),t.validator?.dependencies.validateDependencyName(e,`removeDependency`);let n=t.dependenciesGetStore();Object.hasOwn(n.dependencies,e)||t.validator?.dependencies.warnRemoveNonExistent(e),delete n.dependencies[e]},reset:()=>{C(t.isDisposed);let e=t.dependenciesGetStore();e.dependencies=Object.create(null)},has:e=>(t.validator?.dependencies.validateDependencyName(e,`hasDependency`),Object.hasOwn(t.dependenciesGetStore().dependencies,e))}}function Y(e){let t=S(e),n=t.routeGetStore().lifecycleNamespace;return{addActivateGuard(e,r){C(t.isDisposed),t.validator?.routes.validateRouteName(e,`addActivateGuard`),t.validator?.lifecycle.validateHandler(r,`addActivateGuard`),n.addCanActivate(e,r)},addDeactivateGuard(e,r){C(t.isDisposed),t.validator?.routes.validateRouteName(e,`addDeactivateGuard`),t.validator?.lifecycle.validateHandler(r,`addDeactivateGuard`),n.addCanDeactivate(e,r)},removeActivateGuard(e){C(t.isDisposed),t.validator?.routes.validateRouteName(e,`removeActivateGuard`),n.clearCanActivate(e,`external`)},removeDeactivateGuard(e){C(t.isDisposed),t.validator?.routes.validateRouteName(e,`removeDeactivateGuard`),n.clearCanDeactivate(e,`external`)}}}function X(e,r,i){let a=S(e);if(a.isDisposed())throw new f(t.ROUTER_DISPOSED);a.validator?.dependencies.validateCloneArgs(r);let o=a.routeGetStore(),s=b(o.tree),c=o.config,l=o.resolvedForwardMap,u=o.routeCustomFields,{options:d,dependencies:p,pluginFactories:m,loggerConfig:h}=a.getCloneState(),{definition:g,external:v}=o.lifecycleNamespace.getFactoriesByOrigin(),y={...p,...r},x=i?.logger?{...h,...i.logger}:h,C=new _(s,{...d,logger:x},y),w=S(C),T=w.routeGetStore(),E=T.lifecycleNamespace;n(T.config,c),Object.assign(T.resolvedForwardMap,l),Object.assign(T.routeCustomFields,u),o.rootPath!==``&&w.setRootPath(o.rootPath);let[D,O]=g,[k,A]=v;for(let[e,t]of Object.entries(D))E.addCanDeactivate(e,t,!0);for(let[e,t]of Object.entries(O))E.addCanActivate(e,t,!0);let j=Y(C);for(let[e,t]of Object.entries(k))j.addDeactivateGuard(e,t);for(let[e,t]of Object.entries(A))j.addActivateGuard(e,t);let M=new Set(w.getCloneState().pluginFactories),N=m.filter(e=>!M.has(e));return N.length>0&&C.usePlugin(...N),C}export{X as cloneRouter,J as getDependenciesApi,Y as getLifecycleApi,E as getPluginApi,G as getRoutesApi};
 //# sourceMappingURL=api.mjs.map

package/dist/esm/api.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"api.mjs","names":[],"sources":["../../src/namespaces/RoutesNamespace/routeGuards.ts","../../src/api/getRoutesApi.ts","../../src/api/getDependenciesApi.ts"],"sourcesContent":["import type { RouterLogger } from \"../../types\";\n\n/**\n * Validates removeRoute constraints.\n * Returns false if removal should be blocked (route is active).\n * Logs warnings for edge cases.\n *\n * @param name - Route name to remove\n * @param currentStateName - Current active route name (or undefined)\n * @param isNavigating - Whether navigation is in progress\n * @param logger - Per-router logger instance (from `getInternals(router).logger`)\n * @returns true if removal can proceed, false if blocked\n */\nexport function validateRemoveRoute(\n  name: string,\n  currentStateName: string | undefined,\n  isNavigating: boolean,\n  logger: RouterLogger,\n): boolean {\n  if (currentStateName) {\n    const isExactMatch = currentStateName === name;\n    const isParentOfCurrent = currentStateName.startsWith(`${name}.`);\n\n    if (isExactMatch || isParentOfCurrent) {\n      const suffix = isExactMatch ? \"\" : ` (current: \"${currentStateName}\")`;\n\n      logger.warn(\n        \"router.removeRoute\",\n        `Cannot remove route \"${name}\" — it is currently active${suffix}. Navigate away first.`,\n      );\n\n      return false;\n    }\n  }\n\n  if (isNavigating) {\n    logger.warn(\n      \"router.removeRoute\",\n      `Route \"${name}\" removed while navigation is in progress. This may cause unexpected behavior.`,\n    );\n  }\n\n  return true;\n}\n\n/**\n * Validates clearRoutes operation.\n * Returns false if operation should be blocked (navigation in progress).\n *\n * @param isNavigating - Whether navigation is in progress\n * @param logger - Per-router logger instance (from `getInternals(router).logger`)\n * @returns true if clearRoutes can proceed, false if blocked\n */\nexport function validateClearRoutes(\n  isNavigating: boolean,\n  logger: RouterLogger,\n): boolean {\n  if (isNavigating) {\n    logger.error(\n      \"router.clearRoutes\",\n      \"Cannot clear routes while navigation is in progress. Wait for navigation to complete.\",\n    );\n\n    return false;\n  }\n\n  return true;\n}\n","import { nodeToDefinition } from \"../engine\";\nimport { throwIfDisposed, throwIfReentrantTreeMutation } from \"./helpers\";\nimport { guardRouteStructure } from \"../guards\";\nimport { getInternals } from \"../internals\";\nimport {\n  clearConfigEntries,\n  removeFromDefinitions,\n} from \"../namespaces/RoutesNamespace/helpers\";\nimport {\n  validateClearRoutes,\n  validateRemoveRoute,\n} from \"../namespaces/RoutesNamespace/routeGuards\";\nimport {\n  adoptRouteArtifacts,\n  assertAddable,\n  assertNoDuplicateNamesInBatch,\n  assertNoDuplicatePathsInBatch,\n  assertNoInternalNamesInBatch,\n  assertNoInternalRouteName,\n  buildAddArtifacts,\n  buildReplaceArtifacts,\n  commitRouteUpdate,\n  commitTreeChanges,\n  compileArtifactGuards,\n  resetStore,\n} from \"../namespaces/RoutesNamespace/routesStore\";\nimport { getTransitionPath } from \"../transitionPath\";\n\nimport type { RoutesApi } from \"./types\";\nimport type { RouteDefinition, RouteTree } from \"../engine\";\nimport type { RouterInternals } from \"../internals\";\nimport type { RouteLifecycleNamespace, RouteConfig } from \"../namespaces\";\nimport type { RoutesStore } from \"../namespaces/RoutesNamespace\";\nimport type {\n  DefaultDependencies,\n  ForwardToCallback,\n  NavigationOptions,\n  Params,\n  Router,\n  RouterLogger,\n  State,\n  TreeChangedEvent,\n  TreeStructuralPatch,\n  GuardFnFactory,\n  Route,\n} from \"../types\";\n\n// ============================================================================\n// Helpers\n// ============================================================================\n\n/**\n * Opts attached to the `TRANSITION_SUCCESS` emitted by `replace()` when it\n * revalidates the active state (#950). `replace` does not push history, so it\n * is a replace-type success — matching `navigateToNotFound`'s opts for the\n * dropped-route branch.\n */\nconst REVALIDATE_OPTS: NavigationOptions = Object.freeze({\n  replace: true,\n  revalidate: true,\n});\n\n/**\n * Clears all config entries and lifecycle handlers for a removed route\n * (and all its descendants).\n */\nfunction clearRouteConfigurations<\n  Dependencies extends DefaultDependencies = DefaultDependencies,\n>(\n  routeName: string,\n  config: RouteConfig,\n  routeCustomFields: Record<string, Record<string, unknown>>,\n  lifecycleNamespace: RouteLifecycleNamespace<Dependencies>,\n): void {\n  const shouldClear = (name: string): boolean =>\n    name === routeName || name.startsWith(`${routeName}.`);\n\n  clearConfigEntries(config.decoders, shouldClear);\n  clearConfigEntries(config.encoders, shouldClear);\n  clearConfigEntries(config.defaultParams, shouldClear);\n  clearConfigEntries(config.forwardMap, shouldClear);\n  clearConfigEntries(config.forwardFnMap, shouldClear);\n  clearConfigEntries(routeCustomFields, shouldClear);\n\n  // Clear forwardMap entries pointing TO the deleted route (or its descendants)\n  clearConfigEntries(config.forwardMap, (key) =>\n    shouldClear(config.forwardMap[key]),\n  );\n\n  // Clear lifecycle handlers\n  const [canDeactivateFactories, canActivateFactories] =\n    lifecycleNamespace.getFactories();\n\n  for (const name of Object.keys(canActivateFactories)) {\n    if (shouldClear(name)) {\n      // Route removed from the tree — both origin slots go (route no longer exists).\n      lifecycleNamespace.clearCanActivate(name, \"both\");\n    }\n  }\n\n  for (const name of Object.keys(canDeactivateFactories)) {\n    if (shouldClear(name)) {\n      lifecycleNamespace.clearCanDeactivate(name, \"both\");\n    }\n  }\n}\n\n/**\n * Re-attaches the stored config (forwardTo / defaultParams / encode-decode) and\n * lifecycle guards for `lookupName` onto `route`, then returns it (mutates in\n * place). Shared by {@link enrichRoute} (nested, bare `name`) and\n * {@link buildFlatRoute} (flat, full dotted `name`) — one source of truth for\n * the route-config field set.\n */\nfunction assignRouteConfig<\n  Dependencies extends DefaultDependencies = DefaultDependencies,\n>(\n  route: Route<Dependencies>,\n  lookupName: string,\n  config: RouteConfig,\n  factories: [\n    Record<string, GuardFnFactory<Dependencies>>,\n    Record<string, GuardFnFactory<Dependencies>>,\n  ],\n): Route<Dependencies> {\n  const forwardToFn = config.forwardFnMap[lookupName];\n  const forwardToStr = config.forwardMap[lookupName];\n\n  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition\n  if (forwardToFn !== undefined) {\n    route.forwardTo = forwardToFn;\n    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition\n  } else if (forwardToStr !== undefined) {\n    route.forwardTo = forwardToStr;\n  }\n\n  if (lookupName in config.defaultParams) {\n    route.defaultParams = config.defaultParams[lookupName];\n  }\n\n  if (lookupName in config.decoders) {\n    route.decodeParams = config.decoders[lookupName];\n  }\n\n  if (lookupName in config.encoders) {\n    route.encodeParams = config.encoders[lookupName];\n  }\n\n  const [canDeactivateFactories, canActivateFactories] = factories;\n\n  if (lookupName in canActivateFactories) {\n    route.canActivate = canActivateFactories[lookupName];\n  }\n\n  if (lookupName in canDeactivateFactories) {\n    route.canDeactivate = canDeactivateFactories[lookupName];\n  }\n\n  return route;\n}\n\n/**\n * Builds a full Route object from a bare RouteDefinition by re-attaching\n * config entries and lifecycle factories.\n *\n * RECURSIVE — call with the factories tuple obtained ONCE from\n * `lifecycleNamespace.getFactories()` and pass it through to children.\n */\nfunction enrichRoute<\n  Dependencies extends DefaultDependencies = DefaultDependencies,\n>(\n  routeDef: RouteDefinition,\n  routeName: string,\n  config: RouteConfig,\n  factories: [\n    Record<string, GuardFnFactory<Dependencies>>,\n    Record<string, GuardFnFactory<Dependencies>>,\n  ],\n): Route<Dependencies> {\n  const route: Route<Dependencies> = {\n    name: routeDef.name,\n    path: routeDef.path,\n  };\n\n  assignRouteConfig(route, routeName, config, factories);\n\n  if (routeDef.children) {\n    route.children = routeDef.children.map((child) =>\n      enrichRoute(child, `${routeName}.${child.name}`, config, factories),\n    );\n  }\n\n  return route;\n}\n\n// ============================================================================\n// TREE_CHANGED payload helpers\n// ============================================================================\n\n/**\n * Builds a single FLAT `Route` for `fullName` from the store config + lifecycle\n * factories — `name` is the FULL dotted name and there is no `children` array\n * (consumers want a flat, by-name list). Frozen on construction.\n */\nfunction buildFlatRoute<\n  Dependencies extends DefaultDependencies = DefaultDependencies,\n>(\n  fullName: string,\n  path: string,\n  config: RouteConfig,\n  factories: [\n    Record<string, GuardFnFactory<Dependencies>>,\n    Record<string, GuardFnFactory<Dependencies>>,\n  ],\n): Route<Dependencies> {\n  const route: Route<Dependencies> = { name: fullName, path };\n\n  assignRouteConfig(route, fullName, config, factories);\n\n  return Object.freeze(route);\n}\n\n/**\n * Walks the store's definitions depth-first, building a FLAT\n * `Map<fullName, Route>` for every node whose full dotted name satisfies\n * `include`. Reads the live store, so call it at the right moment relative to\n * the mutation (before for removed, after for added).\n */\nfunction collectFlatRoutes<\n  Dependencies extends DefaultDependencies = DefaultDependencies,\n>(\n  store: RoutesStore<Dependencies>,\n  include: (fullName: string) => boolean,\n): Map<string, Route<Dependencies>> {\n  const result = new Map<string, Route<Dependencies>>();\n  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- guaranteed set after wiring\n  const factories = store.lifecycleNamespace!.getFactories();\n\n  const walk = (defs: readonly RouteDefinition[], parentName: string): void => {\n    for (const def of defs) {\n      const fullName = parentName ? `${parentName}.${def.name}` : def.name;\n\n      if (include(fullName)) {\n        result.set(\n          fullName,\n          buildFlatRoute(fullName, def.path, store.config, factories),\n        );\n      }\n\n      if (def.children) {\n        walk(def.children, fullName);\n      }\n    }\n  };\n\n  walk(store.definitions, \"\");\n\n  return result;\n}\n\n/**\n * Collects the route `name` and all of its descendants as a FLAT, frozen array.\n * MUST be called BEFORE the removal mutation — the nodes are gone afterwards.\n */\nfunction collectSubtree<\n  Dependencies extends DefaultDependencies = DefaultDependencies,\n>(\n  store: RoutesStore<Dependencies>,\n  name: string,\n): readonly Route<Dependencies>[] {\n  const prefix = `${name}.`;\n  const subtree = collectFlatRoutes(\n    store,\n    (fullName) => fullName === name || fullName.startsWith(prefix),\n  );\n\n  return Object.freeze([...subtree.values()]);\n}\n\n/**\n * Builds the FLAT, frozen payload array for an `add`, walking only the input\n * routes — O(added), not O(tree). `path` is taken from the input verbatim\n * (`sanitizeRoute` never rewrites it); config fields are read from the\n * post-commit store by full name. `add` never removes, so the input subtree is\n * exactly what changed.\n */\nfunction collectAddedRoutes<\n  Dependencies extends DefaultDependencies = DefaultDependencies,\n>(\n  routes: readonly Route<Dependencies>[],\n  parentName: string | undefined,\n  store: RoutesStore<Dependencies>,\n): readonly Route<Dependencies>[] {\n  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- guaranteed set after wiring\n  const factories = store.lifecycleNamespace!.getFactories();\n  const result: Route<Dependencies>[] = [];\n\n  const walk = (\n    input: readonly Route<Dependencies>[],\n    parent: string,\n  ): void => {\n    for (const route of input) {\n      const fullName = parent ? `${parent}.${route.name}` : route.name;\n\n      result.push(\n        buildFlatRoute(fullName, route.path, store.config, factories),\n      );\n\n      if (route.children) {\n        walk(route.children, fullName);\n      }\n    }\n  };\n\n  walk(routes, parentName ?? \"\");\n\n  return Object.freeze(result);\n}\n\n/** Diffs two flat route maps by full name into frozen removed/added arrays. */\nfunction diffFlatRoutes<\n  Dependencies extends DefaultDependencies = DefaultDependencies,\n>(\n  before: ReadonlyMap<string, Route<Dependencies>>,\n  after: ReadonlyMap<string, Route<Dependencies>>,\n): {\n  removed: readonly Route<Dependencies>[];\n  added: readonly Route<Dependencies>[];\n} {\n  const removed: Route<Dependencies>[] = [];\n  const added: Route<Dependencies>[] = [];\n\n  for (const [fullName, route] of before) {\n    if (!after.has(fullName)) {\n      removed.push(route);\n    }\n  }\n\n  for (const [fullName, route] of after) {\n    if (!before.has(fullName)) {\n      added.push(route);\n    }\n  }\n\n  return { removed: Object.freeze(removed), added: Object.freeze(added) };\n}\n\n/**\n * Builds the structural subset of an `update()` patch (forwardTo /\n * defaultParams / encodeParams / decodeParams) from the already-destructured\n * update fields — so user getters are not re-invoked. A guard-only patch yields\n * an empty object → the caller emits no TREE_CHANGED (О-7: guards are\n * invoked-on-demand, not cached, so they need no observation channel).\n *\n * The returned envelope is a fresh object (caller's patch untouched) and is\n * frozen on construction. Nested values (e.g. `defaultParams`) are kept by\n * reference — the same objects the router stored — so exotic inputs (circular\n * refs, class instances) are tolerated, matching `update()`'s existing contract.\n */\nfunction buildStructuralPatch<\n  Dependencies extends DefaultDependencies = DefaultDependencies,\n>(fields: {\n  forwardTo?: string | ForwardToCallback<Dependencies> | null | undefined;\n  defaultParams?: Params | null | undefined;\n  decodeParams?: ((params: Params) => Params) | null | undefined;\n  encodeParams?: ((params: Params) => Params) | null | undefined;\n}): Readonly<TreeStructuralPatch<Dependencies>> {\n  const patch: TreeStructuralPatch<Dependencies> = {};\n\n  if (fields.forwardTo !== undefined) {\n    patch.forwardTo = fields.forwardTo;\n  }\n\n  if (fields.defaultParams !== undefined) {\n    patch.defaultParams = fields.defaultParams;\n  }\n\n  if (fields.encodeParams !== undefined) {\n    patch.encodeParams = fields.encodeParams;\n  }\n\n  if (fields.decodeParams !== undefined) {\n    patch.decodeParams = fields.decodeParams;\n  }\n\n  return Object.freeze(patch);\n}\n\n// ============================================================================\n// CRUD operations\n// ============================================================================\n\n/**\n * Adds one or more routes to the router.\n * Input already validated by facade.\n */\nfunction addRoutes<\n  Dependencies extends DefaultDependencies = DefaultDependencies,\n>(\n  store: RoutesStore<Dependencies>,\n  routes: Route<Dependencies>[],\n  parentName: string | undefined,\n  logger: RouterLogger,\n): void {\n  // Prepare-then-commit (issue #698): reject the silent-corruption cases\n  // up front (dup name vs existing, missing parent), build the merged tree /\n  // config into locals (async/circular forwardTo + invalid constraint throw\n  // here), then swap atomically. A rejected add leaves the store untouched.\n  assertAddable(store, routes, parentName);\n\n  const artifacts = buildAddArtifacts(store, routes, parentName, logger);\n\n  // Pre-flight the #961 handler-limit into PREPARE so a limit-exceeding batch\n  // aborts before the swap (#1046). `add` does not clear guards, so the\n  // projection runs against the live union count (clearsDefinition = false).\n  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- guaranteed set after wiring\n  store.lifecycleNamespace!.preflightHandlerLimit(\n    artifacts.pendingCanActivate.keys(),\n    artifacts.pendingCanDeactivate.keys(),\n    false,\n  );\n\n  adoptRouteArtifacts(store, artifacts);\n}\n\n/**\n * Commits a revalidated state after `replace()` and emits `TRANSITION_SUCCESS`\n * so `router.subscribe` / adapters re-render (#950). The emit carries\n * `REVALIDATE_OPTS` — the single distinguishable marker (`revalidate: true`) a\n * plugin's `onTransitionSuccess` can read to special-case a revalidation vs a\n * real navigation (#1201).\n */\nfunction commitRevalidated<\n  Dependencies extends DefaultDependencies = DefaultDependencies,\n>(\n  ctx: RouterInternals<Dependencies>,\n  nextState: State,\n  fromState: State,\n): void {\n  ctx.setState(nextState);\n  ctx.emitTransitionSuccess(nextState, fromState, REVALIDATE_OPTS);\n}\n\n/**\n * Atomically replaces all routes with a new set (HMR / code-splitting).\n * Prepare-then-commit (issue #698): the new set is fully built into locals\n * first — a circular/async forwardTo or invalid path throws here, leaving the\n * existing tree intact — then committed.\n */\nfunction replaceRoutes<\n  Dependencies extends DefaultDependencies = DefaultDependencies,\n>(\n  store: RoutesStore<Dependencies>,\n  routes: Route<Dependencies>[],\n  ctx: RouterInternals<Dependencies>,\n  currentState: State | undefined,\n  onCommitted?: () => void,\n): void {\n  // Reject the silent-corruption cases `assertAddable` catches for `add`, BEFORE\n  // building/swapping, so bare-core parity is symmetric (#1047): within-batch\n  // duplicate names (#968), reserved \"@@\" names (#954), and within-batch\n  // duplicate paths (#955). methodName is \"addRoute\" to match validation-plugin\n  // (which reports \"addRoute\" for replace batches too), so the no-plugin error\n  // is identical to the with-plugin one.\n  assertNoInternalNamesInBatch(routes, \"addRoute\");\n  assertNoDuplicateNamesInBatch(routes, \"\", \"addRoute\");\n  assertNoDuplicatePathsInBatch(routes, \"\", \"addRoute\");\n\n  // Build the whole new set BEFORE touching the store.\n  const artifacts = buildReplaceArtifacts(\n    routes,\n    store.rootPath,\n    store.matcherOptions,\n    ctx.logger,\n  );\n\n  // Pre-flight the #961 handler-limit BEFORE clearDefinitionGuards mutates, so a\n  // limit-exceeding batch aborts with BOTH the tree and the definition guards\n  // intact (#1046). replace clears definition guards first, so the projection\n  // runs against the surviving external guards (clearsDefinition = true).\n  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- guaranteed set after wiring\n  store.lifecycleNamespace!.preflightHandlerLimit(\n    artifacts.pendingCanActivate.keys(),\n    artifacts.pendingCanDeactivate.keys(),\n    true,\n  );\n\n  // Pre-compile the new batch's guard factories in the PREPARE phase — BEFORE\n  // clearDefinitionGuards — so a compile-throwing factory (or a non-function)\n  // aborts here with BOTH the tree AND the old definition guards intact (#1193,\n  // mirror of the #1046 handler-limit hoist). adoptRouteArtifacts then installs\n  // these pre-compiled functions without re-running the factories.\n  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- guaranteed set after wiring\n  const compiledGuards = compileArtifactGuards(artifacts, store.depsStore!);\n\n  // Clear definition lifecycle handlers (preserve external guards), then swap.\n  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- guaranteed set after wiring\n  store.lifecycleNamespace!.clearDefinitionGuards();\n  adoptRouteArtifacts(store, artifacts, compiledGuards);\n\n  // TREE_CHANGED fires here (О-5): the new tree is committed but state is not\n  // yet revalidated, so the handler sees the new tree and the still-old state.\n  onCommitted?.();\n\n  // Revalidate the active state against the new tree AND notify subscribers\n  // (#950). A structural replace can change or drop the currently-active state;\n  // emitting TRANSITION_SUCCESS makes router.subscribe / useSyncExternalStore\n  // adapters re-render instead of rendering the pre-replace state. (This is the\n  // one structural mutation that emits a transition event — clear() stays a\n  // silent reset; the asymmetry is deliberate, see #950.)\n  if (currentState !== undefined) {\n    const revalidated = ctx.matchPath(currentState.path, ctx.getOptions());\n\n    if (revalidated) {\n      if (revalidated.name === currentState.name) {\n        // Survivor — the URL still maps to the route the user was already on.\n        // Keep it WITHOUT re-running guards: the user legitimately reached this\n        // route via a real navigation, and `replace()` is not a navigation they\n        // performed, so re-checking guards here would evict them on a stateful\n        // or async guard (parity with `update()`, which never revalidates the\n        // active state). Preserve the prior transition meta and emit so\n        // subscribers see the revalidated state (#1201). Carry the prior\n        // `context` (#1236): the route name and path are unchanged, so the\n        // plugin data written into `state.context.<namespace>` (SSR data, rsc,\n        // navigation, …) is still valid — the matchPath-rebuilt state would\n        // otherwise wipe it, and revalidation re-runs neither the loader nor the\n        // start interceptor to bring it back.\n        const nextState: State = {\n          ...revalidated,\n          context: currentState.context,\n          transition: currentState.transition,\n        };\n\n        commitRevalidated(ctx, nextState, currentState);\n      } else {\n        // Route-identity change — the URL is now owned by a DIFFERENT route (an\n        // ownership reshuffle, or a newly-added `forwardTo` that teleports the\n        // state). That is effectively a navigation the user never performed, so\n        // consult the new route's guards exactly as `navigate` would (#1201).\n        // Commit on pass; on a block — or an async guard that cannot be\n        // evaluated synchronously (mirrors `canNavigateTo`) — route to\n        // not-found rather than silently activating a guarded route.\n        const { toDeactivate, toActivate } = getTransitionPath(\n          revalidated,\n          currentState,\n        );\n\n        const allowed =\n          // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- guaranteed set after wiring\n          store.lifecycleNamespace!.canNavigateTo(\n            toDeactivate,\n            toActivate,\n            revalidated,\n            currentState,\n          );\n\n        if (allowed) {\n          const nextState: State = {\n            ...revalidated,\n            transition: currentState.transition,\n          };\n\n          commitRevalidated(ctx, nextState, currentState);\n        } else {\n          ctx.navigateToNotFound(currentState.path);\n        }\n      }\n    } else {\n      // The active route no longer exists in the new tree — surface it as\n      // not-found (commits UNKNOWN_ROUTE + emits TRANSITION_SUCCESS) so the\n      // change is observable, rather than silently clearing the state.\n      ctx.navigateToNotFound(currentState.path);\n    }\n  }\n}\n\n/**\n * Removes a route and all its children.\n *\n * @returns true if removed, false if not found\n */\nfunction removeRoute<\n  Dependencies extends DefaultDependencies = DefaultDependencies,\n>(store: RoutesStore<Dependencies>, name: string): boolean {\n  // `store.definitions` is a fresh tree-derived snapshot — mutate it locally,\n  // then commit the mutated table as the new tree.\n  const definitions = store.definitions;\n  const wasRemoved = removeFromDefinitions(definitions, name);\n\n  if (!wasRemoved) {\n    return false;\n  }\n\n  clearRouteConfigurations(\n    name,\n    store.config,\n    store.routeCustomFields,\n    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n    store.lifecycleNamespace!,\n  );\n\n  commitTreeChanges(store, definitions);\n\n  return true;\n}\n\n/**\n * Gets a route by name with all its configuration.\n */\nfunction getRoute<\n  Dependencies extends DefaultDependencies = DefaultDependencies,\n>(\n  store: RoutesStore<Dependencies>,\n  name: string,\n): Route<Dependencies> | undefined {\n  const segments = store.matcher.getSegmentsByName(name);\n\n  if (!segments) {\n    return undefined;\n  }\n\n  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- segments is non-empty (checked above)\n  const targetNode = segments.at(-1)! as RouteTree;\n  const definition = nodeToDefinition(targetNode);\n  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n  const factories = store.lifecycleNamespace!.getFactories();\n\n  return enrichRoute(definition, name, store.config, factories);\n}\n\n// ============================================================================\n// API factory\n// ============================================================================\n\n// Cache the assembled RoutesApi per router — mirrors getPluginApi()/getNavigator():\n// avoids re-allocating the 9-closure bag on each call (adapters/plugins poll it\n// from constructors) and gives spy/stub helpers a stable object identity. Closures\n// capture `ctx`/`store`, both stable for the router's lifetime, so caching is safe.\n// Single cast site: the value is stored as `unknown` (RoutesApi is invariant in\n// Dependencies, so one typed map can't hold every instantiation) and cast on read.\nconst cache = new WeakMap<object, unknown>();\n\nexport function getRoutesApi<\n  Dependencies extends DefaultDependencies = DefaultDependencies,\n>(router: Router<Dependencies>): RoutesApi<Dependencies> {\n  const cached = cache.get(router);\n\n  if (cached) {\n    return cached as RoutesApi<Dependencies>;\n  }\n\n  const ctx = getInternals(router);\n\n  const store = ctx.routeGetStore();\n\n  // Single cast site: the channel is typed with default Dependencies on\n  // RouterInternals (RouterEventMap is non-generic), but payloads are built\n  // with this api's Dependencies. The runtime shape is identical.\n  const emitChange = (event: TreeChangedEvent<Dependencies>): void => {\n    ctx.treeChanged.emit(event as TreeChangedEvent);\n  };\n\n  const api: RoutesApi<Dependencies> = {\n    add: (routes, options) => {\n      throwIfDisposed(ctx.isDisposed);\n      throwIfReentrantTreeMutation(ctx.treeChanged.isEmitting);\n\n      const routeArray = Array.isArray(routes) ? routes : [routes];\n      const parentName = options?.parent;\n\n      guardRouteStructure(routeArray, ctx.validator);\n\n      if (parentName !== undefined) {\n        ctx.validator?.routes.validateParentOption(parentName, store.tree);\n      }\n\n      ctx.validator?.routes.throwIfInternalRouteInArray(routeArray, \"addRoute\");\n      ctx.validator?.routes.validateAddRouteArgs(routeArray);\n      ctx.validator?.routes.validateRoutes(routeArray, store, parentName);\n\n      addRoutes(store, routeArray, parentName, ctx.logger);\n\n      // Built from the post-commit store (О-1), only when someone is listening.\n      if (ctx.treeChanged.listenerCount() > 0) {\n        const added = collectAddedRoutes(routeArray, parentName, store);\n\n        emitChange(\n          parentName === undefined\n            ? { op: \"add\", added }\n            : { op: \"add\", added, parent: parentName },\n        );\n      }\n    },\n\n    remove: (name) => {\n      throwIfDisposed(ctx.isDisposed);\n      throwIfReentrantTreeMutation(ctx.treeChanged.isEmitting);\n\n      ctx.validator?.routes.validateRemoveRouteArgs(name);\n      ctx.validator?.routes.throwIfInternalRoute(name, \"removeRoute\");\n      // Always-on parity backstop (#1047 / #238): a reserved \"@@\" name is\n      // internal and cannot be removed, with or without the validation-plugin.\n      assertNoInternalRouteName(name, \"removeRoute\");\n\n      const canRemove = validateRemoveRoute(\n        name,\n        ctx.getStateName(),\n        ctx.isTransitioning(),\n        ctx.logger,\n      );\n\n      if (!canRemove) {\n        return;\n      }\n\n      // Snapshot the subtree BEFORE the mutation — the nodes are gone after.\n      const removedSubtree =\n        ctx.treeChanged.listenerCount() > 0\n          ? collectSubtree(store, name)\n          : undefined;\n      const wasRemoved = removeRoute(store, name);\n\n      if (!wasRemoved) {\n        ctx.logger.warn(\n          \"router.removeRoute\",\n          `Route \"${name}\" not found. No changes made.`,\n        );\n\n        return;\n      }\n\n      if (removedSubtree !== undefined) {\n        emitChange({ op: \"remove\", name, removedSubtree });\n      }\n    },\n\n    update: (name, updates) => {\n      throwIfDisposed(ctx.isDisposed);\n      throwIfReentrantTreeMutation(ctx.treeChanged.isEmitting);\n\n      ctx.validator?.routes.validateUpdateRouteBasicArgs(name, updates);\n      ctx.validator?.routes.throwIfInternalRoute(name, \"updateRoute\");\n      // Always-on parity backstop (#1047 / #238): a reserved \"@@\" name is\n      // internal and cannot be updated, with or without the validation-plugin.\n      assertNoInternalRouteName(name, \"updateRoute\");\n\n      ctx.validator?.routes.validateUpdateRoutePropertyTypes(name, updates);\n\n      /* v8 ignore next 6 -- @preserve: race condition guard, mirrors Router.updateRoute() same-path guard tested via Router.ts unit tests */\n      if (ctx.isTransitioning()) {\n        ctx.logger.error(\n          \"router.updateRoute\",\n          `Updating route \"${name}\" while navigation is in progress. This may cause unexpected behavior.`,\n        );\n      }\n\n      ctx.validator?.routes.validateUpdateRoute(name, updates, store);\n\n      // #1205: bare-core existence backstop as a TRUE no-op — NOT a throw\n      // (validation is opt-in). update() of a route that does not exist used to\n      // seed config.defaultParams + compile/register the guard (commitRouteUpdate\n      // below) and emit a lying TREE_CHANGED \"update\" event for a route get()/\n      // has() cannot see; a future add() of that name then inherited the phantom\n      // config + a blocking guard. Skip the commit and the emit entirely when the\n      // route is absent. (With the validation-plugin, validateUpdateRoute above\n      // already threw a ReferenceError, so this is only reached in bare core.)\n      if (!store.matcher.hasRoute(name)) {\n        return;\n      }\n\n      // Field-patch commit core (NO_TREE_REBUILD) — co-located in routesStore.ts\n      // beside the add/replace (adoptRouteArtifacts) / remove (commitTreeChanges)\n      // / clear (resetStore) cores. Returns the structural fields for the\n      // conditional emit below (each user getter read once inside).\n      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- guaranteed set after wiring\n      const lifecycle = store.lifecycleNamespace!;\n      const structural = commitRouteUpdate(store, lifecycle, name, updates);\n\n      // Conditional emit: structural fields only. A guard-only or empty patch\n      // produces no event (О-7 + empty-patch rule).\n      if (ctx.treeChanged.listenerCount() > 0) {\n        const patch = buildStructuralPatch<Dependencies>(structural);\n\n        if (Object.keys(patch).length > 0) {\n          emitChange({ op: \"update\", name, patch });\n        }\n      }\n    },\n\n    clear: () => {\n      throwIfDisposed(ctx.isDisposed);\n      throwIfReentrantTreeMutation(ctx.treeChanged.isEmitting);\n\n      const canClear = validateClearRoutes(ctx.isTransitioning(), ctx.logger);\n\n      /* v8 ignore next 3 -- @preserve: race condition guard, mirrors Router.clearRoutes() same-path guard tested via validateClearRoutes unit tests */\n      if (!canClear) {\n        return;\n      }\n\n      // Snapshot the routes BEFORE the reset empties them. Emitted whenever\n      // there is a listener — even for an empty clear (О-4).\n      const removed =\n        ctx.treeChanged.listenerCount() > 0\n          ? Object.freeze([...collectFlatRoutes(store, () => true).values()])\n          : undefined;\n\n      resetStore(store);\n      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- guaranteed set after wiring\n      store.lifecycleNamespace!.clearAll();\n      ctx.clearState();\n\n      if (removed !== undefined) {\n        emitChange({ op: \"clear\", removed });\n      }\n    },\n\n    has: (name) => {\n      ctx.validator?.routes.validateRouteName(name, \"hasRoute\");\n\n      return store.matcher.hasRoute(name);\n    },\n\n    get: (name) => {\n      ctx.validator?.routes.validateRouteName(name, \"getRoute\");\n\n      return getRoute(store, name);\n    },\n\n    replace: (routes) => {\n      throwIfDisposed(ctx.isDisposed);\n      throwIfReentrantTreeMutation(ctx.treeChanged.isEmitting);\n\n      const routeArray = Array.isArray(routes) ? routes : [routes];\n\n      const canReplace = validateClearRoutes(ctx.isTransitioning(), ctx.logger);\n\n      if (!canReplace) {\n        return;\n      }\n\n      guardRouteStructure(routeArray, ctx.validator);\n\n      ctx.validator?.routes.throwIfInternalRouteInArray(\n        routeArray,\n        \"replaceRoutes\",\n      );\n      ctx.validator?.routes.validateAddRouteArgs(routeArray);\n      ctx.validator?.routes.validateRoutes(routeArray, store);\n\n      const currentState = router.getState();\n\n      // The flat removed/added diff is O(N) — compute it only when someone is\n      // listening (Решение 3.B). Snapshot the old tree BEFORE the swap.\n      const before =\n        ctx.treeChanged.listenerCount() > 0\n          ? collectFlatRoutes(store, () => true)\n          : undefined;\n\n      replaceRoutes(\n        store,\n        routeArray,\n        ctx,\n        currentState,\n        before === undefined\n          ? undefined\n          : () => {\n              const after = collectFlatRoutes(store, () => true);\n              const { removed, added } = diffFlatRoutes(before, after);\n\n              emitChange({ op: \"replace\", removed, added });\n            },\n      );\n    },\n\n    subscribeChanges: (handler) => ctx.treeChanged.subscribe(handler),\n  };\n\n  cache.set(router, api);\n\n  return api;\n}\n","import { throwIfDisposed } from \"./helpers\";\nimport { getInternals } from \"../internals\";\n\nimport type { DependenciesApi } from \"./types\";\nimport type { DependenciesStore } from \"../namespaces\";\nimport type { DefaultDependencies, Router } from \"../types\";\nimport type { RouterValidator } from \"../types/RouterValidator\";\n\n// =============================================================================\n// Module-private CRUD functions\n// =============================================================================\n\nfunction setDependency(\n  store: DependenciesStore,\n  dependencyName: string,\n  dependencyValue: unknown,\n  validator?: RouterValidator | null,\n): void {\n  // undefined = \"don't set\" (feature for conditional setting)\n  if (dependencyValue === undefined) {\n    return;\n  }\n\n  const isNewKey = !Object.hasOwn(store.dependencies, dependencyName);\n\n  if (isNewKey) {\n    // Only check limit when adding new keys (overwrites don't increase count)\n    validator?.dependencies.validateDependencyCount(store, \"setDependency\");\n  } else {\n    const oldValue = (store.dependencies as Record<string, unknown>)[\n      dependencyName\n    ];\n    const isChanging = oldValue !== dependencyValue;\n    // Special case for NaN idempotency (NaN !== NaN is always true)\n    const bothAreNaN = Number.isNaN(oldValue) && Number.isNaN(dependencyValue);\n\n    if (isChanging && !bothAreNaN) {\n      validator?.dependencies.warnOverwrite(dependencyName, \"setDependency\");\n    }\n  }\n\n  (store.dependencies as Record<string, unknown>)[dependencyName] =\n    dependencyValue;\n}\n\nfunction setMultipleDependencies(\n  store: DependenciesStore,\n  deps: Record<string, unknown>,\n  validator?: RouterValidator | null,\n): void {\n  const overwrittenKeys: string[] = [];\n\n  for (const key in deps) {\n    if (deps[key] === undefined) {\n      continue;\n    }\n\n    if (Object.hasOwn(store.dependencies, key)) {\n      overwrittenKeys.push(key);\n    } else {\n      validator?.dependencies.validateDependencyCount(store, \"setDependencies\");\n    }\n\n    (store.dependencies as Record<string, unknown>)[key] = deps[key];\n  }\n\n  if (overwrittenKeys.length > 0) {\n    validator?.dependencies.warnBatchOverwrite(\n      overwrittenKeys,\n      \"setDependencies\",\n    );\n  }\n}\n\n// =============================================================================\n// Public API factory\n// =============================================================================\n\nexport function getDependenciesApi<\n  Dependencies extends DefaultDependencies = DefaultDependencies,\n>(router: Router<Dependencies>): DependenciesApi<Dependencies> {\n  const ctx = getInternals(router);\n\n  return {\n    get: (name) => {\n      ctx.validator?.dependencies.validateDependencyName(name, \"getDependency\");\n\n      const store = ctx.dependenciesGetStore();\n      const value = (store.dependencies as Record<string, unknown>)[\n        name as string\n      ];\n\n      ctx.validator?.dependencies.validateDependencyExists(\n        name as string,\n        store,\n      );\n\n      return value as Dependencies[typeof name];\n    },\n    getAll: () => ({ ...ctx.dependenciesGetStore().dependencies }),\n    set: (name, value) => {\n      throwIfDisposed(ctx.isDisposed);\n\n      ctx.validator?.dependencies.validateSetDependencyArgs(\n        name,\n        value,\n        \"setDependency\",\n      );\n\n      setDependency(ctx.dependenciesGetStore(), name, value, ctx.validator);\n    },\n    setAll: (deps) => {\n      throwIfDisposed(ctx.isDisposed);\n\n      const store = ctx.dependenciesGetStore();\n\n      ctx.validator?.dependencies.validateDependenciesObject(\n        deps,\n        \"setDependencies\",\n      );\n\n      setMultipleDependencies(\n        store,\n        deps as Record<string, unknown>,\n        ctx.validator,\n      );\n    },\n    remove: (name) => {\n      throwIfDisposed(ctx.isDisposed);\n\n      ctx.validator?.dependencies.validateDependencyName(\n        name,\n        \"removeDependency\",\n      );\n\n      const store = ctx.dependenciesGetStore();\n\n      if (!Object.hasOwn(store.dependencies, name)) {\n        ctx.validator?.dependencies.warnRemoveNonExistent(name);\n      }\n\n      delete (store.dependencies as Record<string, unknown>)[name as string];\n    },\n    reset: () => {\n      throwIfDisposed(ctx.isDisposed);\n      const store = ctx.dependenciesGetStore();\n\n      store.dependencies = Object.create(null) as Partial<Dependencies>;\n    },\n    has: (name) => {\n      ctx.validator?.dependencies.validateDependencyName(name, \"hasDependency\");\n\n      return Object.hasOwn(ctx.dependenciesGetStore().dependencies, name);\n    },\n  };\n}\n"],"mappings":"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"}
+{"version":3,"file":"api.mjs","names":["cache","RouterClass"],"sources":["../../src/api/helpers.ts","../../src/api/getPluginApi.ts","../../src/namespaces/RoutesNamespace/routeGuards.ts","../../src/api/getRoutesApi.ts","../../src/api/getDependenciesApi.ts","../../src/api/getLifecycleApi.ts","../../src/api/cloneRouter.ts"],"sourcesContent":["// packages/core/src/api/helpers.ts\n\nimport { errorCodes } from \"../constants\";\nimport { RouterError } from \"../RouterError\";\n\nexport function throwIfDisposed(isDisposed: () => boolean): void {\n  if (isDisposed()) {\n    throw new RouterError(errorCodes.ROUTER_DISPOSED);\n  }\n}\n\n/**\n * Bans synchronous reentrant route-CRUD: a CRUD op called while a `TREE_CHANGED`\n * emit is on the stack (i.e. from inside a `subscribeChanges` handler) throws\n * `REENTRANT_TREE_MUTATION` BEFORE mutating — the tree stays atomic (#1032).\n * Deferred CRUD (`queueMicrotask` / `await`) runs after the dispatch settles and\n * is unaffected; CRUD from a transition listener is not a TREE_CHANGED dispatch.\n */\nexport function throwIfReentrantTreeMutation(isEmitting: () => boolean): void {\n  if (isEmitting()) {\n    throw new RouterError(errorCodes.REENTRANT_TREE_MUTATION);\n  }\n}\n","import { throwIfDisposed } from \"./helpers\";\nimport { errorCodes } from \"../constants\";\nimport { getInternals } from \"../internals\";\nimport { RouterError } from \"../RouterError\";\n\nimport type { PluginApi } from \"./types\";\nimport type {\n  ContextNamespaceClaim,\n  DefaultDependencies,\n  Params,\n  Router,\n  State,\n} from \"../types\";\n\n// Cache the assembled PluginApi per router — mirrors getNavigator() (#525):\n// avoids re-allocating the closure-bag on each call (plugins call this once\n// at init, but tests + nested plugins poll it), and gives spy/stub helpers\n// a stable object identity to attach to (e.g. spying on\n// `getPluginApi(router).navigateToState` to inject errors in popstate\n// recovery tests).\nconst cache = new WeakMap<object, PluginApi>();\n\nexport function getPluginApi<\n  Dependencies extends DefaultDependencies = DefaultDependencies,\n>(router: Router<Dependencies>): PluginApi {\n  const cached = cache.get(router);\n\n  if (cached) {\n    return cached;\n  }\n\n  const ctx = getInternals(router);\n  const api: PluginApi = {\n    makeState: (name, params, path, meta) => {\n      ctx.validator?.state.validateMakeStateArgs(name, params, path);\n\n      return ctx.makeState(\n        name,\n        params,\n        path,\n        meta?.params as\n          Record<string, Record<string, \"url\" | \"query\">> | undefined,\n      );\n    },\n    buildState: (routeName, routeParams) => {\n      ctx.validator?.routes.validateStateBuilderArgs(\n        routeName,\n        routeParams,\n        \"buildState\",\n      );\n\n      const { name, params } = ctx.forwardState(routeName, routeParams);\n\n      return ctx.buildStateResolved(name, params);\n    },\n    forwardState: <P extends Params = Params>(\n      routeName: string,\n      routeParams: P,\n    ) => {\n      ctx.validator?.routes.validateStateBuilderArgs(\n        routeName,\n        routeParams,\n        \"forwardState\",\n      );\n\n      return ctx.forwardState(routeName, routeParams);\n    },\n    matchPath: (path) => {\n      ctx.validator?.routes.validateMatchPathArgs(path);\n\n      return ctx.matchPath(path, ctx.getOptions());\n    },\n    navigateToState: (state, options) => {\n      throwIfDisposed(ctx.isDisposed);\n\n      ctx.validator?.navigation.validateNavigateToStateArgs(state);\n\n      if (options !== undefined) {\n        ctx.validator?.navigation.validateNavigationOptions(\n          options,\n          \"navigateToState\",\n        );\n      }\n\n      return ctx.navigateToState(state, options);\n    },\n    setRootPath: (rootPath) => {\n      throwIfDisposed(ctx.isDisposed);\n\n      ctx.validator?.routes.validateSetRootPathArgs(rootPath);\n\n      ctx.setRootPath(rootPath);\n    },\n    getRootPath: ctx.getRootPath,\n    addEventListener: (eventName, cb) => {\n      throwIfDisposed(ctx.isDisposed);\n\n      ctx.validator?.eventBus.validateListenerArgs(eventName, cb);\n\n      return ctx.addEventListener(eventName, cb);\n    },\n    buildNavigationState: (name, params = {}) => {\n      ctx.validator?.routes.validateStateBuilderArgs(\n        name,\n        params,\n        \"buildNavigationState\",\n      );\n\n      const { name: resolvedName, params: resolvedParams } = ctx.forwardState(\n        name,\n        params,\n      );\n      const routeInfo = ctx.buildStateResolved(resolvedName, resolvedParams);\n\n      if (!routeInfo) {\n        return;\n      }\n\n      return ctx.makeState(\n        routeInfo.name,\n        routeInfo.params,\n        ctx.buildPath(routeInfo.name, routeInfo.params),\n        routeInfo.meta,\n      );\n    },\n    getOptions: ctx.getOptions,\n    getTree: ctx.getTree,\n    addInterceptor: (method, fn) => {\n      throwIfDisposed(ctx.isDisposed);\n      ctx.validator?.plugins.validateAddInterceptorArgs(method, fn);\n      let list = ctx.interceptors.get(method);\n\n      if (!list) {\n        list = [];\n        ctx.interceptors.set(method, list);\n      }\n\n      list.push(fn);\n\n      // Idempotency flag (#1198). Without it, a double call would `indexOf(fn)`\n      // again and splice a DUPLICATE registration of the same fn — silently\n      // deactivating another plugin's interceptor whose own unsubscribe was never\n      // called. The `Unsubscribe` contract is documented idempotent. The flag\n      // guarantees exactly one splice of a still-present `fn`, so no `index !== -1`\n      // guard is needed (it would be dead — the second call returns above).\n      let removed = false;\n\n      return () => {\n        if (removed) {\n          return;\n        }\n\n        removed = true;\n        list.splice(list.indexOf(fn), 1);\n      };\n    },\n    getRouteConfig: (name) => {\n      const store = ctx.routeGetStore();\n\n      // Stryker disable next-line ConditionalExpression,BlockStatement: equivalent — a missing route yields routeCustomFields[name] === undefined, identical to this early return\n      if (!store.matcher.hasRoute(name)) {\n        return;\n      }\n\n      return store.routeCustomFields[name];\n    },\n    extendRouter: (extensions: Record<string, unknown>) => {\n      throwIfDisposed(ctx.isDisposed);\n\n      const keys = Object.keys(extensions);\n\n      for (const key of keys) {\n        if (key in router) {\n          throw new RouterError(errorCodes.PLUGIN_CONFLICT, {\n            message: `Cannot extend router: property \"${key}\" already exists`,\n          });\n        }\n      }\n\n      for (const key of keys) {\n        (router as Record<string, unknown>)[key] = extensions[key];\n      }\n\n      const extensionRecord = { keys };\n\n      ctx.routerExtensions.push(extensionRecord);\n\n      let removed = false;\n\n      return () => {\n        if (removed) {\n          return;\n        }\n\n        removed = true;\n\n        for (const key of extensionRecord.keys) {\n          delete (router as Record<string, unknown>)[key];\n        }\n\n        const idx = ctx.routerExtensions.indexOf(extensionRecord);\n\n        // Stryker disable next-line ConditionalExpression,EqualityOperator,UnaryOperator,BlockStatement: equivalent — this splice only tidies the `routerExtensions` TRACKING array; the router INSTANCE is cleaned by the `delete router[key]` loop above, and dispose()'s safety-net re-deletes any leaked key harmlessly. So no mutation of this guard/splice is behaviourally observable (full suite green with `===`, `+1`, and an empty body). Contrast the addInterceptor splice, which IS observable through buildPath and is killed behaviourally by invariantGuardMutants.test.ts.\n        if (idx !== -1) {\n          ctx.routerExtensions.splice(idx, 1);\n        }\n      };\n    },\n    emitTransitionError: (error) => {\n      throwIfDisposed(ctx.isDisposed);\n      ctx.emitTransitionError(error);\n    },\n    claimContextNamespace: (namespace: string) => {\n      throwIfDisposed(ctx.isDisposed);\n\n      // Input-shape guard, symmetric with the other always-on invariant guards\n      // (subscribe / start / navigateToNotFound each typeof-check their input).\n      // A non-string namespace coerces to an inconsistent key (\"42\"); an empty\n      // string is a meaningless namespace (#1191 N4).\n      if (typeof namespace !== \"string\" || namespace === \"\") {\n        throw new TypeError(\n          `[claimContextNamespace] namespace must be a non-empty string, got ${\n            typeof namespace === \"string\" ? \"an empty string\" : typeof namespace\n          }`,\n        );\n      }\n\n      if (ctx.contextClaimRecords.has(namespace)) {\n        throw new RouterError(errorCodes.CONTEXT_NAMESPACE_ALREADY_CLAIMED, {\n          message: `Cannot claim context namespace: \"${namespace}\" is already claimed by another plugin`,\n        });\n      }\n\n      ctx.contextClaimRecords.add(namespace);\n\n      return {\n        write(state: State, value: unknown) {\n          // `state.context[namespace] = value` dispatches into the inherited\n          // Object.prototype.__proto__ setter for the literal key \"__proto__\",\n          // swapping the prototype instead of creating an own entry — the data\n          // then vanishes from Object.keys / serializeRouterState (#1191 N3).\n          // Mirror search-params' assignParam: defineProperty writes a genuine\n          // own property; normal names keep the plain-assignment fast path.\n          if (namespace === \"__proto__\") {\n            Object.defineProperty(state.context, namespace, {\n              value,\n              writable: true,\n              enumerable: true,\n              configurable: true,\n            });\n          } else {\n            state.context[namespace] = value;\n          }\n        },\n        release() {\n          ctx.contextClaimRecords.delete(namespace);\n        },\n      } satisfies ContextNamespaceClaim;\n    },\n  };\n\n  cache.set(router, api);\n\n  return api;\n}\n","import type { RouterLogger } from \"../../types\";\n\n/**\n * Validates removeRoute constraints.\n * Returns false if removal should be blocked (route is active).\n * Logs warnings for edge cases.\n *\n * @param name - Route name to remove\n * @param currentStateName - Current active route name (or undefined)\n * @param isNavigating - Whether navigation is in progress\n * @param logger - Per-router logger instance (from `getInternals(router).logger`)\n * @returns true if removal can proceed, false if blocked\n */\nexport function validateRemoveRoute(\n  name: string,\n  currentStateName: string | undefined,\n  isNavigating: boolean,\n  logger: RouterLogger,\n): boolean {\n  if (currentStateName) {\n    const isExactMatch = currentStateName === name;\n    const isParentOfCurrent = currentStateName.startsWith(`${name}.`);\n\n    if (isExactMatch || isParentOfCurrent) {\n      const suffix = isExactMatch ? \"\" : ` (current: \"${currentStateName}\")`;\n\n      logger.warn(\n        \"router.removeRoute\",\n        `Cannot remove route \"${name}\" — it is currently active${suffix}. Navigate away first.`,\n      );\n\n      return false;\n    }\n  }\n\n  if (isNavigating) {\n    logger.warn(\n      \"router.removeRoute\",\n      `Route \"${name}\" removed while navigation is in progress. This may cause unexpected behavior.`,\n    );\n  }\n\n  return true;\n}\n\n/**\n * Validates clearRoutes operation.\n * Returns false if operation should be blocked (navigation in progress).\n *\n * @param isNavigating - Whether navigation is in progress\n * @param logger - Per-router logger instance (from `getInternals(router).logger`)\n * @returns true if clearRoutes can proceed, false if blocked\n */\nexport function validateClearRoutes(\n  isNavigating: boolean,\n  logger: RouterLogger,\n): boolean {\n  if (isNavigating) {\n    logger.error(\n      \"router.clearRoutes\",\n      \"Cannot clear routes while navigation is in progress. Wait for navigation to complete.\",\n    );\n\n    return false;\n  }\n\n  return true;\n}\n","import { nodeToDefinition } from \"../engine\";\nimport { throwIfDisposed, throwIfReentrantTreeMutation } from \"./helpers\";\nimport { guardRouteStructure } from \"../guards\";\nimport { getInternals } from \"../internals\";\nimport {\n  clearConfigEntries,\n  removeFromDefinitions,\n} from \"../namespaces/RoutesNamespace/helpers\";\nimport {\n  validateClearRoutes,\n  validateRemoveRoute,\n} from \"../namespaces/RoutesNamespace/routeGuards\";\nimport {\n  adoptRouteArtifacts,\n  assertAddable,\n  assertNoDuplicateNamesInBatch,\n  assertNoDuplicatePathsInBatch,\n  assertNoInternalNamesInBatch,\n  assertNoInternalRouteName,\n  buildAddArtifacts,\n  buildReplaceArtifacts,\n  commitRouteUpdate,\n  commitTreeChanges,\n  compileArtifactGuards,\n  resetStore,\n} from \"../namespaces/RoutesNamespace/routesStore\";\nimport { getTransitionPath } from \"../transitionPath\";\n\nimport type { RoutesApi } from \"./types\";\nimport type { RouteDefinition, RouteTree } from \"../engine\";\nimport type { RouterInternals } from \"../internals\";\nimport type { RouteLifecycleNamespace, RouteConfig } from \"../namespaces\";\nimport type { RoutesStore } from \"../namespaces/RoutesNamespace\";\nimport type {\n  DefaultDependencies,\n  ForwardToCallback,\n  NavigationOptions,\n  Params,\n  Router,\n  RouterLogger,\n  State,\n  TreeChangedEvent,\n  TreeStructuralPatch,\n  GuardFnFactory,\n  Route,\n} from \"../types\";\n\n// ============================================================================\n// Helpers\n// ============================================================================\n\n/**\n * Opts attached to the `TRANSITION_SUCCESS` emitted by `replace()` when it\n * revalidates the active state (#950). `replace` does not push history, so it\n * is a replace-type success — matching `navigateToNotFound`'s opts for the\n * dropped-route branch.\n */\nconst REVALIDATE_OPTS: NavigationOptions = Object.freeze({\n  replace: true,\n  revalidate: true,\n});\n\n/**\n * Clears all config entries and lifecycle handlers for a removed route\n * (and all its descendants).\n */\nfunction clearRouteConfigurations<\n  Dependencies extends DefaultDependencies = DefaultDependencies,\n>(\n  routeName: string,\n  config: RouteConfig,\n  routeCustomFields: Record<string, Record<string, unknown>>,\n  lifecycleNamespace: RouteLifecycleNamespace<Dependencies>,\n): void {\n  const shouldClear = (name: string): boolean =>\n    name === routeName || name.startsWith(`${routeName}.`);\n\n  clearConfigEntries(config.decoders, shouldClear);\n  clearConfigEntries(config.encoders, shouldClear);\n  clearConfigEntries(config.defaultParams, shouldClear);\n  clearConfigEntries(config.forwardMap, shouldClear);\n  clearConfigEntries(config.forwardFnMap, shouldClear);\n  clearConfigEntries(routeCustomFields, shouldClear);\n\n  // Clear forwardMap entries pointing TO the deleted route (or its descendants)\n  clearConfigEntries(config.forwardMap, (key) =>\n    shouldClear(config.forwardMap[key]),\n  );\n\n  // Clear lifecycle handlers\n  const [canDeactivateFactories, canActivateFactories] =\n    lifecycleNamespace.getFactories();\n\n  for (const name of Object.keys(canActivateFactories)) {\n    if (shouldClear(name)) {\n      // Route removed from the tree — both origin slots go (route no longer exists).\n      lifecycleNamespace.clearCanActivate(name, \"both\");\n    }\n  }\n\n  for (const name of Object.keys(canDeactivateFactories)) {\n    if (shouldClear(name)) {\n      lifecycleNamespace.clearCanDeactivate(name, \"both\");\n    }\n  }\n}\n\n/**\n * Re-attaches the stored config (forwardTo / defaultParams / encode-decode) and\n * lifecycle guards for `lookupName` onto `route`, then returns it (mutates in\n * place). Shared by {@link enrichRoute} (nested, bare `name`) and\n * {@link buildFlatRoute} (flat, full dotted `name`) — one source of truth for\n * the route-config field set.\n */\nfunction assignRouteConfig<\n  Dependencies extends DefaultDependencies = DefaultDependencies,\n>(\n  route: Route<Dependencies>,\n  lookupName: string,\n  config: RouteConfig,\n  factories: [\n    Record<string, GuardFnFactory<Dependencies>>,\n    Record<string, GuardFnFactory<Dependencies>>,\n  ],\n): Route<Dependencies> {\n  const forwardToFn = config.forwardFnMap[lookupName];\n  const forwardToStr = config.forwardMap[lookupName];\n\n  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition\n  if (forwardToFn !== undefined) {\n    route.forwardTo = forwardToFn;\n    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition\n  } else if (forwardToStr !== undefined) {\n    route.forwardTo = forwardToStr;\n  }\n\n  if (lookupName in config.defaultParams) {\n    route.defaultParams = config.defaultParams[lookupName];\n  }\n\n  if (lookupName in config.decoders) {\n    route.decodeParams = config.decoders[lookupName];\n  }\n\n  if (lookupName in config.encoders) {\n    route.encodeParams = config.encoders[lookupName];\n  }\n\n  const [canDeactivateFactories, canActivateFactories] = factories;\n\n  if (lookupName in canActivateFactories) {\n    route.canActivate = canActivateFactories[lookupName];\n  }\n\n  if (lookupName in canDeactivateFactories) {\n    route.canDeactivate = canDeactivateFactories[lookupName];\n  }\n\n  return route;\n}\n\n/**\n * Builds a full Route object from a bare RouteDefinition by re-attaching\n * config entries and lifecycle factories.\n *\n * RECURSIVE — call with the factories tuple obtained ONCE from\n * `lifecycleNamespace.getFactories()` and pass it through to children.\n */\nfunction enrichRoute<\n  Dependencies extends DefaultDependencies = DefaultDependencies,\n>(\n  routeDef: RouteDefinition,\n  routeName: string,\n  config: RouteConfig,\n  factories: [\n    Record<string, GuardFnFactory<Dependencies>>,\n    Record<string, GuardFnFactory<Dependencies>>,\n  ],\n): Route<Dependencies> {\n  const route: Route<Dependencies> = {\n    name: routeDef.name,\n    path: routeDef.path,\n  };\n\n  assignRouteConfig(route, routeName, config, factories);\n\n  if (routeDef.children) {\n    route.children = routeDef.children.map((child) =>\n      enrichRoute(child, `${routeName}.${child.name}`, config, factories),\n    );\n  }\n\n  return route;\n}\n\n// ============================================================================\n// TREE_CHANGED payload helpers\n// ============================================================================\n\n/**\n * Builds a single FLAT `Route` for `fullName` from the store config + lifecycle\n * factories — `name` is the FULL dotted name and there is no `children` array\n * (consumers want a flat, by-name list). Frozen on construction.\n */\nfunction buildFlatRoute<\n  Dependencies extends DefaultDependencies = DefaultDependencies,\n>(\n  fullName: string,\n  path: string,\n  config: RouteConfig,\n  factories: [\n    Record<string, GuardFnFactory<Dependencies>>,\n    Record<string, GuardFnFactory<Dependencies>>,\n  ],\n): Route<Dependencies> {\n  const route: Route<Dependencies> = { name: fullName, path };\n\n  assignRouteConfig(route, fullName, config, factories);\n\n  return Object.freeze(route);\n}\n\n/**\n * Walks the store's definitions depth-first, building a FLAT\n * `Map<fullName, Route>` for every node whose full dotted name satisfies\n * `include`. Reads the live store, so call it at the right moment relative to\n * the mutation (before for removed, after for added).\n */\nfunction collectFlatRoutes<\n  Dependencies extends DefaultDependencies = DefaultDependencies,\n>(\n  store: RoutesStore<Dependencies>,\n  include: (fullName: string) => boolean,\n): Map<string, Route<Dependencies>> {\n  const result = new Map<string, Route<Dependencies>>();\n  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- guaranteed set after wiring\n  const factories = store.lifecycleNamespace!.getFactories();\n\n  const walk = (defs: readonly RouteDefinition[], parentName: string): void => {\n    for (const def of defs) {\n      const fullName = parentName ? `${parentName}.${def.name}` : def.name;\n\n      if (include(fullName)) {\n        result.set(\n          fullName,\n          buildFlatRoute(fullName, def.path, store.config, factories),\n        );\n      }\n\n      if (def.children) {\n        walk(def.children, fullName);\n      }\n    }\n  };\n\n  walk(store.definitions, \"\");\n\n  return result;\n}\n\n/**\n * Collects the route `name` and all of its descendants as a FLAT, frozen array.\n * MUST be called BEFORE the removal mutation — the nodes are gone afterwards.\n */\nfunction collectSubtree<\n  Dependencies extends DefaultDependencies = DefaultDependencies,\n>(\n  store: RoutesStore<Dependencies>,\n  name: string,\n): readonly Route<Dependencies>[] {\n  const prefix = `${name}.`;\n  const subtree = collectFlatRoutes(\n    store,\n    (fullName) => fullName === name || fullName.startsWith(prefix),\n  );\n\n  return Object.freeze([...subtree.values()]);\n}\n\n/**\n * Builds the FLAT, frozen payload array for an `add`, walking only the input\n * routes — O(added), not O(tree). `path` is taken from the input verbatim\n * (`sanitizeRoute` never rewrites it); config fields are read from the\n * post-commit store by full name. `add` never removes, so the input subtree is\n * exactly what changed.\n */\nfunction collectAddedRoutes<\n  Dependencies extends DefaultDependencies = DefaultDependencies,\n>(\n  routes: readonly Route<Dependencies>[],\n  parentName: string | undefined,\n  store: RoutesStore<Dependencies>,\n): readonly Route<Dependencies>[] {\n  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- guaranteed set after wiring\n  const factories = store.lifecycleNamespace!.getFactories();\n  const result: Route<Dependencies>[] = [];\n\n  const walk = (\n    input: readonly Route<Dependencies>[],\n    parent: string,\n  ): void => {\n    for (const route of input) {\n      const fullName = parent ? `${parent}.${route.name}` : route.name;\n\n      result.push(\n        buildFlatRoute(fullName, route.path, store.config, factories),\n      );\n\n      if (route.children) {\n        walk(route.children, fullName);\n      }\n    }\n  };\n\n  walk(routes, parentName ?? \"\");\n\n  return Object.freeze(result);\n}\n\n/** Diffs two flat route maps by full name into frozen removed/added arrays. */\nfunction diffFlatRoutes<\n  Dependencies extends DefaultDependencies = DefaultDependencies,\n>(\n  before: ReadonlyMap<string, Route<Dependencies>>,\n  after: ReadonlyMap<string, Route<Dependencies>>,\n): {\n  removed: readonly Route<Dependencies>[];\n  added: readonly Route<Dependencies>[];\n} {\n  const removed: Route<Dependencies>[] = [];\n  const added: Route<Dependencies>[] = [];\n\n  for (const [fullName, route] of before) {\n    if (!after.has(fullName)) {\n      removed.push(route);\n    }\n  }\n\n  for (const [fullName, route] of after) {\n    if (!before.has(fullName)) {\n      added.push(route);\n    }\n  }\n\n  return { removed: Object.freeze(removed), added: Object.freeze(added) };\n}\n\n/**\n * Builds the structural subset of an `update()` patch (forwardTo /\n * defaultParams / encodeParams / decodeParams) from the already-destructured\n * update fields — so user getters are not re-invoked. A guard-only patch yields\n * an empty object → the caller emits no TREE_CHANGED (О-7: guards are\n * invoked-on-demand, not cached, so they need no observation channel).\n *\n * The returned envelope is a fresh object (caller's patch untouched) and is\n * frozen on construction. Nested values (e.g. `defaultParams`) are kept by\n * reference — the same objects the router stored — so exotic inputs (circular\n * refs, class instances) are tolerated, matching `update()`'s existing contract.\n */\nfunction buildStructuralPatch<\n  Dependencies extends DefaultDependencies = DefaultDependencies,\n>(fields: {\n  forwardTo?: string | ForwardToCallback<Dependencies> | null | undefined;\n  defaultParams?: Params | null | undefined;\n  decodeParams?: ((params: Params) => Params) | null | undefined;\n  encodeParams?: ((params: Params) => Params) | null | undefined;\n}): Readonly<TreeStructuralPatch<Dependencies>> {\n  const patch: TreeStructuralPatch<Dependencies> = {};\n\n  if (fields.forwardTo !== undefined) {\n    patch.forwardTo = fields.forwardTo;\n  }\n\n  if (fields.defaultParams !== undefined) {\n    patch.defaultParams = fields.defaultParams;\n  }\n\n  if (fields.encodeParams !== undefined) {\n    patch.encodeParams = fields.encodeParams;\n  }\n\n  if (fields.decodeParams !== undefined) {\n    patch.decodeParams = fields.decodeParams;\n  }\n\n  return Object.freeze(patch);\n}\n\n// ============================================================================\n// CRUD operations\n// ============================================================================\n\n/**\n * Adds one or more routes to the router.\n * Input already validated by facade.\n */\nfunction addRoutes<\n  Dependencies extends DefaultDependencies = DefaultDependencies,\n>(\n  store: RoutesStore<Dependencies>,\n  routes: Route<Dependencies>[],\n  parentName: string | undefined,\n  logger: RouterLogger,\n): void {\n  // Prepare-then-commit (issue #698): reject the silent-corruption cases\n  // up front (dup name vs existing, missing parent), build the merged tree /\n  // config into locals (async/circular forwardTo + invalid constraint throw\n  // here), then swap atomically. A rejected add leaves the store untouched.\n  assertAddable(store, routes, parentName);\n\n  const artifacts = buildAddArtifacts(store, routes, parentName, logger);\n\n  // Pre-flight the #961 handler-limit into PREPARE so a limit-exceeding batch\n  // aborts before the swap (#1046). `add` does not clear guards, so the\n  // projection runs against the live union count (clearsDefinition = false).\n  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- guaranteed set after wiring\n  store.lifecycleNamespace!.preflightHandlerLimit(\n    artifacts.pendingCanActivate.keys(),\n    artifacts.pendingCanDeactivate.keys(),\n    false,\n  );\n\n  adoptRouteArtifacts(store, artifacts);\n}\n\n/**\n * Commits a revalidated state after `replace()` and emits `TRANSITION_SUCCESS`\n * so `router.subscribe` / adapters re-render (#950). The emit carries\n * `REVALIDATE_OPTS` — the single distinguishable marker (`revalidate: true`) a\n * plugin's `onTransitionSuccess` can read to special-case a revalidation vs a\n * real navigation (#1201).\n */\nfunction commitRevalidated<\n  Dependencies extends DefaultDependencies = DefaultDependencies,\n>(\n  ctx: RouterInternals<Dependencies>,\n  nextState: State,\n  fromState: State,\n): void {\n  ctx.setState(nextState);\n  ctx.emitTransitionSuccess(nextState, fromState, REVALIDATE_OPTS);\n}\n\n/**\n * Atomically replaces all routes with a new set (HMR / code-splitting).\n * Prepare-then-commit (issue #698): the new set is fully built into locals\n * first — a circular/async forwardTo or invalid path throws here, leaving the\n * existing tree intact — then committed.\n */\nfunction replaceRoutes<\n  Dependencies extends DefaultDependencies = DefaultDependencies,\n>(\n  store: RoutesStore<Dependencies>,\n  routes: Route<Dependencies>[],\n  ctx: RouterInternals<Dependencies>,\n  currentState: State | undefined,\n  onCommitted?: () => void,\n): void {\n  // Reject the silent-corruption cases `assertAddable` catches for `add`, BEFORE\n  // building/swapping, so bare-core parity is symmetric (#1047): within-batch\n  // duplicate names (#968), reserved \"@@\" names (#954), and within-batch\n  // duplicate paths (#955). methodName is \"addRoute\" to match validation-plugin\n  // (which reports \"addRoute\" for replace batches too), so the no-plugin error\n  // is identical to the with-plugin one.\n  assertNoInternalNamesInBatch(routes, \"addRoute\");\n  assertNoDuplicateNamesInBatch(routes, \"\", \"addRoute\");\n  assertNoDuplicatePathsInBatch(routes, \"\", \"addRoute\");\n\n  // Build the whole new set BEFORE touching the store.\n  const artifacts = buildReplaceArtifacts(\n    routes,\n    store.rootPath,\n    store.matcherOptions,\n    ctx.logger,\n  );\n\n  // Pre-flight the #961 handler-limit BEFORE clearDefinitionGuards mutates, so a\n  // limit-exceeding batch aborts with BOTH the tree and the definition guards\n  // intact (#1046). replace clears definition guards first, so the projection\n  // runs against the surviving external guards (clearsDefinition = true).\n  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- guaranteed set after wiring\n  store.lifecycleNamespace!.preflightHandlerLimit(\n    artifacts.pendingCanActivate.keys(),\n    artifacts.pendingCanDeactivate.keys(),\n    true,\n  );\n\n  // Pre-compile the new batch's guard factories in the PREPARE phase — BEFORE\n  // clearDefinitionGuards — so a compile-throwing factory (or a non-function)\n  // aborts here with BOTH the tree AND the old definition guards intact (#1193,\n  // mirror of the #1046 handler-limit hoist). adoptRouteArtifacts then installs\n  // these pre-compiled functions without re-running the factories.\n  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- guaranteed set after wiring\n  const compiledGuards = compileArtifactGuards(artifacts, store.depsStore!);\n\n  // Clear definition lifecycle handlers (preserve external guards), then swap.\n  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- guaranteed set after wiring\n  store.lifecycleNamespace!.clearDefinitionGuards();\n  adoptRouteArtifacts(store, artifacts, compiledGuards);\n\n  // TREE_CHANGED fires here (О-5): the new tree is committed but state is not\n  // yet revalidated, so the handler sees the new tree and the still-old state.\n  onCommitted?.();\n\n  // Revalidate the active state against the new tree AND notify subscribers\n  // (#950). A structural replace can change or drop the currently-active state;\n  // emitting TRANSITION_SUCCESS makes router.subscribe / useSyncExternalStore\n  // adapters re-render instead of rendering the pre-replace state. (This is the\n  // one structural mutation that emits a transition event — clear() stays a\n  // silent reset; the asymmetry is deliberate, see #950.)\n  if (currentState !== undefined) {\n    const revalidated = ctx.matchPath(currentState.path, ctx.getOptions());\n\n    if (revalidated) {\n      if (revalidated.name === currentState.name) {\n        // Survivor — the URL still maps to the route the user was already on.\n        // Keep it WITHOUT re-running guards: the user legitimately reached this\n        // route via a real navigation, and `replace()` is not a navigation they\n        // performed, so re-checking guards here would evict them on a stateful\n        // or async guard (parity with `update()`, which never revalidates the\n        // active state). Preserve the prior transition meta and emit so\n        // subscribers see the revalidated state (#1201). Carry the prior\n        // `context` (#1236): the route name and path are unchanged, so the\n        // plugin data written into `state.context.<namespace>` (SSR data, rsc,\n        // navigation, …) is still valid — the matchPath-rebuilt state would\n        // otherwise wipe it, and revalidation re-runs neither the loader nor the\n        // start interceptor to bring it back.\n        const nextState: State = {\n          ...revalidated,\n          context: currentState.context,\n          transition: currentState.transition,\n        };\n\n        commitRevalidated(ctx, nextState, currentState);\n      } else {\n        // Route-identity change — the URL is now owned by a DIFFERENT route (an\n        // ownership reshuffle, or a newly-added `forwardTo` that teleports the\n        // state). That is effectively a navigation the user never performed, so\n        // consult the new route's guards exactly as `navigate` would (#1201).\n        // Commit on pass; on a block — or an async guard that cannot be\n        // evaluated synchronously (mirrors `canNavigateTo`) — route to\n        // not-found rather than silently activating a guarded route.\n        const { toDeactivate, toActivate } = getTransitionPath(\n          revalidated,\n          currentState,\n        );\n\n        const allowed =\n          // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- guaranteed set after wiring\n          store.lifecycleNamespace!.canNavigateTo(\n            toDeactivate,\n            toActivate,\n            revalidated,\n            currentState,\n          );\n\n        if (allowed) {\n          const nextState: State = {\n            ...revalidated,\n            transition: currentState.transition,\n          };\n\n          commitRevalidated(ctx, nextState, currentState);\n        } else {\n          ctx.navigateToNotFound(currentState.path);\n        }\n      }\n    } else {\n      // The active route no longer exists in the new tree — surface it as\n      // not-found (commits UNKNOWN_ROUTE + emits TRANSITION_SUCCESS) so the\n      // change is observable, rather than silently clearing the state.\n      ctx.navigateToNotFound(currentState.path);\n    }\n  }\n}\n\n/**\n * Removes a route and all its children.\n *\n * @returns true if removed, false if not found\n */\nfunction removeRoute<\n  Dependencies extends DefaultDependencies = DefaultDependencies,\n>(store: RoutesStore<Dependencies>, name: string): boolean {\n  // `store.definitions` is a fresh tree-derived snapshot — mutate it locally,\n  // then commit the mutated table as the new tree.\n  const definitions = store.definitions;\n  const wasRemoved = removeFromDefinitions(definitions, name);\n\n  if (!wasRemoved) {\n    return false;\n  }\n\n  clearRouteConfigurations(\n    name,\n    store.config,\n    store.routeCustomFields,\n    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n    store.lifecycleNamespace!,\n  );\n\n  commitTreeChanges(store, definitions);\n\n  return true;\n}\n\n/**\n * Gets a route by name with all its configuration.\n */\nfunction getRoute<\n  Dependencies extends DefaultDependencies = DefaultDependencies,\n>(\n  store: RoutesStore<Dependencies>,\n  name: string,\n): Route<Dependencies> | undefined {\n  const segments = store.matcher.getSegmentsByName(name);\n\n  if (!segments) {\n    return undefined;\n  }\n\n  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- segments is non-empty (checked above)\n  const targetNode = segments.at(-1)! as RouteTree;\n  const definition = nodeToDefinition(targetNode);\n  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n  const factories = store.lifecycleNamespace!.getFactories();\n\n  return enrichRoute(definition, name, store.config, factories);\n}\n\n// ============================================================================\n// API factory\n// ============================================================================\n\n// Cache the assembled RoutesApi per router — mirrors getPluginApi()/getNavigator():\n// avoids re-allocating the 9-closure bag on each call (adapters/plugins poll it\n// from constructors) and gives spy/stub helpers a stable object identity. Closures\n// capture `ctx`/`store`, both stable for the router's lifetime, so caching is safe.\n// Single cast site: the value is stored as `unknown` (RoutesApi is invariant in\n// Dependencies, so one typed map can't hold every instantiation) and cast on read.\nconst cache = new WeakMap<object, unknown>();\n\nexport function getRoutesApi<\n  Dependencies extends DefaultDependencies = DefaultDependencies,\n>(router: Router<Dependencies>): RoutesApi<Dependencies> {\n  const cached = cache.get(router);\n\n  if (cached) {\n    return cached as RoutesApi<Dependencies>;\n  }\n\n  const ctx = getInternals(router);\n\n  const store = ctx.routeGetStore();\n\n  // Single cast site: the channel is typed with default Dependencies on\n  // RouterInternals (RouterEventMap is non-generic), but payloads are built\n  // with this api's Dependencies. The runtime shape is identical.\n  const emitChange = (event: TreeChangedEvent<Dependencies>): void => {\n    ctx.treeChanged.emit(event as TreeChangedEvent);\n  };\n\n  const api: RoutesApi<Dependencies> = {\n    add: (routes, options) => {\n      throwIfDisposed(ctx.isDisposed);\n      throwIfReentrantTreeMutation(ctx.treeChanged.isEmitting);\n\n      const routeArray = Array.isArray(routes) ? routes : [routes];\n      const parentName = options?.parent;\n\n      guardRouteStructure(routeArray, ctx.validator);\n\n      if (parentName !== undefined) {\n        ctx.validator?.routes.validateParentOption(parentName, store.tree);\n      }\n\n      ctx.validator?.routes.throwIfInternalRouteInArray(routeArray, \"addRoute\");\n      ctx.validator?.routes.validateAddRouteArgs(routeArray);\n      ctx.validator?.routes.validateRoutes(routeArray, store, parentName);\n\n      addRoutes(store, routeArray, parentName, ctx.logger);\n\n      // Built from the post-commit store (О-1), only when someone is listening.\n      if (ctx.treeChanged.listenerCount() > 0) {\n        const added = collectAddedRoutes(routeArray, parentName, store);\n\n        emitChange(\n          parentName === undefined\n            ? { op: \"add\", added }\n            : { op: \"add\", added, parent: parentName },\n        );\n      }\n    },\n\n    remove: (name) => {\n      throwIfDisposed(ctx.isDisposed);\n      throwIfReentrantTreeMutation(ctx.treeChanged.isEmitting);\n\n      ctx.validator?.routes.validateRemoveRouteArgs(name);\n      ctx.validator?.routes.throwIfInternalRoute(name, \"removeRoute\");\n      // Always-on parity backstop (#1047 / #238): a reserved \"@@\" name is\n      // internal and cannot be removed, with or without the validation-plugin.\n      assertNoInternalRouteName(name, \"removeRoute\");\n\n      const canRemove = validateRemoveRoute(\n        name,\n        ctx.getStateName(),\n        ctx.isTransitioning(),\n        ctx.logger,\n      );\n\n      if (!canRemove) {\n        return;\n      }\n\n      // Snapshot the subtree BEFORE the mutation — the nodes are gone after.\n      const removedSubtree =\n        ctx.treeChanged.listenerCount() > 0\n          ? collectSubtree(store, name)\n          : undefined;\n      const wasRemoved = removeRoute(store, name);\n\n      if (!wasRemoved) {\n        ctx.logger.warn(\n          \"router.removeRoute\",\n          `Route \"${name}\" not found. No changes made.`,\n        );\n\n        return;\n      }\n\n      if (removedSubtree !== undefined) {\n        emitChange({ op: \"remove\", name, removedSubtree });\n      }\n    },\n\n    update: (name, updates) => {\n      throwIfDisposed(ctx.isDisposed);\n      throwIfReentrantTreeMutation(ctx.treeChanged.isEmitting);\n\n      ctx.validator?.routes.validateUpdateRouteBasicArgs(name, updates);\n      ctx.validator?.routes.throwIfInternalRoute(name, \"updateRoute\");\n      // Always-on parity backstop (#1047 / #238): a reserved \"@@\" name is\n      // internal and cannot be updated, with or without the validation-plugin.\n      assertNoInternalRouteName(name, \"updateRoute\");\n\n      ctx.validator?.routes.validateUpdateRoutePropertyTypes(name, updates);\n\n      /* v8 ignore next 6 -- @preserve: race condition guard, mirrors Router.updateRoute() same-path guard tested via Router.ts unit tests */\n      if (ctx.isTransitioning()) {\n        ctx.logger.error(\n          \"router.updateRoute\",\n          `Updating route \"${name}\" while navigation is in progress. This may cause unexpected behavior.`,\n        );\n      }\n\n      ctx.validator?.routes.validateUpdateRoute(name, updates, store);\n\n      // #1205: bare-core existence backstop as a TRUE no-op — NOT a throw\n      // (validation is opt-in). update() of a route that does not exist used to\n      // seed config.defaultParams + compile/register the guard (commitRouteUpdate\n      // below) and emit a lying TREE_CHANGED \"update\" event for a route get()/\n      // has() cannot see; a future add() of that name then inherited the phantom\n      // config + a blocking guard. Skip the commit and the emit entirely when the\n      // route is absent. (With the validation-plugin, validateUpdateRoute above\n      // already threw a ReferenceError, so this is only reached in bare core.)\n      if (!store.matcher.hasRoute(name)) {\n        return;\n      }\n\n      // Field-patch commit core (NO_TREE_REBUILD) — co-located in routesStore.ts\n      // beside the add/replace (adoptRouteArtifacts) / remove (commitTreeChanges)\n      // / clear (resetStore) cores. Returns the structural fields for the\n      // conditional emit below (each user getter read once inside).\n      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- guaranteed set after wiring\n      const lifecycle = store.lifecycleNamespace!;\n      const structural = commitRouteUpdate(store, lifecycle, name, updates);\n\n      // Conditional emit: structural fields only. A guard-only or empty patch\n      // produces no event (О-7 + empty-patch rule).\n      if (ctx.treeChanged.listenerCount() > 0) {\n        const patch = buildStructuralPatch<Dependencies>(structural);\n\n        if (Object.keys(patch).length > 0) {\n          emitChange({ op: \"update\", name, patch });\n        }\n      }\n    },\n\n    clear: () => {\n      throwIfDisposed(ctx.isDisposed);\n      throwIfReentrantTreeMutation(ctx.treeChanged.isEmitting);\n\n      const canClear = validateClearRoutes(ctx.isTransitioning(), ctx.logger);\n\n      /* v8 ignore next 3 -- @preserve: race condition guard, mirrors Router.clearRoutes() same-path guard tested via validateClearRoutes unit tests */\n      if (!canClear) {\n        return;\n      }\n\n      // Snapshot the routes BEFORE the reset empties them. Emitted whenever\n      // there is a listener — even for an empty clear (О-4).\n      const removed =\n        ctx.treeChanged.listenerCount() > 0\n          ? Object.freeze([...collectFlatRoutes(store, () => true).values()])\n          : undefined;\n\n      resetStore(store);\n      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- guaranteed set after wiring\n      store.lifecycleNamespace!.clearAll();\n      ctx.clearState();\n\n      if (removed !== undefined) {\n        emitChange({ op: \"clear\", removed });\n      }\n    },\n\n    has: (name) => {\n      ctx.validator?.routes.validateRouteName(name, \"hasRoute\");\n\n      return store.matcher.hasRoute(name);\n    },\n\n    get: (name) => {\n      ctx.validator?.routes.validateRouteName(name, \"getRoute\");\n\n      return getRoute(store, name);\n    },\n\n    replace: (routes) => {\n      throwIfDisposed(ctx.isDisposed);\n      throwIfReentrantTreeMutation(ctx.treeChanged.isEmitting);\n\n      const routeArray = Array.isArray(routes) ? routes : [routes];\n\n      const canReplace = validateClearRoutes(ctx.isTransitioning(), ctx.logger);\n\n      if (!canReplace) {\n        return;\n      }\n\n      guardRouteStructure(routeArray, ctx.validator);\n\n      ctx.validator?.routes.throwIfInternalRouteInArray(\n        routeArray,\n        \"replaceRoutes\",\n      );\n      ctx.validator?.routes.validateAddRouteArgs(routeArray);\n      ctx.validator?.routes.validateRoutes(routeArray, store);\n\n      const currentState = router.getState();\n\n      // The flat removed/added diff is O(N) — compute it only when someone is\n      // listening (Решение 3.B). Snapshot the old tree BEFORE the swap.\n      const before =\n        ctx.treeChanged.listenerCount() > 0\n          ? collectFlatRoutes(store, () => true)\n          : undefined;\n\n      replaceRoutes(\n        store,\n        routeArray,\n        ctx,\n        currentState,\n        before === undefined\n          ? undefined\n          : () => {\n              const after = collectFlatRoutes(store, () => true);\n              const { removed, added } = diffFlatRoutes(before, after);\n\n              emitChange({ op: \"replace\", removed, added });\n            },\n      );\n    },\n\n    subscribeChanges: (handler) => ctx.treeChanged.subscribe(handler),\n  };\n\n  cache.set(router, api);\n\n  return api;\n}\n","import { throwIfDisposed } from \"./helpers\";\nimport { getInternals } from \"../internals\";\n\nimport type { DependenciesApi } from \"./types\";\nimport type { DependenciesStore } from \"../namespaces\";\nimport type { DefaultDependencies, Router } from \"../types\";\nimport type { RouterValidator } from \"../types/RouterValidator\";\n\n// =============================================================================\n// Module-private CRUD functions\n// =============================================================================\n\nfunction setDependency(\n  store: DependenciesStore,\n  dependencyName: string,\n  dependencyValue: unknown,\n  validator?: RouterValidator | null,\n): void {\n  // undefined = \"don't set\" (feature for conditional setting)\n  if (dependencyValue === undefined) {\n    return;\n  }\n\n  const isNewKey = !Object.hasOwn(store.dependencies, dependencyName);\n\n  if (isNewKey) {\n    // Only check limit when adding new keys (overwrites don't increase count)\n    validator?.dependencies.validateDependencyCount(store, \"setDependency\");\n  } else {\n    const oldValue = (store.dependencies as Record<string, unknown>)[\n      dependencyName\n    ];\n    const isChanging = oldValue !== dependencyValue;\n    // Special case for NaN idempotency (NaN !== NaN is always true)\n    const bothAreNaN = Number.isNaN(oldValue) && Number.isNaN(dependencyValue);\n\n    if (isChanging && !bothAreNaN) {\n      validator?.dependencies.warnOverwrite(dependencyName, \"setDependency\");\n    }\n  }\n\n  (store.dependencies as Record<string, unknown>)[dependencyName] =\n    dependencyValue;\n}\n\nfunction setMultipleDependencies(\n  store: DependenciesStore,\n  deps: Record<string, unknown>,\n  validator?: RouterValidator | null,\n): void {\n  const overwrittenKeys: string[] = [];\n\n  for (const key in deps) {\n    if (deps[key] === undefined) {\n      continue;\n    }\n\n    if (Object.hasOwn(store.dependencies, key)) {\n      overwrittenKeys.push(key);\n    } else {\n      validator?.dependencies.validateDependencyCount(store, \"setDependencies\");\n    }\n\n    (store.dependencies as Record<string, unknown>)[key] = deps[key];\n  }\n\n  if (overwrittenKeys.length > 0) {\n    validator?.dependencies.warnBatchOverwrite(\n      overwrittenKeys,\n      \"setDependencies\",\n    );\n  }\n}\n\n// =============================================================================\n// Public API factory\n// =============================================================================\n\nexport function getDependenciesApi<\n  Dependencies extends DefaultDependencies = DefaultDependencies,\n>(router: Router<Dependencies>): DependenciesApi<Dependencies> {\n  const ctx = getInternals(router);\n\n  return {\n    get: (name) => {\n      ctx.validator?.dependencies.validateDependencyName(name, \"getDependency\");\n\n      const store = ctx.dependenciesGetStore();\n      const value = (store.dependencies as Record<string, unknown>)[\n        name as string\n      ];\n\n      ctx.validator?.dependencies.validateDependencyExists(\n        name as string,\n        store,\n      );\n\n      return value as Dependencies[typeof name];\n    },\n    getAll: () => ({ ...ctx.dependenciesGetStore().dependencies }),\n    set: (name, value) => {\n      throwIfDisposed(ctx.isDisposed);\n\n      ctx.validator?.dependencies.validateSetDependencyArgs(\n        name,\n        value,\n        \"setDependency\",\n      );\n\n      setDependency(ctx.dependenciesGetStore(), name, value, ctx.validator);\n    },\n    setAll: (deps) => {\n      throwIfDisposed(ctx.isDisposed);\n\n      const store = ctx.dependenciesGetStore();\n\n      ctx.validator?.dependencies.validateDependenciesObject(\n        deps,\n        \"setDependencies\",\n      );\n\n      setMultipleDependencies(\n        store,\n        deps as Record<string, unknown>,\n        ctx.validator,\n      );\n    },\n    remove: (name) => {\n      throwIfDisposed(ctx.isDisposed);\n\n      ctx.validator?.dependencies.validateDependencyName(\n        name,\n        \"removeDependency\",\n      );\n\n      const store = ctx.dependenciesGetStore();\n\n      if (!Object.hasOwn(store.dependencies, name)) {\n        ctx.validator?.dependencies.warnRemoveNonExistent(name);\n      }\n\n      delete (store.dependencies as Record<string, unknown>)[name as string];\n    },\n    reset: () => {\n      throwIfDisposed(ctx.isDisposed);\n      const store = ctx.dependenciesGetStore();\n\n      store.dependencies = Object.create(null) as Partial<Dependencies>;\n    },\n    has: (name) => {\n      ctx.validator?.dependencies.validateDependencyName(name, \"hasDependency\");\n\n      return Object.hasOwn(ctx.dependenciesGetStore().dependencies, name);\n    },\n  };\n}\n","import { throwIfDisposed } from \"./helpers\";\nimport { getInternals } from \"../internals\";\n\nimport type { LifecycleApi } from \"./types\";\nimport type { DefaultDependencies, Router } from \"../types\";\n\nexport function getLifecycleApi<\n  Dependencies extends DefaultDependencies = DefaultDependencies,\n>(router: Router<Dependencies>): LifecycleApi<Dependencies> {\n  const ctx = getInternals(router);\n  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- guaranteed set after wiring\n  const lifecycleNamespace = ctx.routeGetStore().lifecycleNamespace!;\n\n  return {\n    addActivateGuard(name, handler) {\n      throwIfDisposed(ctx.isDisposed);\n\n      ctx.validator?.routes.validateRouteName(name, \"addActivateGuard\");\n      ctx.validator?.lifecycle.validateHandler(handler, \"addActivateGuard\");\n\n      // Handler-limit enforcement lives at the namespace registration choke point\n      // (RouteLifecycleNamespace.#registerHandler) so all paths are bounded\n      // uniformly — see #961.\n      lifecycleNamespace.addCanActivate(name, handler);\n    },\n\n    addDeactivateGuard(name, handler) {\n      throwIfDisposed(ctx.isDisposed);\n\n      ctx.validator?.routes.validateRouteName(name, \"addDeactivateGuard\");\n      ctx.validator?.lifecycle.validateHandler(handler, \"addDeactivateGuard\");\n\n      lifecycleNamespace.addCanDeactivate(name, handler);\n    },\n\n    removeActivateGuard(name) {\n      throwIfDisposed(ctx.isDisposed);\n\n      ctx.validator?.routes.validateRouteName(name, \"removeActivateGuard\");\n\n      // Inverse of addActivateGuard (external): clears only the external guard;\n      // a route-config (definition) canActivate survives (#1171).\n      lifecycleNamespace.clearCanActivate(name, \"external\");\n    },\n\n    removeDeactivateGuard(name) {\n      throwIfDisposed(ctx.isDisposed);\n\n      ctx.validator?.routes.validateRouteName(name, \"removeDeactivateGuard\");\n\n      // Inverse of addDeactivateGuard (external): clears only the external guard;\n      // a route-config (definition) canDeactivate survives (#1171).\n      lifecycleNamespace.clearCanDeactivate(name, \"external\");\n    },\n  };\n}\n","import { errorCodes } from \"../constants\";\nimport { routeTreeToDefinitions } from \"../engine\";\nimport { getInternals } from \"../internals\";\nimport { getLifecycleApi } from \"./getLifecycleApi\";\nimport { assignConfigEntries } from \"../namespaces/RoutesNamespace/helpers\";\nimport { Router as RouterClass } from \"../Router\";\nimport { RouterError } from \"../RouterError\";\n\nimport type {\n  DefaultDependencies,\n  LoggerConfig,\n  Router,\n  Route,\n} from \"../types\";\n\n/**\n * Per-clone overrides beyond dependencies.\n */\nexport interface CloneOptions {\n  /**\n   * Per-clone logger config override, merged **over** the base router's resolved\n   * logger config. Primary use: per-request `traceId` in SSR — a fresh\n   * `callback` closed over the request id, while `level` inherits the base.\n   * Omitted keys inherit the base (level / callback / callbackIgnoresLevel).\n   *\n   * Override is by **config**, not a logger instance: `RouterLogger` is\n   * core-internal (only its `{ log, warn, error }` interface is public), so\n   * nothing outside core constructs one — configuration is the whole surface.\n   */\n  logger?: Partial<LoggerConfig>;\n}\n\n/**\n * Build an independent router instance that shares the route tree, options,\n * lifecycle guards, and plugin factories of `router`. The primary use case\n * is **SSR multi-tenancy** — one base router per process, one clone per\n * request.\n *\n * @param router - Source router (must not be disposed).\n * @param dependencies - Optional per-clone overrides merged on top of the\n *   base router's dependencies. Always **fresh per call** in the documented\n *   SSR pattern: pass per-request state here, never store it in the base.\n *\n * @remarks\n *\n * **Dependency merge — shallow by design.** `base.dependencies` are spread\n * into the clone via `{ ...sourceDeps, ...dependencies }`. Top-level keys\n * are new objects, but **values are shared by reference**: a `Map`, `Set`,\n * class instance, function, or nested plain object stored in\n * `base.dependencies` is the **same instance** in every clone. Mutations\n * in one clone are visible in the base and in every sibling clone.\n *\n * This is intentional. `structuredClone` of dep values is **not** applied\n * because it would:\n * - strip class prototypes (`new DbClient()` → plain object, methods lost)\n * - reject functions and symbols (`DataCloneError`)\n * - fragment singleton pools (one connection pool per request — pool\n *   semantics destroyed)\n * - reject circular references\n *\n * **SSR rule of thumb.** Place values in `base.dependencies` according to\n * their lifecycle:\n *\n * - **Singletons / shared services** → `base.dependencies`. Examples: DB\n *   client, connection pool, logger, config, feature-flag client. Process-\n *   wide pooling depends on sharing these by reference.\n * - **Per-request state** → the `dependencies` override parameter (or\n *   `createRequestScope`'s `deps` argument). Examples: `currentUser`,\n *   `traceId`, `sessionId`, `abortSignal`. The override is applied last,\n *   so it wins over base keys; pass a fresh object per call.\n *\n * Cross-request data leaks are **only possible** when per-request mutable\n * state is incorrectly placed in `base.dependencies`. The override slot is\n * the safe channel.\n *\n * @example\n * ```typescript\n * // Server boot — singletons only\n * const base = createRouter(routes, options, {\n *   db: new DbClient(dbUrl),\n *   logger,\n * });\n *\n * // Per request — fresh override per call\n * const clone = cloneRouter(base, {\n *   currentUser,\n *   traceId,\n * });\n * // clone.deps.db === base.deps.db  ✓ shared pool (intentional)\n * // clone.deps.currentUser          ✓ unique per request\n * ```\n *\n * @see createRequestScope — `@real-router/ssr-utils` SSR helper that\n *   wraps this function and injects `abortSignal` automatically.\n */\nexport function cloneRouter<\n  Dependencies extends DefaultDependencies = DefaultDependencies,\n>(\n  router: Router<Dependencies>,\n  dependencies?: Dependencies,\n  opts?: CloneOptions,\n): RouterClass<Dependencies> {\n  const ctx = getInternals(router);\n\n  if (ctx.isDisposed()) {\n    throw new RouterError(errorCodes.ROUTER_DISPOSED);\n  }\n\n  ctx.validator?.dependencies.validateCloneArgs(dependencies);\n\n  // Get source store directly\n  const sourceStore = ctx.routeGetStore();\n  const routes = routeTreeToDefinitions(sourceStore.tree);\n  const routeConfig = sourceStore.config;\n  const resolvedForwardMap = sourceStore.resolvedForwardMap;\n  const routeCustomFields = sourceStore.routeCustomFields;\n\n  const {\n    options,\n    dependencies: sourceDeps,\n    pluginFactories,\n    loggerConfig,\n  } = ctx.getCloneState();\n  // Origin-aware factory snapshot — definition guards are re-registered with\n  // `isFromDefinition=true` on the clone so `replace()` can still strip them\n  // via `clearDefinitionGuards()`. External guards take the public lifecycle\n  // API path so they survive `replace()` symmetric with the base.\n  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- guaranteed set after wiring\n  const sourceLifecycleNamespace = sourceStore.lifecycleNamespace!;\n  const { definition: definitionFactories, external: externalFactories } =\n    sourceLifecycleNamespace.getFactoriesByOrigin();\n\n  const mergedDeps = {\n    ...sourceDeps,\n    ...dependencies,\n  } as Dependencies;\n\n  // The clone builds its OWN logger (isolation, #724) but INHERITS the base's\n  // resolved config — frozen options don't carry `logger`, so without this the\n  // clone would fall back to the default logger and lose the base's\n  // callback/level (an M1 regression the singleton used to mask). A per-request\n  // `opts.logger` override (e.g. a traceId-bound callback) merges on top.\n  const clonedLoggerConfig: Partial<LoggerConfig> = opts?.logger\n    ? { ...loggerConfig, ...opts.logger }\n    : loggerConfig;\n\n  const newRouter = new RouterClass<Dependencies>(\n    routes as Route<Dependencies>[],\n    { ...options, logger: clonedLoggerConfig },\n    mergedDeps,\n  );\n\n  const newCtx = getInternals(newRouter);\n  const newStore = newCtx.routeGetStore();\n  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- guaranteed set after wiring\n  const newLifecycleNamespace = newStore.lifecycleNamespace!;\n\n  // Copy the source config + store-level maps BEFORE re-registering guards\n  // (#1331 review): the definition-guard factories re-executed below must\n  // observe the fully-built clone (encoders/decoders/defaultParams/custom\n  // fields), mirroring the constructor where flushPendingGuards runs after the\n  // store is complete. The five RouteConfig sub-maps go through a single\n  // enumeration so a newly added config field is carried over automatically\n  // (#965); resolvedForwardMap and routeCustomFields are store-level (not part\n  // of RouteConfig) and stay explicit.\n  assignConfigEntries(newStore.config, routeConfig);\n  Object.assign(newStore.resolvedForwardMap, resolvedForwardMap);\n  Object.assign(newStore.routeCustomFields, routeCustomFields);\n\n  // #1175: carry the source rootPath. It lives in the store (not options/config),\n  // and neither routeTreeToDefinitions nor getCloneState include it — so a clone\n  // of a base configured with `setRootPath(\"/app\")` would otherwise build/match\n  // under \"\" and 404 every request of a sub-path SSR deployment. setRootPath\n  // rebuilds the tree in place with the just-copied config; the rebuild is only\n  // paid when a rootPath is actually set, and it runs before the definition-guard\n  // factories below so they observe the fully-built clone (rootPath included).\n  if (sourceStore.rootPath !== \"\") {\n    newCtx.setRootPath(sourceStore.rootPath);\n  }\n\n  const [definitionDeactivate, definitionActivate] = definitionFactories;\n  const [externalDeactivate, externalActivate] = externalFactories;\n\n  for (const [name, handler] of Object.entries(definitionDeactivate)) {\n    newLifecycleNamespace.addCanDeactivate(name, handler, true);\n  }\n\n  for (const [name, handler] of Object.entries(definitionActivate)) {\n    newLifecycleNamespace.addCanActivate(name, handler, true);\n  }\n\n  const lifecycle = getLifecycleApi(newRouter);\n\n  for (const [name, handler] of Object.entries(externalDeactivate)) {\n    lifecycle.addDeactivateGuard(name, handler);\n  }\n\n  for (const [name, handler] of Object.entries(externalActivate)) {\n    lifecycle.addActivateGuard(name, handler);\n  }\n\n  // Plugin replay runs last and skips factories that a (contract-violating)\n  // definition-guard factory already registered on the clone during the\n  // re-compilation above — without the filter every clone would double-apply\n  // such a plugin: once via the factory, once via this replay (#1331 review).\n  const alreadyRegistered = new Set(newCtx.getCloneState().pluginFactories);\n  const pluginsToReplay = pluginFactories.filter(\n    (factory) => !alreadyRegistered.has(factory),\n  );\n\n  // Stryker disable next-line EqualityOperator: equivalent — `>= 0` is always true, but `usePlugin(...[])` with an empty spread is a no-op, so entering the block on an empty list behaves identically to skipping it. (ConditionalExpression stays live: `→false` skips a real plugin list and is killable.)\n  if (pluginsToReplay.length > 0) {\n    newRouter.usePlugin(...pluginsToReplay);\n  }\n\n  return newRouter;\n}\n"],"mappings":"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"}