@real-router/core 0.79.0 → 0.80.0

package/dist/cjs/foundation/logger/RouterLogger.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"RouterLogger.js","names":["#config","LEVEL_CONFIGS","#currentThreshold","#writeLog","LOG_LEVELS","#writeToConsole","#invokeCallback","#inCallback","#reportError"],"sources":["../../../../src/foundation/logger/RouterLogger.ts"],"sourcesContent":["// packages/core/src/foundation/logger/RouterLogger.ts\n\nimport { LOG_LEVELS, LEVEL_CONFIGS } from \"./constants\";\n\nimport type {\n  LogLevel,\n  LoggerConfig,\n  LogLevelConfig,\n  LogCallback,\n} from \"../../types\";\n\n/**\n * Internal config type with required callbackIgnoresLevel\n * (always initialized to false)\n */\ninterface InternalLoggerConfig {\n  level: LogLevelConfig;\n  callback?: LogCallback | undefined;\n  callbackIgnoresLevel: boolean;\n}\n\n/**\n * Logger class for centralized logging with configurable levels and callbacks.\n *\n * Features:\n * - Three log levels: log, warn, error\n * - Configurable threshold filtering (all, warn-error, error-only, none)\n * - Optional callback for custom log processing\n * - Callback can optionally ignore level threshold\n * - Context-based message formatting\n *\n * @example\n * ```ts\n * import { logger } from './Logger';\n *\n * // Configure logger\n * logger.configure({ level: 'warn-error' });\n *\n * // Use logger\n * logger.log('Router', 'Navigation started'); // Won't show (below threshold)\n * logger.warn('Router', 'Deprecated API used'); // Will show\n * ```\n */\nexport class RouterLogger {\n  /** Internal configuration storage using private field */\n  readonly #config: InternalLoggerConfig = {\n    level: \"all\",\n    callbackIgnoresLevel: false,\n  };\n\n  /** Cached numeric threshold value for performance (avoids repeated lookups) */\n  #currentThreshold = 0;\n\n  /**\n   * Re-entrancy guard: true while a user callback is executing. Prevents a\n   * callback that itself calls `logger.*` from recursing back through\n   * `#invokeCallback` (which would otherwise spin ~5.9k deep until a swallowed\n   * RangeError, see #791). Console output is unaffected.\n   */\n  #inCallback = false;\n\n  /**\n   * @param config - Optional initial configuration (level / callback /\n   *   callbackIgnoresLevel), applied once at construction.\n   *\n   * Each router owns its own `RouterLogger` instance, built from\n   * `options.logger` in the `Router` constructor. This replaces the former\n   * process-global singleton whose `configure()` leaked across every router in\n   * the process — the last `createRouter` won (#724).\n   */\n  constructor(config?: Partial<LoggerConfig>) {\n    if (config) {\n      this.configure(config);\n    }\n  }\n\n  /**\n   * Configures the logger with new settings.\n   *\n   * @param config - Partial configuration to merge with existing config\n   * @param config.level - Minimum log level to output ('all' | 'warn-error' | 'error-only' | 'none')\n   * @param config.callback - Optional callback function to receive log messages\n   * @param config.callbackIgnoresLevel - If true, callback receives all messages regardless of level\n   *\n   * @example\n   * ```ts\n   * // Set minimum level to warnings\n   * logger.configure({ level: 'warn-error' });\n   *\n   * // Add custom callback that ignores level\n   * logger.configure({\n   *   callback: (level, context, message) => {\n   *     sendToAnalytics({ level, context, message });\n   *   },\n   *   callbackIgnoresLevel: true\n   * });\n   * ```\n   */\n  configure(config: Partial<LoggerConfig>): void {\n    // Read each field ONCE into a local — an unstable getter must not be re-read\n    // between validation and storage: re-reading could pass validation with a\n    // valid level and then store a later, unvalidated one, disabling the\n    // threshold filter (a TOCTOU, #1162).\n    const level = config.level;\n\n    if (level !== undefined) {\n      // Validate that the provided level is a valid configuration level\n      if (!Object.hasOwn(LEVEL_CONFIGS, level)) {\n        throw new Error(\n          `Invalid log level: \"${level}\". Valid levels are: ${Object.keys(LEVEL_CONFIGS).join(\", \")}`,\n        );\n      }\n\n      this.#config.level = level;\n      this.#currentThreshold = LEVEL_CONFIGS[level];\n    }\n    if (Object.hasOwn(config, \"callback\")) {\n      this.#config.callback = config.callback;\n    }\n\n    const callbackIgnoresLevel = config.callbackIgnoresLevel;\n\n    if (callbackIgnoresLevel !== undefined) {\n      this.#config.callbackIgnoresLevel = callbackIgnoresLevel;\n    }\n  }\n\n  /**\n   * Returns the current logger configuration.\n   *\n   * @returns Current configuration object with level, callback, and callbackIgnoresLevel\n   *\n   * @example\n   * ```ts\n   * const config = logger.getConfig();\n   * console.log(config.level); // 'warn'\n   * console.log(config.callbackIgnoresLevel); // false\n   * ```\n   */\n  getConfig(): LoggerConfig {\n    return {\n      level: this.#config.level,\n      callback: this.#config.callback,\n      callbackIgnoresLevel: this.#config.callbackIgnoresLevel,\n    };\n  }\n\n  /**\n   * Logs an informational message at 'log' level.\n   *\n   * This is the lowest severity level. Messages are shown when level is 'all'.\n   *\n   * @param context - Context identifier (e.g., 'Router', 'Plugin')\n   * @param message - Main log message\n   * @param args - Additional arguments to log (objects, arrays, etc.)\n   *\n   * @example\n   * ```ts\n   * logger.log('Router', 'Navigation started', { from: '/home', to: '/about' });\n   * // Output: [Router] Navigation started { from: '/home', to: '/about' }\n   * ```\n   */\n  log(context: string, message: string, ...args: unknown[]): void {\n    this.#writeLog(\"log\", context, message, args);\n  }\n\n  /**\n   * Logs a warning message at 'warn' level.\n   *\n   * Use for deprecation notices, non-critical issues, or potential problems.\n   * Messages are shown when level is 'all' or 'warn-error'.\n   *\n   * @param context - Context identifier (e.g., 'Router', 'Plugin')\n   * @param message - Warning message\n   * @param args - Additional arguments to log\n   *\n   * @example\n   * ```ts\n   * logger.warn('Router', 'Using deprecated API', { method: 'oldNavigate' });\n   * // Output: [Router] Using deprecated API { method: 'oldNavigate' }\n   * ```\n   */\n  warn(context: string, message: string, ...args: unknown[]): void {\n    this.#writeLog(\"warn\", context, message, args);\n  }\n\n  /**\n   * Logs an error message at 'error' level.\n   *\n   * Use for critical errors, exceptions, or failures that require attention.\n   * Messages are shown when level is 'all', 'warn-error', or 'error-only'.\n   *\n   * @param context - Context identifier (e.g., 'Router', 'Plugin')\n   * @param message - Error message\n   * @param args - Additional arguments to log (often error objects)\n   *\n   * @example\n   * ```ts\n   * logger.error('Router', 'Navigation failed', new Error('Route not found'));\n   * // Output: [Router] Navigation failed Error: Route not found\n   * ```\n   */\n  error(context: string, message: string, ...args: unknown[]): void {\n    this.#writeLog(\"error\", context, message, args);\n  }\n\n  /**\n   * Central logging method that coordinates console output and callback invocation.\n   *\n   * This method implements the core logging logic:\n   * 1. Early exit optimization for 'none' level (unless callback ignores level)\n   * 2. Level threshold comparison for console output filtering\n   * 3. Delegates to #writeToConsole and #invokeCallback\n   *\n   * @param level - Log level ('log' | 'warn' | 'error')\n   * @param context - Context identifier\n   * @param message - Log message\n   * @param args - Additional arguments\n   *\n   * @private\n   */\n  #writeLog(\n    level: LogLevel,\n    context: string,\n    message: string,\n    args: unknown[],\n  ): void {\n    // Early exit optimization: if level is 'none' and callback doesn't ignore level,\n    // skip all processing (both console and callback)\n    // Stryker disable next-line BlockStatement: equivalent — emptying this early-exit block falls through, but at level \"none\" the downstream guards already yield no output: #writeToConsole skips (threshold 3 > every message level) and #invokeCallback returns (this branch runs only when callbackIgnoresLevel is false). Pure perf shortcut; the ConditionalExpression →true sibling on this line stays killed (not silenced here).\n    if (this.#config.level === \"none\" && !this.#config.callbackIgnoresLevel) {\n      return;\n    }\n\n    // Convert message level to numeric value for threshold comparison\n    // LOG_LEVELS: { log: 0, warn: 1, error: 2 }\n    const messageLevelValue = LOG_LEVELS[level];\n\n    // Determine if this message should skip console output\n    // Example: if threshold is 'warn' (1), then 'log' messages (0) are skipped\n    const shouldSkipConsole = messageLevelValue < this.#currentThreshold;\n\n    // Console output (respects level threshold)\n    if (!shouldSkipConsole) {\n      this.#writeToConsole(level, context, message, args);\n    }\n\n    // Callback handling (may ignore level threshold based on config)\n    this.#invokeCallback(level, context, message, shouldSkipConsole, args);\n  }\n\n  /**\n   * Writes a formatted log message to the console.\n   *\n   * Features:\n   * - Formats message with context: \"[Context] message\"\n   * - Uses appropriate console method (log/warn/error)\n   * - Safe: checks for console existence (for non-browser environments)\n   *\n   * @param level - Console method to use ('log' | 'warn' | 'error')\n   * @param context - Context identifier (prepended to message if present)\n   * @param message - Log message\n   * @param args - Additional arguments to pass to console\n   *\n   * @private\n   */\n  #writeToConsole(\n    level: LogLevel,\n    context: string,\n    message: string,\n    args: unknown[],\n  ): void {\n    // Safety check: ensure console exists and has the required method\n    // This is important for environments like Node.js tests or edge cases\n    if (\n      typeof console !== \"undefined\" &&\n      typeof console[level] === \"function\"\n    ) {\n      // Format message with context bracket notation for visual clarity\n      // Note: formatting is done inside the check to avoid unnecessary string allocation\n      // when console is not available\n      const formattedMessage = context ? `[${context}] ${message}` : message;\n\n      console[level](formattedMessage, ...args);\n    }\n  }\n\n  /**\n   * Invokes the configured callback with log data, respecting level settings.\n   *\n   * Complex logic handling:\n   * 1. Skip if no callback configured\n   * 2. Skip if callback respects level AND message is below threshold\n   * 3. Call callback with error handling (prevents callback errors from breaking logger)\n   *\n   * The callbackIgnoresLevel flag enables two modes:\n   * - false (default): callback only receives messages that pass threshold (same as console)\n   * - true: callback receives ALL messages regardless of threshold (useful for analytics)\n   *\n   * @param level - Log level\n   * @param context - Context identifier\n   * @param message - Log message\n   * @param shouldSkipConsole - Whether console output was skipped (used for level logic)\n   * @param args - Additional arguments\n   *\n   * @private\n   */\n  #invokeCallback(\n    level: LogLevel,\n    context: string,\n    message: string,\n    shouldSkipConsole: boolean,\n    args: unknown[],\n  ): void {\n    // Early exit: no callback configured, or callback respects level and message is filtered\n    if (\n      !this.#config.callback ||\n      (!this.#config.callbackIgnoresLevel && shouldSkipConsole)\n    ) {\n      return;\n    }\n\n    // Re-entrancy guard: a callback calling logger.* re-enters here via\n    // #writeLog → #invokeCallback. Skip the nested invocation so the pattern is\n    // a safe no-op (console output already happened in #writeLog) instead of\n    // recursing to a swallowed RangeError (#791).\n    if (this.#inCallback) {\n      return;\n    }\n\n    // Wrap callback invocation in try-catch to prevent user code errors\n    // from breaking the logger or causing cascading failures\n    this.#inCallback = true;\n    try {\n      // An async callback (`(...) => Promise<void>` is assignable to the\n      // void-typed LogCallback) returns a Promise whose rejection would otherwise\n      // leak as a Node `unhandledRejection` — process-fatal under\n      // `--unhandled-rejections=strict` (Node 22+ default). Read the runtime\n      // return and isolate it like core's subscribe (#944): duck-check the\n      // thenable + `.catch` into the same console.error sink a sync throw uses\n      // (#1161).\n      // eslint-disable-next-line @typescript-eslint/no-confusing-void-expression -- read the runtime Promise of a void-typed async callback (#1161)\n      const result: unknown = this.#config.callback(\n        level,\n        context,\n        message,\n        ...args,\n      );\n\n      if (\n        result !== null &&\n        result !== undefined &&\n        typeof (result as PromiseLike<unknown>).then === \"function\"\n      ) {\n        Promise.resolve(result as PromiseLike<unknown>).catch(\n          (error: unknown) => {\n            this.#reportError(\"[Logger] Error in async callback:\", error);\n          },\n        );\n      }\n    } catch (error) {\n      // Fallback error reporting if the callback throws synchronously\n      this.#reportError(\"[Logger] Error in callback:\", error);\n    } finally {\n      this.#inCallback = false;\n    }\n  }\n\n  // Report a callback error via console.error directly — never call the logger\n  // (would recurse). Shared by the sync-throw catch and the async-rejection\n  // `.catch` (#1161). Console-safety guard mirrors #writeToConsole.\n  #reportError(message: string, error: unknown): void {\n    if (typeof console !== \"undefined\" && typeof console.error === \"function\") {\n      console.error(message, error);\n    }\n  }\n}\n"],"mappings":"kCA2CA,IAAa,EAAb,KAA0B,CAExB,GAAyC,CACvC,MAAO,MACP,qBAAsB,EACxB,EAGA,GAAoB,EAQpB,GAAc,GAWd,YAAY,EAAgC,CACtC,GACF,KAAK,UAAU,CAAM,CAEzB,CAwBA,UAAU,EAAqC,CAK7C,IAAM,EAAQ,EAAO,MAErB,GAAI,IAAU,IAAA,GAAW,CAEvB,GAAI,CAAC,OAAO,OAAOC,EAAAA,cAAe,CAAK,EACrC,MAAU,MACR,uBAAuB,EAAM,uBAAuB,OAAO,KAAKA,EAAAA,aAAa,CAAC,CAAC,KAAK,IAAI,GAC1F,EAGF,KAAKD,GAAQ,MAAQ,EACrB,KAAKE,GAAoBD,EAAAA,cAAc,EACzC,CACI,OAAO,OAAO,EAAQ,UAAU,IAClC,KAAKD,GAAQ,SAAW,EAAO,UAGjC,IAAM,EAAuB,EAAO,qBAEhC,IAAyB,IAAA,KAC3B,KAAKA,GAAQ,qBAAuB,EAExC,CAcA,WAA0B,CACxB,MAAO,CACL,MAAO,KAAKA,GAAQ,MACpB,SAAU,KAAKA,GAAQ,SACvB,qBAAsB,KAAKA,GAAQ,oBACrC,CACF,CAiBA,IAAI,EAAiB,EAAiB,GAAG,EAAuB,CAC9D,KAAKG,GAAU,MAAO,EAAS,EAAS,CAAI,CAC9C,CAkBA,KAAK,EAAiB,EAAiB,GAAG,EAAuB,CAC/D,KAAKA,GAAU,OAAQ,EAAS,EAAS,CAAI,CAC/C,CAkBA,MAAM,EAAiB,EAAiB,GAAG,EAAuB,CAChE,KAAKA,GAAU,QAAS,EAAS,EAAS,CAAI,CAChD,CAiBA,GACE,EACA,EACA,EACA,EACM,CAIN,GAAI,KAAKH,GAAQ,QAAU,QAAU,CAAC,KAAKA,GAAQ,qBACjD,OASF,IAAM,EAJoBI,EAAAA,WAAW,GAIS,KAAKF,GAG9C,GACH,KAAKG,GAAgB,EAAO,EAAS,EAAS,CAAI,EAIpD,KAAKC,GAAgB,EAAO,EAAS,EAAS,EAAmB,CAAI,CACvE,CAiBA,GACE,EACA,EACA,EACA,EACM,CAGN,GACE,OAAO,QAAY,KACnB,OAAO,QAAQ,IAAW,WAC1B,CAIA,IAAM,EAAmB,EAAU,IAAI,EAAQ,IAAI,IAAY,EAE/D,QAAQ,EAAM,CAAC,EAAkB,GAAG,CAAI,CAC1C,CACF,CAsBA,GACE,EACA,EACA,EACA,EACA,EACM,CAGJ,MAAC,KAAKN,GAAQ,UACb,CAAC,KAAKA,GAAQ,sBAAwB,IASrC,MAAKO,GAMT,MAAKA,GAAc,GACnB,GAAI,CASF,IAAM,EAAkB,KAAKP,GAAQ,SACnC,EACA,EACA,EACA,GAAG,CACL,EAGE,GAAW,MAEX,OAAQ,EAAgC,MAAS,YAEjD,QAAQ,QAAQ,CAA8B,CAAC,CAAC,MAC7C,GAAmB,CAClB,KAAKQ,GAAa,oCAAqC,CAAK,CAC9D,CACF,CAEJ,OAAS,EAAO,CAEd,KAAKA,GAAa,8BAA+B,CAAK,CACxD,QAAU,CACR,KAAKD,GAAc,EACrB,CAjCmB,CAkCrB,CAKA,GAAa,EAAiB,EAAsB,CAC9C,OAAO,QAAY,KAAe,OAAO,QAAQ,OAAU,YAC7D,QAAQ,MAAM,EAAS,CAAK,CAEhC,CACF"}

package/dist/cjs/foundation/logger/constants.js

@@ -0,0 +1,2 @@
+const e=Object.freeze({log:0,warn:1,error:2}),t=Object.freeze({all:0,"warn-error":1,"error-only":2,none:3});exports.LEVEL_CONFIGS=t,exports.LOG_LEVELS=e;
+//# sourceMappingURL=constants.js.map

package/dist/cjs/foundation/logger/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.js","names":[],"sources":["../../../../src/foundation/logger/constants.ts"],"sourcesContent":["import type { LogLevel, LogLevelConfig } from \"../../types\";\n\n/**\n * Numeric mapping for log message severity levels.\n *\n * Maps each severity level to a numeric value for threshold comparison.\n * Lower values = lower severity, higher values = higher severity.\n *\n * Used internally to determine if a message should be filtered based on\n * the configured threshold level.\n *\n * Mapping:\n * - `log`: 0 (lowest severity - informational)\n * - `warn`: 1 (medium severity - warnings)\n * - `error`: 2 (highest severity - critical errors)\n *\n * @example\n * ```ts\n * const messageLevel = LOG_LEVELS['warn'];  // 1\n * const threshold = 2;  // error-only\n * const shouldFilter = messageLevel < threshold;  // true (warn is filtered)\n * ```\n *\n * @internal This is used for internal filtering logic\n */\nexport const LOG_LEVELS: Record<LogLevel, number> = Object.freeze({\n  log: 0,\n  warn: 1,\n  error: 2,\n});\n\n/**\n * Numeric thresholds for logger configuration levels.\n *\n * Maps each configuration level to a minimum threshold value.\n * Messages with a severity level below this threshold are filtered out.\n *\n * Threshold logic:\n * - A message is shown if: `LOG_LEVELS[messageLevel] >= LEVEL_CONFIGS[configLevel]`\n * - Higher threshold value = stricter filtering = fewer messages shown\n *\n * Mapping:\n * - `all`: 0 (no filtering - show everything)\n *   - Shows: log (0), warn (1), error (2) ✓\n * - `warn-error`: 1 (filter log messages)\n *   - Shows: warn (1), error (2) ✓\n *   - Filters: log (0) ✗\n * - `error-only`: 2 (filter log and warn messages)\n *   - Shows: error (2) ✓\n *   - Filters: log (0), warn (1) ✗\n * - `none`: 3 (filter all messages - complete silence)\n *   - Filters: log (0), warn (1), error (2) ✗\n *\n * @example\n * ```ts\n * // Configuration: warn-error\n * const threshold = LEVEL_CONFIGS['warn-error'];  // 1\n *\n * // Check if 'log' message should be shown\n * LOG_LEVELS['log'] >= threshold  // 0 >= 1 = false (filtered)\n *\n * // Check if 'warn' message should be shown\n * LOG_LEVELS['warn'] >= threshold  // 1 >= 1 = true (shown)\n *\n * // Check if 'error' message should be shown\n * LOG_LEVELS['error'] >= threshold  // 2 >= 1 = true (shown)\n * ```\n *\n * @internal This is used for internal threshold comparison\n */\nexport const LEVEL_CONFIGS: Record<LogLevelConfig, number> = Object.freeze({\n  all: 0,\n  \"warn-error\": 1,\n  \"error-only\": 2,\n  none: 3,\n});\n"],"mappings":"AAyBA,MAAa,EAAuC,OAAO,OAAO,CAChE,IAAK,EACL,KAAM,EACN,MAAO,CACT,CAAC,EAyCY,EAAgD,OAAO,OAAO,CACzE,IAAK,EACL,aAAc,EACd,aAAc,EACd,KAAM,CACR,CAAC"}

package/dist/cjs/getNavigator.d.ts

@@ -0,0 +1,6 @@
+import { DefaultDependencies, Navigator, Router } from "./types/router.js";
+//#region src/getNavigator.d.ts
+declare const getNavigator: <Dependencies extends DefaultDependencies = DefaultDependencies>(router: Router<Dependencies>) => Navigator;
+//#endregion
+export { getNavigator };
+//# sourceMappingURL=getNavigator.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"getNavigator.d.ts","names":[],"sources":["../../src/getNavigator.ts"],"mappings":";;cAIa,eACX,qBAAqB,sBAAsB,qBAE3C,QAAQ,OAAO,kBACd"}

package/dist/cjs/getNavigator.js

@@ -0,0 +1,2 @@
+const e=new WeakMap,t=t=>{let n=e.get(t);return n||(n=Object.freeze({navigate:t.navigate,getState:t.getState,isActiveRoute:t.isActiveRoute,canNavigateTo:t.canNavigateTo,subscribe:t.subscribe,subscribeLeave:t.subscribeLeave,isLeaveApproved:t.isLeaveApproved}),e.set(t,n)),n};exports.getNavigator=t;
+//# sourceMappingURL=getNavigator.js.map

package/dist/cjs/getNavigator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"getNavigator.js","names":[],"sources":["../../src/getNavigator.ts"],"sourcesContent":["import type { Navigator, DefaultDependencies, Router } from \"./types\";\n\nconst cache = new WeakMap<Router, Navigator>();\n\nexport const getNavigator = <\n  Dependencies extends DefaultDependencies = DefaultDependencies,\n>(\n  router: Router<Dependencies>,\n): Navigator => {\n  let nav = cache.get(router);\n\n  if (!nav) {\n    nav = Object.freeze({\n      navigate: router.navigate,\n      getState: router.getState,\n      isActiveRoute: router.isActiveRoute,\n      canNavigateTo: router.canNavigateTo,\n      subscribe: router.subscribe,\n      subscribeLeave: router.subscribeLeave,\n      isLeaveApproved: router.isLeaveApproved,\n    } as Navigator);\n    cache.set(router, nav);\n  }\n\n  return nav;\n};\n"],"mappings":"AAEA,MAAM,EAAQ,IAAI,QAEL,EAGX,GACc,CACd,IAAI,EAAM,EAAM,IAAI,CAAM,EAe1B,OAbK,IACH,EAAM,OAAO,OAAO,CAClB,SAAU,EAAO,SACjB,SAAU,EAAO,SACjB,cAAe,EAAO,cACtB,cAAe,EAAO,cACtB,UAAW,EAAO,UAClB,eAAgB,EAAO,eACvB,gBAAiB,EAAO,eAC1B,CAAc,EACd,EAAM,IAAI,EAAQ,CAAG,GAGhB,CACT"}

package/dist/cjs/guards.js

@@ -0,0 +1,2 @@
+function e(e){if(!e||typeof e!=`object`||e.constructor!==Object)throw TypeError(`dependencies must be a plain object`);for(let t in e)if(Object.getOwnPropertyDescriptor(e,t)?.get)throw TypeError(`dependencies cannot contain getters: "${t}"`)}function t(e,n){for(let r of e){let e=r;if(typeof e!=`object`||!e||Array.isArray(e))throw TypeError(`route must be a non-array object`);n?.routes.guardRouteCallbacks(r),n?.routes.guardNoAsyncCallbacks(r);let i=r.children;i&&t(i,n)}}const n=new Set([`all`,`warn-error`,`error-only`,`none`]);function r(e){return typeof e==`string`&&n.has(e)}function i(e){return typeof e==`string`?`"${e}"`:typeof e==`object`?JSON.stringify(e):String(e)}function a(e){if(typeof e!=`object`)throw TypeError(`Logger config must be an object`);let t=e;for(let e of Object.keys(t))if(e!==`level`&&e!==`callback`&&e!==`callbackIgnoresLevel`)throw TypeError(`Unknown logger config property: "${e}"`);if(`level`in t&&t.level!==void 0&&!r(t.level))throw TypeError(`Invalid logger level: ${i(t.level)}. Expected: "all" | "warn-error" | "error-only" | "none"`);if(`callback`in t&&t.callback!==void 0&&typeof t.callback!=`function`)throw TypeError(`Logger callback must be a function, got ${typeof t.callback}`);if(`callbackIgnoresLevel`in t&&t.callbackIgnoresLevel!==void 0&&typeof t.callbackIgnoresLevel!=`boolean`)throw TypeError(`Logger callbackIgnoresLevel must be a boolean, got ${typeof t.callbackIgnoresLevel}`)}exports.assertLoggerConfig=a,exports.guardDependencies=e,exports.guardRouteStructure=t;
+//# sourceMappingURL=guards.js.map

package/dist/cjs/guards.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"guards.js","names":[],"sources":["../../src/guards.ts"],"sourcesContent":["// packages/core/src/guards.ts\n\nimport type { LoggerConfig, LogLevelConfig, Route } from \"./types\";\nimport type { RouterValidator } from \"./types/RouterValidator\";\n\n// ============================================================================\n// Structural invariant guards (dependencies + route-tree shape)\n// ============================================================================\n\nexport function guardDependencies(deps: unknown): void {\n  if (\n    !deps ||\n    typeof deps !== \"object\" ||\n    (deps as { constructor: unknown }).constructor !== Object\n  ) {\n    throw new TypeError(\"dependencies must be a plain object\");\n  }\n  for (const key in deps as Record<string, unknown>) {\n    if (Object.getOwnPropertyDescriptor(deps, key)?.get) {\n      throw new TypeError(`dependencies cannot contain getters: \"${key}\"`);\n    }\n  }\n}\n\n/* eslint-disable @typescript-eslint/no-explicit-any -- accepts any Route type */\nexport function guardRouteStructure(\n  routes: Route<any>[],\n  validator?: RouterValidator | null,\n): void {\n  /* eslint-enable @typescript-eslint/no-explicit-any */\n  for (const route of routes) {\n    const routeValue: unknown = route;\n\n    if (\n      routeValue === null ||\n      typeof routeValue !== \"object\" ||\n      Array.isArray(routeValue)\n    ) {\n      throw new TypeError(\"route must be a non-array object\");\n    }\n\n    validator?.routes.guardRouteCallbacks(route as Route);\n    validator?.routes.guardNoAsyncCallbacks(route as Route);\n    const children = (route as Route).children;\n\n    if (children) {\n      guardRouteStructure(children, validator);\n    }\n  }\n}\n\n// ============================================================================\n// Logger config assertion (RealRouter-specific)\n// ============================================================================\n\nconst VALID_LEVELS_SET = new Set<string>([\n  \"all\",\n  \"warn-error\",\n  \"error-only\",\n  \"none\",\n]);\n\nfunction isValidLevel(value: unknown): value is LogLevelConfig {\n  return typeof value === \"string\" && VALID_LEVELS_SET.has(value);\n}\n\nfunction formatValue(value: unknown): string {\n  if (typeof value === \"string\") {\n    return `\"${value}\"`;\n  }\n  if (typeof value === \"object\") {\n    return JSON.stringify(value);\n  }\n\n  // eslint-disable-next-line @typescript-eslint/no-base-to-string\n  return String(value);\n}\n\nexport function assertLoggerConfig(\n  config: unknown,\n): asserts config is LoggerConfig {\n  if (typeof config !== \"object\") {\n    throw new TypeError(\"Logger config must be an object\");\n  }\n\n  // `typeof null === \"object\"`, so TS still sees `object | null` here — but the\n  // sole caller (Router's ctor) gates on `if (loggerConfig)`, so null/falsy never\n  // arrives; treat it as the non-null object the gate guarantees.\n  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- gated caller never passes null\n  const obj = config!;\n\n  // Check for unknown properties\n  for (const key of Object.keys(obj)) {\n    if (\n      key !== \"level\" &&\n      key !== \"callback\" &&\n      key !== \"callbackIgnoresLevel\"\n    ) {\n      throw new TypeError(`Unknown logger config property: \"${key}\"`);\n    }\n  }\n\n  // Validate level if present\n  if (\"level\" in obj && obj.level !== undefined && !isValidLevel(obj.level)) {\n    throw new TypeError(\n      `Invalid logger level: ${formatValue(obj.level)}. Expected: \"all\" | \"warn-error\" | \"error-only\" | \"none\"`,\n    );\n  }\n\n  // Validate callback if present\n  if (\n    \"callback\" in obj &&\n    obj.callback !== undefined &&\n    typeof obj.callback !== \"function\"\n  ) {\n    throw new TypeError(\n      `Logger callback must be a function, got ${typeof obj.callback}`,\n    );\n  }\n\n  // Validate callbackIgnoresLevel if present (logger.configure does not type-check it)\n  if (\n    \"callbackIgnoresLevel\" in obj &&\n    obj.callbackIgnoresLevel !== undefined &&\n    typeof obj.callbackIgnoresLevel !== \"boolean\"\n  ) {\n    throw new TypeError(\n      `Logger callbackIgnoresLevel must be a boolean, got ${typeof obj.callbackIgnoresLevel}`,\n    );\n  }\n}\n"],"mappings":"AASA,SAAgB,EAAkB,EAAqB,CACrD,GACE,CAAC,GACD,OAAO,GAAS,UACf,EAAkC,cAAgB,OAEnD,MAAU,UAAU,qCAAqC,EAE3D,IAAK,IAAM,KAAO,EAChB,GAAI,OAAO,yBAAyB,EAAM,CAAG,CAAC,EAAE,IAC9C,MAAU,UAAU,yCAAyC,EAAI,EAAE,CAGzE,CAGA,SAAgB,EACd,EACA,EACM,CAEN,IAAK,IAAM,KAAS,EAAQ,CAC1B,IAAM,EAAsB,EAE5B,GAEE,OAAO,GAAe,WADtB,GAEA,MAAM,QAAQ,CAAU,EAExB,MAAU,UAAU,kCAAkC,EAGxD,GAAW,OAAO,oBAAoB,CAAc,EACpD,GAAW,OAAO,sBAAsB,CAAc,EACtD,IAAM,EAAY,EAAgB,SAE9B,GACF,EAAoB,EAAU,CAAS,CAE3C,CACF,CAMA,MAAM,EAAmB,IAAI,IAAY,CACvC,MACA,aACA,aACA,MACF,CAAC,EAED,SAAS,EAAa,EAAyC,CAC7D,OAAO,OAAO,GAAU,UAAY,EAAiB,IAAI,CAAK,CAChE,CAEA,SAAS,EAAY,EAAwB,CAS3C,OARI,OAAO,GAAU,SACZ,IAAI,EAAM,GAEf,OAAO,GAAU,SACZ,KAAK,UAAU,CAAK,EAItB,OAAO,CAAK,CACrB,CAEA,SAAgB,EACd,EACgC,CAChC,GAAI,OAAO,GAAW,SACpB,MAAU,UAAU,iCAAiC,EAOvD,IAAM,EAAM,EAGZ,IAAK,IAAM,KAAO,OAAO,KAAK,CAAG,EAC/B,GACE,IAAQ,SACR,IAAQ,YACR,IAAQ,uBAER,MAAU,UAAU,oCAAoC,EAAI,EAAE,EAKlE,GAAI,UAAW,GAAO,EAAI,QAAU,IAAA,IAAa,CAAC,EAAa,EAAI,KAAK,EACtE,MAAU,UACR,yBAAyB,EAAY,EAAI,KAAK,EAAE,yDAClD,EAIF,GACE,aAAc,GACd,EAAI,WAAa,IAAA,IACjB,OAAO,EAAI,UAAa,WAExB,MAAU,UACR,2CAA2C,OAAO,EAAI,UACxD,EAIF,GACE,yBAA0B,GAC1B,EAAI,uBAAyB,IAAA,IAC7B,OAAO,EAAI,sBAAyB,UAEpC,MAAU,UACR,sDAAsD,OAAO,EAAI,sBACnE,CAEJ"}

package/dist/cjs/helpers.js

@@ -0,0 +1,2 @@
+const e=require("./constants.js");function t(e){return Object.freeze(e)}function n(t={}){return{...e.DEFAULT_LIMITS,...t}}function r(t){if(t===void 0)return t;let n;for(let e in t){if(!Object.hasOwn(t,e))continue;let r=t[e];r!==void 0&&(n??={},n[e]=r)}return n??e.EMPTY_PARAMS}exports.createLimits=n,exports.freezeStateInPlace=t,exports.normalizeParams=r;
+//# sourceMappingURL=helpers.js.map

package/dist/cjs/helpers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.js","names":["DEFAULT_LIMITS","EMPTY_PARAMS"],"sources":["../../src/helpers.ts"],"sourcesContent":["// packages/core/src/helpers.ts\n\nimport { DEFAULT_LIMITS, EMPTY_PARAMS } from \"./constants\";\n\nimport type { Params, State, LimitsConfig } from \"./types\";\nimport type { Limits } from \"./types/internal\";\n\n// =============================================================================\n// State Helpers\n// =============================================================================\n\n/**\n * Shallow-freezes a State object in place.\n *\n * Freezes only the top-level State object (blocks reassignment of `name`,\n * `params`, `path`, `transition`, `context`). Nested objects (`params`,\n * `transition`, `transition.segments`, `transition.segments.{deactivated,activated}`)\n * are expected to be **already frozen at creation time** by their producers:\n *\n * - `params` frozen in `makeState()` / `navigateToNotFound()`\n * - `transition`, `segments`, `deactivated`, `activated` frozen in\n *   `buildTransitionMeta()` (or inline in `navigateToNotFound()`)\n *\n * `state.context` is **intentionally not frozen** — plugins write to it via\n * `claim.write(state, value)` after state creation.\n *\n * @internal\n */\nexport function freezeStateInPlace<T extends State>(state: T): T {\n  // `Object.freeze` returns non-objects (incl. null/undefined) unchanged, so the\n  // former `if (!state) return state` guard was redundant — callers also gate it\n  // (`state ? freezeStateInPlace(state) : undefined`) and `T extends State` is\n  // typed non-null.\n  return Object.freeze(state);\n}\n\n/**\n * Merges user limits with defaults.\n * Returns frozen object for immutability.\n */\nexport function createLimits(userLimits: Partial<LimitsConfig> = {}): Limits {\n  return { ...DEFAULT_LIMITS, ...userLimits };\n}\n\n// =============================================================================\n// Params Helpers\n// =============================================================================\n\n/**\n * Strips `undefined` values from a params object before handoff to the query\n * string engine and state storage.\n *\n * **Why this exists:** `router.navigate(name, { x: undefined })` must not put\n * `x` into the resulting URL (publicly documented contract). The underlying\n * query engine (`search-params`) already does this, but the contract belongs\n * to `@real-router/core` — this function guarantees it at the core boundary\n * so that:\n * - Plugin interceptors on `forwardState` that inject `undefined` values are\n *   caught before they reach the engine\n * - `state.params` never contains `undefined` values (roundtrip consistent\n *   with URL)\n * - The contract is verifiable at core's own test surface (doesn't depend on\n *   engine behavior for regression detection)\n *\n * Single pass. When nothing survives (empty input, or every value `undefined`)\n * it returns the shared frozen `EMPTY_PARAMS` singleton, so `makeState`'s\n * `params === EMPTY_PARAMS` reuse branch fires and an empty-params navigation\n * allocates zero transient `{}` (#1027); a non-empty input returns a fresh\n * object. Either way reference identity is not preserved across calls, and the\n * result MUST be treated as read-only — callers must not mutate it (the empty\n * case is a shared frozen singleton).\n */\nexport function normalizeParams(params: Params): Params;\n\nexport function normalizeParams(params: undefined): undefined;\n\nexport function normalizeParams(params: Params | undefined): Params | undefined;\n\nexport function normalizeParams(\n  params: Params | undefined,\n): Params | undefined {\n  if (params === undefined) {\n    return params;\n  }\n\n  let normalized: Params | undefined;\n\n  for (const key in params) {\n    if (!Object.hasOwn(params, key)) {\n      continue;\n    }\n\n    const value = params[key];\n\n    if (value !== undefined) {\n      // Lazy allocation: an all-empty / all-undefined input costs zero objects.\n      normalized ??= {};\n      normalized[key] = value;\n    }\n  }\n\n  // Reuse the shared singleton when nothing survived so makeState's\n  // `params === EMPTY_PARAMS` reuse branch fires (#1027).\n  return normalized ?? EMPTY_PARAMS;\n}\n"],"mappings":"kCA4BA,SAAgB,EAAoC,EAAa,CAK/D,OAAO,OAAO,OAAO,CAAK,CAC5B,CAMA,SAAgB,EAAa,EAAoC,CAAC,EAAW,CAC3E,MAAO,CAAE,GAAGA,EAAAA,eAAgB,GAAG,CAAW,CAC5C,CAoCA,SAAgB,EACd,EACoB,CACpB,GAAI,IAAW,IAAA,GACb,OAAO,EAGT,IAAI,EAEJ,IAAK,IAAM,KAAO,EAAQ,CACxB,GAAI,CAAC,OAAO,OAAO,EAAQ,CAAG,EAC5B,SAGF,IAAM,EAAQ,EAAO,GAEjB,IAAU,IAAA,KAEZ,IAAe,CAAC,EAChB,EAAW,GAAO,EAEtB,CAIA,OAAO,GAAcC,EAAAA,YACvB"}

package/dist/cjs/index.d.ts

@@ -1,239 +1,17 @@
-import { n as RouteTree } from "./types-DaXCTxi1.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, 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";
+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 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-BRuC-daj.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

@@ -0,0 +1,98 @@
+import { RouteTree } from "./engine/builder/types.js";
+import { RouteTreeState } from "./types/route-node-types.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 { 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  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/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