@moku-labs/web 1.4.0 → 1.4.1

package/dist/browser.d.mts

@@ -557,6 +557,32 @@ type Api$3 = {
    */
   t(locale: string, key: string): string;
 };
+//#endregion
+//#region src/plugins/router/iso-match.d.ts
+/**
+ * A compiled, engine-agnostic path matcher: the same `.exec({ pathname })` shape the
+ * router consumed from `URLPattern`, but backed by a native `RegExp` with named
+ * groups. Dropping `URLPattern` keeps route matching alive in every browser engine —
+ * Safari < 18.4 and Firefox < ~142 have no `URLPattern` global and would otherwise
+ * throw `ReferenceError` the instant the router compiles its table on boot.
+ */
+interface PathMatcher {
+  /**
+   * Match a pathname, mirroring `URLPattern.exec`: the named-group bag (under
+   * `pathname.groups`) on a hit, or `null` on a miss.
+   *
+   * @param input - The match input carrying the `pathname` to test.
+   * @param input.pathname - The URL pathname to match, e.g. `/en/hello/`.
+   * @returns A `{ pathname: { groups } }` result on a match, or `null` on no match.
+   */
+  exec(input: {
+    readonly pathname: string;
+  }): {
+    readonly pathname: {
+      readonly groups: Record<string, string | undefined>;
+    };
+  } | null;
+}
 declare namespace types_d_exports$5 {
   export { Api$2 as Api, ClientRoute, CompileInput, CompiledRoute, Config$2 as Config, ExtractApi$1 as ExtractApi, ExtractRouteParams, ExtractSegmentParameter, GenerateContext, HeadConfig$1 as HeadConfig, LayoutContext, LoadContext, MatcherTable, Prettify, RouteBuilder, RouteContext, RouteDefinition, RouteHandlers, RouteMap, RouteRequire, RouteState, RouterApi, RouterConfig, RouterState, State$2 as State, TypedRoute, Urls };
 }
@@ -836,10 +862,10 @@ interface CompiledRoute {
   readonly pattern: string;
   /** Dynamic-segment count (lower = more specific = matched first). */
   readonly dynamicSegmentCount: number;
-  /** Pre-built URLPattern matchers (lang-aware + bare fallback). */
+  /** Pre-built path matchers (lang-aware + bare fallback). */
   readonly matchers: {
-    readonly withLang: URLPattern;
-    readonly bare: URLPattern;
+    readonly withLang: PathMatcher;
+    readonly bare: PathMatcher;
   };
   /** Resolve pathname into params (withLang first, then bare with defaultLocale injected). */
   readonly matchFn: (pathname: string) => Record<string, string> | null;

package/dist/browser.mjs

@@ -1331,22 +1331,101 @@ function extractGroups(groups) {
 	}
 	return params;
 }
-//#endregion
-//#region src/plugins/router/builders/match.ts
+/** Regex metacharacters escaped when a static path segment is inlined into a compiled pattern. */
+const REGEX_METACHARS = /[.*+?^${}()|[\]\\]/g;
+/** Matches a `:name` or `:name(regex)` URLPattern group occupying one whole segment. */
+const NAMED_GROUP = /^:([A-Za-z_]\w*)(?:\((.+)\))?$/;
 /**
-* @file router plugin — runtime matching domain.
+* Escape a static path segment so its literal text matches verbatim inside the
+* compiled `RegExp` (a segment like `c++` must not be read as regex syntax).
 *
-* Pure functions that turn compiled patterns into a pathname matcher: build the
-* lang-aware/bare `URLPattern` pair, the `matchFn` (withLang first, bare fallback
-* injecting `defaultLocale`), and extract/strip params. No `ctx` here.
+* @param text - The static segment text.
+* @returns The regex-escaped segment.
+* @example
+* ```ts
+* escapeStaticSegment("about"); // "about"
+* ```
 */
+function escapeStaticSegment(text) {
+	return text.replaceAll(REGEX_METACHARS, String.raw`\$&`);
+}
 /**
-* Build a pathname matcher for a single route: tries the `withLang` URLPattern,
-* then the `bare` pattern injecting `defaultLocale` on miss.
+* Compile one URLPattern source segment (no surrounding slash) into a regex fragment
+* that captures a single path segment: `:name` → a named `[^/]+` group, `:name(re)` →
+* a named group constrained by `re`, and static text → its escaped literal.
 *
-* @param matchers - The pre-built `withLang` and `bare` URLPattern pair.
-* @param matchers.withLang - The locale-aware URLPattern variant.
-* @param matchers.bare - The bare URLPattern variant (no leading locale segment).
+* @param segment - One source segment, e.g. `:slug`, `:lang(en|uk)`, or `archive`.
+* @returns The regex fragment for that segment.
+* @example
+* ```ts
+* segmentToRegex(":lang(en|uk)"); // "(?<lang>en|uk)"
+* ```
+*/
+function segmentToRegex(segment) {
+	const named = NAMED_GROUP.exec(segment);
+	if (named) {
+		const [, name, constraint] = named;
+		return `(?<${name}>${constraint ?? "[^/]+"})`;
+	}
+	return escapeStaticSegment(segment);
+}
+/**
+* Compile a URLPattern pathname source string into a {@link PathMatcher} backed by a
+* native `RegExp` — a drop-in replacement for `new URLPattern({ pathname })` over the
+* subset the router emits: `:name`, `:name(regex)`, the optional `:name?` segment
+* (whose leading `/` is absorbed, so `/:lang?` matches `/en` or nothing), static
+* segments, and a required trailing slash. Anchored full-match, like `URLPattern`.
+*
+* @param source - The URLPattern pathname source, e.g. `/:lang?/:slug/`.
+* @returns A matcher whose `.exec({ pathname })` yields named groups or `null`.
+* @example
+* ```ts
+* const m = createPathMatcher("/:lang?/:slug/");
+* m.exec({ pathname: "/en/hello/" }); // { pathname: { groups: { lang: "en", slug: "hello" } } }
+* ```
+*/
+function createPathMatcher(source) {
+	const segments = source.split("/");
+	let pattern = "^";
+	for (let index = 1; index < segments.length; index += 1) {
+		const segment = segments[index] ?? "";
+		if (segment === "") {
+			pattern += "/";
+			continue;
+		}
+		const optional = segment.endsWith("?");
+		const fragment = segmentToRegex(optional ? segment.slice(0, -1) : segment);
+		pattern += optional ? `(?:/${fragment})?` : `/${fragment}`;
+	}
+	pattern += "$";
+	const regexp = new RegExp(pattern);
+	return { 
+	/**
+	* Run the compiled regex over a pathname (the {@link PathMatcher.exec} contract).
+	*
+	* @param input - The match input carrying the `pathname` to test.
+	* @param input.pathname - The URL pathname to match, e.g. `/en/hello/`.
+	* @returns A `{ pathname: { groups } }` result on a match, or `null` on no match.
+	* @example
+	* ```ts
+	* matcher.exec({ pathname: "/en/hello/" });
+	* ```
+	*/
+exec(input) {
+		const result = regexp.exec(input.pathname);
+		if (!result) return null;
+		return { pathname: { groups: result.groups ?? {} } };
+	} };
+}
+//#endregion
+//#region src/plugins/router/builders/match.ts
+/**
+* Build a pathname matcher for a single route: tries the `withLang` matcher,
+* then the `bare` matcher injecting `defaultLocale` on miss.
+*
+* @param matchers - The pre-built `withLang` and `bare` matcher pair.
+* @param matchers.withLang - The locale-aware matcher variant.
+* @param matchers.bare - The bare matcher variant (no leading locale segment).
 * @param defaultLocale - Locale injected when the bare fallback matches.
 * @returns A function resolving a pathname into params, or `null` on no match.
 * @example
@@ -1390,14 +1469,6 @@ function matchRoute(compiled, pathname) {
 }
 //#endregion
 //#region src/plugins/router/builders/compile.ts
-/**
-* @file router plugin — compilation + validation domain.
-*
-* Pure functions invoked from `onInit`: validate the route map, then compile each
-* route into URLPattern matchers + URL/file builders, count dynamic segments,
-* sort by specificity, and assemble the immutable `MatcherTable`. Receives DATA
-* only (`CompileInput`) — never the plugin ctx.
-*/
 /** Shared `[web]` error prefix for router validation failures. */
 const ERROR_PREFIX$6 = "[web] router";
 /** Maximum number of optional `{lang:?}` segments a single pattern may declare. */
@@ -1569,8 +1640,8 @@ function buildFilePath(pattern, params) {
 function buildMatchers(pattern, locales) {
 	const langRegex = `(${locales.join("|")})`;
 	return {
-		withLang: new URLPattern({ pathname: patternToUrlPattern(pattern, "withLang", langRegex) }),
-		bare: new URLPattern({ pathname: patternToUrlPattern(pattern, "bare", langRegex) })
+		withLang: createPathMatcher(patternToUrlPattern(pattern, "withLang", langRegex)),
+		bare: createPathMatcher(patternToUrlPattern(pattern, "bare", langRegex))
 	};
 }
 /**

package/dist/index.cjs

@@ -1889,22 +1889,101 @@ function extractGroups(groups) {
 	}
 	return params;
 }
-//#endregion
-//#region src/plugins/router/builders/match.ts
+/** Regex metacharacters escaped when a static path segment is inlined into a compiled pattern. */
+const REGEX_METACHARS = /[.*+?^${}()|[\]\\]/g;
+/** Matches a `:name` or `:name(regex)` URLPattern group occupying one whole segment. */
+const NAMED_GROUP = /^:([A-Za-z_]\w*)(?:\((.+)\))?$/;
 /**
-* @file router plugin — runtime matching domain.
+* Escape a static path segment so its literal text matches verbatim inside the
+* compiled `RegExp` (a segment like `c++` must not be read as regex syntax).
 *
-* Pure functions that turn compiled patterns into a pathname matcher: build the
-* lang-aware/bare `URLPattern` pair, the `matchFn` (withLang first, bare fallback
-* injecting `defaultLocale`), and extract/strip params. No `ctx` here.
+* @param text - The static segment text.
+* @returns The regex-escaped segment.
+* @example
+* ```ts
+* escapeStaticSegment("about"); // "about"
+* ```
 */
+function escapeStaticSegment(text) {
+	return text.replaceAll(REGEX_METACHARS, String.raw`\$&`);
+}
 /**
-* Build a pathname matcher for a single route: tries the `withLang` URLPattern,
-* then the `bare` pattern injecting `defaultLocale` on miss.
+* Compile one URLPattern source segment (no surrounding slash) into a regex fragment
+* that captures a single path segment: `:name` → a named `[^/]+` group, `:name(re)` →
+* a named group constrained by `re`, and static text → its escaped literal.
 *
-* @param matchers - The pre-built `withLang` and `bare` URLPattern pair.
-* @param matchers.withLang - The locale-aware URLPattern variant.
-* @param matchers.bare - The bare URLPattern variant (no leading locale segment).
+* @param segment - One source segment, e.g. `:slug`, `:lang(en|uk)`, or `archive`.
+* @returns The regex fragment for that segment.
+* @example
+* ```ts
+* segmentToRegex(":lang(en|uk)"); // "(?<lang>en|uk)"
+* ```
+*/
+function segmentToRegex(segment) {
+	const named = NAMED_GROUP.exec(segment);
+	if (named) {
+		const [, name, constraint] = named;
+		return `(?<${name}>${constraint ?? "[^/]+"})`;
+	}
+	return escapeStaticSegment(segment);
+}
+/**
+* Compile a URLPattern pathname source string into a {@link PathMatcher} backed by a
+* native `RegExp` — a drop-in replacement for `new URLPattern({ pathname })` over the
+* subset the router emits: `:name`, `:name(regex)`, the optional `:name?` segment
+* (whose leading `/` is absorbed, so `/:lang?` matches `/en` or nothing), static
+* segments, and a required trailing slash. Anchored full-match, like `URLPattern`.
+*
+* @param source - The URLPattern pathname source, e.g. `/:lang?/:slug/`.
+* @returns A matcher whose `.exec({ pathname })` yields named groups or `null`.
+* @example
+* ```ts
+* const m = createPathMatcher("/:lang?/:slug/");
+* m.exec({ pathname: "/en/hello/" }); // { pathname: { groups: { lang: "en", slug: "hello" } } }
+* ```
+*/
+function createPathMatcher(source) {
+	const segments = source.split("/");
+	let pattern = "^";
+	for (let index = 1; index < segments.length; index += 1) {
+		const segment = segments[index] ?? "";
+		if (segment === "") {
+			pattern += "/";
+			continue;
+		}
+		const optional = segment.endsWith("?");
+		const fragment = segmentToRegex(optional ? segment.slice(0, -1) : segment);
+		pattern += optional ? `(?:/${fragment})?` : `/${fragment}`;
+	}
+	pattern += "$";
+	const regexp = new RegExp(pattern);
+	return { 
+	/**
+	* Run the compiled regex over a pathname (the {@link PathMatcher.exec} contract).
+	*
+	* @param input - The match input carrying the `pathname` to test.
+	* @param input.pathname - The URL pathname to match, e.g. `/en/hello/`.
+	* @returns A `{ pathname: { groups } }` result on a match, or `null` on no match.
+	* @example
+	* ```ts
+	* matcher.exec({ pathname: "/en/hello/" });
+	* ```
+	*/
+exec(input) {
+		const result = regexp.exec(input.pathname);
+		if (!result) return null;
+		return { pathname: { groups: result.groups ?? {} } };
+	} };
+}
+//#endregion
+//#region src/plugins/router/builders/match.ts
+/**
+* Build a pathname matcher for a single route: tries the `withLang` matcher,
+* then the `bare` matcher injecting `defaultLocale` on miss.
+*
+* @param matchers - The pre-built `withLang` and `bare` matcher pair.
+* @param matchers.withLang - The locale-aware matcher variant.
+* @param matchers.bare - The bare matcher variant (no leading locale segment).
 * @param defaultLocale - Locale injected when the bare fallback matches.
 * @returns A function resolving a pathname into params, or `null` on no match.
 * @example
@@ -1948,14 +2027,6 @@ function matchRoute(compiled, pathname) {
 }
 //#endregion
 //#region src/plugins/router/builders/compile.ts
-/**
-* @file router plugin — compilation + validation domain.
-*
-* Pure functions invoked from `onInit`: validate the route map, then compile each
-* route into URLPattern matchers + URL/file builders, count dynamic segments,
-* sort by specificity, and assemble the immutable `MatcherTable`. Receives DATA
-* only (`CompileInput`) — never the plugin ctx.
-*/
 /** Shared `[web]` error prefix for router validation failures. */
 const ERROR_PREFIX$11 = "[web] router";
 /** Maximum number of optional `{lang:?}` segments a single pattern may declare. */
@@ -2127,8 +2198,8 @@ function buildFilePath(pattern, params) {
 function buildMatchers(pattern, locales) {
 	const langRegex = `(${locales.join("|")})`;
 	return {
-		withLang: new URLPattern({ pathname: patternToUrlPattern(pattern, "withLang", langRegex) }),
-		bare: new URLPattern({ pathname: patternToUrlPattern(pattern, "bare", langRegex) })
+		withLang: createPathMatcher(patternToUrlPattern(pattern, "withLang", langRegex)),
+		bare: createPathMatcher(patternToUrlPattern(pattern, "bare", langRegex))
 	};
 }
 /**

package/dist/index.d.cts

@@ -557,6 +557,32 @@ type Api$6 = {
    */
   t(locale: string, key: string): string;
 };
+//#endregion
+//#region src/plugins/router/iso-match.d.ts
+/**
+ * A compiled, engine-agnostic path matcher: the same `.exec({ pathname })` shape the
+ * router consumed from `URLPattern`, but backed by a native `RegExp` with named
+ * groups. Dropping `URLPattern` keeps route matching alive in every browser engine —
+ * Safari < 18.4 and Firefox < ~142 have no `URLPattern` global and would otherwise
+ * throw `ReferenceError` the instant the router compiles its table on boot.
+ */
+interface PathMatcher {
+  /**
+   * Match a pathname, mirroring `URLPattern.exec`: the named-group bag (under
+   * `pathname.groups`) on a hit, or `null` on a miss.
+   *
+   * @param input - The match input carrying the `pathname` to test.
+   * @param input.pathname - The URL pathname to match, e.g. `/en/hello/`.
+   * @returns A `{ pathname: { groups } }` result on a match, or `null` on no match.
+   */
+  exec(input: {
+    readonly pathname: string;
+  }): {
+    readonly pathname: {
+      readonly groups: Record<string, string | undefined>;
+    };
+  } | null;
+}
 declare namespace types_d_exports$8 {
   export { Api$5 as Api, ClientRoute, CompileInput, CompiledRoute, Config$5 as Config, ExtractApi$2 as ExtractApi, ExtractRouteParams, ExtractSegmentParameter, GenerateContext, HeadConfig$1 as HeadConfig, LayoutContext, LoadContext, MatcherTable, Prettify, RouteBuilder, RouteContext, RouteDefinition, RouteHandlers, RouteMap, RouteRequire, RouteState, RouterApi, RouterConfig, RouterState, State$5 as State, TypedRoute, Urls };
 }
@@ -836,10 +862,10 @@ interface CompiledRoute {
   readonly pattern: string;
   /** Dynamic-segment count (lower = more specific = matched first). */
   readonly dynamicSegmentCount: number;
-  /** Pre-built URLPattern matchers (lang-aware + bare fallback). */
+  /** Pre-built path matchers (lang-aware + bare fallback). */
   readonly matchers: {
-    readonly withLang: URLPattern;
-    readonly bare: URLPattern;
+    readonly withLang: PathMatcher;
+    readonly bare: PathMatcher;
   };
   /** Resolve pathname into params (withLang first, then bare with defaultLocale injected). */
   readonly matchFn: (pathname: string) => Record<string, string> | null;

package/dist/index.d.mts

@@ -557,6 +557,32 @@ type Api$6 = {
    */
   t(locale: string, key: string): string;
 };
+//#endregion
+//#region src/plugins/router/iso-match.d.ts
+/**
+ * A compiled, engine-agnostic path matcher: the same `.exec({ pathname })` shape the
+ * router consumed from `URLPattern`, but backed by a native `RegExp` with named
+ * groups. Dropping `URLPattern` keeps route matching alive in every browser engine —
+ * Safari < 18.4 and Firefox < ~142 have no `URLPattern` global and would otherwise
+ * throw `ReferenceError` the instant the router compiles its table on boot.
+ */
+interface PathMatcher {
+  /**
+   * Match a pathname, mirroring `URLPattern.exec`: the named-group bag (under
+   * `pathname.groups`) on a hit, or `null` on a miss.
+   *
+   * @param input - The match input carrying the `pathname` to test.
+   * @param input.pathname - The URL pathname to match, e.g. `/en/hello/`.
+   * @returns A `{ pathname: { groups } }` result on a match, or `null` on no match.
+   */
+  exec(input: {
+    readonly pathname: string;
+  }): {
+    readonly pathname: {
+      readonly groups: Record<string, string | undefined>;
+    };
+  } | null;
+}
 declare namespace types_d_exports$8 {
   export { Api$5 as Api, ClientRoute, CompileInput, CompiledRoute, Config$5 as Config, ExtractApi$2 as ExtractApi, ExtractRouteParams, ExtractSegmentParameter, GenerateContext, HeadConfig$1 as HeadConfig, LayoutContext, LoadContext, MatcherTable, Prettify, RouteBuilder, RouteContext, RouteDefinition, RouteHandlers, RouteMap, RouteRequire, RouteState, RouterApi, RouterConfig, RouterState, State$5 as State, TypedRoute, Urls };
 }
@@ -836,10 +862,10 @@ interface CompiledRoute {
   readonly pattern: string;
   /** Dynamic-segment count (lower = more specific = matched first). */
   readonly dynamicSegmentCount: number;
-  /** Pre-built URLPattern matchers (lang-aware + bare fallback). */
+  /** Pre-built path matchers (lang-aware + bare fallback). */
   readonly matchers: {
-    readonly withLang: URLPattern;
-    readonly bare: URLPattern;
+    readonly withLang: PathMatcher;
+    readonly bare: PathMatcher;
   };
   /** Resolve pathname into params (withLang first, then bare with defaultLocale injected). */
   readonly matchFn: (pathname: string) => Record<string, string> | null;

package/dist/index.mjs

@@ -1876,22 +1876,101 @@ function extractGroups(groups) {
 	}
 	return params;
 }
-//#endregion
-//#region src/plugins/router/builders/match.ts
+/** Regex metacharacters escaped when a static path segment is inlined into a compiled pattern. */
+const REGEX_METACHARS = /[.*+?^${}()|[\]\\]/g;
+/** Matches a `:name` or `:name(regex)` URLPattern group occupying one whole segment. */
+const NAMED_GROUP = /^:([A-Za-z_]\w*)(?:\((.+)\))?$/;
 /**
-* @file router plugin — runtime matching domain.
+* Escape a static path segment so its literal text matches verbatim inside the
+* compiled `RegExp` (a segment like `c++` must not be read as regex syntax).
 *
-* Pure functions that turn compiled patterns into a pathname matcher: build the
-* lang-aware/bare `URLPattern` pair, the `matchFn` (withLang first, bare fallback
-* injecting `defaultLocale`), and extract/strip params. No `ctx` here.
+* @param text - The static segment text.
+* @returns The regex-escaped segment.
+* @example
+* ```ts
+* escapeStaticSegment("about"); // "about"
+* ```
 */
+function escapeStaticSegment(text) {
+	return text.replaceAll(REGEX_METACHARS, String.raw`\$&`);
+}
 /**
-* Build a pathname matcher for a single route: tries the `withLang` URLPattern,
-* then the `bare` pattern injecting `defaultLocale` on miss.
+* Compile one URLPattern source segment (no surrounding slash) into a regex fragment
+* that captures a single path segment: `:name` → a named `[^/]+` group, `:name(re)` →
+* a named group constrained by `re`, and static text → its escaped literal.
 *
-* @param matchers - The pre-built `withLang` and `bare` URLPattern pair.
-* @param matchers.withLang - The locale-aware URLPattern variant.
-* @param matchers.bare - The bare URLPattern variant (no leading locale segment).
+* @param segment - One source segment, e.g. `:slug`, `:lang(en|uk)`, or `archive`.
+* @returns The regex fragment for that segment.
+* @example
+* ```ts
+* segmentToRegex(":lang(en|uk)"); // "(?<lang>en|uk)"
+* ```
+*/
+function segmentToRegex(segment) {
+	const named = NAMED_GROUP.exec(segment);
+	if (named) {
+		const [, name, constraint] = named;
+		return `(?<${name}>${constraint ?? "[^/]+"})`;
+	}
+	return escapeStaticSegment(segment);
+}
+/**
+* Compile a URLPattern pathname source string into a {@link PathMatcher} backed by a
+* native `RegExp` — a drop-in replacement for `new URLPattern({ pathname })` over the
+* subset the router emits: `:name`, `:name(regex)`, the optional `:name?` segment
+* (whose leading `/` is absorbed, so `/:lang?` matches `/en` or nothing), static
+* segments, and a required trailing slash. Anchored full-match, like `URLPattern`.
+*
+* @param source - The URLPattern pathname source, e.g. `/:lang?/:slug/`.
+* @returns A matcher whose `.exec({ pathname })` yields named groups or `null`.
+* @example
+* ```ts
+* const m = createPathMatcher("/:lang?/:slug/");
+* m.exec({ pathname: "/en/hello/" }); // { pathname: { groups: { lang: "en", slug: "hello" } } }
+* ```
+*/
+function createPathMatcher(source) {
+	const segments = source.split("/");
+	let pattern = "^";
+	for (let index = 1; index < segments.length; index += 1) {
+		const segment = segments[index] ?? "";
+		if (segment === "") {
+			pattern += "/";
+			continue;
+		}
+		const optional = segment.endsWith("?");
+		const fragment = segmentToRegex(optional ? segment.slice(0, -1) : segment);
+		pattern += optional ? `(?:/${fragment})?` : `/${fragment}`;
+	}
+	pattern += "$";
+	const regexp = new RegExp(pattern);
+	return { 
+	/**
+	* Run the compiled regex over a pathname (the {@link PathMatcher.exec} contract).
+	*
+	* @param input - The match input carrying the `pathname` to test.
+	* @param input.pathname - The URL pathname to match, e.g. `/en/hello/`.
+	* @returns A `{ pathname: { groups } }` result on a match, or `null` on no match.
+	* @example
+	* ```ts
+	* matcher.exec({ pathname: "/en/hello/" });
+	* ```
+	*/
+exec(input) {
+		const result = regexp.exec(input.pathname);
+		if (!result) return null;
+		return { pathname: { groups: result.groups ?? {} } };
+	} };
+}
+//#endregion
+//#region src/plugins/router/builders/match.ts
+/**
+* Build a pathname matcher for a single route: tries the `withLang` matcher,
+* then the `bare` matcher injecting `defaultLocale` on miss.
+*
+* @param matchers - The pre-built `withLang` and `bare` matcher pair.
+* @param matchers.withLang - The locale-aware matcher variant.
+* @param matchers.bare - The bare matcher variant (no leading locale segment).
 * @param defaultLocale - Locale injected when the bare fallback matches.
 * @returns A function resolving a pathname into params, or `null` on no match.
 * @example
@@ -1935,14 +2014,6 @@ function matchRoute(compiled, pathname) {
 }
 //#endregion
 //#region src/plugins/router/builders/compile.ts
-/**
-* @file router plugin — compilation + validation domain.
-*
-* Pure functions invoked from `onInit`: validate the route map, then compile each
-* route into URLPattern matchers + URL/file builders, count dynamic segments,
-* sort by specificity, and assemble the immutable `MatcherTable`. Receives DATA
-* only (`CompileInput`) — never the plugin ctx.
-*/
 /** Shared `[web]` error prefix for router validation failures. */
 const ERROR_PREFIX$11 = "[web] router";
 /** Maximum number of optional `{lang:?}` segments a single pattern may declare. */
@@ -2114,8 +2185,8 @@ function buildFilePath(pattern, params) {
 function buildMatchers(pattern, locales) {
 	const langRegex = `(${locales.join("|")})`;
 	return {
-		withLang: new URLPattern({ pathname: patternToUrlPattern(pattern, "withLang", langRegex) }),
-		bare: new URLPattern({ pathname: patternToUrlPattern(pattern, "bare", langRegex) })
+		withLang: createPathMatcher(patternToUrlPattern(pattern, "withLang", langRegex)),
+		bare: createPathMatcher(patternToUrlPattern(pattern, "bare", langRegex))
 	};
 }
 /**

package/package.json

@@ -113,5 +113,5 @@
     "test:cli-e2e": "bun test src/plugins/cli/__tests__/e2e/",
     "test:coverage": "vitest run --project unit --project integration --coverage"
   },
-  "version": "1.4.0"
+  "version": "1.4.1"
 }