@real-router/core 0.78.0 → 0.79.1

package/dist/esm/engine/builder/types.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.mts","names":[],"sources":["../../../../src/engine/builder/types.ts"],"mappings":";;;;;UAiBiB;GACd;EACD;EACA;EACA,WAAW;;;;;;;;;;;;UAiBI;;WAIN;;WAGA;;WAGA;;WAGA,UAAU,oBAAoB;;WAG9B,WAAW;;WAKX,QAAQ;;WAGR,8BAA8B;;WAG9B;;;;;;WAOA,cAAc,SAAS"}

package/dist/esm/engine/createMatcher.d.mts

@@ -0,0 +1,29 @@
+import { Options } from "./search-params/types.mjs";
+import { SegmentMatcher } from "./path-matcher/SegmentMatcher.mjs";
+//#region src/engine/createMatcher.d.ts
+/**
+ * Query string formatting options.
+ *
+ * Controls how arrays, booleans, nulls, and numbers are serialized in query strings.
+ */
+type QueryParamsConfig = Readonly<Options>;
+/**
+ * Options for creating a path matcher.
+ */
+interface CreateMatcherOptions {
+  readonly caseSensitive?: boolean;
+  readonly strictTrailingSlash?: boolean;
+  readonly strictQueryParams?: boolean;
+  readonly urlParamsEncoding?: "default" | "uri" | "uriComponent" | "none";
+  readonly queryParams?: QueryParamsConfig;
+}
+/**
+ * Path matcher instance type.
+ *
+ * Opaque type — consumers use methods (match, buildPath, hasRoute, etc.)
+ * without knowing the underlying SegmentMatcher implementation.
+ */
+type Matcher = SegmentMatcher;
+//#endregion
+export { CreateMatcherOptions, Matcher, QueryParamsConfig };
+//# sourceMappingURL=createMatcher.d.mts.map

package/dist/esm/engine/createMatcher.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createMatcher.d.mts","names":[],"sources":["../../../src/engine/createMatcher.ts"],"mappings":";;;;;;;;KAwBY,oBAAoB,SAAS;;;;UAKxB;WACN;WACA;WACA;WACA;WACA,cAAc;;;;;;;;KASb,UAAU"}

package/dist/esm/engine/path-matcher/SegmentMatcher.d.mts

@@ -0,0 +1,16 @@
+import { BuildPathOptions, MatchResult, MatcherInputNode, ResolvedMatcherOptions, SegmentMatcherOptions } from "./types.mjs";
+//#region src/engine/path-matcher/SegmentMatcher.d.ts
+declare class SegmentMatcher {
+  #private;
+  get options(): ResolvedMatcherOptions;
+  constructor(options: SegmentMatcherOptions);
+  registerTree(node: MatcherInputNode): void;
+  match(path: string): MatchResult | undefined;
+  buildPath(name: string, params?: Record<string, unknown>, options?: BuildPathOptions): string;
+  getSegmentsByName(name: string): readonly MatcherInputNode[] | undefined;
+  getMetaByName(name: string): Readonly<Record<string, Record<string, "url" | "query">>> | undefined;
+  hasRoute(name: string): boolean;
+}
+//#endregion
+export { SegmentMatcher };
+//# sourceMappingURL=SegmentMatcher.d.mts.map

package/dist/esm/engine/path-matcher/SegmentMatcher.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SegmentMatcher.d.mts","names":[],"sources":["../../../../src/engine/path-matcher/SegmentMatcher.ts"],"mappings":";;cA6Da;;MACP,WAAW;EA2BH,YAAA,SAAS;EAiBrB,aAAa,MAAM;EAiBnB,MAAM,eAAe;EAqDrB,UACE,cACA,SAAS,yBACT,UAAU;EAmBZ,kBAAkB,wBAAwB;EAO1C,cACE,eACC,SAAS,eAAe;EAI3B,SAAS"}

package/dist/esm/{types-xg2zHVF6.d.mts → engine/path-matcher/types.d.mts}

@@ -6,23 +6,6 @@
  *
  * @module path-matcher/types
  */
-/**
- * Constraint pattern for a URL parameter.
- */
-interface ConstraintPattern {
-  /**
-   * Compiled RegExp for validating the parameter value.
-   *
-   * @example /^(\d+)$/ for constraint "<\\d+>"
-   */
-  readonly pattern: RegExp;
-  /**
-   * Raw constraint string from the route pattern.
-   *
-   * @example "<\\d+>"
-   */
-  readonly constraint: string;
-}
 /**
  * Parameter metadata extracted from a route path pattern.
  */
@@ -51,22 +34,6 @@ interface ParamMeta {
    * @example { id: "url", q: "query" }
    */
   readonly paramTypeMap: Readonly<Record<string, "url" | "query">>;
-  /**
-   * Map of parameter names to their constraint patterns.
-   *
-   * Only includes parameters with explicit constraints (e.g., `:id<\\d+>`).
-   * Parameters without constraints are not included in this map.
-   *
-   * @example
-   * ```typescript
-   * buildParamMeta("/users/:id<\\d+>").constraintPatterns.get("id")
-   * // → { pattern: /^(\d+)$/, constraint: "<\\d+>" }
-   *
-   * buildParamMeta("/users/:id").constraintPatterns.size
-   * // → 0 (no constraints)
-   * ```
-   */
-  readonly constraintPatterns: ReadonlyMap<string, ConstraintPattern>;
   /**
    * Path pattern without query string, pre-computed for buildPath.
    *
@@ -122,50 +89,5 @@ interface ResolvedMatcherOptions {
   readonly buildQueryString: (params: Record<string, unknown>) => string;
 }
 //#endregion
-//#region src/engine/builder/types.d.ts
-/**
- * Definition of a route for configuration.
- */
-interface RouteDefinition {
-  [key: string]: unknown;
-  name: string;
-  path: string;
-  children?: RouteDefinition[] | undefined;
-}
-/**
- * Immutable route tree node.
- *
- * This is the core data structure of the new route-tree architecture.
- * It contains only data (no methods) and is created by the builder.
- *
- * All caches are pre-computed at build time:
- * - nonAbsoluteChildren: filtered children without absolute paths
- * - fullName: pre-computed "users.profile" instead of runtime join
- */
-interface RouteTree {
-  /** Route segment name (e.g., "users" in "users.profile") */
-  readonly name: string;
-  /** Route path pattern (e.g., "/users/:id") */
-  readonly path: string;
-  /** Whether this route uses absolute path matching (path starts with "~") */
-  readonly absolute: boolean;
-  /** Child route nodes (Map for O(1) lookup by name) */
-  readonly children: ReadonlyMap<string, RouteTree>;
-  /** Parameter metadata extracted from path pattern (replaces parser dependency) */
-  readonly paramMeta: ParamMeta;
-  /** Parent node (null for root) */
-  readonly parent: RouteTree | null;
-  /** Children without absolute paths (for regular matching) */
-  readonly nonAbsoluteChildren: readonly RouteTree[];
-  /** Pre-computed full name (e.g., "users.profile") */
-  readonly fullName: string;
-  /**
-   * Pre-computed parameter type map for this segment.
-   * Cached to avoid recomputing on every navigation.
-   * Maps param name → "url" | "query".
-   */
-  readonly paramTypeMap: Readonly<Record<string, "url" | "query">>;
-}
-//#endregion
-export { MatcherInputNode as a, MatchResult as i, RouteTree as n, ResolvedMatcherOptions as o, BuildPathOptions as r, SegmentMatcherOptions as s, RouteDefinition as t };
-//# sourceMappingURL=types-xg2zHVF6.d.mts.map
+export { BuildPathOptions, MatchResult, MatcherInputNode, ParamMeta, ResolvedMatcherOptions, SegmentMatcherOptions, URLParamsEncodingType };
+//# sourceMappingURL=types.d.mts.map

package/dist/esm/engine/path-matcher/types.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.mts","names":[],"sources":["../../../../src/engine/path-matcher/types.ts"],"mappings":";;;;;;;;;;;UAWiB;;;;;;WAMN;;;;;;WAOA;;;;;;WAOA;;;;;;WAOA,cAAc,SAAS;;;;;;WAOvB;;;;;;;;;;KAeC;UAMK;WACN;WACA;WACA;WACA;WACA,UAAU,oBAAoB;WAC9B,8BAA8B;WAC9B,WAAW;WACX,cAAc,SAAS;;;;;UAqCjB;WACN;WACA;;UA0BM;WACN,mBAAmB;WACnB,QAAQ,SAAS;WACjB,MAAM,SAAS,eAAe;;UAOxB;EACf;EACA;EACA;EACA,oBAAoB;EACpB,mBAAmB,wBAAwB;EAC3C,mBAAmB,QAAQ;;UAGZ;WACN;WACA;WACA;WACA,mBAAmB;WACnB,mBAAmB,wBAAwB;WAC3C,mBAAmB,QAAQ"}

package/dist/esm/engine/search-params/types.d.mts

@@ -0,0 +1,72 @@
+//#region src/engine/search-params/types.d.ts
+/**
+ * Search Params Type Definitions.
+ *
+ * Consolidated interfaces and type aliases for the search-params module.
+ *
+ * @module search-params/types
+ */
+/**
+ * Array parameter encoding format.
+ *
+ * @remarks
+ * - `none` - repeated keys: `a=1&a=2`
+ * - `brackets` - bracket notation: `a[]=1&a[]=2`
+ * - `index` - indexed notation: `a[0]=1&a[1]=2`
+ * - `comma` - comma-separated: `a=1,2`
+ */
+type ArrayFormat = "none" | "brackets" | "index" | "comma";
+/**
+ * Boolean parameter encoding format.
+ *
+ * @remarks
+ * - `none` - no special handling
+ * - `auto` - auto-detect "true"/"false" strings as boolean values
+ * - `empty-true` - true values have no value: `?flag` instead of `?flag=true`
+ *
+ * @remarks
+ * Under `empty-true` the bare-key wire form (`?flag`) is reserved for `true`, so
+ * a `null` value with `nullFormat: "default"` (which also encodes to a bare key)
+ * is **not representable**: it round-trips back as `true`, not `null`. Both null
+ * and true collapse to the same token and only `true` decodes back. Pair
+ * `empty-true` with `nullFormat: "hidden"`, or avoid null query values.
+ */
+type BooleanFormat = "none" | "auto" | "empty-true";
+/**
+ * Null parameter encoding format.
+ *
+ * @remarks
+ * - `default` - key only: `?key` (collides with `booleanFormat: "empty-true"`,
+ *   which reserves the bare-key form for `true` — null then decodes as `true`)
+ * - `hidden` - omit from query string
+ */
+type NullFormat = "default" | "hidden";
+/**
+ * Number parameter encoding format.
+ *
+ * @remarks
+ * - `none` - no special handling
+ * - `auto` - decode canonical decimal numbers (`/^-?(0|[1-9]\d*)(\.\d+)?$/`) to
+ *   `Number()`. Recognizes negatives so the parsed type matches what
+ *   `build`/`navigate` produce; rejects leading zeros (`"007"`), exponent
+ *   notation, unsafe integers, and negative zero (`"-0"` — the grammar matches
+ *   it, but an `Object.is` guard rejects it since `build(-0)` emits `"0"`, #898)
+ *   — those keep their exact text as strings.
+ */
+type NumberFormat = "none" | "auto";
+/**
+ * Options for search-params parsing and building.
+ */
+interface Options {
+  /** Array parameter encoding format. @default "none" */
+  arrayFormat?: ArrayFormat;
+  /** Boolean parameter encoding format. @default "auto" */
+  booleanFormat?: BooleanFormat;
+  /** Null parameter encoding format. @default "default" */
+  nullFormat?: NullFormat;
+  /** Number parameter encoding format. @default "auto" */
+  numberFormat?: NumberFormat;
+}
+//#endregion
+export { ArrayFormat, BooleanFormat, NullFormat, NumberFormat, Options };
+//# sourceMappingURL=types.d.mts.map

package/dist/esm/engine/search-params/types.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.mts","names":[],"sources":["../../../../src/engine/search-params/types.ts"],"mappings":";;;;;;;;;;;;;;;;;KAqBY;;;;;;;;;;;;;;;;KAiBA;;;;;;;;;KAUA;;;;;;;;;;;;;KAcA;;;;UASK;;EAEf,cAAc;;EAEd,gBAAgB;;EAEhB,aAAa;;EAEb,eAAe"}

package/dist/esm/engine/validation/route-batch.d.mts

@@ -0,0 +1,38 @@
+import { RouteDefinition, RouteTree } from "../builder/types.mjs";
+//#region src/engine/validation/route-batch.d.ts
+/**
+ * Validates route structure for add operations.
+ *
+ * Performs comprehensive validation including:
+ * - Type check (must be object)
+ * - Name validation
+ * - Path validation
+ * - Duplicate name detection (in tree and batch)
+ * - Duplicate path detection (in tree and batch)
+ * - Recursive children validation
+ *
+ * @param route - Route to validate
+ * @param methodName - Calling method for error context
+ * @param rootNode - Optional root node for duplicate checking
+ * @param parentName - Parent route name for building full path (used in recursion)
+ * @param seenNames - Set of names already seen in this batch
+ * @param seenPathsByParent - Map of paths by parent for path duplicate detection
+ * @throws {TypeError} If route structure is invalid
+ * @throws {Error} If route already exists (duplicate)
+ * @throws {Error} If path already defined (duplicate)
+ *
+ * @example
+ * ```typescript
+ * const seenNames = new Set<string>();
+ * const seenPaths = new Map<string, Set<string>>();
+ *
+ * // Validate routes before adding
+ * for (const route of routes) {
+ *   validateRoute(route, "add", rootNode, "", seenNames, seenPaths);
+ * }
+ * ```
+ */
+declare function validateRoute(route: unknown, methodName: string, rootNode?: RouteTree, parentName?: string, seenNames?: Set<string>, seenPathsByParent?: Map<string, Set<string>>): asserts route is RouteDefinition;
+//#endregion
+export { validateRoute };
+//# sourceMappingURL=route-batch.d.mts.map

package/dist/esm/engine/validation/route-batch.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"route-batch.d.mts","names":[],"sources":["../../../../src/engine/validation/route-batch.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA0YgB,cACd,gBACA,oBACA,WAAW,WACX,qBACA,YAAY,aACZ,oBAAoB,YAAY,uBACvB,SAAS"}

package/dist/esm/getNavigator.d.mts

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

package/dist/esm/getNavigator.d.mts.map

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

package/dist/esm/index.d.mts

@@ -1,239 +1,17 @@
-import { n as RouteTree } from "./types-xg2zHVF6.mjs";
-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.mjs";
-import { t as Router } from "./Router-Cy75qbgU.mjs";
-import { t as RouterValidator } from "./RouterValidator-CZ8kPkrI.mjs";
-
-//#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.mts.map
+import { RouteTree } from "./engine/builder/types.mjs";
+import { QueryParamsMode, QueryParamsOptions, RouteParams, RouteTreeState } from "./types/route-node-types.mjs";
+import { Params, SimpleState, State, StateMetaInput, TransitionMeta, TransitionPhase, TransitionReason, Unsubscribe } from "./types/base.mjs";
+import { LimitsConfig } from "./types/limits.mjs";
+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.mjs";
+import { ErrorCodeKeys, ErrorCodeToValueMap, ErrorCodeValues, EventMethodMap, EventName, EventToNameMap, EventToPluginMap, EventsKeys, PluginMethod } from "./types/constants.mjs";
+import { TreeChangedAdd, TreeChangedClear, TreeChangedEvent, TreeChangedRemove, TreeChangedReplace, TreeChangedUpdate, TreeStructuralPatch } from "./types/tree-changed.mjs";
+import { ContextNamespaceClaim, DependenciesApi, InterceptableMethodMap, InterceptorFn, LifecycleApi, PluginApi, RoutesApi } from "./types/api.mjs";
+import { NavigationOptions, StateContext } from "./types.mjs";
+import { Router } from "./Router.mjs";
+import { RouterValidator } from "./types/RouterValidator.mjs";
+import { Constants, ErrorCodes, UNKNOWN_ROUTE, constants, errorCodes, events } from "./constants.mjs";
+import { RouterError } from "./RouterError.mjs";
+import { createRouter } from "./createRouter.mjs";
+import { getNavigator } from "./getNavigator.mjs";
+import { resolveForwardChain } from "./namespaces/RoutesNamespace/forwardChain.mjs";
+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/esm/index.mjs

@@ -1,2 +1,2 @@
-import{C as e,E as t,T as n,g as r,n as i,t as a,w as o}from"./Router-De0Gr9Ll.mjs";const s=(e=[],t={},n={})=>new a(e,t,n),c=new WeakMap,l=e=>{let t=c.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}),c.set(e,t)),t};export{a as Router,i as RouterError,e as UNKNOWN_ROUTE,o as constants,s as createRouter,n as errorCodes,t as events,l as getNavigator,r as resolveForwardChain};
+import{C as e,E as t,T as n,g as r,n as i,t as a,w as o}from"./Router-Bk6PfSE8.mjs";const s=(e=[],t={},n={})=>new a(e,t,n),c=new WeakMap,l=e=>{let t=c.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}),c.set(e,t)),t};export{a as Router,i as RouterError,e as UNKNOWN_ROUTE,o as constants,s as createRouter,n as errorCodes,t as events,l as getNavigator,r as resolveForwardChain};
 //# sourceMappingURL=index.mjs.map

package/dist/esm/internals.d.mts

@@ -0,0 +1,99 @@
+import { RouteTree } from "./engine/builder/types.mjs";
+import { RouteTreeState } from "./types/route-node-types.mjs";
+import { Params, SimpleState, State, Unsubscribe } from "./types/base.mjs";
+import { DefaultDependencies, LoggerConfig, Options, Plugin, PluginFactory, Router, RouterLogger } from "./types/router.mjs";
+import { EventMethodMap, EventName } from "./types/constants.mjs";
+import { TreeChangedEvent } from "./types/tree-changed.mjs";
+import { NavigationOptions } from "./types.mjs";
+import { RouterValidator } from "./types/RouterValidator.mjs";
+import { SerializedRouterState } from "./utils/serializeRouterState.mjs";
+import { DependenciesStore } from "./namespaces/DependenciesNamespace/dependenciesStore.mjs";
+import { RoutesStore } from "./namespaces/RoutesNamespace/routesStore.mjs";
+//#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.mts.map