@real-router/core 0.40.1 → 0.42.0

package/dist/esm/validation.d.mts

@@ -1,12 +1,14 @@
-import { L as Limits, R as RouterValidator } from './RouterValidator-mx2Zooya.mjs';
-import { DefaultDependencies, Params, ForwardToCallback, GuardFnFactory, State, SimpleState, GuardFn, RouteTreeState, Options, EventName, Plugin, EventMethodMap, Unsubscribe, PluginFactory, Router } from '@real-router/types';
-import { a as RouteDefinition, R as RouteTree, M as Matcher, C as CreateMatcherOptions } from './index.d-y2b-8_3Y.mjs';
+import { a as Limits, d as RouteDefinition, f as RouteTree, i as GuardFnFactory, l as CreateMatcherOptions, o as PluginFactory, r as EventMethodMap, u as Matcher } from "./Router-4JRfQLMM.mjs";
+import { t as RouterValidator } from "./RouterValidator-DphcVMEp.mjs";
+import { DefaultDependencies, EventName, ForwardToCallback, GuardFn, Options, Params, Plugin, RouteTreeState, Router, SimpleState, State, Unsubscribe } from "@real-router/types";
 
+//#region src/namespaces/DependenciesNamespace/dependenciesStore.d.ts
 interface DependenciesStore<Dependencies extends DefaultDependencies = DefaultDependencies> {
-    dependencies: Partial<Dependencies>;
-    limits: Limits;
+  dependencies: Partial<Dependencies>;
+  limits: Limits;
 }
-
+//#endregion
+//#region src/namespaces/RoutesNamespace/types.d.ts
 /**
  * Dependencies injected into RoutesNamespace.
  *
@@ -14,42 +16,44 @@ interface DependenciesStore<Dependencies extends DefaultDependencies = DefaultDe
  * avoiding the need to pass the entire Router object.
  */
 interface RoutesDependencies<Dependencies extends DefaultDependencies = DefaultDependencies> {
-    /** Register canActivate handler for a route */
-    addActivateGuard: (name: string, handler: GuardFnFactory<Dependencies>) => void;
-    /** Register canDeactivate handler for a route */
-    addDeactivateGuard: (name: string, handler: GuardFnFactory<Dependencies>) => void;
-    /** Create state object */
-    makeState: <P extends Params = Params, MP extends Params = Params>(name: string, params?: P, path?: string, meta?: Record<string, Record<string, "url" | "query">>) => State<P, MP>;
-    /** Get current router state */
-    getState: () => State | undefined;
-    /** Compare two states for equality */
-    areStatesEqual: (state1: State | undefined, state2: State | undefined, ignoreQueryParams?: boolean) => boolean;
-    /** Get a dependency by name */
-    getDependency: <K extends keyof Dependencies>(name: K) => Dependencies[K];
-    /** Forward state through facade (allows plugin interception) */
-    forwardState: <P extends Params = Params>(name: string, params: P) => SimpleState<P>;
+  /** Register canActivate handler for a route */
+  addActivateGuard: (name: string, handler: GuardFnFactory<Dependencies>) => void;
+  /** Register canDeactivate handler for a route */
+  addDeactivateGuard: (name: string, handler: GuardFnFactory<Dependencies>) => void;
+  /** Create state object */
+  makeState: <P extends Params = Params>(name: string, params?: P, path?: string, meta?: Record<string, Record<string, "url" | "query">>) => State<P>;
+  /** Get current router state */
+  getState: () => State | undefined;
+  /** Compare two states for equality */
+  areStatesEqual: (state1: State | undefined, state2: State | undefined, ignoreQueryParams?: boolean) => boolean;
+  /** Get a dependency by name */
+  getDependency: <K extends keyof Dependencies>(name: K) => Dependencies[K];
+  /** Forward state through facade (allows plugin interception) */
+  forwardState: <P extends Params = Params>(name: string, params: P) => SimpleState<P>;
 }
 /**
  * Configuration storage for routes.
  * Stores decoders, encoders, default params, and forward mappings.
  */
 interface RouteConfig {
-    /** Custom param decoders per route */
-    decoders: Record<string, (params: Params) => Params>;
-    /** Custom param encoders per route */
-    encoders: Record<string, (params: Params) => Params>;
-    /** Default params per route */
-    defaultParams: Record<string, Params>;
-    /** Forward mappings (source -> target) */
-    forwardMap: Record<string, string>;
-    /** Dynamic forward callbacks (source -> callback) */
-    forwardFnMap: Record<string, ForwardToCallback<any>>;
+  /** Custom param decoders per route */
+  decoders: Record<string, (params: Params) => Params>;
+  /** Custom param encoders per route */
+  encoders: Record<string, (params: Params) => Params>;
+  /** Default params per route */
+  defaultParams: Record<string, Params>;
+  /** Forward mappings (source -> target) */
+  forwardMap: Record<string, string>;
+  /** Dynamic forward callbacks (source -> callback) */
+  forwardFnMap: Record<string, ForwardToCallback<any>>;
 }
-
+//#endregion
+//#region src/namespaces/RouteLifecycleNamespace/types.d.ts
 interface RouteLifecycleDependencies<Dependencies extends DefaultDependencies = DefaultDependencies> {
-    compileFactory: (factory: GuardFnFactory<Dependencies>) => GuardFn;
+  compileFactory: (factory: GuardFnFactory<Dependencies>) => GuardFn;
 }
-
+//#endregion
+//#region src/namespaces/RouteLifecycleNamespace/RouteLifecycleNamespace.d.ts
 /**
  * Independent namespace for managing route lifecycle handlers.
  *
@@ -57,128 +61,125 @@ interface RouteLifecycleDependencies<Dependencies extends DefaultDependencies =
  * Instance methods handle state-dependent validation, storage and business logic.
  */
 declare class RouteLifecycleNamespace<Dependencies extends DefaultDependencies = DefaultDependencies> {
-    #private;
-    setDependencies(deps: RouteLifecycleDependencies<Dependencies>): void;
-    /**
-     * Updates handler registration limits (max lifecycle handlers threshold).
-     *
-     * @param limits - Limits configuration with maxLifecycleHandlers
-     */
-    setLimits(limits: Limits): void;
-    setValidatorGetter(getter: () => RouterValidator | null): void;
-    getHandlerCount(type: "activate" | "deactivate"): number;
-    /**
-     * Adds a canActivate guard for a route.
-     * Handles overwrite detection and registration.
-     *
-     * @param name - Route name (input-validated by facade)
-     * @param handler - Guard function or boolean (input-validated by facade)
-     * @param isFromDefinition - True when guard comes from route definition (tracked for HMR replace)
-     */
-    addCanActivate(name: string, handler: GuardFnFactory<Dependencies> | boolean, isFromDefinition?: boolean): void;
-    /**
-     * Adds a canDeactivate guard for a route.
-     * Handles overwrite detection and registration.
-     *
-     * @param name - Route name (input-validated by facade)
-     * @param handler - Guard function or boolean (input-validated by facade)
-     * @param isFromDefinition - True when guard comes from route definition (tracked for HMR replace)
-     */
-    addCanDeactivate(name: string, handler: GuardFnFactory<Dependencies> | boolean, isFromDefinition?: boolean): void;
-    /**
-     * Removes a canActivate guard for a route.
-     * Input already validated by facade (not registering).
-     *
-     * @param name - Route name (already validated by facade)
-     */
-    clearCanActivate(name: string): void;
-    /**
-     * Removes a canDeactivate guard for a route.
-     * Input already validated by facade (not registering).
-     *
-     * @param name - Route name (already validated by facade)
-     */
-    clearCanDeactivate(name: string): void;
-    /**
-     * Clears all lifecycle handlers (canActivate and canDeactivate).
-     * Used by clearRoutes to reset all lifecycle state.
-     */
-    clearAll(): void;
-    /**
-     * Clears only lifecycle handlers that were registered from route definitions.
-     * Used by HMR to remove definition-sourced guards without touching externally-added guards.
-     */
-    clearDefinitionGuards(): void;
-    /**
-     * Returns lifecycle factories as records for cloning.
-     *
-     * @returns Tuple of [canDeactivateFactories, canActivateFactories]
-     */
-    getFactories(): [
-        Record<string, GuardFnFactory<Dependencies>>,
-        Record<string, GuardFnFactory<Dependencies>>
-    ];
-    /**
-     * Returns compiled lifecycle functions for transition execution.
-     *
-     * @returns Tuple of [canDeactivateFunctions, canActivateFunctions] as Maps
-     */
-    getFunctions(): [Map<string, GuardFn>, Map<string, GuardFn>];
-    canNavigateTo(toDeactivate: string[], toActivate: string[], toState: State, fromState: State | undefined): boolean;
+  #private;
+  setDependencies(deps: RouteLifecycleDependencies<Dependencies>): void;
+  /**
+   * Updates handler registration limits (max lifecycle handlers threshold).
+   *
+   * @param limits - Limits configuration with maxLifecycleHandlers
+   */
+  setLimits(limits: Limits): void;
+  setValidatorGetter(getter: () => RouterValidator | null): void;
+  getHandlerCount(type: "activate" | "deactivate"): number;
+  /**
+   * Adds a canActivate guard for a route.
+   * Handles overwrite detection and registration.
+   *
+   * @param name - Route name (input-validated by facade)
+   * @param handler - Guard function or boolean (input-validated by facade)
+   * @param isFromDefinition - True when guard comes from route definition (tracked for HMR replace)
+   */
+  addCanActivate(name: string, handler: GuardFnFactory<Dependencies> | boolean, isFromDefinition?: boolean): void;
+  /**
+   * Adds a canDeactivate guard for a route.
+   * Handles overwrite detection and registration.
+   *
+   * @param name - Route name (input-validated by facade)
+   * @param handler - Guard function or boolean (input-validated by facade)
+   * @param isFromDefinition - True when guard comes from route definition (tracked for HMR replace)
+   */
+  addCanDeactivate(name: string, handler: GuardFnFactory<Dependencies> | boolean, isFromDefinition?: boolean): void;
+  /**
+   * Removes a canActivate guard for a route.
+   * Input already validated by facade (not registering).
+   *
+   * @param name - Route name (already validated by facade)
+   */
+  clearCanActivate(name: string): void;
+  /**
+   * Removes a canDeactivate guard for a route.
+   * Input already validated by facade (not registering).
+   *
+   * @param name - Route name (already validated by facade)
+   */
+  clearCanDeactivate(name: string): void;
+  /**
+   * Clears all lifecycle handlers (canActivate and canDeactivate).
+   * Used by clearRoutes to reset all lifecycle state.
+   */
+  clearAll(): void;
+  /**
+   * Clears only lifecycle handlers that were registered from route definitions.
+   * Used by HMR to remove definition-sourced guards without touching externally-added guards.
+   */
+  clearDefinitionGuards(): void;
+  /**
+   * Returns lifecycle factories as records for cloning.
+   *
+   * @returns Tuple of [canDeactivateFactories, canActivateFactories]
+   */
+  getFactories(): [Record<string, GuardFnFactory<Dependencies>>, Record<string, GuardFnFactory<Dependencies>>];
+  /**
+   * Returns compiled lifecycle functions for transition execution.
+   *
+   * @returns Tuple of [canDeactivateFunctions, canActivateFunctions] as Maps
+   */
+  getFunctions(): [Map<string, GuardFn>, Map<string, GuardFn>];
+  canNavigateTo(toDeactivate: string[], toActivate: string[], toState: State, fromState: State | undefined): boolean;
 }
-
+//#endregion
+//#region src/namespaces/RoutesNamespace/routesStore.d.ts
 interface RoutesStore<Dependencies extends DefaultDependencies = DefaultDependencies> {
-    readonly definitions: RouteDefinition[];
-    readonly config: RouteConfig;
-    tree: RouteTree;
-    matcher: Matcher;
-    resolvedForwardMap: Record<string, string>;
-    routeCustomFields: Record<string, Record<string, unknown>>;
-    rootPath: string;
-    readonly matcherOptions: CreateMatcherOptions | undefined;
-    depsStore: RoutesDependencies<Dependencies> | undefined;
-    lifecycleNamespace: RouteLifecycleNamespace<Dependencies> | undefined;
-    readonly pendingCanActivate: Map<string, GuardFnFactory<Dependencies>>;
-    readonly pendingCanDeactivate: Map<string, GuardFnFactory<Dependencies>>;
-    readonly treeOperations: {
-        readonly commitTreeChanges: (store: RoutesStore<Dependencies>) => void;
-        readonly resetStore: (store: RoutesStore<Dependencies>) => void;
-        readonly nodeToDefinition: (node: RouteTree) => RouteDefinition;
-    };
+  readonly definitions: RouteDefinition[];
+  readonly config: RouteConfig;
+  tree: RouteTree;
+  matcher: Matcher;
+  resolvedForwardMap: Record<string, string>;
+  routeCustomFields: Record<string, Record<string, unknown>>;
+  rootPath: string;
+  readonly matcherOptions: CreateMatcherOptions | undefined;
+  depsStore: RoutesDependencies<Dependencies> | undefined;
+  lifecycleNamespace: RouteLifecycleNamespace<Dependencies> | undefined;
+  readonly pendingCanActivate: Map<string, GuardFnFactory<Dependencies>>;
+  readonly pendingCanDeactivate: Map<string, GuardFnFactory<Dependencies>>;
+  readonly treeOperations: {
+    readonly commitTreeChanges: (store: RoutesStore<Dependencies>) => void;
+    readonly resetStore: (store: RoutesStore<Dependencies>) => void;
+    readonly nodeToDefinition: (node: RouteTree) => RouteDefinition;
+  };
 }
-
+//#endregion
+//#region src/internals.d.ts
 interface RouterInternals<D extends DefaultDependencies = DefaultDependencies> {
-    readonly makeState: <P extends Params = Params, MP extends Params = Params>(name: string, params?: P, path?: string, meta?: Record<string, Record<string, "url" | "query">>, forceId?: number) => State<P, MP>;
-    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, MP extends Params = Params>(path: string, options?: Options) => State<P, MP> | undefined;
-    readonly getOptions: () => Options;
-    readonly addEventListener: <E extends EventName>(eventName: E, cb: Plugin[EventMethodMap[E]]) => Unsubscribe;
-    readonly buildPath: (route: string, params?: Params) => string;
-    readonly start: (path: string) => 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 dependenciesGetStore: () => DependenciesStore<D>;
-    readonly cloneOptions: () => Options;
-    readonly cloneDependencies: () => Record<string, unknown>;
-    readonly getLifecycleFactories: () => [
-        Record<string, GuardFnFactory<D>>,
-        Record<string, GuardFnFactory<D>>
-    ];
-    readonly getPluginFactories: () => PluginFactory<D>[];
-    readonly routeGetStore: () => RoutesStore<D>;
-    readonly getStateName: () => string | undefined;
-    readonly isTransitioning: () => boolean;
-    readonly clearState: () => void;
-    readonly setState: (state: State) => void;
-    readonly routerExtensions: {
-        keys: string[];
-    }[];
+  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;
+  readonly buildPath: (route: string, params?: Params) => string;
+  readonly start: (path: string) => 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 dependenciesGetStore: () => DependenciesStore<D>;
+  readonly cloneOptions: () => Options;
+  readonly cloneDependencies: () => Record<string, unknown>;
+  readonly getLifecycleFactories: () => [Record<string, GuardFnFactory<D>>, Record<string, GuardFnFactory<D>>];
+  readonly getPluginFactories: () => PluginFactory<D>[];
+  readonly routeGetStore: () => RoutesStore<D>;
+  readonly getStateName: () => string | undefined;
+  readonly isTransitioning: () => boolean;
+  readonly clearState: () => void;
+  readonly setState: (state: State) => void;
+  readonly routerExtensions: {
+    keys: string[];
+  }[];
 }
 declare function getInternals<D extends DefaultDependencies>(router: Router<D>): RouterInternals<D>;
-
-export { type RouterInternals, RouterValidator, getInternals };
+//#endregion
+export { type RouterInternals, type RouterValidator, getInternals };
+//# sourceMappingURL=validation.d.mts.map

package/dist/esm/validation.mjs

@@ -1 +1 @@
-export{getInternals}from"./chunk-QUUNDESP.mjs";//# sourceMappingURL=validation.mjs.map
+import{r as e}from"./internals-CCymabFj.mjs";export{e as getInternals};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@real-router/core",
-  "version": "0.40.1",
+  "version": "0.42.0",
   "type": "commonjs",
   "description": "A simple, powerful, view-agnostic, modular and extensible router",
   "main": "./dist/cjs/index.js",
@@ -85,20 +85,18 @@
     "url": "https://github.com/greydragon888/real-router/issues"
   },
   "homepage": "https://github.com/greydragon888/real-router",
-  "sideEffects": [
-    "./dist/esm/chunk-*.mjs"
-  ],
+  "sideEffects": false,
   "dependencies": {
     "@real-router/fsm": "^0.2.2",
     "@real-router/logger": "^0.2.1",
-    "@real-router/types": "^0.26.0"
+    "@real-router/types": "^0.28.0"
   },
   "devDependencies": {
     "event-emitter": "^0.1.2",
     "route-tree": "^0.3.4"
   },
   "scripts": {
-    "build": "tsup",
+    "build": "tsdown --config-loader unrun",
     "test": "vitest run functional/",
     "test:properties": "vitest run --config vitest.config.properties.mts",
     "test:coverage": "vitest run functional/ --coverage",
@@ -109,6 +107,6 @@
     "lint": "eslint --cache --ext .ts src/ tests/ --fix --max-warnings 0",
     "lint:package": "publint",
     "lint:types": "attw --pack .",
-    "build:dist-only": "tsup"
+    "build:dist-only": "tsdown --config-loader unrun"
   }
 }

package/src/Router.ts

@@ -189,8 +189,8 @@ export class Router<
     const interceptorsMap: RouterInternals["interceptors"] = new Map();
 
     registerInternals(this, {
-      makeState: (name, params, path, meta, forceId) =>
-        this.#state.makeState(name, params, path, meta, forceId),
+      makeState: (name, params, path, meta) =>
+        this.#state.makeState(name, params, path, meta),
       forwardState: createInterceptable2(
         "forwardState",
         (name: string, params: Params) =>
@@ -345,10 +345,8 @@ export class Router<
   // State Management (delegated to StateNamespace)
   // ============================================================================
 
-  getState<P extends Params = Params, MP extends Params = Params>():
-    | State<P, MP>
-    | undefined {
-    return this.#state.get<P, MP>();
+  getState<P extends Params = Params>(): State<P> | undefined {
+    return this.#state.get<P>();
   }
 
   getPreviousState(): State | undefined {

package/src/api/getPluginApi.ts

@@ -12,8 +12,8 @@ export function getPluginApi<
   const ctx = getInternals(router);
 
   return {
-    makeState: (name, params, path, meta, forceId) => {
-      ctx.validator?.state.validateMakeStateArgs(name, params, path, forceId);
+    makeState: (name, params, path, meta) => {
+      ctx.validator?.state.validateMakeStateArgs(name, params, path);
 
       return ctx.makeState(
         name,
@@ -22,7 +22,6 @@ export function getPluginApi<
         meta?.params as
           | Record<string, Record<string, "url" | "query">>
           | undefined,
-        forceId,
       );
     },
     buildState: (routeName, routeParams) => {

package/src/helpers.ts

@@ -91,12 +91,15 @@ export function deepFreezeState<T extends State>(state: T): T {
     // Freeze the object/array itself
     Object.freeze(obj);
 
-    // Get all values to freeze recursively
-    const values = Array.isArray(obj) ? obj : Object.values(obj);
-
-    // Recursively freeze nested values
-    for (const value of values) {
-      freezeClonedRecursive(value);
+    // Iterate without Object.values() allocation
+    if (Array.isArray(obj)) {
+      for (const item of obj) {
+        freezeClonedRecursive(item);
+      }
+    } else {
+      for (const key in obj) {
+        freezeClonedRecursive((obj as Record<string, unknown>)[key]);
+      }
     }
   }
 
@@ -159,7 +162,6 @@ export function freezeStateInPlace<T extends State>(state: T): T {
     return state;
   }
 
-  // Freeze the entire state tree
   freezeRecursive(state);
 
   // Mark root as processed for future calls

package/src/index.ts

@@ -28,7 +28,6 @@ export type {
   Plugin,
   SimpleState,
   State,
-  StateMeta,
   SubscribeFn,
   SubscribeState,
   Subscription,

package/src/internals.ts

@@ -20,13 +20,12 @@ import type { RouteTree } from "route-tree";
 export interface RouterInternals<
   D extends DefaultDependencies = DefaultDependencies,
 > {
-  readonly makeState: <P extends Params = Params, MP extends Params = Params>(
+  readonly makeState: <P extends Params = Params>(
     name: string,
     params?: P,
     path?: string,
     meta?: Record<string, Record<string, "url" | "query">>,
-    forceId?: number,
-  ) => State<P, MP>;
+  ) => State<P>;
 
   readonly forwardState: <P extends Params = Params>(
     routeName: string,
@@ -38,10 +37,10 @@ export interface RouterInternals<
     resolvedParams: Params,
   ) => RouteTreeState | undefined;
 
-  readonly matchPath: <P extends Params = Params, MP extends Params = Params>(
+  readonly matchPath: <P extends Params = Params>(
     path: string,
     options?: Options,
-  ) => State<P, MP> | undefined;
+  ) => State<P> | undefined;
 
   readonly getOptions: () => Options;
 

package/src/namespaces/NavigationNamespace/NavigationNamespace.ts

@@ -149,7 +149,6 @@ export class NavigationNamespace {
       const { toDeactivate, toActivate, intersection } = getTransitionPath(
         toState,
         fromState,
-        opts.reload,
       );
 
       const shouldDeactivate =

package/src/namespaces/OptionsNamespace/constants.ts

@@ -14,6 +14,7 @@ export const defaultOptions: Options = {
     arrayFormat: "none",
     booleanFormat: "none",
     nullFormat: "default",
+    numberFormat: "none",
   },
   urlParamsEncoding: "default",
   allowNotFound: true,

package/src/namespaces/OptionsNamespace/helpers.ts

@@ -35,7 +35,6 @@ export function resolveOption(
   getDependency: (name: string) => unknown,
 ): Params;
 
-// eslint-disable-next-line sonarjs/function-return-type -- overloads: string for defaultRoute, Params for defaultParams
 export function resolveOption(
   value: Options["defaultRoute"] | Options["defaultParams"],
   getDependency: (name: string) => unknown,

package/src/namespaces/RouterLifecycleNamespace/types.ts

@@ -16,9 +16,7 @@ export interface RouterLifecycleDependencies {
   ) => Promise<State>;
   navigateToNotFound: (path: string) => State;
   clearState: () => void;
-  matchPath: <P extends Params = Params, MP extends Params = Params>(
-    path: string,
-  ) => State<P, MP> | undefined;
+  matchPath: <P extends Params = Params>(path: string) => State<P> | undefined;
   completeStart: () => void;
   emitTransitionError: (
     toState: State | undefined,

package/src/namespaces/RoutesNamespace/RoutesNamespace.ts

@@ -224,10 +224,10 @@ export class RoutesNamespace<
    * Matches a URL path to a route in the tree.
    * Note: Argument validation is done by facade (Router.ts) via validateMatchPathArgs.
    */
-  matchPath<P extends Params = Params, MP extends Params = Params>(
+  matchPath<P extends Params = Params>(
     path: string,
     options?: Options,
-  ): State<P, MP> | undefined {
+  ): State<P> | undefined {
     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- Router.ts always passes options
     const opts = options!;
 
@@ -268,7 +268,7 @@ export class RoutesNamespace<
       });
     }
 
-    return this.#deps.makeState<P, MP>(routeName, routeParams, builtPath, meta);
+    return this.#deps.makeState<P>(routeName, routeParams, builtPath, meta);
   }
 
   /**

package/src/namespaces/RoutesNamespace/types.ts

@@ -31,12 +31,12 @@ export interface RoutesDependencies<
   ) => void;
 
   /** Create state object */
-  makeState: <P extends Params = Params, MP extends Params = Params>(
+  makeState: <P extends Params = Params>(
     name: string,
     params?: P,
     path?: string,
     meta?: Record<string, Record<string, "url" | "query">>,
-  ) => State<P, MP>;
+  ) => State<P>;
 
   /** Get current router state */
   getState: () => State | undefined;