@real-router/core 0.79.0 → 0.80.0

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

@@ -0,0 +1 @@
+{"version":3,"file":"StateNamespace.js","names":["#frozenState","#previousState","freezeStateInPlace","#deps","EMPTY_PARAMS","DEFAULT_TRANSITION","areParamValuesEqual"],"sources":["../../../../src/namespaces/StateNamespace/StateNamespace.ts"],"sourcesContent":["// packages/core/src/namespaces/StateNamespace/StateNamespace.ts\n\nimport { areParamValuesEqual } from \"./helpers\";\nimport { DEFAULT_TRANSITION, EMPTY_PARAMS } from \"../../constants\";\nimport { freezeStateInPlace } from \"../../helpers\";\nimport { setStateMetaParams } from \"../../stateMetaStore\";\n\nimport type { StateNamespaceDependencies } from \"./types\";\nimport type { RouteTreeStateMeta } from \"../../engine\";\nimport type { Params, State } from \"../../types\";\n\n/**\n * Independent namespace for managing router state storage and creation.\n *\n * Static methods handle validation (called by facade).\n * Instance methods handle state storage, freezing, and creation.\n */\nexport class StateNamespace {\n  /**\n   * Cached frozen state - avoids structuredClone on every getState() call.\n   */\n  #frozenState: State | undefined = undefined;\n\n  /**\n   * Previous state before the last setState call.\n   */\n  #previousState: State | undefined = undefined;\n\n  /**\n   * Dependencies injected from Router.\n   */\n  #deps!: StateNamespaceDependencies;\n\n  // =========================================================================\n  // Instance methods (trust input - already validated by facade)\n  // =========================================================================\n\n  /**\n   * Returns the current router state.\n   *\n   * The returned state is deeply frozen (immutable) for safety.\n   * Returns `undefined` if the router has not been started or has been stopped.\n   */\n  get<P extends Params = Params>(): State<P> | undefined {\n    return this.#frozenState as State<P> | undefined; // NOSONAR -- generic narrowing needed for public API\n  }\n\n  /**\n   * Sets the current router state.\n   *\n   * The state is deeply frozen before storage to ensure immutability.\n   * The previous state is preserved and accessible via `getPrevious()`.\n   *\n   * @param state - Already validated by facade, or undefined to clear\n   */\n  set(state: State | undefined): void {\n    // Preserve current state as previous before updating\n    this.#previousState = this.#frozenState;\n\n    // If state is already frozen (from makeState()), use it directly.\n    // For external states, freeze in place without cloning.\n    this.#frozenState = state ? freezeStateInPlace(state) : undefined;\n  }\n\n  /**\n   * Returns the previous router state (before the last navigation).\n   */\n  getPrevious(): State | undefined {\n    return this.#previousState;\n  }\n\n  reset(): void {\n    this.#frozenState = undefined;\n    this.#previousState = undefined;\n  }\n\n  // =========================================================================\n  // Dependency Injection\n  // =========================================================================\n\n  /**\n   * Sets dependencies for state creation methods.\n   * Must be called before using makeState, areStatesEqual, etc.\n   */\n  setDependencies(deps: StateNamespaceDependencies): void {\n    this.#deps = deps;\n  }\n\n  // =========================================================================\n  // State Creation Methods\n  // =========================================================================\n\n  /**\n   * Creates a state object for a route.\n   *\n   * `params` is frozen at creation so it is always immutable, even when\n   * `skipFreeze=true` is passed to defer the outer `Object.freeze(state)` call.\n   * This keeps params-freezing invariants independent of transition-pipeline\n   * mutation (e.g. `completeTransition` attaching `state.transition`).\n   *\n   * `context` is initialized as a fresh empty object — intentionally NOT frozen\n   * so plugins can publish data via `claim.write(state, value)` after creation.\n   */\n  makeState<P extends Params = Params>(\n    name: string,\n    params?: P,\n    path?: string,\n    meta?: RouteTreeStateMeta,\n    skipFreeze?: boolean,\n  ): State<P> {\n    // Optimization: O(1) lookup instead of O(depth) ancestor iteration\n    const defaultParamsConfig = this.#deps.getDefaultParams();\n    const hasDefaultParams = Object.hasOwn(defaultParamsConfig, name);\n\n    // Conditional allocation: avoid spreading when no defaultParams exist\n    let mergedParams: P;\n\n    if (hasDefaultParams) {\n      mergedParams = Object.freeze({\n        ...defaultParamsConfig[name],\n        ...params,\n      }) as P;\n    } else if (!params || params === EMPTY_PARAMS) {\n      mergedParams = EMPTY_PARAMS as P;\n    } else {\n      mergedParams = Object.freeze({ ...params });\n    }\n\n    const state = {\n      name,\n      params: mergedParams,\n      path: path ?? this.#deps.buildPath(name, params),\n      context: {},\n      ...(!skipFreeze && { transition: DEFAULT_TRANSITION }),\n    } as State<P>;\n\n    if (meta) {\n      setStateMetaParams(state, meta);\n    }\n\n    return skipFreeze ? state : freezeStateInPlace(state);\n  }\n\n  // =========================================================================\n  // State Comparison Methods\n  // =========================================================================\n\n  /**\n   * Compares two states for equality.\n   * By default, ignores query params (only compares URL params).\n   */\n  areStatesEqual(\n    state1: State | undefined,\n    state2: State | undefined,\n    ignoreQueryParams = true,\n  ): boolean {\n    if (!state1 || !state2) {\n      return !!state1 === !!state2;\n    }\n\n    if (state1.name !== state2.name) {\n      return false;\n    }\n\n    if (ignoreQueryParams) {\n      // URL (path) param names are cached at the routes layer and invalidated\n      // on every tree mutation, so this stays correct after replace() (#723).\n      const urlParams = this.#deps.getUrlParams(state1.name);\n\n      for (const urlParam of urlParams) {\n        if (\n          !areParamValuesEqual(state1.params[urlParam], state2.params[urlParam])\n        ) {\n          return false;\n        }\n      }\n\n      return true;\n    }\n\n    const state1Keys = Object.keys(state1.params);\n    const state2Keys = Object.keys(state2.params);\n\n    if (state1Keys.length !== state2Keys.length) {\n      return false;\n    }\n\n    for (const param of state1Keys) {\n      if (\n        !(param in state2.params) ||\n        !areParamValuesEqual(state1.params[param], state2.params[param])\n      ) {\n        return false;\n      }\n    }\n\n    return true;\n  }\n}\n"],"mappings":"mIAiBA,IAAa,EAAb,KAA4B,CAI1B,GAAkC,IAAA,GAKlC,GAAoC,IAAA,GAKpC,GAYA,KAAuD,CACrD,OAAO,KAAKA,EACd,CAUA,IAAI,EAAgC,CAElC,KAAKC,GAAiB,KAAKD,GAI3B,KAAKA,GAAe,EAAQE,EAAAA,mBAAmB,CAAK,EAAI,IAAA,EAC1D,CAKA,aAAiC,CAC/B,OAAO,KAAKD,EACd,CAEA,OAAc,CACZ,KAAKD,GAAe,IAAA,GACpB,KAAKC,GAAiB,IAAA,EACxB,CAUA,gBAAgB,EAAwC,CACtD,KAAKE,GAAQ,CACf,CAiBA,UACE,EACA,EACA,EACA,EACA,EACU,CAEV,IAAM,EAAsB,KAAKA,GAAM,iBAAiB,EAClD,EAAmB,OAAO,OAAO,EAAqB,CAAI,EAG5D,EAEJ,AAQE,EARE,EACa,OAAO,OAAO,CAC3B,GAAG,EAAoB,GACvB,GAAG,CACL,CAAC,EACQ,CAAC,GAAU,IAAWC,EAAAA,aAChBA,EAAAA,aAEA,OAAO,OAAO,CAAE,GAAG,CAAO,CAAC,EAG5C,IAAM,EAAQ,CACZ,OACA,OAAQ,EACR,KAAM,GAAQ,KAAKD,GAAM,UAAU,EAAM,CAAM,EAC/C,QAAS,CAAC,EACV,GAAI,CAAC,GAAc,CAAE,WAAYE,EAAAA,kBAAmB,CACtD,EAMA,OAJI,GACF,EAAA,mBAAmB,EAAO,CAAI,EAGzB,EAAa,EAAQH,EAAAA,mBAAmB,CAAK,CACtD,CAUA,eACE,EACA,EACA,EAAoB,GACX,CACT,GAAI,CAAC,GAAU,CAAC,EACd,MAAO,CAAC,CAAC,GAAW,CAAC,CAAC,EAGxB,GAAI,EAAO,OAAS,EAAO,KACzB,MAAO,GAGT,GAAI,EAAmB,CAGrB,IAAM,EAAY,KAAKC,GAAM,aAAa,EAAO,IAAI,EAErD,IAAK,IAAM,KAAY,EACrB,GACE,CAACG,EAAAA,oBAAoB,EAAO,OAAO,GAAW,EAAO,OAAO,EAAS,EAErE,MAAO,GAIX,MAAO,EACT,CAEA,IAAM,EAAa,OAAO,KAAK,EAAO,MAAM,EACtC,EAAa,OAAO,KAAK,EAAO,MAAM,EAE5C,GAAI,EAAW,SAAW,EAAW,OACnC,MAAO,GAGT,IAAK,IAAM,KAAS,EAClB,GACE,EAAE,KAAS,EAAO,SAClB,CAACA,EAAAA,oBAAoB,EAAO,OAAO,GAAQ,EAAO,OAAO,EAAM,EAE/D,MAAO,GAIX,MAAO,EACT,CACF"}

package/dist/cjs/namespaces/StateNamespace/helpers.js

@@ -0,0 +1,2 @@
+function e(t,n){if(t===n)return!0;if(Array.isArray(t)&&Array.isArray(n)){if(t.length!==n.length)return!1;for(let r=0;r<t.length;r++)if(!e(t[r],n[r]))return!1;return!0}return!1}exports.areParamValuesEqual=e;
+//# sourceMappingURL=helpers.js.map

package/dist/cjs/namespaces/StateNamespace/helpers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.js","names":[],"sources":["../../../../src/namespaces/StateNamespace/helpers.ts"],"sourcesContent":["// packages/core/src/namespaces/StateNamespace/helpers.ts\n\nexport function areParamValuesEqual(val1: unknown, val2: unknown): boolean {\n  if (val1 === val2) {\n    return true;\n  }\n\n  if (Array.isArray(val1) && Array.isArray(val2)) {\n    if (val1.length !== val2.length) {\n      return false;\n    }\n\n    // eslint-disable-next-line unicorn/no-for-loop -- hot path: for-of entries() allocates iterator per recursive call\n    for (let i = 0; i < val1.length; i++) {\n      if (!areParamValuesEqual(val1[i], val2[i])) {\n        return false;\n      }\n    }\n\n    return true;\n  }\n\n  return false;\n}\n"],"mappings":"AAEA,SAAgB,EAAoB,EAAe,EAAwB,CACzE,GAAI,IAAS,EACX,MAAO,GAGT,GAAI,MAAM,QAAQ,CAAI,GAAK,MAAM,QAAQ,CAAI,EAAG,CAC9C,GAAI,EAAK,SAAW,EAAK,OACvB,MAAO,GAIT,IAAK,IAAI,EAAI,EAAG,EAAI,EAAK,OAAQ,IAC/B,GAAI,CAAC,EAAoB,EAAK,GAAI,EAAK,EAAE,EACvC,MAAO,GAIX,MAAO,EACT,CAEA,MAAO,EACT"}

package/dist/cjs/routerFSM.js

@@ -0,0 +1,2 @@
+const e=require("./foundation/fsm/fsm.js"),t={IDLE:`IDLE`,STARTING:`STARTING`,READY:`READY`,TRANSITION_STARTED:`TRANSITION_STARTED`,LEAVE_APPROVED:`LEAVE_APPROVED`,DISPOSED:`DISPOSED`},n={START:`START`,STARTED:`STARTED`,NAVIGATE:`NAVIGATE`,LEAVE_APPROVE:`LEAVE_APPROVE`,COMPLETE:`COMPLETE`,FAIL:`FAIL`,CANCEL:`CANCEL`,STOP:`STOP`,DISPOSE:`DISPOSE`},r={initial:t.IDLE,context:null,transitions:{[t.IDLE]:{[n.START]:t.STARTING,[n.DISPOSE]:t.DISPOSED},[t.STARTING]:{[n.STARTED]:t.READY,[n.FAIL]:t.IDLE,[n.STOP]:t.IDLE,[n.DISPOSE]:t.DISPOSED},[t.READY]:{[n.NAVIGATE]:t.TRANSITION_STARTED,[n.FAIL]:t.READY,[n.STOP]:t.IDLE,[n.DISPOSE]:t.DISPOSED},[t.TRANSITION_STARTED]:{[n.NAVIGATE]:t.TRANSITION_STARTED,[n.LEAVE_APPROVE]:t.LEAVE_APPROVED,[n.CANCEL]:t.READY,[n.FAIL]:t.READY,[n.DISPOSE]:t.DISPOSED},[t.LEAVE_APPROVED]:{[n.NAVIGATE]:t.TRANSITION_STARTED,[n.COMPLETE]:t.READY,[n.CANCEL]:t.READY,[n.FAIL]:t.READY,[n.DISPOSE]:t.DISPOSED},[t.DISPOSED]:{}}};function i(){return new e.FSM(r)}exports.createRouterFSM=i,exports.routerEvents=n,exports.routerStates=t;
+//# sourceMappingURL=routerFSM.js.map

package/dist/cjs/routerFSM.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"routerFSM.js","names":["FSM"],"sources":["../../src/routerFSM.ts"],"sourcesContent":["// packages/core/src/routerFSM.ts\n\nimport { FSM } from \"./foundation/fsm\";\n\nimport type { FSMConfig } from \"./foundation/fsm\";\nimport type { NavigationOptions, State } from \"./types\";\n\n/**\n * Router FSM states.\n *\n * - IDLE: Router not started or stopped\n * - STARTING: Router is initializing\n * - READY: Router is ready for navigation\n * - TRANSITION_STARTED: Navigation in progress (before deactivation guards)\n * - LEAVE_APPROVED: Deactivation guards passed, activation guards pending\n * - DISPOSED: Router has been disposed (R2+)\n */\nexport const routerStates = {\n  IDLE: \"IDLE\",\n  STARTING: \"STARTING\",\n  READY: \"READY\",\n  TRANSITION_STARTED: \"TRANSITION_STARTED\",\n  LEAVE_APPROVED: \"LEAVE_APPROVED\",\n  DISPOSED: \"DISPOSED\",\n} as const;\n\nexport type RouterState = (typeof routerStates)[keyof typeof routerStates];\n\n/**\n * Router FSM events.\n *\n * - START: Begin router initialization\n * - STARTED: Router initialization complete\n * - NAVIGATE: Begin navigation\n * - COMPLETE: Navigation completed successfully\n * - FAIL: Navigation or initialization failed\n * - CANCEL: Navigation cancelled\n * - STOP: Stop router\n * - DISPOSE: Dispose router (R2+)\n */\nexport const routerEvents = {\n  START: \"START\",\n  STARTED: \"STARTED\",\n  NAVIGATE: \"NAVIGATE\",\n  LEAVE_APPROVE: \"LEAVE_APPROVE\",\n  COMPLETE: \"COMPLETE\",\n  FAIL: \"FAIL\",\n  CANCEL: \"CANCEL\",\n  STOP: \"STOP\",\n  DISPOSE: \"DISPOSE\",\n} as const;\n\nexport type RouterEvent = (typeof routerEvents)[keyof typeof routerEvents];\n\n/**\n * Per-event payloads for the router FSM (#1169 commit-gate). The three hot\n * navigation transitions carry their transition states so the FSM action\n * dispatched by `send()` emits the matching transition event — i.e. events are\n * literal consequences of FSM transitions (no `forceState` + manual emit). See\n * `EventBusNamespace.#setupFSMActions`.\n */\nexport interface RouterPayloads {\n  NAVIGATE: { toState: State; fromState?: State | undefined };\n  LEAVE_APPROVE: { toState: State; fromState?: State | undefined };\n  COMPLETE: {\n    toState: State;\n    fromState?: State | undefined;\n    opts?: NavigationOptions | undefined;\n  };\n}\n\n/**\n * Router FSM configuration.\n *\n * Transitions:\n * - IDLE → STARTING (START), DISPOSED (DISPOSE)\n * - STARTING → READY (STARTED), IDLE (FAIL, STOP), DISPOSED (DISPOSE)\n * - READY → TRANSITION_STARTED (NAVIGATE), READY (FAIL, self-loop for early validation errors), IDLE (STOP), DISPOSED (DISPOSE)\n * - TRANSITION_STARTED → LEAVE_APPROVED (LEAVE_APPROVE), TRANSITION_STARTED (NAVIGATE, self-loop), READY (CANCEL, FAIL), DISPOSED (DISPOSE)\n * - LEAVE_APPROVED → READY (COMPLETE, CANCEL, FAIL), TRANSITION_STARTED (NAVIGATE), DISPOSED (DISPOSE)\n * - DISPOSED → (no transitions)\n *\n * DISPOSE is wired from every non-DISPOSED state so `router.dispose()` always\n * settles the FSM at DISPOSED. The facade orchestrates cleanup through IDLE\n * for healthy flows; the direct transitions guarantee the FSM is not left\n * stuck if cleanup is skipped (e.g. dispose mid-STARTING when the start\n * pipeline threw before STARTED/FAIL).\n */\nconst routerFSMConfig: FSMConfig<RouterState, RouterEvent, null> = {\n  initial: routerStates.IDLE,\n  context: null,\n  transitions: {\n    [routerStates.IDLE]: {\n      [routerEvents.START]: routerStates.STARTING,\n      [routerEvents.DISPOSE]: routerStates.DISPOSED,\n    },\n    [routerStates.STARTING]: {\n      [routerEvents.STARTED]: routerStates.READY,\n      [routerEvents.FAIL]: routerStates.IDLE,\n      [routerEvents.STOP]: routerStates.IDLE,\n      [routerEvents.DISPOSE]: routerStates.DISPOSED,\n    },\n    [routerStates.READY]: {\n      [routerEvents.NAVIGATE]: routerStates.TRANSITION_STARTED,\n      [routerEvents.FAIL]: routerStates.READY,\n      [routerEvents.STOP]: routerStates.IDLE,\n      [routerEvents.DISPOSE]: routerStates.DISPOSED,\n    },\n    [routerStates.TRANSITION_STARTED]: {\n      [routerEvents.NAVIGATE]: routerStates.TRANSITION_STARTED,\n      [routerEvents.LEAVE_APPROVE]: routerStates.LEAVE_APPROVED,\n      [routerEvents.CANCEL]: routerStates.READY,\n      [routerEvents.FAIL]: routerStates.READY,\n      [routerEvents.DISPOSE]: routerStates.DISPOSED,\n    },\n    [routerStates.LEAVE_APPROVED]: {\n      [routerEvents.NAVIGATE]: routerStates.TRANSITION_STARTED,\n      [routerEvents.COMPLETE]: routerStates.READY,\n      [routerEvents.CANCEL]: routerStates.READY,\n      [routerEvents.FAIL]: routerStates.READY,\n      [routerEvents.DISPOSE]: routerStates.DISPOSED,\n    },\n    [routerStates.DISPOSED]: {},\n  },\n};\n\n/**\n * Factory function to create a router FSM instance.\n *\n * @returns FSM instance with initial state \"IDLE\"\n */\nexport function createRouterFSM(): FSM<\n  RouterState,\n  RouterEvent,\n  null,\n  RouterPayloads\n> {\n  return new FSM<RouterState, RouterEvent, null, RouterPayloads>(\n    routerFSMConfig,\n  );\n}\n"],"mappings":"2CAiBa,EAAe,CAC1B,KAAM,OACN,SAAU,WACV,MAAO,QACP,mBAAoB,qBACpB,eAAgB,iBAChB,SAAU,UACZ,EAgBa,EAAe,CAC1B,MAAO,QACP,QAAS,UACT,SAAU,WACV,cAAe,gBACf,SAAU,WACV,KAAM,OACN,OAAQ,SACR,KAAM,OACN,QAAS,SACX,EAsCM,EAA6D,CACjE,QAAS,EAAa,KACtB,QAAS,KACT,YAAa,EACV,EAAa,MAAO,EAClB,EAAa,OAAQ,EAAa,UAClC,EAAa,SAAU,EAAa,QACvC,GACC,EAAa,UAAW,EACtB,EAAa,SAAU,EAAa,OACpC,EAAa,MAAO,EAAa,MACjC,EAAa,MAAO,EAAa,MACjC,EAAa,SAAU,EAAa,QACvC,GACC,EAAa,OAAQ,EACnB,EAAa,UAAW,EAAa,oBACrC,EAAa,MAAO,EAAa,OACjC,EAAa,MAAO,EAAa,MACjC,EAAa,SAAU,EAAa,QACvC,GACC,EAAa,oBAAqB,EAChC,EAAa,UAAW,EAAa,oBACrC,EAAa,eAAgB,EAAa,gBAC1C,EAAa,QAAS,EAAa,OACnC,EAAa,MAAO,EAAa,OACjC,EAAa,SAAU,EAAa,QACvC,GACC,EAAa,gBAAiB,EAC5B,EAAa,UAAW,EAAa,oBACrC,EAAa,UAAW,EAAa,OACrC,EAAa,QAAS,EAAa,OACnC,EAAa,MAAO,EAAa,OACjC,EAAa,SAAU,EAAa,QACvC,GACC,EAAa,UAAW,CAAC,CAC5B,CACF,EAOA,SAAgB,GAKd,CACA,OAAO,IAAIA,EAAAA,IACT,CACF,CACF"}

package/dist/cjs/stateMetaStore.js

@@ -0,0 +1,2 @@
+const e=new WeakMap;function t(t){return e.get(t)}function n(t,n){e.set(t,n)}exports.getStateMetaParams=t,exports.setStateMetaParams=n;
+//# sourceMappingURL=stateMetaStore.js.map

package/dist/cjs/stateMetaStore.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stateMetaStore.js","names":[],"sources":["../../src/stateMetaStore.ts"],"sourcesContent":["// packages/core/src/stateMetaStore.ts\n\nimport type { Params, State } from \"./types\";\n\nconst store = new WeakMap<State, Params>();\n\n/** @internal */\nexport function getStateMetaParams(state: State): Params | undefined {\n  return store.get(state);\n}\n\n/** @internal */\nexport function setStateMetaParams(state: State, params: Params): void {\n  store.set(state, params);\n}\n"],"mappings":"AAIA,MAAM,EAAQ,IAAI,QAGlB,SAAgB,EAAmB,EAAkC,CACnE,OAAO,EAAM,IAAI,CAAK,CACxB,CAGA,SAAgB,EAAmB,EAAc,EAAsB,CACrE,EAAM,IAAI,EAAO,CAAM,CACzB"}

package/dist/cjs/transitionPath.js

@@ -0,0 +1,2 @@
+const e=require("./stateMetaStore.js"),t=[];Object.freeze(t);function n(e){let t=e.split(`.`),n=t.length,r=[t[0]],i=t[0].length;for(let a=1;a<n-1;a++)i+=1+t[a].length,r.push(e.slice(0,i));return r.push(e),r}const r=new Set([`string`,`number`,`boolean`]);function i(e){return r.has(typeof e)}function a(e,t,n,r){let a=t[e];if(!a||typeof a!=`object`)return!0;for(let e of Object.keys(a)){let t=n.params[e],a=r.params[e];if(i(t)&&i(a)&&String(t)!==String(a))return!1}return!0}function o(e,t,n,r,i,o){for(let s=0;s<o;s++){let o=r[s];if(o!==i[s]||!a(o,e,t,n))return s}return o}const s=new Map;function c(e){let t=s.get(e);if(t)return t;let n=l(e);return Object.freeze(n),s.set(e,n),n}function l(e){if(!e)return[``];let t=e.indexOf(`.`);if(t===-1)return[e];let r=e.indexOf(`.`,t+1);if(r===-1)return[e.slice(0,t),e];let i=e.indexOf(`.`,r+1);return i===-1?[e.slice(0,t),e.slice(0,r),e]:e.indexOf(`.`,i+1)===-1?[e.slice(0,t),e.slice(0,r),e.slice(0,i),e]:n(e)}let u,d,f=null,p,m,h=null;function g(n,r){if(!r)return{intersection:``,toActivate:c(n.name),toDeactivate:t};let i=e.getStateMetaParams(n),a=e.getStateMetaParams(r);if(!i&&!a)return{intersection:``,toActivate:c(n.name),toDeactivate:c(r.name)};let s=c(n.name),l=c(r.name),u=Math.min(l.length,s.length),d=o(i??a,n,r,s,l,u),f;if(d>=l.length)f=t;else if(d===0&&l.length===1)f=l;else{f=[];for(let e=l.length-1;e>=d;e--)f.push(l[e])}let p=d===0?s:s.slice(d);return{intersection:d>0?l[d-1]:``,toDeactivate:f,toActivate:p}}function _(e,t){if(f!==null&&e===u&&t===d)return f;if(h!==null&&e===p&&t===m)return h;let n=g(e,t);return p=u,m=d,h=f,u=e,d=t,f=n,n}exports.getTransitionPath=_,exports.nameToIDs=c;
+//# sourceMappingURL=transitionPath.js.map

package/dist/cjs/transitionPath.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"transitionPath.js","names":["getStateMetaParams"],"sources":["../../src/transitionPath.ts"],"sourcesContent":["// packages/core/src/transitionPath.ts\n\nimport { getStateMetaParams } from \"./stateMetaStore\";\n\nimport type { State } from \"./types\";\n\n/**\n * Parameters extracted from a route segment.\n * Maps parameter names to their string values.\n */\ntype PrimitiveParam = string | number | boolean;\n\n/**\n * Represents a transition path between two router states.\n * Contains information about which route segments need to be activated/deactivated.\n */\nexport interface TransitionPath {\n  /** The common ancestor route segment where paths diverge */\n  intersection: string;\n  /** Route segments that need to be deactivated (in reverse order) */\n  toDeactivate: string[];\n  /** Route segments that need to be activated (in order) */\n  toActivate: string[];\n}\n\n// Constants for better maintainability\nconst ROUTE_SEGMENT_SEPARATOR = \".\";\nconst EMPTY_INTERSECTION = \"\";\nconst DEFAULT_ROUTE_NAME = \"\";\nconst FROZEN_EMPTY_ARRAY: string[] = [];\n\nObject.freeze(FROZEN_EMPTY_ARRAY);\n\n/**\n * Handles conversion of route names with many segments (5+).\n * Internal helper for nameToIDs function.\n *\n * Uses optimized hybrid approach: split to get segments, then slice original\n * string to build cumulative paths. This approach is 65-81% faster than\n * string concatenation for typical cases (5-10 segments).\n *\n * @param name - Route name with 5 or more segments\n * @returns Array of cumulative segment IDs\n * @throws {Error} If route depth exceeds maximum allowed\n * @internal\n */\nfunction nameToIDsGeneral(name: string): string[] {\n  // We know there are at least 5 segments at this point (after fast paths)\n  const segments = name.split(ROUTE_SEGMENT_SEPARATOR);\n  const segmentCount = segments.length;\n\n  // First segment is always just itself\n  const ids: string[] = [segments[0]];\n\n  // Calculate cumulative lengths and slice from original string\n  // This avoids repeated string concatenation (O(k²) → O(k))\n  let cumulativeLength = segments[0].length;\n\n  for (let i = 1; i < segmentCount - 1; i++) {\n    cumulativeLength += 1 + segments[i].length; // +1 for dot separator\n    ids.push(name.slice(0, cumulativeLength));\n  }\n\n  // Last segment is always the full route name\n  ids.push(name);\n\n  return ids;\n}\n\nconst PRIMITIVE_TYPES: ReadonlySet<string> = new Set([\n  \"string\",\n  \"number\",\n  \"boolean\",\n]);\n\nfunction isPrimitive(value: unknown): value is PrimitiveParam {\n  return PRIMITIVE_TYPES.has(typeof value);\n}\n\n/**\n * Compares segment parameters between two states without creating intermediate objects.\n * Returns true if all primitive params for the given segment are equal in both states.\n */\nfunction segmentParamsEqual(\n  name: string,\n  toMetaParams: Record<string, unknown>,\n  toState: State,\n  fromState: State,\n): boolean {\n  const keys = toMetaParams[name];\n\n  if (!keys || typeof keys !== \"object\") {\n    return true;\n  }\n\n  for (const key of Object.keys(keys)) {\n    const toVal = toState.params[key];\n    const fromVal = fromState.params[key];\n\n    if (\n      isPrimitive(toVal) &&\n      isPrimitive(fromVal) &&\n      String(toVal) !== String(fromVal)\n    ) {\n      return false;\n    }\n  }\n\n  return true;\n}\n\n/**\n * Finds the point where two state paths diverge based on segments and parameters.\n * Compares both segment names and their parameters to find the first difference.\n *\n * @param toMetaParams - Cached meta.params from toState (avoids per-segment WeakMap lookup)\n * @param toState - Target state\n * @param fromState - Source state\n * @param toStateIds - Segment IDs for target state\n * @param fromStateIds - Segment IDs for source state\n * @param maxI - Maximum index to check (minimum of both arrays)\n * @returns Index of first difference, or maxI if all checked segments match\n */\nfunction pointOfDifference(\n  toMetaParams: Record<string, unknown>,\n  toState: State,\n  fromState: State,\n  toStateIds: string[],\n  fromStateIds: string[],\n  maxI: number,\n): number {\n  for (let i = 0; i < maxI; i++) {\n    const toSegment = toStateIds[i];\n    const fromSegment = fromStateIds[i];\n\n    // Different segment names - immediate difference\n    if (toSegment !== fromSegment) {\n      return i;\n    }\n\n    if (!segmentParamsEqual(toSegment, toMetaParams, toState, fromState)) {\n      return i;\n    }\n  }\n\n  return maxI;\n}\n\n/**\n * Converts a route name to an array of hierarchical segment identifiers.\n * Each segment ID includes all parent segments in the path.\n *\n * @param name - Route name in dot notation (e.g., 'users.profile.edit')\n * @returns Array of cumulative segment IDs\n * @throws {Error} If route depth exceeds maximum allowed depth\n *\n * @example\n * // Simple route\n * nameToIDs('users');\n * // Returns: ['users']\n *\n * @example\n * // Nested route\n * nameToIDs('users.profile.edit');\n * // Returns: ['users', 'users.profile', 'users.profile.edit']\n *\n * @example\n * // Empty string (root route)\n * nameToIDs('');\n * // Returns: ['']\n *\n * @remarks\n * Input parameter is NOT validated in this function for performance reasons.\n * Validation significantly slows down nameToIDs execution.\n * The input should be validated by the function/method that calls nameToIDs.\n */\n// Module-global cache (shared across all router instances): bounded in practice by\n// the app's route-name vocabulary, which is stable across cloneRouter() requests, so\n// it does not grow per request. Intentionally NOT cleared on dispose() — it is not\n// per-router, so one router's teardown must not evict entries other routers rely on.\nconst nameToIDsCache = new Map<string, string[]>();\n\nexport function nameToIDs(name: string): string[] {\n  const cached = nameToIDsCache.get(name);\n\n  // Stryker disable next-line BlockStatement: equivalent — dropping the cache-hit early return recomputes the identical frozen id chain (the cache is a perf optimization, not a correctness gate).\n  if (cached) {\n    return cached;\n  }\n\n  const result = computeNameToIDs(name);\n\n  Object.freeze(result);\n  nameToIDsCache.set(name, result);\n\n  return result;\n}\n\nfunction computeNameToIDs(name: string): string[] {\n  if (!name) {\n    return [DEFAULT_ROUTE_NAME];\n  }\n\n  const firstDot = name.indexOf(ROUTE_SEGMENT_SEPARATOR);\n\n  if (firstDot === -1) {\n    return [name];\n  }\n\n  const secondDot = name.indexOf(ROUTE_SEGMENT_SEPARATOR, firstDot + 1);\n\n  if (secondDot === -1) {\n    return [name.slice(0, firstDot), name];\n  }\n\n  const thirdDot = name.indexOf(ROUTE_SEGMENT_SEPARATOR, secondDot + 1);\n\n  // Stryker disable next-line UnaryOperator,BlockStatement: equivalent — inverting/emptying the 3-segment fast path routes the name through nameToIDsGeneral (below), which yields the identical id chain (same rationale as the L242 ArithmeticOperator disable). The ConditionalExpression/EqualityOperator siblings stay live (→true and !== are killed).\n  if (thirdDot === -1) {\n    return [name.slice(0, firstDot), name.slice(0, secondDot), name];\n  }\n\n  // Stryker disable next-line ArithmeticOperator: equivalent — `thirdDot - 1` makes fourthDot non-(-1), routing 5+ segment names through nameToIDsGeneral, which yields the identical id chain.\n  const fourthDot = name.indexOf(ROUTE_SEGMENT_SEPARATOR, thirdDot + 1);\n\n  // Stryker disable next-line UnaryOperator,BlockStatement: equivalent — inverting/emptying the 4-segment fast path routes the name through nameToIDsGeneral (below), which yields the identical id chain (same rationale as the L242 ArithmeticOperator disable). The ConditionalExpression/EqualityOperator siblings stay live (→true and !== are killed).\n  if (fourthDot === -1) {\n    return [\n      name.slice(0, firstDot),\n      name.slice(0, secondDot),\n      name.slice(0, thirdDot),\n      name,\n    ];\n  }\n\n  return nameToIDsGeneral(name);\n}\n\n/**\n * Calculates the transition path between two router states.\n * Determines which route segments need to be deactivated and activated\n * to transition from one state to another.\n *\n * @param toState - Target state to transition to\n * @param fromState - Current state to transition from (optional)\n * @returns Transition path with intersection and segments to activate/deactivate\n *\n * @throws {TypeError} When toState is null or undefined\n * @throws {TypeError} When toState is not an object\n * @throws {TypeError} When toState.name is missing or not a string\n * @throws {TypeError} When toState.params is missing or not an object\n * @throws {TypeError} When toState.path is missing or not a string\n * @throws {TypeError} When toState.name contains invalid route format:\n *   - Contains only whitespace (e.g., \"   \")\n *   - Has consecutive dots (e.g., \"users..profile\")\n *   - Has leading/trailing dots (e.g., \".users\" or \"users.\")\n *   - Segments don't match pattern [a-zA-Z_][a-zA-Z0-9_-]* (e.g., \"users.123\")\n *   - Contains spaces or special characters (e.g., \"users profile\")\n *   - Exceeds maximum length (8192 characters)\n * @throws {TypeError} When fromState is provided and has any of the validation errors listed above for toState\n *\n * @example\n * // ✅ Valid calls\n * getTransitionPath({ name: 'users.profile', params: {}, path: '/users/profile' });\n * getTransitionPath(toState, fromState);\n * getTransitionPath({ name: '', params: {}, path: '/' }); // root route\n *\n * @example\n * // ❌ Invalid calls that throw TypeError\n * getTransitionPath(null);                                    // toState is null\n * getTransitionPath(undefined);                               // toState is undefined\n * getTransitionPath({});                                      // missing required fields\n * getTransitionPath({ name: 123, params: {}, path: '/' });    // name not a string\n * getTransitionPath({ name: 'home', path: '/' });             // missing params\n * getTransitionPath({ name: 'users..profile', params: {}, path: '/' }); // consecutive dots\n * getTransitionPath({ name: '.users', params: {}, path: '/' });         // leading dot\n * getTransitionPath({ name: 'users.', params: {}, path: '/' });         // trailing dot\n * getTransitionPath({ name: 'users profile', params: {}, path: '/' });  // contains space\n * getTransitionPath({ name: 'users.123', params: {}, path: '/' });      // segment starts with number\n * getTransitionPath(validToState, { name: 'invalid..route', params: {}, path: '/' }); // fromState invalid\n *\n * @example\n * // Full activation (no fromState)\n * getTransitionPath(makeState('users.profile'));\n * // Returns: {\n * //   intersection: '',\n * //   toActivate: ['users', 'users.profile'],\n * //   toDeactivate: []\n * // }\n *\n * @example\n * // Partial transition with common ancestor\n * getTransitionPath(\n *   makeState('users.profile'),\n *   makeState('users.list')\n * );\n * // Returns: {\n * //   intersection: 'users',\n * //   toActivate: ['users.profile'],\n * //   toDeactivate: ['users.list']\n * // }\n *\n * @example\n * // Complete route change\n * getTransitionPath(\n *   makeState('admin.dashboard'),\n *   makeState('users.profile')\n * );\n * // Returns: {\n * //   intersection: '',\n * //   toActivate: ['admin', 'admin.dashboard'],\n * //   toDeactivate: ['users.profile', 'users']\n * // }\n */\n// Single-entry cache: shouldUpdateNode calls getTransitionPath N times per\n// navigation with the same state objects (once per subscribed node).\n// Cache by reference eliminates N-1 redundant computations.\n// Module-global (≤2 State refs); not cleared on dispose — negligible, not per-router.\nlet cached1To: State | undefined;\nlet cached1From: State | undefined;\nlet cached1Result: TransitionPath | null = null;\n\nlet cached2To: State | undefined;\nlet cached2From: State | undefined;\nlet cached2Result: TransitionPath | null = null;\n\nfunction computeTransitionPath(\n  toState: State,\n  fromState?: State,\n): TransitionPath {\n  // ===== FAST PATH 1: Initial navigation (no fromState) =====\n  // This is the best performing case in benchmarks (5M ops/sec)\n  if (!fromState) {\n    return {\n      intersection: EMPTY_INTERSECTION,\n      toActivate: nameToIDs(toState.name),\n      toDeactivate: FROZEN_EMPTY_ARRAY,\n    };\n  }\n\n  // ===== FAST PATH 3: Missing meta requires full reload =====\n  // Single WeakMap lookup per state, reused in pointOfDifference/segmentParamsEqual\n  const toMetaParams = getStateMetaParams(toState);\n  const fromMetaParams = getStateMetaParams(fromState);\n\n  if (!toMetaParams && !fromMetaParams) {\n    // FAST PATH 3 (both states meta-less). Consumers that land here read the\n    // result order-INSENSITIVELY, so the from-chain is returned as-is\n    // (root→leaf, no reverse needed):\n    //   • `shouldUpdateNode` reads `toDeactivate` by MEMBERSHIP (`.includes`).\n    //   • Externally-supplied meta-less states (e.g. a plugin passing a raw\n    //     `{name, params, path}` to `navigateToState`) land here. Since #1170,\n    //     `navigateToState` carries the source's WeakMap meta across its writable\n    //     shell, so start()/popstate states are NOT meta-less. A `replace()`\n    //     survivor stays meta-less but is benign: the next transition's `toState`\n    //     always carries meta (buildNavigateState), so this both-meta-less path\n    //     is not reached from it.\n    // (`canNavigateTo` no longer reaches this path — since #970 it builds its\n    // toState WITH meta, mirroring buildNavigateState.)\n    // The navigate pipeline always carries meta (buildNavigateState) → STANDARD\n    // PATH below, which trims the shared ancestor and reverses correctly.\n    return {\n      intersection: EMPTY_INTERSECTION,\n      toActivate: nameToIDs(toState.name),\n      toDeactivate: nameToIDs(fromState.name),\n    };\n  }\n\n  // ===== STANDARD PATH: Routes with parameters =====\n  const toStateIds = nameToIDs(toState.name);\n  const fromStateIds = nameToIDs(fromState.name);\n  // Stryker disable next-line MethodExpression: equivalent — Math.max reads one index past the shorter id array; that slot is undefined, so the `toSegment !== fromSegment` check in pointOfDifference returns the same divergence index Math.min would stop at.\n  const maxI = Math.min(fromStateIds.length, toStateIds.length);\n\n  const i = pointOfDifference(\n    (toMetaParams ?? fromMetaParams) as Record<string, unknown>,\n    toState,\n    fromState,\n    toStateIds,\n    fromStateIds,\n    maxI,\n  );\n\n  // Optimization: Build deactivation list in reverse order directly\n  // instead of slice(i).toReversed() which creates 2 arrays\n  let toDeactivate: string[];\n\n  if (i >= fromStateIds.length) {\n    toDeactivate = FROZEN_EMPTY_ARRAY;\n  } else if (i === 0 && fromStateIds.length === 1) {\n    // Single-segment route: reversed = original, reuse cached frozen array\n    toDeactivate = fromStateIds;\n  } else {\n    toDeactivate = [];\n\n    for (let j = fromStateIds.length - 1; j >= i; j--) {\n      toDeactivate.push(fromStateIds[j]);\n    }\n  }\n\n  // Build activation list — reuse cached frozen array when using full list\n  const toActivate = i === 0 ? toStateIds : toStateIds.slice(i);\n\n  // Determine intersection point (common ancestor)\n  const intersection = i > 0 ? fromStateIds[i - 1] : EMPTY_INTERSECTION;\n\n  return {\n    intersection,\n    toDeactivate,\n    toActivate,\n  };\n}\n\nexport function getTransitionPath(\n  toState: State,\n  fromState?: State,\n): TransitionPath {\n  // Stryker disable BlockStatement: equivalent — both cache short-circuits below; emptying either early-return recomputes the identical TransitionPath (computeTransitionPath is deterministic for the same to/from states) and re-caches it. Restored right after.\n  if (\n    cached1Result !== null &&\n    toState === cached1To &&\n    fromState === cached1From\n  ) {\n    return cached1Result;\n  }\n\n  if (\n    cached2Result !== null &&\n    toState === cached2To &&\n    fromState === cached2From\n  ) {\n    return cached2Result;\n  }\n  // Stryker restore BlockStatement\n\n  const result = computeTransitionPath(toState, fromState);\n\n  cached2To = cached1To;\n  cached2From = cached1From;\n  cached2Result = cached1Result;\n\n  cached1To = toState;\n  cached1From = fromState;\n  cached1Result = result;\n\n  return result;\n}\n"],"mappings":"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"}

package/dist/cjs/{RouterValidator-CZ8kPkrI.d.ts → types/RouterValidator.d.ts}

@@ -103,5 +103,5 @@ interface RouterValidator {
   };
 }
 //#endregion
-export { RouterValidator as t };
-//# sourceMappingURL=RouterValidator-CZ8kPkrI.d.ts.map
+export { RouterValidator };
+//# sourceMappingURL=RouterValidator.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"RouterValidator.d.ts","names":[],"sources":["../../../src/types/RouterValidator.ts"],"mappings":";;;;;;;;;;UAUiB;;;;EAIf;IACE,wBAAwB;IACxB,wBAAwB;IACxB,4BACE,eACA,iBACA,iBACA;IAEF,+BAA+B;IAC/B,2BACE,eACA,iBACA;IAEF,uBAAuB;IACvB,iBACE,mBACA,eACA;IAEF,0BAA0B;IAC1B,+BAA+B,eAAe;IAC9C,mCAAmC,cAAc;IACjD,sBACE,cACA,kBACA;IAEF,uBAAuB,iBAAiB;IACxC,oBAAoB,eAAe;IACnC,uBAAuB,eAAe;IACtC,8BAA8B,mBAAmB;IACjD,0BAA0B;IAC1B,sBAAsB;IACtB,wBAAwB;;;;;EAM1B;IACE,kBAAkB,kBAAkB;IACpC,+BAA+B,oBAAoB;;;;;EAMrD;IACE,yBAAyB,eAAe;IACxC,4BACE,eACA,gBACA;IAEF,6BAA6B,eAAe;IAC5C,2BAA2B,cAAc;IACzC,0BAA0B,gBAAgB;IAC1C,oBAAoB;IACpB,gBAAgB,cAAc;IAC9B,qBAAqB,gBAAgB;IACrC,wBAAwB;;;;;EAM1B;IACE,sBAAsB,eAAe;IACrC,6BACE,kBACA;IAEF,qBAAqB;IACrB,0BAA0B;IAC1B,sBAAsB;IACtB,uBAAuB;IACvB,uBAAuB;IACvB,6BAA6B,iBAAiB;;;;;EAMhD;IACE,kBAAkB,kBAAkB;IACpC,uBAAuB,eAAe;IACtC,0BAA0B,eAAe;IACzC,gBAAgB,cAAc,cAAc;IAC5C,qBAAqB,cAAc;;;;;EAMrC;IACE,uBAAuB;IACvB,gCAAgC;IAChC,8BAA8B;IAC9B,4BAA4B,kBAAkB;IAC9C,iBAAiB,iBAAiB;IAClC,oBAAoB;;;;;EAMtB;IACE,wBACE,eACA,iBACA;IAEF,6BACE,aACA,aACA;;;;;EAOJ;IACE,uBAAuB,eAAe;IACtC,0BACE,eACA,mBACA"}

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

@@ -0,0 +1,184 @@
+import { RouteTreeState } from "./route-node-types.js";
+import { Params, SimpleState, State, StateMetaInput, Unsubscribe } from "./base.js";
+import { DefaultDependencies, GuardFnFactory, Options, Plugin, Route, RouteConfigUpdate } from "./router.js";
+import { EventMethodMap, EventName } from "./constants.js";
+import { TreeChangedEvent } from "./tree-changed.js";
+import { NavigationOptions, StateContext } from "../types.js";
+//#region src/types/api.d.ts
+/**
+ * Maps interceptable method names to their signatures.
+ * Used by {@link PluginApi.addInterceptor} to provide type-safe interceptor registration.
+ *
+ * To add a new interceptable method:
+ * 1. Add its signature here
+ * 2. Wrap it with `createInterceptable()` / `createBinaryInterceptable()` in
+ *    the `registerInternals` block of the Router constructor
+ *    (`packages/core/src/Router.ts`)
+ */
+interface InterceptableMethodMap {
+  start: (path?: string) => Promise<State>;
+  buildPath: (route: string, params?: Params) => string;
+  forwardState: (routeName: string, routeParams: Params) => SimpleState;
+}
+/**
+ * Type-safe interceptor callback.
+ * Receives `next` (the next function in the chain) followed by the method's original parameters.
+ */
+type InterceptorFn<M extends keyof InterceptableMethodMap> = (next: InterceptableMethodMap[M], ...args: Parameters<InterceptableMethodMap[M]>) => ReturnType<InterceptableMethodMap[M]>;
+/**
+ * Writer object returned by {@link PluginApi.claimContextNamespace}. Holds
+ * exclusive ownership of a single `state.context.<namespace>` key for the
+ * lifetime of the owning plugin.
+ *
+ * @description
+ * A plugin obtains a claim by calling `api.claimContextNamespace("ns")` at
+ * registration, then publishes per-navigation data via {@link write} from a
+ * lifecycle hook (typically `onTransitionSuccess`) or from an interceptor.
+ * The plugin must call {@link release} in its `teardown()` so another plugin
+ * can reclaim the same namespace.
+ *
+ * The core runtime enforces one invariant: a namespace can be held by at most
+ * one claim at a time. Double-claiming throws `CONTEXT_NAMESPACE_ALREADY_CLAIMED`.
+ *
+ * @example
+ * ```typescript
+ * const navigationPlugin: PluginFactory = (router) => {
+ *   const api = getPluginApi(router);
+ *   const claim = api.claimContextNamespace("navigation");
+ *
+ *   return {
+ *     onTransitionSuccess(toState, fromState) {
+ *       claim.write(toState, { direction: detectDirection(fromState, toState) });
+ *     },
+ *     teardown() {
+ *       claim.release();
+ *     },
+ *   };
+ * };
+ * ```
+ *
+ * @see {@link PluginApi.claimContextNamespace}
+ * @see {@link State.context}
+ */
+interface ContextNamespaceClaim<T = unknown> {
+  write: (state: State, value: T) => void;
+  release: () => void;
+}
+/**
+ * Plugin API — for plugins and infrastructure packages.
+ * Hides plugin-internal methods from public autocomplete.
+ */
+interface PluginApi {
+  makeState: <P extends Params = Params>(name: string, params?: P, path?: string, meta?: StateMetaInput) => State<P>;
+  buildState: (routeName: string, routeParams: Params) => RouteTreeState | undefined;
+  forwardState: <P extends Params = Params>(routeName: string, routeParams: P) => SimpleState<P>;
+  matchPath: <P extends Params = Params>(path: string) => State<P> | undefined;
+  /**
+   * Navigate to a fully-built `State`, skipping the redundant
+   * `forwardState`/`buildPath` round-trip in `buildNavigateState`.
+   *
+   * Plugin-only entry point for browser-initiated navigation: a plugin
+   * receives a URL event, resolves it via `api.matchPath(url)`, then commits
+   * the resulting `State` directly via `api.navigateToState(state, opts)`.
+   *
+   * Semantics vs `router.navigate(name, params, opts)`:
+   * - `forwardState` is NOT re-applied (matchPath already ran it).
+   * - `buildPath` is NOT re-run; `state.path` is used verbatim, preserving
+   *   `trailingSlash:"preserve"` source-URL output.
+   * - `forwardState`/`buildPath` interceptors do NOT run on this path; the
+   *   URL the user navigated to is the source of truth.
+   * - Pipeline: SAME_STATES check, FSM transition, guards, `subscribeLeave`,
+   *   `completeTransition`, plugin lifecycle hooks — all unchanged.
+   *
+   * Programmatic / userland navigation should keep using
+   * `router.navigate(name, params, opts)` so interceptors apply.
+   */
+  navigateToState: (state: State, options?: NavigationOptions) => Promise<State>;
+  setRootPath: (rootPath: string) => void;
+  getRootPath: () => string;
+  addEventListener: <E extends EventName>(eventName: E, cb: Plugin[EventMethodMap[E]]) => Unsubscribe;
+  buildNavigationState: (name: string, params?: Params) => State | undefined;
+  getOptions: () => Options;
+  getTree: () => unknown;
+  addInterceptor: <M extends keyof InterceptableMethodMap>(method: M, fn: InterceptorFn<M>) => Unsubscribe;
+  extendRouter: (extensions: Record<string, unknown>) => Unsubscribe;
+  /**
+   * Emits a `$$error` event without going through the navigation pipeline.
+   *
+   * Used by plugins that detect an error outside a running transition (e.g.,
+   * an unmatched URL on popstate in strict mode). The event reaches any
+   * `onTransitionError` plugin hook and any `$$error` listener so developers
+   * can observe errors raised by the plugin layer.
+   *
+   * The current router state is used as `fromState`; `toState` is `undefined`
+   * because no transition was attempted. Safe to call at any FSM state —
+   * delegates to `sendFailSafe` internally (direct emit when not READY).
+   */
+  emitTransitionError: (error: Error) => void;
+  claimContextNamespace: {
+    <K extends keyof StateContext & string>(namespace: K): ContextNamespaceClaim<StateContext[K]>;
+    (namespace: string): ContextNamespaceClaim;
+  };
+  getRouteConfig: (name: string) => Record<string, unknown> | undefined;
+}
+/**
+ * Routes API — for dynamic route mutation.
+ */
+interface RoutesApi<Dependencies extends DefaultDependencies = DefaultDependencies> {
+  add: (routes: Route<Dependencies>[] | Route<Dependencies>, options?: {
+    parent?: string;
+  }) => void;
+  remove: (name: string) => void;
+  /**
+   * Patch an existing route's configuration in place (no tree rebuild).
+   *
+   * Applies the structural/guard fields and any plugin-defined custom fields
+   * (lifecycle hooks, `preload`, `searchSchema`, …) from the patch. Fields are
+   * shallow-merged by key; `null` removes a field, `undefined` is a no-op.
+   * `name`/`path`/`children` are immutable — use `remove` + `add` to
+   * restructure. See {@link RouteConfigUpdate} for the full semantics and the
+   * plugin augmentation pattern.
+   */
+  update: (name: string, updates: RouteConfigUpdate<Dependencies>) => void;
+  clear: () => void;
+  replace: (routes: Route<Dependencies>[] | Route<Dependencies>) => void;
+  has: (name: string) => boolean;
+  get: (name: string) => Route<Dependencies> | undefined;
+  /**
+   * Subscribe to structural route-tree mutations (`add` / `remove` / `update`
+   * with structural fields / `replace` / `clear`). Fire-and-forget: the handler
+   * cannot cancel the mutation, runs after the atomic commit, and sees the
+   * post-mutation tree via `get()` / `has()`.
+   *
+   * Duplicate-registration semantics are **lenient** (mirrors
+   * `router.subscribe`): each call registers an independent listener and
+   * returns its own unsubscribe.
+   *
+   * @returns Unsubscribe function for this specific registration.
+   */
+  subscribeChanges: (handler: (event: TreeChangedEvent<Dependencies>) => void) => Unsubscribe;
+}
+/**
+ * Dependencies API — CRUD for dependency injection.
+ */
+interface DependenciesApi<Dependencies extends DefaultDependencies = DefaultDependencies> {
+  get: <K extends keyof Dependencies>(key: K) => Dependencies[K];
+  getAll: () => Partial<Dependencies>;
+  set: <K extends keyof Dependencies & string>(name: K, value: Dependencies[K]) => void;
+  setAll: (deps: Dependencies) => void;
+  remove: (name: keyof Dependencies) => void;
+  reset: () => void;
+  has: (name: keyof Dependencies) => boolean;
+}
+/**
+ * Lifecycle API — guard registration (addActivateGuard, addDeactivateGuard, etc.)
+ */
+interface LifecycleApi<Dependencies extends DefaultDependencies = DefaultDependencies> {
+  addActivateGuard: (name: string, canActivateHandler: GuardFnFactory<Dependencies> | boolean) => void;
+  addDeactivateGuard: (name: string, canDeactivateHandler: GuardFnFactory<Dependencies> | boolean) => void;
+  removeActivateGuard: (name: string) => void;
+  removeDeactivateGuard: (name: string) => void;
+}
+//#endregion
+export { ContextNamespaceClaim, DependenciesApi, InterceptableMethodMap, InterceptorFn, LifecycleApi, PluginApi, RoutesApi };
+//# sourceMappingURL=api.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"api.d.ts","names":[],"sources":["../../../src/types/api.ts"],"mappings":";;;;;;;;;;;;;;;;;UAqCiB;EACf,QAAQ,kBAAkB,QAAQ;EAClC,YAAY,eAAe,SAAS;EACpC,eAAe,mBAAmB,aAAa,WAAW;;;;;;KAOhD,cAAc,gBAAgB,2BACxC,MAAM,uBAAuB,OAC1B,MAAM,WAAW,uBAAuB,QACxC,WAAW,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAqCtB,sBAAsB;EACrC,QAAQ,OAAO,OAAO,OAAO;EAC7B;;;;;;UAOe;EACf,YAAY,UAAU,SAAS,QAC7B,cACA,SAAS,GACT,eACA,OAAO,mBACJ,MAAM;EAEX,aACE,mBACA,aAAa,WACV;EAEL,eAAe,UAAU,SAAS,QAChC,mBACA,aAAa,MACV,YAAY;EAEjB,YAAY,UAAU,SAAS,QAAQ,iBAAiB,MAAM;;;;;;;;;;;;;;;;;;;;;EAsB9D,kBACE,OAAO,OACP,UAAU,sBACP,QAAQ;EAEb,cAAc;EACd;EAEA,mBAAmB,UAAU,WAC3B,WAAW,GACX,IAAI,OAAO,eAAe,QACvB;EAEL,uBAAuB,cAAc,SAAS,WAAW;EAEzD,kBAAkB;EAElB;EAEA,iBAAiB,gBAAgB,wBAC/B,QAAQ,GACR,IAAI,cAAc,OACf;EAEL,eAAe,YAAY,4BAA4B;;;;;;;;;;;;;EAcvD,sBAAsB,OAAO;EAE7B;KAEG,gBAAgB,uBACf,WAAW,IACV,sBAAsB,aAAa;KACrC,oBAAoB;;EAGvB,iBAAiB,iBAAiB;;;;;UAMnB,UACf,qBAAqB,sBAAsB;EAE3C,MACE,QAAQ,MAAM,kBAAkB,MAAM,eACtC;IAAY;;EAGd,SAAS;;;;;;;;;;;EAYT,SAAS,cAAc,SAAS,kBAAkB;EAElD;EAEA,UAAU,QAAQ,MAAM,kBAAkB,MAAM;EAEhD,MAAM;EAEN,MAAM,iBAAiB,MAAM;;;;;;;;;;;;;EAc7B,mBACE,UAAU,OAAO,iBAAiB,2BAC/B;;;;;UAMU,gBACf,qBAAqB,sBAAsB;EAE3C,MAAM,gBAAgB,cAAc,KAAK,MAAM,aAAa;EAC5D,cAAc,QAAQ;EACtB,MAAM,gBAAgB,uBACpB,MAAM,GACN,OAAO,aAAa;EAEtB,SAAS,MAAM;EACf,SAAS,YAAY;EACrB;EACA,MAAM,YAAY;;;;;UAMH,aACf,qBAAqB,sBAAsB;EAE3C,mBACE,cACA,oBAAoB,eAAe;EAErC,qBACE,cACA,sBAAsB,eAAe;EAEvC,sBAAsB;EACtB,wBAAwB"}

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

@@ -0,0 +1,95 @@
+import { StateContext } from "../types.js";
+//#region src/types/base.d.ts
+/**
+ * Detach function returned by subscription APIs.
+ *
+ * @description
+ * Calling this function removes the associated listener. Returned by
+ * `router.subscribe()`, `router.addEventListener()`, `router.subscribeLeave()`,
+ * and plugin interceptors. Idempotent — calling more than once is safe and
+ * has no additional effect after the first call.
+ */
+type Unsubscribe = () => void;
+interface SimpleState<P extends Params = Params> {
+  name: string;
+  params: P;
+}
+type TransitionPhase = "deactivating" | "activating";
+type TransitionReason = "success" | "blocked" | "cancelled" | "error";
+interface TransitionMeta {
+  phase: TransitionPhase;
+  reason: TransitionReason;
+  reload?: boolean;
+  replace?: boolean;
+  redirected?: boolean;
+  from?: string;
+  blocker?: string;
+  segments: {
+    deactivated: string[];
+    activated: string[];
+    intersection: string;
+  };
+}
+interface State<P extends Params = Params> {
+  name: string;
+  params: P;
+  path: string;
+  transition: TransitionMeta;
+  /**
+   * Plugin-extensible per-route data, attached by plugins via
+   * `PluginApi.claimContextNamespace()` + `claim.write(state, value)`.
+   *
+   * @description
+   * Required field — always present as at least `{}` on every State created by
+   * the router (via `makeState`, `navigateToNotFound`, or `cloneRouter`).
+   *
+   * Typed extensions come from plugins augmenting {@link StateContext} through
+   * module augmentation. The intersection with `Record<string, unknown>` allows
+   * untyped namespaces (inline plugins, tests, or plugins that skip augmentation)
+   * to write without compile errors.
+   *
+   * The `context` object itself is **not frozen** — this is intentional, so
+   * plugins can attach data without cloning state. Core structural fields
+   * (`name`, `params`, `path`, `transition`) remain immutable via shallow
+   * `Object.freeze(state)`.
+   *
+   * @see {@link StateContext}
+   */
+  context: StateContext & Record<string, unknown>;
+}
+interface StateMetaInput<P extends Params = Params> {
+  params: P;
+}
+/**
+ * Parsed shape produced by `serializeRouterState()` (`@real-router/ssr-utils`,
+ * after `JSON.parse`). Identical to {@link State} minus `transition`
+ * (per-navigation `TransitionMeta` is meaningless after hydration; the client
+ * builds its own on commit). Defined here (not in `ssr-utils`) because core's
+ * own hydration scratchpad (`RouterInternals.hydrationState`) is typed against
+ * it — see `internals.ts`.
+ */
+type SerializedRouterState<P extends Params = Params> = Omit<State<P>, "transition">;
+/**
+ * RouterError interface describing the public API of the RouterError class.
+ * The actual class implementation is in the real-router package.
+ * This interface enables structural typing compatibility between
+ * core-types and real-router packages.
+ */
+interface RouterError extends Error {
+  [key: string]: unknown;
+  readonly code: string;
+  readonly segment: string | undefined;
+  readonly path: string | undefined;
+  setCode: (code: string) => void;
+  setErrorInstance: (err: Error) => void;
+  setAdditionalFields: (fields: Record<string, unknown>) => void;
+  hasField: (key: string) => boolean;
+  getField: (key: string) => unknown;
+  toJSON: () => Record<string, unknown>;
+}
+interface Params {
+  [key: string]: string | string[] | number | number[] | boolean | boolean[] | Params | Params[] | Record<string, string | number | boolean> | null | undefined;
+}
+//#endregion
+export { Params, RouterError, SerializedRouterState, SimpleState, State, StateMetaInput, TransitionMeta, TransitionPhase, TransitionReason, Unsubscribe };
+//# sourceMappingURL=base.d.ts.map

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

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

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

@@ -0,0 +1,72 @@
+//#region src/types/constants.d.ts
+/**
+ * Plugin lifecycle method names
+ */
+type PluginMethod = "onStart" | "onStop" | "onTransitionStart" | "onTransitionLeaveApprove" | "onTransitionCancel" | "onTransitionSuccess" | "onTransitionError";
+/**
+ * Router event names
+ */
+type EventName = "$start" | "$stop" | "$$start" | "$$leaveApprove" | "$$cancel" | "$$success" | "$$error";
+/**
+ * Event type keys
+ */
+type EventsKeys = "ROUTER_START" | "ROUTER_STOP" | "TRANSITION_START" | "TRANSITION_LEAVE_APPROVE" | "TRANSITION_CANCEL" | "TRANSITION_SUCCESS" | "TRANSITION_ERROR";
+/**
+ * Error code values
+ */
+type ErrorCodeValues = "NOT_STARTED" | "NO_START_PATH_OR_STATE" | "ALREADY_STARTED" | "ROUTE_NOT_FOUND" | "SAME_STATES" | "CANNOT_DEACTIVATE" | "CANNOT_ACTIVATE" | "TRANSITION_ERR" | "CANCELLED" | "DISPOSED" | "PLUGIN_CONFLICT" | "CONTEXT_NAMESPACE_ALREADY_CLAIMED";
+/**
+ * Error code keys
+ */
+type ErrorCodeKeys = "ROUTER_NOT_STARTED" | "NO_START_PATH_OR_STATE" | "ROUTER_ALREADY_STARTED" | "ROUTE_NOT_FOUND" | "SAME_STATES" | "CANNOT_DEACTIVATE" | "CANNOT_ACTIVATE" | "TRANSITION_ERR" | "TRANSITION_CANCELLED" | "ROUTER_DISPOSED" | "PLUGIN_CONFLICT" | "CONTEXT_NAMESPACE_ALREADY_CLAIMED" | "REENTRANT_NAVIGATION" | "REENTRANT_TREE_MUTATION";
+/**
+ * Mapping of event keys to plugin methods
+ */
+interface EventToPluginMap {
+  readonly ROUTER_START: "onStart";
+  readonly ROUTER_STOP: "onStop";
+  readonly TRANSITION_START: "onTransitionStart";
+  readonly TRANSITION_LEAVE_APPROVE: "onTransitionLeaveApprove";
+  readonly TRANSITION_CANCEL: "onTransitionCancel";
+  readonly TRANSITION_SUCCESS: "onTransitionSuccess";
+  readonly TRANSITION_ERROR: "onTransitionError";
+}
+/**
+ * Mapping of event keys to event names
+ */
+interface EventToNameMap {
+  ROUTER_START: "$start";
+  ROUTER_STOP: "$stop";
+  TRANSITION_START: "$$start";
+  TRANSITION_LEAVE_APPROVE: "$$leaveApprove";
+  TRANSITION_CANCEL: "$$cancel";
+  TRANSITION_SUCCESS: "$$success";
+  TRANSITION_ERROR: "$$error";
+}
+/**
+ * Mapping of event names to plugin method names.
+ * Type-level computation from EventToNameMap + EventToPluginMap.
+ */
+type EventMethodMap = { [K in EventsKeys as EventToNameMap[K]]: EventToPluginMap[K]; };
+/**
+ * Mapping of error code keys to their values
+ */
+interface ErrorCodeToValueMap {
+  ROUTER_NOT_STARTED: "NOT_STARTED";
+  NO_START_PATH_OR_STATE: "NO_START_PATH_OR_STATE";
+  ROUTER_ALREADY_STARTED: "ALREADY_STARTED";
+  ROUTE_NOT_FOUND: "ROUTE_NOT_FOUND";
+  SAME_STATES: "SAME_STATES";
+  CANNOT_DEACTIVATE: "CANNOT_DEACTIVATE";
+  CANNOT_ACTIVATE: "CANNOT_ACTIVATE";
+  TRANSITION_ERR: "TRANSITION_ERR";
+  TRANSITION_CANCELLED: "CANCELLED";
+  ROUTER_DISPOSED: "DISPOSED";
+  PLUGIN_CONFLICT: "PLUGIN_CONFLICT";
+  CONTEXT_NAMESPACE_ALREADY_CLAIMED: "CONTEXT_NAMESPACE_ALREADY_CLAIMED";
+  REENTRANT_NAVIGATION: "REENTRANT_NAVIGATION";
+  REENTRANT_TREE_MUTATION: "REENTRANT_TREE_MUTATION";
+}
+//#endregion
+export { ErrorCodeKeys, ErrorCodeToValueMap, ErrorCodeValues, EventMethodMap, EventName, EventToNameMap, EventToPluginMap, EventsKeys, PluginMethod };
+//# sourceMappingURL=constants.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","names":[],"sources":["../../../src/types/constants.ts"],"mappings":";;;;KAGY;;;;KAYA;;;;KAYA;;;;KAYA;;;;KAiBA;;;;UAmBK;WACN;WACA;WACA;WACA;WACA;WACA;WACA;;;;;UAMM;EACf;EACA;EACA;EACA;EACA;EACA;EACA;;;;;;KAOU,oBACT,KAAK,cAAc,eAAe,KAAK,iBAAiB;;;;UAM1C;EACf;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA"}

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

@@ -0,0 +1,9 @@
+import { LimitsConfig } from "./limits.js";
+//#region src/types/internal.d.ts
+/**
+ * Immutable limits configuration type.
+ */
+type Limits = Readonly<LimitsConfig>;
+//#endregion
+export { Limits };
+//# sourceMappingURL=internal.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"internal.d.ts","names":[],"sources":["../../../src/types/internal.ts"],"mappings":";;;;;KAwDY,SAAS,SAAS"}

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

@@ -0,0 +1,45 @@
+//#region src/types/limits.d.ts
+/**
+ * Configuration for router resource limits.
+ * Controls maximum allowed values for various router operations to prevent resource exhaustion.
+ */
+interface LimitsConfig {
+  /**
+   * Maximum number of route dependencies allowed.
+   * Prevents circular dependency chains and excessive dependency graphs.
+   *
+   * @default 100
+   */
+  maxDependencies: number;
+  /**
+   * Maximum number of plugins that can be registered.
+   * Limits plugin stack depth to prevent performance degradation.
+   *
+   * @default 50
+   */
+  maxPlugins: number;
+  /**
+   * Maximum number of event listeners per event type.
+   * Prevents memory leaks from excessive listener registration.
+   *
+   * @default 10000
+   */
+  maxListeners: number;
+  /**
+   * Listener count at which a memory leak warning is logged per event type.
+   * Set to 0 to disable the warning.
+   *
+   * @default 1000
+   */
+  warnListeners: number;
+  /**
+   * Maximum number of lifecycle handlers (canActivate/canDeactivate) per route.
+   * Controls guard function stack to prevent excessive validation overhead.
+   *
+   * @default 200
+   */
+  maxLifecycleHandlers: number;
+}
+//#endregion
+export { LimitsConfig };
+//# sourceMappingURL=limits.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"limits.d.ts","names":[],"sources":["../../../src/types/limits.ts"],"mappings":";;;;;UAIiB;;;;;;;EAOf;;;;;;;EAQA;;;;;;;EAQA;;;;;;;EAQA;;;;;;;EAQA"}

package/dist/cjs/types/route-node-types.d.ts

@@ -0,0 +1,46 @@
+//#region src/types/route-node-types.d.ts
+/**
+ * Route Node Type Definitions — Minimal Public API.
+ *
+ * This module exports ONLY the essential types used by real-router:
+ * - QueryParamsMode, QueryParamsOptions
+ * - RouteParams, RouteTreeState
+ *
+ * These types are copied from route-node to avoid circular dependencies.
+ *
+ * @module route-node-types
+ */
+type ArrayFormat = "none" | "brackets" | "index" | "comma";
+type BooleanFormat = "none" | "auto" | "empty-true";
+type NullFormat = "default" | "hidden";
+type NumberFormat = "none" | "auto";
+/**
+ * Options for query parameter parsing and building.
+ */
+interface QueryParamsOptions {
+  arrayFormat?: ArrayFormat;
+  booleanFormat?: BooleanFormat;
+  nullFormat?: NullFormat;
+  numberFormat?: NumberFormat;
+}
+/**
+ * Controls how query parameters are handled during matching.
+ */
+type QueryParamsMode = "default" | "strict" | "loose";
+type ParamSource = "url" | "query";
+type ParamTypeMap = Record<string, ParamSource>;
+type RouteTreeStateMeta = Record<string, ParamTypeMap>;
+interface RouteParams {
+  [key: string]: string | string[] | number | number[] | boolean | boolean[] | RouteParams | RouteParams[] | Record<string, string | number | boolean> | null | undefined;
+}
+/**
+ * Complete state representation of a matched route.
+ */
+interface RouteTreeState<P extends Record<string, unknown> = RouteParams> {
+  name: string;
+  params: P;
+  meta: RouteTreeStateMeta;
+}
+//#endregion
+export { QueryParamsMode, QueryParamsOptions, RouteParams, RouteTreeState };
+//# sourceMappingURL=route-node-types.d.ts.map

package/dist/cjs/types/route-node-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"route-node-types.d.ts","names":[],"sources":["../../../src/types/route-node-types.ts"],"mappings":";;;;;;;;;;;;KAgBK;KACA;KACA;KACA;;;;UAKY;EACf,cAAc;EACd,gBAAgB;EAChB,aAAa;EACb,eAAe;;;;;KAUL;KAMP;KACA,eAAe,eAAe;KAC9B,qBAAqB,eAAe;UAExB;GACd,4EAOG,cACA,gBACA;;;;;UAQW,eACf,UAAU,0BAA0B;EAEpC;EACA,QAAQ;EACR,MAAM"}