packages/router/src/experimental/route-resolver/matchers/matcher-pattern.spec.ts (4)

124-127: Add a symmetry check for double-slash build output

You verify star.build() preserves double slashes; also assert that the produced path re-matches and yields the expected pathMatch.

   it('keep paths as is', () => {
     const pattern = new MatcherPatternPathStar('/team/')
     expect(pattern.build({ pathMatch: '/hey' })).toBe('/team//hey')
+    // roundtrip: built path should match back to the same suffix
+    expect(pattern.match('/team//hey')).toEqual({ pathMatch: '/hey' })
   })

---

242-253: Add build() assertions for catch-all route

Cover the build side for empty, null, and non-empty pathMatch when trailingSlash is null (splat). This guards the “add trailing slash when empty” behavior.

   it('catch all route', () => {
     const pattern = new MatcherPatternPathDynamic(
       /^\/(.*)$/,
       { pathMatch: [] },
       [0],
       null
     )

     expect(pattern.match('/ok')).toEqual({ pathMatch: 'ok' })
     expect(pattern.match('/ok/ok/ok')).toEqual({ pathMatch: 'ok/ok/ok' })
     expect(pattern.match('/')).toEqual({ pathMatch: '' })
+    // build side
+    expect(pattern.build({ pathMatch: 'ok' })).toBe('/ok')
+    expect(pattern.build({ pathMatch: '' })).toBe('/')
+    expect(pattern.build({ pathMatch: null })).toBe('/')
   })

---

376-383: Keep the sparse tuple — add a linter-ignore to document intent

Acknowledged from prior context: the sparse tuple is intentional to validate support for sparse arrays. Add an inline Biome ignore to prevent false-positive lint errors and to explain intent for future readers.

   const pattern = new MatcherPatternPathDynamic(
     /^\/teams\/(.+?)\/$/,
     {
-      teamId: [, true],
+      // biome-ignore lint/suspicious/noSparseArray: intentionally testing sparse array support
+      teamId: [, true],
     },
     ['teams', 1],
     true
   )

---

433-441: Unreachable branch for v === undefined in parser.get

In match(), captures are normalized with ?? null, so get() never receives undefined. Either drop that branch or add a brief comment stating it’s unreachable with current matcher semantics.

-    const nullAwareParser = definePathParamParser({
-      get: (v: string | null) => {
-        if (v === null) return 'was-null'
-        if (v === undefined) return 'was-undefined'
-        return `processed-${v}`
-      },
+    const nullAwareParser = definePathParamParser({
+      get: (v: string | null) => {
+        if (v === null) return 'was-null'
+        // Note: `undefined` is not produced by the matcher (normalized to null)
+        return `processed-${v}`
+      },
       set: (v: string | null) =>
         v === 'was-null' ? null : String(v).replace('processed-', ''),
     })

packages/router/src/experimental/route-resolver/matchers/param-parsers/integers.spec.ts (4)

28-33: Add boundary tests for safe integers.

Guard against regressions on limits accepted by Number.isSafeInteger:

Apply this diff to extend coverage:

     it('parses valid scientific notation as integers', () => {
       expect(PARAM_PARSER_INT.get('1e5')).toBe(100000)
       expect(PARAM_PARSER_INT.get('1e2')).toBe(100)
       expect(PARAM_PARSER_INT.get('2.5e10')).toBe(25000000000)
       expect(PARAM_PARSER_INT.get('1.5e2')).toBe(150)
     })
+
+    it('respects MAX_SAFE_INTEGER boundaries', () => {
+      expect(PARAM_PARSER_INT.get('9007199254740991')).toBe(9007199254740991) // Number.MAX_SAFE_INTEGER
+      expect(() => PARAM_PARSER_INT.get('9007199254740992')).toThrow()
+    })
+
+    it('accepts explicit plus sign and -0', () => {
+      expect(PARAM_PARSER_INT.get('+42')).toBe(42)
+      expect(PARAM_PARSER_INT.get('-0')).toBe(0)
+    })

---

39-49: Decide policy for non-decimal numeric literals (0x, 0b, 0o).

Number() accepts hex/binary/octal (e.g., '0x2A' → 42). If you want to reject these for predictability, add tests (and a small guard in the parser). If you prefer to allow them, add tests to lock the behavior.

Possible tests to add (choose one direction and keep):

+    it('rejects non-decimal literal prefixes', () => {
+      expect(() => PARAM_PARSER_INT.get('0x2A')).toThrow()
+      expect(() => PARAM_PARSER_INT.get('0b1010')).toThrow()
+      expect(() => PARAM_PARSER_INT.get('0o52')).toThrow()
+    })
+    // or, to lock-in acceptance instead:
+    // expect(PARAM_PARSER_INT.get('0x2A')).toBe(42)
+    // expect(PARAM_PARSER_INT.get('0b1010')).toBe(10)
+    // expect(PARAM_PARSER_INT.get('0o52')).toBe(42)

---

67-76: Array cases are good; add whitespace-array coverage.

Single values accept whitespace as zero; mirror that in arrays to make the behavior explicit.

Apply this diff:

     it('handles empty arrays', () => {
       expect(PARAM_PARSER_INT.get([])).toEqual([])
     })
+
+    it('parses whitespace strings in arrays as zeros', () => {
+      expect(PARAM_PARSER_INT.get([' ', '\t', '\n'])).toEqual([0, 0, 0])
+    })

Also applies to: 79-99

---

102-115: Serialization tests look good; consider a negative-zero check.

String(-0) becomes '0'. Add a quick assertion to lock this behavior if desired.

Apply this diff:

     it('converts integers to strings', () => {
       expect(PARAM_PARSER_INT.set(0)).toBe('0')
       expect(PARAM_PARSER_INT.set(1)).toBe('1')
       expect(PARAM_PARSER_INT.set(42)).toBe('42')
       expect(PARAM_PARSER_INT.set(-1)).toBe('-1')
       expect(PARAM_PARSER_INT.set(-999)).toBe('-999')
       expect(PARAM_PARSER_INT.set(2147483647)).toBe('2147483647')
+      // -0 stringifies to '0'
+      // @ts-expect-error ensure runtime behavior is locked
+      expect(PARAM_PARSER_INT.set(-0 as any)).toBe('0')
     })

Also applies to: 117-132

packages/router/src/experimental/route-resolver/matchers/matcher-pattern-query.spec.ts (5)

89-125: Build() coverage is solid; fix a minor typo.

The test title has a split word.

Apply this diff:

-      it('strips off und efined values', () => {
+      it('strips off undefined values', () => {

Also applies to: 127-150

---

152-209: Default handling scenarios are well covered; fix a small comment typo.

Minor spelling nit.

Apply this diff:

-          // this leavs the value as null
+          // this leaves the value as null

---

211-231: Parser integration looks correct; add array-error fallback and BOOL array roundtrip tests.

Strengthen guarantees for arrays when a parser throws and default exists; also ensure array boolean build retains shape.

Apply this diff:

   describe('parser integration', () => {
@@
     it('throws on error without default', () => {
@@
     })
+
+    it('array: falls back to default on parser error', () => {
+      const matcher = new MatcherPatternQueryParam(
+        'ids',
+        'id',
+        'array',
+        PARAM_PARSER_INT,
+        [0]
+      )
+      expect(() => matcher.match({ id: ['ok', 'bad'] })).not.toThrow()
+      expect(matcher.match({ id: ['ok', 'bad'] })).toEqual({ ids: [0] })
+    })
@@
     it('can use PARAM_PARSER_BOOL for booleans', () => {
@@
       expect(matcher.build({ enabled: true })).toEqual({ e: 'true' })
     })
+
+    it('can handle boolean arrays end-to-end', () => {
+      const matcher = new MatcherPatternQueryParam(
+        'flags',
+        'f',
+        'array',
+        PARAM_PARSER_BOOL
+      )
+      expect(matcher.match({ f: ['true', 'false'] })).toEqual({
+        flags: [true, false],
+      })
+      expect(matcher.build({ flags: [true, false] })).toEqual({
+        f: ['true', 'false'],
+      })
+    })
   })

Also applies to: 233-257

---

404-476: Add tests for 'format: both' to document intended behavior.

Currently, 'both' is treated like 'array' in match(). Make it explicit via tests to avoid confusion and future regressions.

Apply this diff:

   describe('parser fallback', () => {
+    it('format: both behaves like array for match/build', () => {
+      const matcher = new MatcherPatternQueryParam(
+        'items',
+        'i',
+        'both',
+        PARAM_PARSER_DEFAULTS
+      )
+      expect(matcher.match({ i: 'one' })).toEqual({ items: ['one'] })
+      expect(matcher.match({ i: ['one', 'two'] })).toEqual({
+        items: ['one', 'two'],
+      })
+      expect(matcher.build({ items: ['x', 'y'] })).toEqual({ i: ['x', 'y'] })
+    })

---

439-476: Consider adding a build() test for arrays containing null with default serializer.

Locks behavior that nulls are preserved (not coerced into 'null').

Apply this diff:

       it('should handle array values with missing set method', () => {
@@
       })
+
+      it('build: preserves nulls in arrays with default serializer', () => {
+        const matcher = new MatcherPatternQueryParam(
+          'vals',
+          'v',
+          'array',
+          PARAM_PARSER_DEFAULTS
+        )
+        expect(matcher.build({ vals: ['a', null, 'b'] })).toEqual({
+          v: ['a', null, 'b'],
+        })
+      })

packages/router/src/experimental/route-resolver/matchers/param-parsers/integers.ts (2)

4-13: Optional: Reject non-decimal literal prefixes (0x/0b/0o) while preserving whitespace→0.

Number() accepts hex/binary/octal; this can be surprising for query params. If you want only decimal/scientific forms, add a small guard that doesn’t break the current whitespace-to-zero behavior.

Apply this diff:

 const PARAM_INTEGER_SINGLE = {
   get: (value: string | null) => {
-    const num = Number(value)
+    // Forbid non-decimal literal prefixes after trimming, but keep Number(value)
+    // so that whitespace-only strings still parse to 0.
+    const trimmed = typeof value === 'string' ? value.trim() : value
+    if (typeof trimmed === 'string' && /^(0[xX]|0[bB]|0[oO])/.test(trimmed)) {
+      throw miss()
+    }
+    const num = Number(value)
     if (value && Number.isSafeInteger(num)) {
       return num
     }
     throw miss()
   },
   set: (value: number) => String(value),
 } satisfies ParamParser<number, string | null>

---

12-13: Optional: Validate on set() to maintain integer invariants.

Helps catch accidental non-integer writes (e.g., from loose typing in user code).

Apply this diff:

-  set: (value: number) => String(value),
+  set: (value: number) => {
+    if (!Number.isSafeInteger(value)) throw miss()
+    return String(value)
+  },

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

💡 Knowledge Base configuration:

• MCP integration is disabled by default for public repositories
• Jira integration is disabled by default for public repositories
• Linear integration is disabled by default for public repositories

You can enable these sources in your CodeRabbit configuration.

Learnt from: posva
PR: vuejs/router#2415
File: packages/router/src/experimental/route-resolver/matchers/matcher-pattern.spec.ts:378-383
Timestamp: 2025-08-26T20:28:25.688Z
Learning: In Vue Router experimental code, sparse arrays like `[, true]` in matcher parameter options are intentionally used to test system support for sparse array syntax, not bugs to be fixed.

packages/router/src/experimental/route-resolver/matchers/matcher-pattern.spec.ts (1)

401-401: Keep sparse array test, but suppress linter noise with an inline directive

Per the learning from earlier discussion, the sparse array is intentional for support testing. Add a Biome ignore comment to prevent false positives.

Apply:

-        teamId: [, true],
+        // biome-ignore lint/suspicious/noSparseArray: intentional sparse array to test support
+        teamId: [, true],

packages/router/src/experimental/route-resolver/matchers/param-parsers/index.ts (2)

7-7: Empty PATH_PARAM_SINGLE_DEFAULT will crash at call sites — provide identity get/set or remove export

An empty object violates callers expecting parser.get/set. Provide safe no-ops.

Apply:

-export const PATH_PARAM_SINGLE_DEFAULT: ParamParser<string, string> = {}
+export const PATH_PARAM_SINGLE_DEFAULT: ParamParser<string, string> = {
+  get: (value: string) => value,
+  set: (value: string) => value,
+}

---

22-31: PATH_PARAM_PARSER_DEFAULTS: don’t stringify nullish array entries to 'null'

Comment says “doesn't allow null values in arrays” but set() maps them to 'null'. Reject nullish entries to avoid corrupt URLs.

Apply:

 export const PATH_PARAM_PARSER_DEFAULTS = {
   get: value => value ?? null,
-  set: value =>
-    value == null
-      ? null
-      : Array.isArray(value)
-        ? value.map(String)
-        : String(value),
+  set: value => {
+    if (value == null) return null
+    if (Array.isArray(value)) {
+      if (value.some(v => v == null)) {
+        throw new TypeError('Path param arrays cannot contain null/undefined entries')
+      }
+      return value.map(String)
+    }
+    return String(value)
+  },
   // differently from PARAM_PARSER_DEFAULTS, this doesn't allow null values in arrays
 } satisfies ParamParser<string | string[] | null, string | string[] | null>

packages/router/src/experimental/route-resolver/matchers/param-parsers/types.ts (1)

27-34: Clarify doc: this “Generic” alias models path params (no nullish array entries)

The wording implies universal usage; suggest scoping it to path params to avoid confusion with query parsers that may accept nulls.

Apply:

-/**
- * Generic type for a param parser that can handle both single and repeatable params.
- *
- * @see ParamParser
- */
+/**
+ * Generic type for a path param parser that can handle both single and repeatable params.
+ * Note: path params don't allow nullish entries in arrays; for query params use defineQueryParamParser.
+ *
+ * @see ParamParser
+ */

packages/router/src/experimental/route-resolver/matchers/param-parsers/index.ts (1)

49-50: Doc typo: “extend / infering” → “extends / inferring”

Minor polish.

Apply:

-  // path params are parsed by the router as these
-  // we use extend to allow infering a more specific type
+  // path params are parsed by the router as these
+  // we use extends to allow inferring a more specific type

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

💡 Knowledge Base configuration:

• MCP integration is disabled by default for public repositories
• Jira integration is disabled by default for public repositories
• Linear integration is disabled by default for public repositories

You can enable these sources in your CodeRabbit configuration.

Learnt from: posva
PR: vuejs/router#2415
File: packages/router/src/experimental/route-resolver/matchers/matcher-pattern.ts:0-0
Timestamp: 2025-08-14T13:58:50.446Z
Learning: The `encodeParam` function in vue-router handles nullish values (null/undefined) by returning an empty string, rather than stringifying them to "null" or "undefined". This means missing parameters in route building result in empty path segments rather than literal "undefined" in URLs.

Learnt from: posva
PR: vuejs/router#2415
File: packages/router/src/experimental/route-resolver/matchers/matcher-pattern.ts:0-0
Timestamp: 2025-08-14T13:58:50.446Z
Learning: The `encodeParam` function in vue-router has the signature `(text: string | number | null | undefined): string` and specifically handles nullish values by returning an empty string via `text == null ? '' : encodePath(text).replace(SLASH_RE, '%2F')`. This means missing or null parameters in route building result in empty path segments rather than literal "null"/"undefined" strings in URLs.

Learnt from: posva
PR: vuejs/router#2415
File: packages/router/src/experimental/route-resolver/matchers/matcher-pattern.spec.ts:378-383
Timestamp: 2025-08-26T20:28:25.698Z
Learning: In Vue Router experimental code, sparse arrays like `[, true]` in matcher parameter options are intentionally used to test system support for sparse array syntax, not bugs to be fixed.

packages/router/src/experimental/route-resolver/matchers/param-parsers/index.ts (2)

8-8: Provide safe no-op implementations to avoid runtime crashes.

An empty object will cause parser.get!/parser.set! call-sites to crash.

-export const PATH_PARAM_SINGLE_DEFAULT: ParamParser<string, string> = {}
+export const PATH_PARAM_SINGLE_DEFAULT: ParamParser<string, string> = {
+  get: (value: string) => value,
+  set: (value: string) => value,
+}

---

23-32: Do not stringify nullish array entries for path params.

map(String) turns null into the literal "null", contradicting the comment that arrays don’t allow nulls.

 export const PATH_PARAM_PARSER_DEFAULTS = {
   get: value => value ?? null,
   set: value =>
     value == null
       ? null
       : Array.isArray(value)
-        ? value.map(String)
+        ? value.filter((v): v is string => v != null).map(String)
         : String(value),
   // differently from PARAM_PARSER_DEFAULTS, this doesn't allow null values in arrays
 } satisfies ParamParser<string | string[] | null, string | string[] | null>

If you prefer, we can throw on nullish entries instead of filtering.

packages/router/src/experimental/route-resolver/matchers/param-parsers/strings.ts (1)

18-19: Doc nit: clarify sentence.

- * params. It doesn't make much sense to use it for path params will be `null |
- * string | string[]` (all cases combined).
+ * params. It doesn't make much sense to use it for path params, which will be
+ * `null | string | string[]` (all cases combined).

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

💡 Knowledge Base configuration:

• MCP integration is disabled by default for public repositories
• Jira integration is disabled by default for public repositories
• Linear integration is disabled by default for public repositories

You can enable these sources in your CodeRabbit configuration.

Learnt from: posva
PR: vuejs/router#2415
File: packages/router/src/experimental/route-resolver/matchers/matcher-pattern.ts:0-0
Timestamp: 2025-08-14T13:58:50.446Z
Learning: The `encodeParam` function in vue-router handles nullish values (null/undefined) by returning an empty string, rather than stringifying them to "null" or "undefined". This means missing parameters in route building result in empty path segments rather than literal "undefined" in URLs.

Learnt from: posva
PR: vuejs/router#2415
File: packages/router/src/experimental/route-resolver/matchers/matcher-pattern.ts:0-0
Timestamp: 2025-08-14T13:58:50.446Z
Learning: The `encodeParam` function in vue-router has the signature `(text: string | number | null | undefined): string` and specifically handles nullish values by returning an empty string via `text == null ? '' : encodePath(text).replace(SLASH_RE, '%2F')`. This means missing or null parameters in route building result in empty path segments rather than literal "null"/"undefined" strings in URLs.

packages/router/src/router.ts (2)

96-113: JSDoc references are correct now

The links target RouteRecordRaw (not EXPERIMENTAL_*). This resolves prior feedback.

---

71-74: Make this a type-only import to avoid runtime circular deps

These are types only; using a value import risks a runtime cycle with experimental/router.

-import {
-  EXPERIMENTAL_RouterOptions_Base,
-  EXPERIMENTAL_Router_Base,
-  _OnReadyCallback,
-} from './experimental/router'
+import type {
+  EXPERIMENTAL_RouterOptions_Base,
+  EXPERIMENTAL_Router_Base,
+  _OnReadyCallback,
+} from './experimental/router'

packages/router/src/router.ts (4)

20-20: Split type and value imports

HistoryState is a type; make it type-only for clarity and cleaner emits.

-import { HistoryState, NavigationType } from './history/common'
+import type { HistoryState } from './history/common'
+import { NavigationType } from './history/common'

---

47-47: Import App as a type

App is only used in type positions; import it as type.

-import { shallowRef, nextTick, App, unref, shallowReactive } from 'vue'
+import type { App } from 'vue'
+import { shallowRef, nextTick, unref, shallowReactive } from 'vue'

---

48-48: Type-only deep import (and good call on deep path per learnings)

RouteRecordNormalized is a type; import it as type. The deep path aligns with the repo’s dependency rules.

-import { RouteRecordNormalized } from './matcher/types'
+import type { RouteRecordNormalized } from './matcher/types'

---

897-901: Initialize ready to a boolean

Avoids relying on undefined truthiness.

-let ready: boolean
+let ready = false

packages/router/src/experimental/route-resolver/matchers/matcher-pattern-query.ts (3)

112-114: Avoid as any on set call

Use a typed helper to keep strong typing without any.

Apply:

-    return {
-      [this.queryKey]: (this.parser.set ?? PARAM_PARSER_DEFAULTS.set)(
-        paramValue as any
-      ),
-    }
+    const set: (v: T) => MatcherQueryParamsValue =
+      (this.parser.set ?? PARAM_PARSER_DEFAULTS.set) as (v: T) => MatcherQueryParamsValue
+    return {
+      [this.queryKey]: set(paramValue),
+    }

Longer-term, consider parameterizing TRaw on the class (e.g., ParamParser<T, MatcherQueryParamsValue, TRaw>) so build() can accept raw values without casts.

---

32-38: Doc update nit: comment mentions “value => keep the last value”

After the fix, please clarify the comment to note shape-preserving behavior for 'both', and that empty arrays arise only under 'array' normalization.

I can push a tiny doc tweak if you prefer.

---

21-31: Constructor surface looks good; consider documenting defaultValue ambiguity when T is a function

Make it explicit in the JSDoc that if T is a function/class, defaultValue should be provided as a zero-arg thunk (() => T) to avoid accidental invocation.

I can add the JSDoc line in a follow-up commit.

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

💡 Knowledge Base configuration:

• MCP integration is disabled by default for public repositories
• Jira integration is disabled by default for public repositories
• Linear integration is disabled by default for public repositories

You can enable these sources in your CodeRabbit configuration.

Learnt from: posva
PR: vuejs/router#2415
File: packages/router/src/experimental/index.ts:43-44
Timestamp: 2025-08-11T15:22:32.526Z
Learning: In the Vue Router codebase, files within the src directory should not import from src/index to avoid circular dependencies. Deep imports like `../matcher/types` are intentional and necessary for maintaining proper dependency hierarchy.

packages/router/src/experimental/route-resolver/matchers/matcher-pattern-query.ts (4)

39-43: Avoid Array.prototype.at for compat; use index math.

-        ? Array.isArray(queryValue)
-          ? queryValue.at(-1)
+        ? Array.isArray(queryValue)
+          ? (queryValue.length ? queryValue[queryValue.length - 1] : undefined)

---

33-38: Early-return on missing query key instead of flowing through parsing.

Short-circuit reduces try/catch paths and ensures parser.get is never called with absent data.

   match(query: MatcherQueryParams): Record<ParamName, T> {
     const queryValue: MatcherQueryParamsValue | undefined = query[this.queryKey]
 
+    // Absent key → use default or miss immediately.
+    if (queryValue === undefined) {
+      const def = resolveDefault(this.defaultValue)
+      if (def === undefined) throw miss()
+      return { [this.paramName]: def } as Record<ParamName, T>
+    }
+
     // normalize the value coming from the query based on the expected format

---

52-71: Clarify/align array parsing contract (whole-array vs per-item).

You pass the entire array to parser.get. If custom parsers expect string inputs, this will throw for any multi-value query. Either document that get must accept arrays or map per-item and skip invalids.

Optional per-item approach:

-      } else {
-        try {
-          value = (this.parser.get ?? PARAM_PARSER_DEFAULTS.get)(
-            valueBeforeParse
-          ) as T
-        } catch (error) {
-          if (this.defaultValue === undefined) {
-            throw error
-          }
-          value = undefined
-        }
-      }
+      } else {
+        const get = this.parser.get ?? PARAM_PARSER_DEFAULTS.get
+        try {
+          // Map each element; skip invalids unless no default provided.
+          const out: unknown[] = []
+          for (const v of valueBeforeParse) {
+            if (v != null) {
+              try { out.push(get(v as any)) } catch (e) { if (this.defaultValue == null) throw e }
+            }
+          }
+          value = (out.length ? (out as any) : undefined) as T | undefined
+        } catch (error) {
+          if (this.defaultValue === undefined) throw error
+          value = undefined
+        }
+      }

---

1-1: Replace vue.toValue with a local default resolver (avoids Vue 3.3+ peer bump and accidental calls).

toValue() forces a Vue ≥3.3 peer and will eagerly invoke function/class defaults. Use a tiny local helper and drop the import.

Apply:

- import { toValue } from 'vue'
+ // (toValue import removed; using local resolver)

Add after imports:

@@
 import { miss } from './errors'
 
+// Resolve defaults without pulling Vue and with explicit () => T semantics.
+function resolveDefault<T>(def: T | (() => T) | undefined): T | undefined {
+  return def === undefined ? undefined : (typeof def === 'function' ? (def as () => T)() : def)
+}

Replace usages:

-        value = toValue(this.defaultValue)
+        value = resolveDefault(this.defaultValue)!

-      value = toValue(this.defaultValue)
+      value = resolveDefault(this.defaultValue)!

If you prefer keeping toValue(), bump peerDependencies.vue to ^3.3.0 and verify.

#!/usr/bin/env bash
# Check peer dependency and remaining toValue imports
jq -r '.peerDependencies.vue // empty' packages/router/package.json
rg -n "toValue\\(" -n packages/router

Also applies to: 55-57, 95-96, 11-16

packages/router/package.json (1)

8-11: Ship CJS-aware typings (.d.cts) and wire them in exports

Only .d.mts is emitted. CJS/NodeNext consumers may miss types. Add a CJS declaration and point the require branch to it; also include it in published files.

   "types": "dist/vue-router.d.mts",
   "exports": {
     ".": {
-      "types": "./dist/vue-router.d.mts",
+      "types": "./dist/vue-router.d.mts",
       "node": {
         "import": {
           "production": "./vue-router.node.mjs",
           "development": "./vue-router.node.mjs",
           "default": "./vue-router.node.mjs"
         },
         "require": {
+          "types": "./dist/vue-router.d.cts",
           "production": "./dist/vue-router.prod.cjs",
           "development": "./dist/vue-router.cjs",
           "default": "./index.js"
         }
       },
       "import": "./dist/vue-router.mjs",
       "require": "./index.js"
     },

Outside this hunk:

-    "dist/**/*.d.{ts,mts}",
+    "dist/**/*.d.{ts,mts,cts}",

And ensure the file exists (see comment on Lines 95-98 for build step).

packages/router/src/experimental/route-resolver/matchers/matcher-pattern-query.ts (1)

111-115: Don’t emit an empty array in query; omit the key instead.

Serializing [] usually yields no meaningful URL state; returning EmptyParams is cleaner.

-    return {
-      [this.queryKey]: (this.parser.set ?? PARAM_PARSER_DEFAULTS.set)(
-        paramValue as any
-      ),
-    }
+    const serialized = (this.parser.set ?? PARAM_PARSER_DEFAULTS.set)(paramValue as any)
+    if (Array.isArray(serialized) && serialized.length === 0) {
+      return {} as EmptyParams
+    }
+    return { [this.queryKey]: serialized }

packages/router/package.json (3)

30-30: Expose types for "./experimental" subpath

Add a types entry so TS resolves subpath declarations without relying on root d.mts re-exports.

-    "./experimental": "./dist/experimental/index.mjs",
+    "./experimental": {
+      "types": "./dist/experimental/index.d.mts",
+      "default": "./dist/experimental/index.mjs"
+    },

---

95-98: Make build produce typings deterministically

Ensure build always emits declarations (including .d.cts) so “pnpm publish” doesn’t miss appended bits.

-    "build": "tsdown",
+    "build": "tsdown && pnpm run build:dts",
-    "build:dts": "tail -n +10 src/globalExtensions.ts >> dist/vue-router.d.mts",
+    "build:dts": "tail -n +10 src/globalExtensions.ts >> dist/vue-router.d.mts && cp dist/vue-router.d.mts dist/vue-router.d.cts",

Optional:

+    "prepublishOnly": "pnpm run build"

---

123-123: Remove unused API Extractor devDependency

No api-extractor invocation found in packages/router/package.json and the shared config isn’t used here; drop "@microsoft/api-extractor": "^7.52.8" from devDependencies to slim installs.

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

💡 Knowledge Base configuration:

• MCP integration is disabled by default for public repositories
• Jira integration is disabled by default for public repositories
• Linear integration is disabled by default for public repositories

You can enable these sources in your CodeRabbit configuration.

Learnt from: posva
PR: vuejs/router#2415
File: packages/router/src/experimental/index.ts:43-44
Timestamp: 2025-08-11T15:22:32.526Z
Learning: In the Vue Router codebase, files within the src directory should not import from src/index to avoid circular dependencies. Deep imports like `../matcher/types` are intentional and necessary for maintaining proper dependency hierarchy.

packages/router/src/experimental/route-resolver/resolver-fixed.ts (1)

233-235: Respect explicit hash and keep current hash for relative-by-name

Explicit to.hash should win. For relative-by-name (no to.name), reuse currentLocation.hash. Otherwise fall back to record default. Current order ignores to.hash.

-      const hash =
-        record.hash?.build(params) ?? to.hash ?? currentLocation?.hash ?? ''
+      const hash =
+        // Prefer explicit hash; for relative-by-name keep current hash; else use record default
+        to.hash ??
+        (to.name == null ? currentLocation?.hash : record.hash?.build(params)) ??
+        record.hash?.build(params) ??
+        ''

packages/router/src/experimental/route-resolver/matchers/matcher-pattern-query.ts (2)

41-44: Avoid Array.prototype.at for broader runtime compatibility.

Replace .at(-1) with index math to support older browsers without polyfills.

-        ? Array.isArray(queryValue)
-          ? queryValue.at(-1)
+        ? Array.isArray(queryValue)
+          ? (queryValue.length ? queryValue[queryValue.length - 1] : undefined)

---

1-1: Remove Vue dependency for defaults; add local resolver (or bump Vue peer dep to ≥3.3).

Using toValue ties the router to Vue ≥3.3 and can eagerly invoke function/class defaults. Prefer a local resolveDefault() and drop the import, or explicitly bump the vue peerDependency to ^3.3.0.

Apply:

-import { toValue } from 'vue'
+// Local default resolver to avoid Vue peer dependency and accidental invocation of classes.
+function resolveDefault<T>(def: T | (() => T) | undefined): T | undefined {
+  if (def === undefined) return undefined
+  return typeof def === 'function' ? (def as () => T)() : def
+}

-        value = toValue(this.defaultValue)
+        value = resolveDefault(this.defaultValue)!

-      value = toValue(this.defaultValue)
+      value = resolveDefault(this.defaultValue)!

Also applies to: 56-59, 97-98

packages/router/src/experimental/route-resolver/resolver-abstract.ts (3)

119-124: Fix minor doc typo (“the the”)

“the the one that matched the location” → “the one that matched the location”.

-   * Chain of route records that lead to the matched one. The last record is
-   * the the one that matched the location. Each previous record is the parent
+   * Chain of route records that lead to the matched one. The last record is
+   * the one that matched the location. Each previous record is the parent

---

131-135: Make NO_MATCH_LOCATION immutable

Prevent accidental mutation of the sentinel at runtime.

-export const NO_MATCH_LOCATION = {
+export const NO_MATCH_LOCATION = Object.freeze({
   name: __DEV__ ? Symbol('no-match') : Symbol(),
   params: {},
   matched: [],
-} satisfies Omit<ResolverLocationResolved<never>, keyof LocationNormalized>
+}) as Omit<ResolverLocationResolved<never>, keyof LocationNormalized>

---

146-158: Clarify params optionality for named locations

Type currently requires params. If unresolved routes can have no params, consider params?: MatcherParamsFormatted for DX consistency with classic router.

packages/router/src/experimental/route-resolver/resolver-fixed.ts (5)

190-205: Message nit: missing space in warning

Small readability fix.

-          `Cannot resolve relative location "${JSON.stringify(to)}"without a "name" or a current location. This will crash in production.`,
+          `Cannot resolve relative location "${JSON.stringify(to)}" without a "name" or a current location. This will crash in production.`,

---

270-282: Warn on malformed hash for object-relative path too (parity with named branch)

Mirror the DEV warning used in the named branch.

-      } else {
-        const query = normalizeQuery(to.query)
+      } else {
+        if (__DEV__ && to.hash && !to.hash.startsWith('#')) {
+          warn(
+            `A "hash" should start with "#". Replace "${to.hash}" with "#${to.hash}".`
+          )
+        }
+        const query = normalizeQuery(to.query)
         const path = resolveRelativePath(to.path, currentLocation?.path || '/')
         url = {
           fullPath: NEW_stringifyURL(stringifyQuery, path, query, to.hash),
           path,
           query,
           hash: to.hash || '',
         }
       }

---

246-256: Ensure LocationNormalized.hash has a consistent leading “#”

parseURL returns a hash that includes “#”; object branches may set url.hash to a value without it. Consider normalizing hash (e.g., always storing with leading “#” while letting NEW_stringifyURL handle encoding).

Would you like me to add a small helper (e.g., normalizeHash(str?: string): string) and update both branches plus a test?

---

102-111: Guard against cycles in parent chain

A malformed record graph with cycles will loop forever. Add a DEV-only visited set to break and warn.

 export function buildMatched<T extends EXPERIMENTAL_ResolverRecord>(
   record: T
 ): T[] {
   const matched: T[] = []
-  let node: T | undefined = record
-  while (node) {
+  const seen = __DEV__ ? new Set<T>() : undefined
+  let node: T | undefined = record
+  while (node) {
+    if (__DEV__ && seen!.has(node)) {
+      warn(`Cycle detected in record.parent chain for "${String((node as any).name)}".`)
+      break
+    }
+    __DEV__ && seen!.add(node)
     matched.unshift(node)
     node = node.parent as T
   }
   return matched
 }

---

125-130: Duplicate record names silently overwrite earlier entries

If two records share the same name, the later one wins with no signal. In DEV, detect duplicates and warn/throw.

-  for (const record of records) {
-    recordMap.set(record.name, record)
-  }
+  for (const record of records) {
+    if (__DEV__ && recordMap.has(record.name)) {
+      warn(`Duplicate resolver record name "${String(record.name)}"; the last one wins.`)
+    }
+    recordMap.set(record.name, record)
+  }

packages/router/src/experimental/route-resolver/matchers/matcher-pattern-query.ts (2)

34-36: Optional: short-circuit early when key is absent and a default exists.

Tiny simplification: if queryValue === undefined and there is a default, return immediately and skip normalization/parsing branches.

   match(query: MatcherQueryParams): Record<ParamName, T> {
     const queryValue: MatcherQueryParamsValue | undefined = query[this.queryKey]
+
+    if (queryValue === undefined && this.defaultValue !== undefined) {
+      return {
+        [this.paramName]: resolveDefault(this.defaultValue)!,
+      } as Record<ParamName, T>
+    }

---

40-51: Nit: type the intermediate for clarity.

Annotate valueBeforeParse as MatcherQueryParamsValue to make intent explicit and keep inference stable across refactors.

-    let valueBeforeParse =
+    let valueBeforeParse: MatcherQueryParamsValue =

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

💡 Knowledge Base configuration:

• MCP integration is disabled by default for public repositories
• Jira integration is disabled by default for public repositories
• Linear integration is disabled by default for public repositories

You can enable these sources in your CodeRabbit configuration.

Learnt from: posva
PR: vuejs/router#2415
File: packages/router/src/experimental/index.ts:43-44
Timestamp: 2025-08-11T15:22:32.526Z
Learning: In the Vue Router codebase, files within the src directory should not import from src/index to avoid circular dependencies. Deep imports like `../matcher/types` are intentional and necessary for maintaining proper dependency hierarchy.

package.json (1)

4-4: Pin pnpm in Volta and confirm lockfile upgrade.

Add pnpm to Volta to avoid local/CI drift and ensure pnpm-lock.yaml was regenerated by pnpm 10.

Apply:

 "volta": {
-  "node": "24.7.0"
+  "node": "24.7.0",
+  "pnpm": "10.15.0"
 }

Quick checks:

#!/bin/bash
# Expect lockfileVersion compatible with pnpm@10 and packageManager matching
rg -n '^lockfileVersion:' pnpm-lock.yaml || true
rg -n '^  "packageManager":' package.json

.github/workflows/test.yml (4)

22-22: Harden checkout step: drop token, keep shallow fetch

Prevent write access to the repo in this job and make the intent explicit.

Apply:

-      - uses: actions/checkout@v5
+      - uses: actions/checkout@v5
+        with:
+          persist-credentials: false
+          fetch-depth: 1

---

18-21: Set least-privilege GITHUB_TOKEN for the job

Explicit permissions help reduce blast radius; this job only reads code.

     runs-on: ubuntu-latest
+    permissions:
+      contents: read

If you want fully deterministic runners, consider pinning the OS image (e.g., ubuntu-24.04) instead of ubuntu-latest.

---

36-36: Use frozen lockfile for deterministic installs

Fail fast on lockfile drift in CI.

-      - run: pnpm install
+      - run: pnpm install --frozen-lockfile

---

46-48: Fail CI if Codecov upload errors, and consider pinning

Make coverage upload issues visible; also consider pinning to a commit SHA.

-      - uses: codecov/codecov-action@v4
+      - uses: codecov/codecov-action@v4
         with:
           token: ${{ secrets.CODECOV_TOKEN }}
+          fail_ci_if_error: true

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

💡 Knowledge Base configuration:

• MCP integration is disabled by default for public repositories
• Jira integration is disabled by default for public repositories
• Linear integration is disabled by default for public repositories

You can enable these sources in your CodeRabbit configuration.