@real-router/core 0.78.0 → 0.79.1

package/dist/cjs/index.d.ts

@@ -1,239 +1,17 @@
-import { n as RouteTree } from "./types-xg2zHVF6.js";
-import { $ as State, A as LeaveFn, B as PluginFactory, C as PluginMethod, D as ForwardToCallback, E as DefaultRouteCallback, F as LogLevelConfig, G as SubscribeFn, H as RouteConfigUpdate, I as LoggerConfig, J as LimitsConfig, K as SubscribeState, L as Navigator, M as Listener, N as LogCallback, O as GuardFn, P as LogLevel, Q as SimpleState, R as Options, S as EventsKeys, T as DefaultParamsCallback, U as Router$1, V as Route, W as RouterLogger, X as Params, Y as NavigationOptions, _ as ErrorCodeValues, a as LifecycleApi, at as Unsubscribe, b as EventToNameMap, c as TreeChangedAdd, ct as RouteParams, d as TreeChangedRemove, et as StateContext, f as TreeChangedReplace, g as ErrorCodeToValueMap, h as ErrorCodeKeys, i as InterceptorFn, it as TransitionReason, j as LeaveState, k as GuardFnFactory, l as TreeChangedClear, lt as RouteTreeState, m as TreeStructuralPatch, n as DependenciesApi, nt as TransitionMeta, o as PluginApi, ot as QueryParamsMode, p as TreeChangedUpdate, q as Subscription, r as InterceptableMethodMap, rt as TransitionPhase, s as RoutesApi, st as QueryParamsOptions, t as ContextNamespaceClaim, tt as StateMetaInput, u as TreeChangedEvent, v as EventMethodMap, w as DefaultDependencies, x as EventToPluginMap, y as EventName, z as Plugin } from "./index-CAnGQpnz.js";
-import { t as Router } from "./Router-BG5yNYUG.js";
-import { t as RouterValidator } from "./RouterValidator-CZ8kPkrI.js";
-
-//#region src/constants.d.ts
-type ConstantsKeys = "UNKNOWN_ROUTE";
-type Constants = Record<ConstantsKeys, string>;
-type ErrorCodes = Record<ErrorCodeKeys, ErrorCodeValues>;
-/**
- * Error codes for router operations.
- * Used to identify specific failure scenarios in navigation and lifecycle.
- * Frozen to prevent accidental modifications.
- */
-declare const errorCodes: ErrorCodeToValueMap;
-/**
- * General router constants.
- * Special route names and identifiers.
- */
-declare const UNKNOWN_ROUTE = "@@router/UNKNOWN_ROUTE";
-declare const constants: Constants;
-/**
- * Event names for router event system.
- * Used with addEventListener/removeEventListener for reactive subscriptions.
- */
-declare const events: EventToNameMap;
-//#endregion
-//#region src/RouterError.d.ts
-declare class RouterError extends Error {
-  [key: string]: unknown;
-  readonly segment: string | undefined;
-  readonly path: string | undefined;
-  code: string;
-  /**
-   * Creates a new RouterError instance.
-   *
-   * The options object accepts built-in fields (message, segment, path)
-   * and any additional custom fields, which will all be attached to the error instance.
-   *
-   * @param code - The error code (e.g., "ROUTE_NOT_FOUND", "CANNOT_ACTIVATE")
-   * @param options - Optional configuration object
-   * @param options.message - Custom error message (defaults to code if not provided)
-   * @param options.segment - The route segment where the error occurred
-   * @param options.path - The full path where the error occurred
-   *
-   * @example
-   * ```typescript
-   * // Basic error
-   * const err1 = new RouterError("ROUTE_NOT_FOUND");
-   *
-   * // Error with custom message
-   * const err2 = new RouterError("ERR", { message: "Something went wrong" });
-   *
-   * // Error with context and custom fields
-   * const err3 = new RouterError("CANNOT_ACTIVATE", {
-   *   message: "Insufficient permissions",
-   *   segment: "admin",
-   *   path: "/admin/users",
-   *   userId: "123"  // custom field
-   * });
-   * ```
-   */
-  constructor(code: string, {
-    message,
-    segment,
-    path,
-    ...rest
-  }?: {
-    [key: string]: unknown;
-    message?: string | undefined;
-    segment?: string | undefined;
-    path?: string | undefined;
-  });
-  /**
-   * Updates the error code and conditionally updates the message.
-   *
-   * If the current message is one of the standard error code values
-   * (e.g., "ROUTE_NOT_FOUND", "SAME_STATES"), it will be replaced with the new code.
-   * This allows keeping error messages in sync with codes when using standard error codes.
-   *
-   * If the message is custom (not a standard error code), it will be preserved.
-   *
-   * @param newCode - The new error code to set
-   *
-   * @example
-   * // Message follows code (standard error code as message)
-   * const err = new RouterError("ROUTE_NOT_FOUND", { message: "ROUTE_NOT_FOUND" });
-   * err.setCode("CUSTOM_ERROR"); // message becomes "CUSTOM_ERROR"
-   *
-   * @example
-   * // Custom message is preserved
-   * const err = new RouterError("ERR", { message: "Custom error message" });
-   * err.setCode("NEW_CODE"); // message stays "Custom error message"
-   */
-  setCode(newCode: string): void;
-  /**
-   * Copies properties from another Error instance to this RouterError.
-   *
-   * This method updates the message, cause, and stack trace from the provided error.
-   * Useful for wrapping native errors while preserving error context.
-   *
-   * @param err - The Error instance to copy properties from
-   * @throws {TypeError} If err is null or undefined
-   *
-   * @example
-   * ```typescript
-   * const routerErr = new RouterError("TRANSITION_ERR");
-   * try {
-   *   // some operation that might fail
-   * } catch (nativeErr) {
-   *   routerErr.setErrorInstance(nativeErr);
-   *   throw routerErr;
-   * }
-   * ```
-   */
-  setErrorInstance(err: Error): void;
-  /**
-   * Adds custom fields to the error object.
-   *
-   * This method allows attaching arbitrary data to the error for debugging or logging purposes.
-   * All fields become accessible as properties on the error instance and are included in JSON serialization.
-   *
-   * Reserved method names (setCode, setErrorInstance, setAdditionalFields, hasField, getField, toJSON)
-   * are automatically filtered out to prevent accidental overwriting of class methods.
-   *
-   * @param fields - Object containing custom fields to add to the error
-   *
-   * @example
-   * ```typescript
-   * const err = new RouterError("CANNOT_ACTIVATE");
-   * err.setAdditionalFields({
-   *   userId: "123",
-   *   attemptedRoute: "/admin",
-   *   reason: "insufficient permissions"
-   * });
-   *
-   * console.log(err.userId); // "123"
-   * console.log(JSON.stringify(err)); // includes all custom fields
-   * ```
-   */
-  setAdditionalFields(fields: Record<string, unknown>): void;
-  /**
-   * Checks if a custom field exists on the error object.
-   *
-   * This method checks for both custom fields added via setAdditionalFields()
-   * and built-in fields (code, message, segment, etc.).
-   *
-   * @param key - The field name to check
-   * @returns `true` if the field exists, `false` otherwise
-   *
-   * @example
-   * ```typescript
-   * const err = new RouterError("ERR", { segment: "users" });
-   * err.setAdditionalFields({ userId: "123" });
-   *
-   * err.hasField("userId");  // true
-   * err.hasField("segment"); // true
-   * err.hasField("unknown"); // false
-   * ```
-   */
-  hasField(key: string): boolean;
-  /**
-   * Retrieves a custom field value from the error object.
-   *
-   * This method can access both custom fields and built-in fields.
-   * Returns `undefined` if the field doesn't exist.
-   *
-   * @param key - The field name to retrieve
-   * @returns The field value, or `undefined` if it doesn't exist
-   *
-   * @example
-   * ```typescript
-   * const err = new RouterError("ERR");
-   * err.setAdditionalFields({ userId: "123", role: "admin" });
-   *
-   * err.getField("userId"); // "123"
-   * err.getField("role");   // "admin"
-   * err.getField("code");   // "ERR" (built-in field)
-   * err.getField("unknown"); // undefined
-   * ```
-   */
-  getField(key: string): unknown;
-  /**
-   * Serializes the error to a JSON-compatible object.
-   *
-   * This method is automatically called by JSON.stringify() and includes:
-   * - Built-in fields: code, message, segment (if set), path (if set)
-   * - All custom fields added via setAdditionalFields() or constructor
-   * - Excludes: stack trace (for security/cleanliness)
-   *
-   * @returns A plain object representation of the error, suitable for JSON serialization
-   *
-   * @example
-   * ```typescript
-   * const err = new RouterError("ROUTE_NOT_FOUND", {
-   *   message: "Route not found",
-   *   path: "/admin/users/123"
-   * });
-   * err.setAdditionalFields({ userId: "123" });
-   *
-   * JSON.stringify(err);
-   * // {
-   * //   "code": "ROUTE_NOT_FOUND",
-   * //   "message": "Route not found",
-   * //   "path": "/admin/users/123",
-   * //   "userId": "123"
-   * // }
-   * ```
-   */
-  toJSON(): Record<string, unknown>;
-}
-//#endregion
-//#region src/createRouter.d.ts
-/**
- * Creates a new router instance.
- *
- * @param routes - Array of route definitions
- * @param options - Router configuration options
- * @param dependencies - Dependencies to inject into the router
- * @returns A new Router instance
- *
- * @example
- * const router = createRouter([
- *   { name: 'home', path: '/' },
- *   { name: 'users', path: '/users' },
- * ]);
- *
- * router.start('/');
- */
-declare const createRouter: <Dependencies extends DefaultDependencies = DefaultDependencies>(routes?: Route<Dependencies>[], options?: Partial<Options>, dependencies?: Dependencies) => Router<Dependencies>;
-//#endregion
-//#region src/getNavigator.d.ts
-declare const getNavigator: <Dependencies extends DefaultDependencies = DefaultDependencies>(router: Router$1<Dependencies>) => Navigator;
-//#endregion
-//#region src/namespaces/RoutesNamespace/forwardChain.d.ts
-declare function resolveForwardChain(startRoute: string, forwardMap: Record<string, string>, maxDepth?: number): string;
-//#endregion
-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 };
-//# sourceMappingURL=index.d.ts.map
+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 { 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";
+import { TreeChangedAdd, TreeChangedClear, TreeChangedEvent, TreeChangedRemove, TreeChangedReplace, TreeChangedUpdate, TreeStructuralPatch } from "./types/tree-changed.js";
+import { ContextNamespaceClaim, DependenciesApi, InterceptableMethodMap, InterceptorFn, LifecycleApi, PluginApi, RoutesApi } from "./types/api.js";
+import { NavigationOptions, StateContext } from "./types.js";
+import { Router } from "./Router.js";
+import { RouterValidator } from "./types/RouterValidator.js";
+import { Constants, ErrorCodes, UNKNOWN_ROUTE, constants, errorCodes, events } from "./constants.js";
+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 };

package/dist/cjs/index.js

@@ -1,2 +1,2 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require("./Router-D6NzRxBA.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;
+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

package/dist/cjs/internals.d.ts

@@ -0,0 +1,99 @@
+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 { 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
+interface RouterInternals<D extends DefaultDependencies = DefaultDependencies> {
+  readonly makeState: <P extends Params = Params>(name: string, params?: P, path?: string, meta?: Record<string, Record<string, "url" | "query">>) => State<P>;
+  readonly forwardState: <P extends Params = Params>(routeName: string, routeParams: P) => SimpleState<P>;
+  readonly buildStateResolved: (resolvedName: string, resolvedParams: Params) => RouteTreeState | undefined;
+  readonly matchPath: <P extends Params = Params>(path: string, options?: Options) => State<P> | undefined;
+  readonly getOptions: () => Options;
+  readonly addEventListener: <E extends EventName>(eventName: E, cb: Plugin[EventMethodMap[E]]) => Unsubscribe;
+  /**
+   * Route-tree mutation channel — internal access for the `getRoutesApi`
+   * wrapper. A dedicated bridge is required because the public
+   * `addEventListener<E extends EventName>` structurally rejects
+   * `"TREE_CHANGED"` (it is not in the public `EventName` union), is strict on
+   * duplicates, and exposes neither `emit` nor `listenerCount`.
+   */
+  readonly treeChanged: {
+    readonly emit: (event: TreeChangedEvent) => void;
+    readonly subscribe: (handler: (event: TreeChangedEvent) => void) => Unsubscribe;
+    readonly listenerCount: () => number;
+    /**
+     * True while a `TREE_CHANGED` emit is on the stack — `getRoutesApi` reads it
+     * to reject reentrant route-CRUD from a `subscribeChanges` handler (#1032).
+     */
+    readonly isEmitting: () => boolean;
+  };
+  readonly buildPath: (route: string, params?: Params) => string;
+  readonly emitTransitionError: (error: Error) => void;
+  /**
+   * Emits `TRANSITION_SUCCESS` directly (no FSM transition) — used by
+   * `getRoutesApi().replace()` to notify `router.subscribe` listeners when a
+   * structural replace revalidates the active state (#950). Mirrors the success
+   * emission `completeTransition` / `navigateToNotFound` perform.
+   */
+  readonly emitTransitionSuccess: (toState: State, fromState: State | undefined, opts?: NavigationOptions) => void;
+  /**
+   * Commits the not-found (`UNKNOWN_ROUTE`) state for `path` and emits
+   * `TRANSITION_SUCCESS` — the `NavigationNamespace.navigateToNotFound`
+   * primitive. `replace()` uses it when a structural replace drops the active
+   * route, so subscribers are notified instead of the state silently clearing
+   * (#950).
+   */
+  readonly navigateToNotFound: (path: string) => State;
+  readonly start: (path: string) => Promise<State>;
+  /**
+   * Plugin-only navigation entry point — delegates to
+   * `NavigationNamespace.navigateToState` (`getPluginApi(router).navigateToState`).
+   * Hidden from `Router`/`Navigator` to keep the userland surface minimal;
+   * see `core-types/src/api.ts` for usage docs.
+   */
+  readonly navigateToState: (state: State, options?: NavigationOptions) => Promise<State>;
+  readonly interceptors: Map<string, ((next: (...args: any[]) => any, ...args: any[]) => any)[]>;
+  readonly setRootPath: (rootPath: string) => void;
+  readonly getRootPath: () => string;
+  readonly getTree: () => RouteTree;
+  readonly isDisposed: () => boolean;
+  validator: RouterValidator | null;
+  readonly logger: RouterLogger;
+  readonly dependenciesGetStore: () => DependenciesStore<D>;
+  readonly getCloneState: () => {
+    options: Options;
+    dependencies: Record<string, unknown>;
+    pluginFactories: PluginFactory<D>[];
+    loggerConfig: LoggerConfig;
+  };
+  readonly routeGetStore: () => RoutesStore<D>;
+  readonly getStateName: () => string | undefined;
+  readonly isTransitioning: () => boolean;
+  readonly clearState: () => void;
+  readonly setState: (state: State) => void;
+  readonly routerExtensions: {
+    keys: string[];
+  }[];
+  readonly contextClaimRecords: Set<string>;
+  /**
+   * One-shot hydration scratchpad populated by `hydrateRouter` immediately
+   * before delegating to `router.start(parsed.path)` and cleared in the
+   * matching `finally`. SSR loader plugins read this slot directly via
+   * `getInternals(router).hydrationState` to short-circuit their own loader
+   * call when the server-resolved namespace value is already present in the
+   * parsed state (#596). `null` outside of an active `hydrateRouter`
+   * invocation.
+   */
+  hydrationState: SerializedRouterState | null;
+}
+declare function getInternals<D extends DefaultDependencies>(router: Router<D>): RouterInternals<D>;
+//#endregion
+export { RouterInternals, getInternals };
+//# sourceMappingURL=internals.d.ts.map

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

@@ -0,0 +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"}

package/dist/cjs/internals.js

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

package/dist/cjs/internals.js.map

@@ -0,0 +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"}

package/dist/cjs/namespaces/DependenciesNamespace/dependenciesStore.d.ts

@@ -0,0 +1,10 @@
+import { DefaultDependencies } from "../../types/router.js";
+import { Limits } from "../../types/internal.js";
+//#region src/namespaces/DependenciesNamespace/dependenciesStore.d.ts
+interface DependenciesStore<Dependencies extends DefaultDependencies = DefaultDependencies> {
+  dependencies: Partial<Dependencies>;
+  limits: Limits;
+}
+//#endregion
+export { DependenciesStore };
+//# sourceMappingURL=dependenciesStore.d.ts.map

package/dist/cjs/namespaces/DependenciesNamespace/dependenciesStore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dependenciesStore.d.ts","names":[],"sources":["../../../../src/namespaces/DependenciesNamespace/dependenciesStore.ts"],"mappings":";;;UAKiB,kBACf,qBAAqB,sBAAsB;EAE3C,cAAc,QAAQ;EACtB,QAAQ"}

package/dist/cjs/namespaces/DependenciesNamespace/dependenciesStore.js

@@ -0,0 +1,2 @@
+const e=require("../../constants.js");function t(t={}){let n=Object.create(null);for(let e in t)t[e]!==void 0&&(n[e]=t[e]);return{dependencies:n,limits:e.DEFAULT_LIMITS}}exports.createDependenciesStore=t;
+//# sourceMappingURL=dependenciesStore.js.map

package/dist/cjs/namespaces/DependenciesNamespace/dependenciesStore.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dependenciesStore.js","names":["DEFAULT_LIMITS"],"sources":["../../../../src/namespaces/DependenciesNamespace/dependenciesStore.ts"],"sourcesContent":["import { DEFAULT_LIMITS } from \"../../constants\";\n\nimport type { DefaultDependencies } from \"../../types\";\nimport type { Limits } from \"../../types/internal\";\n\nexport interface DependenciesStore<\n  Dependencies extends DefaultDependencies = DefaultDependencies,\n> {\n  dependencies: Partial<Dependencies>;\n  limits: Limits;\n}\n\nexport function createDependenciesStore<\n  Dependencies extends DefaultDependencies = DefaultDependencies,\n>(\n  initialDependencies: Partial<Dependencies> = {},\n): DependenciesStore<Dependencies> {\n  const dependencies = Object.create(null) as Partial<Dependencies>;\n\n  for (const key in initialDependencies) {\n    if (initialDependencies[key] !== undefined) {\n      dependencies[key] = initialDependencies[key];\n    }\n  }\n\n  return {\n    dependencies,\n    limits: DEFAULT_LIMITS,\n  };\n}\n"],"mappings":"sCAYA,SAAgB,EAGd,EAA6C,CAAC,EACb,CACjC,IAAM,EAAe,OAAO,OAAO,IAAI,EAEvC,IAAK,IAAM,KAAO,EACZ,EAAoB,KAAS,IAAA,KAC/B,EAAa,GAAO,EAAoB,IAI5C,MAAO,CACL,eACA,OAAQA,EAAAA,cACV,CACF"}

package/dist/cjs/namespaces/EventBusNamespace/EventBusNamespace.js

@@ -0,0 +1,2 @@
+const e=require("../../constants.js"),t=require("../../RouterError.js"),n=require("../../routerFSM.js"),r=`TREE_CHANGED`;function i(e){return e instanceof Error?e:Error(String(e))}function a(n,r,a){return new Promise((o,s)=>{let c=()=>{let n=a.reason;s(n instanceof t.RouterError&&n.code===e.errorCodes.TRANSITION_CANCELLED?n:new t.RouterError(e.errorCodes.TRANSITION_CANCELLED,{reason:n}))};if(a.aborted){c();return}a.addEventListener(`abort`,c,{once:!0}),Promise.allSettled(n).then(e=>{if(a.removeEventListener(`abort`,c),a.aborted)return;if(r!==void 0){s(i(r));return}let t=e.find(e=>e.status===`rejected`);if(t!==void 0){s(i(t.reason));return}o()})})}var o=class{#e;#t;#n;#r;#i=[];#a=0;#o;#s;#c;#l;#u;constructor(e){this.#e=e.routerFSM,this.#t=e.emitter,this.#n=e.abortController,this.#o=void 0,this.#p()}static validateSubscribeListener(e){if(typeof e!=`function`)throw TypeError(`[router.subscribe] Expected a function. For Observable pattern use observable(router) from @real-router/rx`)}static validateSubscribeLeaveListener(e){if(typeof e!=`function`)throw TypeError(`[router.subscribeLeave] Expected a function`)}emitRouterStart(){this.#t.emit(e.events.ROUTER_START)}emitRouterStop(){this.#t.emit(e.events.ROUTER_STOP)}emitTransitionStart(t,n){this.#a++;try{this.#t.emit(e.events.TRANSITION_START,t,n)}finally{this.#a--}}emitTransitionSuccess(t,n,r){this.#a++;try{this.#t.emit(e.events.TRANSITION_SUCCESS,t,n,r)}finally{this.#a--}}emitTransitionError(t,n,r){this.#a++;try{this.#t.emit(e.events.TRANSITION_ERROR,t,n,r)}finally{this.#a--}}emitTransitionCancel(t,n){this.#a++;try{this.#t.emit(e.events.TRANSITION_CANCEL,t,n)}finally{this.#a--}}emitTransitionLeaveApprove(t,n){this.#a++;try{this.#t.emit(e.events.TRANSITION_LEAVE_APPROVE,t,n)}finally{this.#a--}}isProcessing(){return this.#a>0}emitTreeChanged(e){this.#t.emit(r,e)}isEmittingTreeChanged(){return this.#t.isDispatching(r)}subscribeTreeChanged(n){if(this.isDisposed())throw new t.RouterError(e.errorCodes.ROUTER_DISPOSED);return this.#t.on(r,e=>{n(e)})}treeChangedListenerCount(){return this.#t.listenerCount(r)}sendStart(){this.#e.send(n.routerEvents.START)}sendStop(){this.#e.send(n.routerEvents.STOP)}sendDispose(){this.#e.send(n.routerEvents.DISPOSE)}sendStarted(){this.#e.send(n.routerEvents.STARTED)}sendNavigate(e,t){this.#o=e,this.#e.send(n.routerEvents.NAVIGATE,{toState:e,fromState:t})}sendComplete(e,t,r={}){this.#e.send(n.routerEvents.COMPLETE,{toState:e,fromState:t,opts:r}),this.#o=void 0}sendLeaveApprove(e,t){this.#e.send(n.routerEvents.LEAVE_APPROVE,{toState:e,fromState:t})}sendFail(e,t,r){this.#s=e,this.#c=t,this.#l=r,this.#e.send(n.routerEvents.FAIL),this.#o=void 0}sendFailSafe(e,t,n){this.isReady()?this.sendFail(e,t,n):this.emitTransitionError(e,t,n)}sendCancel(e,t,r){this.#s=e,this.#c=t,this.#u=r,this.#e.send(n.routerEvents.CANCEL),this.#o=void 0}canBeginTransition(){return this.#e.canSend(n.routerEvents.NAVIGATE)}canStart(){return this.#e.canSend(n.routerEvents.START)}canCancel(){return this.#e.canSend(n.routerEvents.CANCEL)}isActive(){let e=this.#e.getState();return e!==n.routerStates.IDLE&&e!==n.routerStates.DISPOSED}isDisposed(){return this.#e.getState()===n.routerStates.DISPOSED}isTransitioning(){let e=this.#e.getState();return e===n.routerStates.TRANSITION_STARTED||e===n.routerStates.LEAVE_APPROVED}isLeaveApproved(){return this.#e.getState()===n.routerStates.LEAVE_APPROVED}isReady(){return this.#e.getState()===n.routerStates.READY}isStarting(){return this.#e.getState()===n.routerStates.STARTING}isIdle(){return this.#e.getState()===n.routerStates.IDLE}addEventListener(e,t){return this.#d(e,`addEventListener`),this.#t.on(e,t)}subscribe(n){if(this.isDisposed())throw new t.RouterError(e.errorCodes.ROUTER_DISPOSED);return this.#d(e.events.TRANSITION_SUCCESS,`subscribe`),this.#t.on(e.events.TRANSITION_SUCCESS,(e,t)=>n({route:e,previousRoute:t}))}subscribeLeave(n){if(this.isDisposed())throw new t.RouterError(e.errorCodes.ROUTER_DISPOSED);this.#i.push(n);let r=!1;return()=>{if(r)return;r=!0;let e=this.#i.indexOf(n);e!==-1&&this.#i.splice(e,1)}}hasLeaveListeners(){return this.#i.length>0}hasPreCommitListeners(){return this.#t.listenerCount(e.events.TRANSITION_START)>0||this.#t.listenerCount(e.events.TRANSITION_LEAVE_APPROVE)>0}awaitLeaveListeners(e,t,n){if(t===void 0)return;let r=Object.freeze({route:t,nextRoute:e,signal:n}),o,s,c=[...this.#i];this.#a++;try{for(let e of c)try{let t=e(r);t!==void 0&&typeof t.then==`function`&&(o??=[],o.push(t))}catch(e){s===void 0&&(s=e)}}finally{this.#a--}if(o===void 0){if(s!==void 0)throw i(s);return}return a(o,s,n)}clearAll(){this.#t.clearAll(),this.#i.length=0}setLimits(e){this.#t.setLimits(e)}setValidatorAccessor(e){this.#r=e}sendCancelIfPossible(e,t){let n=this.#o;!this.canCancel()||n===void 0||this.sendCancel(n,e,t)}#d(e,t){let n=this.#r?.();n&&n.eventBus.validateCountThresholds(this.#t.listenerCount(e)+1,e,t)}#f(){this.emitTransitionError(this.#s,this.#c,this.#l),this.#s=void 0,this.#c=void 0,this.#l=void 0}#p(){let e=this.#e;e.on(n.routerStates.STARTING,n.routerEvents.STARTED,()=>{this.emitRouterStart()}),e.on(n.routerStates.READY,n.routerEvents.STOP,()=>{this.emitRouterStop()});let t=e=>{this.emitTransitionStart(e.toState,e.fromState)};e.on(n.routerStates.READY,n.routerEvents.NAVIGATE,t),e.on(n.routerStates.TRANSITION_STARTED,n.routerEvents.NAVIGATE,t),e.on(n.routerStates.LEAVE_APPROVED,n.routerEvents.NAVIGATE,t),e.on(n.routerStates.TRANSITION_STARTED,n.routerEvents.LEAVE_APPROVE,e=>{this.emitTransitionLeaveApprove(e.toState,e.fromState)}),e.on(n.routerStates.LEAVE_APPROVED,n.routerEvents.COMPLETE,e=>{this.emitTransitionSuccess(e.toState,e.fromState,e.opts)});let r=()=>{let e=this.#s,t=this.#u;this.#u=void 0,this.#n(t),e!==void 0&&this.emitTransitionCancel(e,this.#c)};e.on(n.routerStates.TRANSITION_STARTED,n.routerEvents.CANCEL,r),e.on(n.routerStates.LEAVE_APPROVED,n.routerEvents.CANCEL,r),e.on(n.routerStates.LEAVE_APPROVED,n.routerEvents.FAIL,()=>{this.#f()}),e.on(n.routerStates.STARTING,n.routerEvents.FAIL,()=>{this.#f()}),e.on(n.routerStates.READY,n.routerEvents.FAIL,()=>{this.#f()}),e.on(n.routerStates.TRANSITION_STARTED,n.routerEvents.FAIL,()=>{this.#f()})}};exports.EventBusNamespace=o;
+//# sourceMappingURL=EventBusNamespace.js.map

package/dist/cjs/namespaces/EventBusNamespace/EventBusNamespace.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"EventBusNamespace.js","names":["RouterError","errorCodes","#fsm","#emitter","#abortController","#leaveListeners","#currentToState","#setupFSMActions","events","#dispatchDepth","routerEvents","#pendingToState","#pendingFromState","#pendingError","#pendingCancelReason","routerStates","#checkListenerThreshold","#getValidator","#emitPendingError"],"sources":["../../../../src/namespaces/EventBusNamespace/EventBusNamespace.ts"],"sourcesContent":["// packages/core/src/namespaces/EventBusNamespace/EventBusNamespace.ts\n\nimport { errorCodes, events } from \"../../constants\";\nimport { RouterError } from \"../../RouterError\";\nimport { routerEvents, routerStates } from \"../../routerFSM\";\n\nimport type { EventBusOptions } from \"./types\";\nimport type { EventEmitter } from \"../../foundation/event-emitter\";\nimport type { FSM } from \"../../foundation/fsm\";\nimport type { RouterEvent, RouterPayloads, RouterState } from \"../../routerFSM\";\nimport type {\n  EventName,\n  LeaveFn,\n  LeaveState,\n  NavigationOptions,\n  Plugin,\n  State,\n  SubscribeFn,\n  TreeChangedEvent,\n  Unsubscribe,\n  EventMethodMap,\n} from \"../../types\";\nimport type { RouterEventMap } from \"../../types/internal\";\nimport type { RouterValidator } from \"../../types/RouterValidator\";\n\n/**\n * Internal-only event key for route-tree mutations. Lives on the same\n * `EventEmitter` as the 7 transition events but never enters the public\n * `EventName` union — reachable only through\n * `getRoutesApi(router).subscribeChanges()`.\n */\nconst TREE_CHANGED = \"TREE_CHANGED\";\n\nfunction ensureError(value: unknown): Error {\n  return value instanceof Error ? value : new Error(String(value));\n}\n\nfunction settleLeavePromises(\n  promises: Promise<void>[],\n  firstSyncError: unknown,\n  signal: AbortSignal,\n): Promise<void> {\n  return new Promise<void>((resolve, reject) => {\n    // #1197 — canonicalize the abort outcome: reject with a\n    // `RouterError(TRANSITION_CANCELLED)` carrying the external reason, so the\n    // no-guards leave path classifies identically to the guard path (no raw\n    // reject, no spurious TRANSITION_ERROR). Internal sources\n    // (supersede/stop/dispose) already abort with such a RouterError — thread it\n    // through unchanged so the #943 reason is preserved.\n    const onAbort = (): void => {\n      const reason: unknown = signal.reason;\n\n      reject(\n        reason instanceof RouterError &&\n          reason.code === errorCodes.TRANSITION_CANCELLED\n          ? reason\n          : new RouterError(errorCodes.TRANSITION_CANCELLED, { reason }),\n      );\n    };\n\n    if (signal.aborted) {\n      onAbort();\n\n      return;\n    }\n\n    // Stryker disable next-line ObjectLiteral,BooleanLiteral: equivalent — `{ once: true }` is redundant: onAbort fires at most once (a signal aborts once) and the success path explicitly removeEventListener's it, so dropping `once` is unobservable. StringLiteral sibling stays live (the \"abort\" event name is killed).\n    signal.addEventListener(\"abort\", onAbort, { once: true });\n\n    void Promise.allSettled(promises).then((results) => {\n      // Stryker disable next-line StringLiteral: equivalent — this cleanup name is redundant: onAbort is registered with `{ once: true }` and the per-navigation signal is discarded unaborted on success, so failing to remove the listener leaks nothing observable.\n      signal.removeEventListener(\"abort\", onAbort);\n\n      // Stryker disable next-line BlockStatement: equivalent — emptying the post-allSettled abort-race early-return falls through to resolve()/reject(), but the abort handler already settled the promise, so the extra settle is a no-op. CE sibling stays live (→true hangs the pipeline = killed via timeout).\n      if (signal.aborted) {\n        // Race lost to abort — the abort handler already rejected; do nothing\n        return;\n      }\n\n      if (firstSyncError !== undefined) {\n        reject(ensureError(firstSyncError));\n\n        return;\n      }\n\n      const rejected = results.find(\n        (result): result is PromiseRejectedResult =>\n          result.status === \"rejected\",\n      );\n\n      if (rejected !== undefined) {\n        reject(ensureError(rejected.reason));\n\n        return;\n      }\n\n      resolve();\n    });\n  });\n}\n\nexport class EventBusNamespace {\n  readonly #fsm: FSM<RouterState, RouterEvent, null, RouterPayloads>;\n  readonly #emitter: EventEmitter<RouterEventMap>;\n  // Effect of the FSM CANCEL action: aborts the in-flight navigation's\n  // controller. Wired to NavigationNamespace.\n  readonly #abortController: (reason?: unknown) => void;\n  // Lazy accessor for the opt-in RouterValidator (wired by wireNamespaces).\n  // Returns `null` until validation-plugin is registered — so the proactive\n  // listener-count threshold (#1188) costs the no-plugin path nothing.\n  #getValidator: (() => RouterValidator | null) | undefined;\n  readonly #leaveListeners: LeaveFn[] = [];\n\n  // Depth of the synchronous transition-dispatch window — elevated while a\n  // transition event is being emitted (`emitTransition*`) or a `subscribeLeave`\n  // listener batch runs. `isProcessing()` reads it so the navigation facade can\n  // reject a synchronous reentrant navigate() from inside a transition listener\n  // with REENTRANT_NAVIGATION (RFC navigation-cancellation-unification §4). A\n  // counter (not a boolean) tolerates legitimately-nested transition emits. The\n  // ceiling-bounded \"allow reentrant navigate, throw RecursionDepthError at\n  // `maxEventDepth`\" behaviour (#935/#945) is gone: such a navigate now throws\n  // REENTRANT_NAVIGATION at depth 1, before it can recurse. (The emitter's old\n  // `maxEventDepth` depth-bound is gone too — re-entrant emits are coalesced to a\n  // no-op at the emitter, #1033 — so no event can re-enter its own dispatch.)\n  #dispatchDepth = 0;\n\n  #currentToState: State | undefined;\n  #pendingToState: State | undefined;\n  #pendingFromState: State | undefined;\n  #pendingError: unknown;\n  // Abort reason for the pending CANCEL — read by handleCancel, set by sendCancel.\n  #pendingCancelReason: unknown;\n\n  constructor(options: EventBusOptions) {\n    this.#fsm = options.routerFSM;\n    this.#emitter = options.emitter;\n    this.#abortController = options.abortController;\n    this.#currentToState = undefined;\n    this.#setupFSMActions();\n  }\n\n  static validateSubscribeListener(listener: unknown): void {\n    if (typeof listener !== \"function\") {\n      throw new TypeError(\n        \"[router.subscribe] Expected a function. \" +\n          \"For Observable pattern use observable(router) from @real-router/rx\",\n      );\n    }\n  }\n\n  /**\n   * Validates the `subscribeLeave` listener. Unlike\n   * {@link validateSubscribeListener}, the error carries **no**\n   * `@real-router/rx` hint — rx exposes the Observable pattern for *success*\n   * transitions (`observable(router)`, `state$`, `events$`), not for leave\n   * events, so steering leave-listener misuse toward rx would mislead. The\n   * asymmetry is intentional (mirrored in `core/CLAUDE.md`).\n   */\n  static validateSubscribeLeaveListener(listener: unknown): void {\n    if (typeof listener !== \"function\") {\n      throw new TypeError(\"[router.subscribeLeave] Expected a function\");\n    }\n  }\n\n  emitRouterStart(): void {\n    this.#emitter.emit(events.ROUTER_START);\n  }\n\n  emitRouterStop(): void {\n    this.#emitter.emit(events.ROUTER_STOP);\n  }\n\n  emitTransitionStart(toState: State, fromState?: State): void {\n    this.#dispatchDepth++;\n    try {\n      this.#emitter.emit(events.TRANSITION_START, toState, fromState);\n    } finally {\n      this.#dispatchDepth--;\n    }\n  }\n\n  emitTransitionSuccess(\n    toState: State,\n    fromState?: State,\n    opts?: NavigationOptions,\n  ): void {\n    this.#dispatchDepth++;\n    try {\n      this.#emitter.emit(events.TRANSITION_SUCCESS, toState, fromState, opts);\n    } finally {\n      this.#dispatchDepth--;\n    }\n  }\n\n  emitTransitionError(\n    toState?: State,\n    fromState?: State,\n    error?: RouterError,\n  ): void {\n    this.#dispatchDepth++;\n    try {\n      this.#emitter.emit(events.TRANSITION_ERROR, toState, fromState, error);\n    } finally {\n      this.#dispatchDepth--;\n    }\n  }\n\n  emitTransitionCancel(toState: State, fromState?: State): void {\n    this.#dispatchDepth++;\n    try {\n      this.#emitter.emit(events.TRANSITION_CANCEL, toState, fromState);\n    } finally {\n      this.#dispatchDepth--;\n    }\n  }\n\n  emitTransitionLeaveApprove(toState: State, fromState?: State): void {\n    this.#dispatchDepth++;\n    try {\n      this.#emitter.emit(events.TRANSITION_LEAVE_APPROVE, toState, fromState);\n    } finally {\n      this.#dispatchDepth--;\n    }\n  }\n\n  /**\n   * True while a transition event is being dispatched synchronously — an\n   * `emitTransition*` call or a `subscribeLeave` listener batch is on the stack.\n   * The navigation facade reads this to reject a synchronous reentrant\n   * navigate() from inside a transition listener (RFC §4).\n   */\n  isProcessing(): boolean {\n    return this.#dispatchDepth > 0;\n  }\n\n  /**\n   * Emits the internal `TREE_CHANGED` event after a structural route-tree\n   * mutation. Reuses the shared `EventEmitter` — so re-entrancy coalescing\n   * (#1033) and per-listener error isolation (`onListenerError`) apply\n   * automatically.\n   */\n  emitTreeChanged(event: TreeChangedEvent): void {\n    this.#emitter.emit(TREE_CHANGED, event);\n  }\n\n  /**\n   * True while a `TREE_CHANGED` event is being dispatched synchronously.\n   * Delegates to the emitter's own in-flight tracking (#1034) — `getRoutesApi`\n   * reads this to reject reentrant route-CRUD from a `subscribeChanges` handler\n   * (#1032).\n   */\n  isEmittingTreeChanged(): boolean {\n    return this.#emitter.isDispatching(TREE_CHANGED);\n  }\n\n  /**\n   * Subscribes to `TREE_CHANGED`. **Lenient** duplicate semantics (mirrors\n   * {@link subscribe}): each call wraps the handler in a fresh closure, so N\n   * registrations of the same reference produce N independent subscriptions.\n   */\n  subscribeTreeChanged(\n    handler: (event: TreeChangedEvent) => void,\n  ): Unsubscribe {\n    // Same disposed-state enforcement as subscribe()/subscribeLeave() (#946),\n    // completing the guard across all three subscription primitives — extended\n    // here to the internal route-tree channel (#982). A `subscribeChanges`\n    // reference bound before dispose() (`const s = routes.subscribeChanges\n    // .bind(routes)`) reaches this method via the getRoutesApi delegate, which\n    // — unlike its add/remove/update siblings — does not itself check\n    // isDisposed(). Without this guard, `emitter.on` would re-register a\n    // TREE_CHANGED listener that can never fire (clearAll already ran, the FSM\n    // is DISPOSED, the route tree is torn down, no future emit) — a silent\n    // no-op, the internal-channel counterpart of the #946 hazard.\n    if (this.isDisposed()) {\n      throw new RouterError(errorCodes.ROUTER_DISPOSED);\n    }\n\n    return this.#emitter.on(TREE_CHANGED, (event: TreeChangedEvent) => {\n      handler(event);\n    });\n  }\n\n  /** Number of active `TREE_CHANGED` listeners (drives conditional emit). */\n  treeChangedListenerCount(): number {\n    return this.#emitter.listenerCount(TREE_CHANGED);\n  }\n\n  sendStart(): void {\n    this.#fsm.send(routerEvents.START);\n  }\n\n  sendStop(): void {\n    this.#fsm.send(routerEvents.STOP);\n  }\n\n  sendDispose(): void {\n    this.#fsm.send(routerEvents.DISPOSE);\n  }\n\n  sendStarted(): void {\n    this.#fsm.send(routerEvents.STARTED);\n  }\n\n  sendNavigate(toState: State, fromState?: State): void {\n    this.#currentToState = toState;\n    // Table-driven: the FSM action emits TRANSITION_START (#1169 D-full). A\n    // NAVIGATE that the table rejects is a no-op — the FSM never leaves an\n    // invalid state and no event fires.\n    this.#fsm.send(routerEvents.NAVIGATE, { toState, fromState });\n  }\n\n  sendComplete(\n    state: State,\n    fromState?: State,\n    opts: NavigationOptions = {},\n  ): void {\n    // Table-driven: the FSM action emits TRANSITION_SUCCESS (#1169 D-full).\n    // COMPLETE from IDLE/DISPOSED (a listener stopped/disposed mid-transition)\n    // is a table no-op — no resurrection, no phantom success emit.\n    this.#fsm.send(routerEvents.COMPLETE, { toState: state, fromState, opts });\n\n    // Nav committed — clear so a later stop()/dispose() cannot cancel a finished\n    // navigation. Unconditional now that synchronous reentrant navigate is banned\n    // (RFC §4): nothing can replace #currentToState during the emit above, so the\n    // #308 reentrant-preserve guard is no longer needed.\n    this.#currentToState = undefined;\n  }\n\n  sendLeaveApprove(toState: State, fromState?: State): void {\n    // Table-driven: the FSM action emits TRANSITION_LEAVE_APPROVE (#1169 D-full).\n    // LEAVE_APPROVE from IDLE/DISPOSED is a table no-op — no resurrection.\n    this.#fsm.send(routerEvents.LEAVE_APPROVE, { toState, fromState });\n  }\n\n  sendFail(toState?: State, fromState?: State, error?: unknown): void {\n    this.#pendingToState = toState;\n    this.#pendingFromState = fromState;\n    this.#pendingError = error;\n    this.#fsm.send(routerEvents.FAIL);\n\n    // Nav failed — clear (unconditional; synchronous reentrant navigate is\n    // banned (RFC §4), so nothing replaces #currentToState during the emit).\n    this.#currentToState = undefined;\n  }\n\n  /**\n   * Surfaces a `TRANSITION_ERROR` for callers that do **not** know — or do not\n   * control — the current FSM state: the plugin-facing `emitTransitionError`\n   * primitive (`getPluginApi`), the dispose chain, and validator / same-state\n   * rejections. It is the state-agnostic counterpart to {@link sendFail}.\n   *\n   * **What \"Safe\" means here.** The error event is never *dropped*, whatever the\n   * FSM state — it does **not** mean the method catches every error. Errors\n   * thrown *inside* a `TRANSITION_ERROR` listener are isolated by the\n   * `EventEmitter`'s per-listener `onListenerError` sink, not by this method.\n   *\n   * **Why it branches on its own FSM state.** When the FSM is settled in `READY`\n   * (no transition in flight) it routes through the FSM `FAIL` action via\n   * {@link sendFail}, so the error rides the normal FSM-driven emit. Otherwise —\n   * the router may be starting, mid-transition, or torn down — it emits\n   * `TRANSITION_ERROR` directly: a fire-and-forget error report from an unknown\n   * state must not drive a second FSM transition that could collide with an\n   * in-flight one. Both branches guarantee the event reaches subscribers.\n   */\n  sendFailSafe(toState?: State, fromState?: State, error?: unknown): void {\n    if (this.isReady()) {\n      this.sendFail(toState, fromState, error);\n    } else {\n      this.emitTransitionError(toState, fromState, error as RouterError);\n    }\n  }\n\n  sendCancel(toState: State, fromState?: State, reason?: unknown): void {\n    this.#pendingToState = toState;\n    this.#pendingFromState = fromState;\n    this.#pendingCancelReason = reason;\n    this.#fsm.send(routerEvents.CANCEL);\n\n    // Nav cancelled — clear (unconditional; synchronous reentrant navigate is\n    // banned (RFC §4), so nothing replaces #currentToState during the emit).\n    this.#currentToState = undefined;\n  }\n\n  canBeginTransition(): boolean {\n    return this.#fsm.canSend(routerEvents.NAVIGATE);\n  }\n\n  canStart(): boolean {\n    return this.#fsm.canSend(routerEvents.START);\n  }\n\n  canCancel(): boolean {\n    return this.#fsm.canSend(routerEvents.CANCEL);\n  }\n\n  isActive(): boolean {\n    const fsmState = this.#fsm.getState();\n\n    return fsmState !== routerStates.IDLE && fsmState !== routerStates.DISPOSED;\n  }\n\n  isDisposed(): boolean {\n    return this.#fsm.getState() === routerStates.DISPOSED;\n  }\n\n  isTransitioning(): boolean {\n    const state = this.#fsm.getState();\n\n    return (\n      state === routerStates.TRANSITION_STARTED ||\n      state === routerStates.LEAVE_APPROVED\n    );\n  }\n\n  isLeaveApproved(): boolean {\n    return this.#fsm.getState() === routerStates.LEAVE_APPROVED;\n  }\n\n  isReady(): boolean {\n    return this.#fsm.getState() === routerStates.READY;\n  }\n\n  isStarting(): boolean {\n    return this.#fsm.getState() === routerStates.STARTING;\n  }\n\n  isIdle(): boolean {\n    return this.#fsm.getState() === routerStates.IDLE;\n  }\n\n  /**\n   * Plugin-author API for subscribing to internal router events.\n   *\n   * @remarks\n   *\n   * **Duplicate-registration semantics — strict (throws).** Passing the same\n   * callback reference twice for the same event throws\n   * `Error(\"Duplicate listener for ...\")` from the underlying `EventEmitter`.\n   * This is loud-on-misuse by design: plugin code is expected to register\n   * each callback once. The contract differs from {@link subscribe} /\n   * {@link subscribeLeave}, which are end-user surfaces and silently accept\n   * duplicates.\n   */\n  addEventListener<E extends EventName>(\n    eventName: E,\n    cb: Plugin[EventMethodMap[E]],\n  ): Unsubscribe {\n    this.#checkListenerThreshold(eventName, \"addEventListener\");\n\n    return this.#emitter.on(\n      eventName,\n      cb as (...args: RouterEventMap[typeof eventName]) => void,\n    );\n  }\n\n  /**\n   * End-user / UI-binding API for subscribing to successful transitions.\n   *\n   * @remarks\n   *\n   * **Duplicate-registration semantics — independent.** Each call wraps\n   * `listener` in a fresh closure and registers it as a distinct internal\n   * slot. `router.subscribe(fn)` twice produces **two** active subscriptions;\n   * `fn` fires twice per `TRANSITION_SUCCESS`. The returned `Unsubscribe` is\n   * paired with its specific call — invoking it removes exactly that\n   * registration.\n   *\n   * This contract differs from {@link addEventListener} (plugin API, throws\n   * on duplicate). End-user code that wants idempotent registration must\n   * gate itself, e.g. `if (!unsub) unsub = router.subscribe(fn);`.\n   */\n  subscribe(listener: SubscribeFn): Unsubscribe {\n    // Enforce the disposed state HERE, not only on the facade. A reference\n    // bound before dispose() (`const s = router.subscribe.bind(router)`)\n    // bypasses the facade's #markDisposed swap and reaches this method\n    // directly. Without this guard, `emitter.on` would silently re-register a\n    // listener that can never fire (clearAll already ran, FSM is DISPOSED, no\n    // future emit) — a silent no-op / stuck-UI hazard (#946).\n    if (this.isDisposed()) {\n      throw new RouterError(errorCodes.ROUTER_DISPOSED);\n    }\n\n    this.#checkListenerThreshold(events.TRANSITION_SUCCESS, \"subscribe\");\n\n    // `subscribe` is fire-and-forget; the listener's return value is ignored at\n    // the type level (`SubscribeFn` is `=> void`). A void-typed async listener\n    // still returns a rejecting Promise at runtime, so return it to the emitter,\n    // whose central isolation routes the rejection to the same `onListenerError`\n    // sink a sync throw flows through — instead of leaking an `unhandledRejection`\n    // (fatal under `--unhandled-rejections=strict`, the Node 22+ default). This\n    // is #944, now folded into the emitter's central #1412 async isolation — the\n    // former per-site `.catch` here is redundant (symmetric with `subscribeLeave`,\n    // which isolates via `Promise.allSettled`).\n    return this.#emitter.on(\n      events.TRANSITION_SUCCESS,\n      (toState: State, fromState?: State) => {\n        // Return the listener's runtime value to the emitter so its central\n        // isolation catches an async listener's rejection (#944/#1412). Read the\n        // void-typed result into `unknown` first — a returned `void` expression\n        // is forbidden, but returning the read `unknown` is fine.\n        // eslint-disable-next-line @typescript-eslint/no-confusing-void-expression -- read the void-typed listener's runtime value so it can be returned for central async isolation (#944/#1412)\n        const result: unknown = listener({\n          route: toState,\n          previousRoute: fromState,\n        });\n\n        return result;\n      },\n    );\n  }\n\n  /**\n   * End-user / UI-binding API for subscribing to **approved** route departures\n   * (`LEAVE_APPROVED` phase): all `canDeactivate` guards have passed, but the\n   * departure is **tentative, not committed** — an activation (`canActivate`)\n   * guard can still reject (or the target route be removed mid-transition),\n   * leaving the user on the current route (#932). Treat the leave as tentative\n   * for non-idempotent side-effects and use the payload `signal` (which aborts\n   * with the failure reason, #943) to roll back when the navigation does not\n   * commit. Async listeners block the activation phase.\n   *\n   * @remarks\n   *\n   * **Duplicate-registration semantics — independent.** Each call pushes\n   * `listener` onto the internal array; `router.subscribeLeave(fn)` twice\n   * produces two entries and `fn` fires twice per leave. Each returned\n   * `Unsubscribe` is **idempotent** (a `removed` flag, #1349) and removes\n   * exactly ONE entry — the first still matching the reference (`indexOf`\n   * semantic). So a repeated call of one unsubscribe is a true no-op and does\n   * **not** touch the other registration; N subscribes + M *distinct*\n   * unsubscribes leave N − M entries. Which physical entry survives is\n   * irrelevant — the reference is the same.\n   *\n   * Contract differs from {@link addEventListener} (throws on duplicate).\n   * For idempotent *registration* (one active subscription), gate at the call site.\n   */\n  subscribeLeave(listener: LeaveFn): Unsubscribe {\n    // Same disposed-state enforcement as subscribe() (#946): a pre-bound\n    // reference would otherwise push onto #leaveListeners after dispose() and\n    // silently never fire (FSM is DISPOSED, no LEAVE_APPROVE emit).\n    if (this.isDisposed()) {\n      throw new RouterError(errorCodes.ROUTER_DISPOSED);\n    }\n\n    this.#leaveListeners.push(listener);\n\n    // Idempotency flag (#1349), mirroring extendRouter / addInterceptor (#1198).\n    // Without it, a double call would `indexOf(listener)` again and splice a\n    // DUPLICATE registration of the same fn — silently deactivating another\n    // subscriber whose own unsubscribe was never called. The `Unsubscribe`\n    // contract names subscribeLeave as idempotent. (Unlike addInterceptor, the\n    // `idx !== -1` guard stays: `dispose()` empties `#leaveListeners` via\n    // `clearAll`, so an unsubscribe called after dispose reaches this with\n    // idx === -1.)\n    let removed = false;\n\n    return () => {\n      if (removed) {\n        return;\n      }\n\n      removed = true;\n\n      const idx = this.#leaveListeners.indexOf(listener);\n\n      if (idx !== -1) {\n        this.#leaveListeners.splice(idx, 1);\n      }\n    };\n  }\n\n  hasLeaveListeners(): boolean {\n    return this.#leaveListeners.length > 0;\n  }\n\n  /**\n   * True when a plugin listener runs in a PRE-COMMIT transition window where a\n   * synchronous `stop()`/`dispose()` can supersede the in-flight navigation\n   * before it commits — i.e. `onTransitionStart` (TRANSITION_START) or\n   * `onTransitionLeaveApprove` (TRANSITION_LEAVE_APPROVE). (`subscribeLeave` is\n   * tracked separately via `hasLeaveListeners`; `onTransitionSuccess` fires\n   * post-commit and cannot cancel.) Read into the pre-`startTransition` liveness\n   * snapshot so the commit-gate (#1169) fires for these windows too.\n   */\n  hasPreCommitListeners(): boolean {\n    return (\n      this.#emitter.listenerCount(events.TRANSITION_START) > 0 ||\n      this.#emitter.listenerCount(events.TRANSITION_LEAVE_APPROVE) > 0\n    );\n  }\n\n  awaitLeaveListeners(\n    toState: State,\n    fromState: State | undefined,\n    signal: AbortSignal,\n  ): Promise<void> | undefined {\n    if (fromState === undefined) {\n      return undefined;\n    }\n\n    // Freeze the payload wrapper so listeners cannot mutate it (`payload.route`\n    // is already deep-frozen via the State immutability invariant; this closes\n    // the wrapper-mutation gap surfaced by audit `probe-05-payload-frozen`).\n    const leaveState: LeaveState = Object.freeze({\n      route: fromState,\n      nextRoute: toState,\n      signal,\n    });\n\n    let promises: Promise<void>[] | undefined;\n    let firstSyncError: unknown;\n\n    // Snapshot before iteration — a listener that reentrantly calls\n    // `subscribeLeave(newFn)` or its own `unsubscribe()` must not affect the\n    // current emit cycle. Symmetric with the EventEmitter snapshot invariant\n    // (PR #666 / #659).\n    const snapshot = [...this.#leaveListeners];\n\n    // Elevated across the SYNC leave-listener dispatch: `isProcessing()` reads\n    // it, so a sync subscribeLeave listener that calls navigate() is rejected\n    // with REENTRANT_NAVIGATION at the facade (RFC §4). The `finally` restores it\n    // before any async tail (returned promise) runs, so a DEFERRED navigate from\n    // an async listener (after its first `await`) sees depth 0 and is allowed.\n    this.#dispatchDepth++;\n\n    try {\n      for (const listener of snapshot) {\n        try {\n          const result = listener(leaveState);\n\n          if (result !== undefined && typeof result.then === \"function\") {\n            promises ??= [];\n            promises.push(result);\n          }\n        } catch (error: unknown) {\n          if (firstSyncError === undefined) {\n            firstSyncError = error;\n          }\n        }\n      }\n    } finally {\n      this.#dispatchDepth--;\n    }\n\n    if (promises === undefined) {\n      if (firstSyncError !== undefined) {\n        throw ensureError(firstSyncError);\n      }\n\n      return undefined;\n    }\n\n    return settleLeavePromises(promises, firstSyncError, signal);\n  }\n\n  clearAll(): void {\n    this.#emitter.clearAll();\n    this.#leaveListeners.length = 0;\n  }\n\n  setLimits(limits: { maxListeners: number; warnListeners: number }): void {\n    this.#emitter.setLimits(limits);\n  }\n\n  /**\n   * Injects the lazy validator accessor (wireNamespaces), mirroring\n   * `PluginsNamespace` / `RouteLifecycleNamespace`. The closure reads the live\n   * `RouterInternals.validator`, so a validation-plugin registered AFTER wiring\n   * is still observed on the next `subscribe` / `addEventListener`.\n   */\n  setValidatorAccessor(getValidator: () => RouterValidator | null): void {\n    this.#getValidator = getValidator;\n  }\n\n  // Single guarded entry point for routing a cancel into the FSM `CANCEL` action\n  // — used by every source: stop/dispose (RouterLifecycle) pass no reason;\n  // supersede / external `opts.signal` (via the wiring `cancelNavigation` dep)\n  // pass the abort reason (#943). `canCancel()` makes it a no-op outside a\n  // cancellable FSM state (#1034: was a second, unguarded `cancelNavigation` path).\n  sendCancelIfPossible(fromState: State | undefined, reason?: unknown): void {\n    const toState = this.#currentToState;\n\n    if (!this.canCancel() || toState === undefined) {\n      return;\n    }\n\n    this.sendCancel(toState, fromState, reason);\n  }\n\n  /**\n   * Proactive listener-count threshold (#1188) — mirrors the plugins /\n   * lifecycle / dependencies counters. Opt-in: the emitter's per-event count is\n   * read ONLY when the validator is installed, so the bare-core hot path pays\n   * nothing. `count` is the POST-add size (`listenerCount + 1`), matching\n   * `RouteLifecycleNamespace`'s `count + 1`, so warn/error fire exactly when the\n   * new listener reaches the threshold. Core keeps the emitter's bare-`Error`\n   * hard cap; this only surfaces an actionable signal well before it.\n   */\n  #checkListenerThreshold(eventName: EventName, methodName: string): void {\n    const validator = this.#getValidator?.();\n\n    if (validator) {\n      validator.eventBus.validateCountThresholds(\n        this.#emitter.listenerCount(eventName) + 1,\n        eventName,\n        methodName,\n      );\n    }\n  }\n\n  #emitPendingError(): void {\n    this.emitTransitionError(\n      this.#pendingToState,\n      this.#pendingFromState,\n      this.#pendingError as RouterError | undefined,\n    );\n\n    // Clear the pending payload once this FAIL action has consumed it. `#pending*`\n    // is only meaningful in the window between the sendFail()/sendFailSafe() that\n    // sets it and this emit; keeping it afterwards pins a stale State/RouterError\n    // on the instance and leaves an implicit \"valid only in this window\" coupling\n    // (#949). Hygiene only — every consumer overwrites the fields before\n    // re-reading (handleCancel reads what its own sendCancel just set), so there\n    // is no observable behaviour change.\n    this.#pendingToState = undefined;\n    this.#pendingFromState = undefined;\n    this.#pendingError = undefined;\n  }\n\n  #setupFSMActions(): void {\n    const fsm = this.#fsm;\n\n    fsm.on(routerStates.STARTING, routerEvents.STARTED, () => {\n      this.emitRouterStart();\n    });\n\n    fsm.on(routerStates.READY, routerEvents.STOP, () => {\n      this.emitRouterStop();\n    });\n\n    // NAVIGATE / LEAVE_APPROVE / COMPLETE emit their transition event as the FSM\n    // action (payload = the transition states), so `send()` from an invalid\n    // state (e.g. COMPLETE from IDLE after a listener's stop()/dispose()) is a\n    // table no-op that emits nothing — the FSM table is the sole authority over\n    // state, no `forceState` resurrection (#1169 D-full). NAVIGATE fires from\n    // READY plus the TRANSITION_STARTED / LEAVE_APPROVED self-loops (supersede).\n    const emitNavigate = (payload: RouterPayloads[\"NAVIGATE\"]): void => {\n      this.emitTransitionStart(payload.toState, payload.fromState);\n    };\n\n    fsm.on(routerStates.READY, routerEvents.NAVIGATE, emitNavigate);\n    fsm.on(\n      routerStates.TRANSITION_STARTED,\n      routerEvents.NAVIGATE,\n      emitNavigate,\n    );\n    fsm.on(routerStates.LEAVE_APPROVED, routerEvents.NAVIGATE, emitNavigate);\n\n    fsm.on(\n      routerStates.TRANSITION_STARTED,\n      routerEvents.LEAVE_APPROVE,\n      (payload) => {\n        this.emitTransitionLeaveApprove(payload.toState, payload.fromState);\n      },\n    );\n\n    fsm.on(routerStates.LEAVE_APPROVED, routerEvents.COMPLETE, (payload) => {\n      this.emitTransitionSuccess(\n        payload.toState,\n        payload.fromState,\n        payload.opts,\n      );\n    });\n\n    const handleCancel = () => {\n      const toState = this.#pendingToState;\n      const reason = this.#pendingCancelReason;\n\n      this.#pendingCancelReason = undefined;\n\n      // (RFC navigation-cancellation-unification §5): the FSM CANCEL\n      // action OWNS the abort. Aborting the in-flight controller wakes the parked\n      // async pipeline (#1018) and rejects navigate() — the post-race local\n      // isActive() sees signal.aborted; `reason` surfaces as the leave signal's\n      // reason (#943). Order: (i) abort (wake) then (ii) emit TRANSITION_CANCEL.\n      // No cycle: onInternalAbort is wake-only, it does not re-enter cancel.\n      this.#abortController(reason);\n\n      /* v8 ignore next -- @preserve: #pendingToState guaranteed set by sendCancel before send() */\n      if (toState === undefined) {\n        return;\n      }\n\n      this.emitTransitionCancel(toState, this.#pendingFromState);\n    };\n\n    fsm.on(routerStates.TRANSITION_STARTED, routerEvents.CANCEL, handleCancel);\n    fsm.on(routerStates.LEAVE_APPROVED, routerEvents.CANCEL, handleCancel);\n\n    fsm.on(routerStates.LEAVE_APPROVED, routerEvents.FAIL, () => {\n      this.#emitPendingError();\n    });\n\n    fsm.on(routerStates.STARTING, routerEvents.FAIL, () => {\n      this.#emitPendingError();\n    });\n\n    fsm.on(routerStates.READY, routerEvents.FAIL, () => {\n      this.#emitPendingError();\n    });\n\n    fsm.on(routerStates.TRANSITION_STARTED, routerEvents.FAIL, () => {\n      this.#emitPendingError();\n    });\n  }\n}\n"],"mappings":"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"}

package/dist/cjs/namespaces/NavigationNamespace/NavigationNamespace.js

@@ -0,0 +1,2 @@
+const e=require("../../constants.js"),t=require("../../stateMetaStore.js"),n=require("../../transitionPath.js"),r=require("../../RouterError.js"),i=require("./constants.js"),a=require("./transition/completeTransition.js"),o=require("./transition/errorHandling.js"),s=require("./transition/guardPhase.js"),c=Object.freeze([e.constants.UNKNOWN_ROUTE]),l=Object.freeze({replace:!0});function u(t,n){return n?.name===e.constants.UNKNOWN_ROUTE&&!t.replace?{...t,replace:!0}:t}function d(e,t,n){return!!e&&!t.reload&&!t.force&&e.path===n.path}var f=class{lastSyncResolved=!1;lastSyncRejected=!1;#e;#t=null;#n=0;setDependencies(e){this.#e=e}navigate(e,t,n){this.lastSyncResolved=!1;let r=this.#e;if(!r.canNavigate())return this.lastSyncRejected=!0,i.CACHED_NOT_STARTED_REJECTION;let a;try{a=r.buildNavigateState(e,t)}catch(e){return Promise.reject(e)}return a?this.#r(a,n):(r.emitTransitionError(void 0,r.getState(),i.CACHED_ROUTE_NOT_FOUND_ERROR),this.lastSyncRejected=!0,i.CACHED_ROUTE_NOT_FOUND_REJECTION)}navigateToState(n,a){this.lastSyncResolved=!1;let o=this.#e;if(!o.canNavigate())return this.lastSyncRejected=!0,i.CACHED_NOT_STARTED_REJECTION;if(n.name!==e.constants.UNKNOWN_ROUTE&&!o.hasRoute(n.name)){let t=new r.RouterError(e.errorCodes.ROUTE_NOT_FOUND,{routeName:n.name});return o.emitTransitionError(void 0,o.getState(),t),Promise.reject(t)}let s={name:n.name,params:n.params,path:n.path,context:{...n.context}},c=t.getStateMetaParams(n);return c!==void 0&&t.setStateMetaParams(s,c),this.#r(s,a)}navigateToDefault(t){this.lastSyncResolved=!1;let n=this.#e;if(!n.getOptions().defaultRoute)return Promise.reject(new r.RouterError(e.errorCodes.ROUTE_NOT_FOUND,{routeName:`defaultRoute not configured`}));let i,a;try{({route:i,params:a}=n.resolveDefault())}catch(e){return Promise.reject(e)}return i?this.navigate(i,a,t):Promise.reject(new r.RouterError(e.errorCodes.ROUTE_NOT_FOUND,{routeName:`defaultRoute resolved to empty`}))}navigateToNotFound(t){if(!this.#e.isActive())throw new r.RouterError(e.errorCodes.ROUTER_DISPOSED);this.#c();let i=this.#e.getState(),a=i?n.nameToIDs(i.name).toReversed():[];Object.freeze(a);let o={deactivated:a,activated:c,intersection:``};Object.freeze(o);let s={phase:`activating`,...i&&{from:i.name},reason:`success`,replace:!0,segments:o};Object.freeze(s);let u={name:e.constants.UNKNOWN_ROUTE,params:e.EMPTY_PARAMS,path:t,transition:s,context:{}};return Object.freeze(u),this.#e.setState(u),this.#e.emitTransitionSuccess(u,i,l),u}abortCurrentController(t){this.#t?.abort(t??new r.RouterError(e.errorCodes.TRANSITION_CANCELLED)),this.#t=null}#r(t,o){let c=this.#e,l,f=!1,p=null;try{if(l=c.getState(),o=u(o,l),d(l,o,t))return c.emitTransitionError(t,l,i.CACHED_SAME_STATES_ERROR),this.lastSyncRejected=!0,i.CACHED_SAME_STATES_REJECTION;this.#c(o.signal);let m=++this.#n,h=o.signal!==void 0||c.hasLeaveListeners()||c.hasPreCommitListeners();c.startTransition(t,l),f=!0;let[g,_]=c.getLifecycleFunctions(),v=t.name===e.constants.UNKNOWN_ROUTE,y=n.getTransitionPath(t,l),{toDeactivate:b,toActivate:x,intersection:S}=y,C=l&&!o.forceDeactivate&&b.length>0,w=!v&&x.length>0,T=g.size>0||_.size>0,E=t;if(!T){let e=this.#o(E,l,m,o,y,g);if(e!==void 0)return e}if(T){p=new AbortController,this.#t=p;let n=()=>this.#n===m&&c.isActive(),i=p.signal,a=s.executeGuardPipeline(g,_,b,x,!!C,w,t,l,i,n,()=>{if(c.sendLeaveApprove(E,l),c.hasLeaveListeners())return c.awaitLeaveListeners(E,l,i)});if(a!==void 0)return this.#i(a,{toState:t,fromState:l,opts:o,toDeactivate:b,toActivate:x,intersection:S,canDeactivateFunctions:g},p,m);if(!n())throw new r.RouterError(e.errorCodes.TRANSITION_CANCELLED);this.#s(p,!1)}if(h&&(!c.isActive()||o.signal?.aborted===!0))throw new r.RouterError(e.errorCodes.TRANSITION_CANCELLED);let D=a.completeTransition(c,{toState:t,fromState:l,opts:o,toDeactivate:b,toActivate:x,intersection:S,canDeactivateFunctions:g});return this.lastSyncResolved=!0,Promise.resolve(D)}catch(e){return this.#a(e,p,f,t,l),Promise.reject(e)}}async#i(t,n,i,s){let c=this.#e,l=()=>this.#n===s&&!i.signal.aborted&&c.isActive(),u=n.opts.signal,d,f,p=!1,m,h=new Promise(e=>{if(i.signal.aborted){e();return}f=()=>{e()},i.signal.addEventListener(`abort`,f,{once:!0})});t.catch(()=>{});try{if(u){if(u.aborted)throw new r.RouterError(e.errorCodes.TRANSITION_CANCELLED,{reason:u.reason});d=()=>{c.cancelNavigation(u.reason)},u.addEventListener(`abort`,d,{once:!0})}if(await Promise.race([t,h]),!l())throw new r.RouterError(e.errorCodes.TRANSITION_CANCELLED);let i=a.completeTransition(c,n);return p=!0,i}catch(e){throw m=e,o.routeTransitionError(c,e,n.toState,n.fromState),e}finally{d&&u?.removeEventListener(`abort`,d),f&&i.signal.removeEventListener(`abort`,f),this.#s(i,!p,m)}}#a(e,t,n,r,i){t&&this.#s(t,!0,e),n&&r&&o.routeTransitionError(this.#e,e,r,i)}#o(e,t,n,r,i,a){let o=this.#e;if(o.sendLeaveApprove(e,t),o.hasLeaveListeners()){let s=new AbortController;this.#t=s;let c;try{c=o.awaitLeaveListeners(e,t,s.signal)}catch(e){throw this.#s(s,!0,e),e}if(c!==void 0)return this.#i(c,{toState:e,fromState:t,opts:r,toDeactivate:i.toDeactivate,toActivate:i.toActivate,intersection:i.intersection,canDeactivateFunctions:a},s,n);this.#s(s,!1);return}}#s(e,t,n){t&&e.abort(n),this.#t===e&&(this.#t=null)}#c(t){if(this.#e.isTransitioning()&&(this.#e.logger.warn(`router.navigate`,`Concurrent navigation detected on shared router instance. For SSR, use cloneRouter() to create isolated instance per request.`),this.#e.cancelNavigation()),t?.aborted)throw new r.RouterError(e.errorCodes.TRANSITION_CANCELLED,{reason:t.reason})}};exports.NavigationNamespace=f;
+//# sourceMappingURL=NavigationNamespace.js.map