@void/edge 0.25.0 → 0.26.1

package/README.md

@@ -1,5 +1,11 @@
 # @void/edge
 
-Shared routing and static asset helpers for Void's direct Cloudflare deployments and platform dispatch runtime.
+Routing and static asset helpers shared by [Void](https://void.cloud)'s direct Cloudflare deployments and platform runtime.
 
-Configure redirects, rewrites, headers, and asset behavior through `void.config.ts`. See [Static Assets](https://void.cloud/guide/edge/static-assets) and the [configuration reference](https://void.cloud/reference/config#routing).
+Configure redirects, rewrites, headers, and asset behavior through `void.config.ts`.
+
+## Documentation
+
+See [Static Assets](https://void.cloud/guide/edge/static-assets) and the [configuration reference](https://void.cloud/reference/config#routing).
+
+Read the [Void documentation](https://void.cloud) online or use the Markdown guides and references in `node_modules/void/docs/`, included with the `void` package.

package/dist/index.d.mts

@@ -71,8 +71,7 @@ export declare function compilePattern(source: string): CompiledPattern;
  */
 export declare function matchPatternCaptures(pattern: string, pathname: string): Record<string, string> | null;
 /**
- * Match a pattern against a pathname (boolean form). Header-rule callers only
- * need a yes/no — they don't care about captures. Malformed patterns yield
+ * Match a pattern against a pathname (boolean form). Malformed patterns yield
  * `false` rather than throwing (see `matchPatternCaptures`).
  */
 export declare function matchPattern(pattern: string, pathname: string): boolean;
@@ -81,14 +80,10 @@ export declare function matchPattern(pattern: string, pathname: string): boolean
  * captures. Only `*` is special (matches any characters including `/`); every
  * other character (including `:`) is treated as a literal.
  *
- * This preserves the pre-`feat/rewrites` semantics of header rules,
- * `routing.revalidate` keys, and `routing.revalidateQueryAllowlist` keys —
- * those callers never had `:name` capture syntax and existing tenant configs
- * may include literal `:` (e.g. `/api/v1:health`, `:batchGet`-style URLs).
- *
- * The capture-aware `matchPattern` above continues to be used by routing
- * rules (`redirects`/`rewrites`/`fallbacks`) where `:name` capture syntax was
- * intentionally introduced (see design-doc 0064).
+ * Used for header rules and `routing.revalidateQueryAllowlist` keys, which
+ * never had `:name` capture syntax; existing tenant configs may include literal
+ * `:` (e.g. `/api/v1:health`, `:batchGet`-style URLs). Routing rules
+ * (`redirects`/`rewrites`/`fallbacks`) use the capture-aware `compilePattern`.
  */
 export declare function matchLiteralPattern(pattern: string, pathname: string): boolean;
 /**
@@ -111,8 +106,7 @@ export declare function matchLiteralPattern(pattern: string, pathname: string):
  * from page routes on the deploy write side (`[slug]` → `/blog/:slug`,
  * `[...path]` → `/docs/:path{.+}`), so the `:name` here is a real route param
  * and MUST bind the same way the framework's own client route matcher
- * (`patternToRegex` in `pages/manifest.ts`) binds it — matching the write-side
- * matcher in `packages/api/src/routes/deploy.ts`.
+ * (`patternToRegex` in `pages/manifest.ts`) binds it.
  *
  * It is intentionally NOT used for user-authored header rules
  * (`applyHeaderRules`) or `revalidateQueryAllowlist` keys
@@ -230,8 +224,7 @@ type ResolvedAsset = Readonly<{
  *
  * Known limitation: a file whose name contains a literal `%` (e.g. `logo%20.svg`,
  * requested as `logo%2520.svg`) is not resolved — the path encoder leaves `%`
- * as-is, so the round-trip can't reproduce the double-escaped request. Such
- * names 404'd before this change too, so this is not a regression.
+ * as-is, so the round-trip can't reproduce the double-escaped request.
  */
 export declare function safeDecodePathname(pathname: string): string;
 /**

package/dist/index.mjs

@@ -15,13 +15,26 @@ const MAX_CACHE = 256;
 const compileCache = /* @__PURE__ */ new Map();
 const REGEX_SPECIAL = /[.+?^${}()|[\]\\]/;
 const PARAM_CHAR = /[A-Za-z0-9_]/;
-function compilePattern(source) {
-	const cached = compileCache.get(source);
-	if (cached) {
-		compileCache.delete(source);
-		compileCache.set(source, cached);
-		return cached;
+/** LRU read: re-inserting a hit moves it to the most-recently-used end of Map order. */
+function lruGet(cache, key) {
+	const value = cache.get(key);
+	if (value !== void 0) {
+		cache.delete(key);
+		cache.set(key, value);
+	}
+	return value;
+}
+/** LRU write: evict the least-recently-used entry once the cache is full. */
+function lruSet(cache, key, value) {
+	if (cache.size >= MAX_CACHE) {
+		const first = cache.keys().next();
+		if (!first.done) cache.delete(first.value);
 	}
+	cache.set(key, value);
+}
+function compilePattern(source) {
+	const cached = lruGet(compileCache, source);
+	if (cached) return cached;
 	const paramNames = [];
 	let legacySplatCaptured = false;
 	let pattern = "";
@@ -37,12 +50,11 @@ function compilePattern(source) {
 				index++;
 				continue;
 			}
+			paramNames.push(name);
 			if (source[nameEnd] === "*") {
-				paramNames.push(name);
 				pattern += `(?<${name}>.*)`;
 				index = nameEnd + 1;
 			} else {
-				paramNames.push(name);
 				pattern += `(?<${name}>[^/]+)`;
 				index = nameEnd;
 			}
@@ -64,11 +76,7 @@ function compilePattern(source) {
 		regex: new RegExp(`^${pattern}$`),
 		paramNames
 	};
-	if (compileCache.size >= MAX_CACHE) {
-		const first = compileCache.keys().next();
-		if (!first.done) compileCache.delete(first.value);
-	}
-	compileCache.set(source, compiled);
+	lruSet(compileCache, source, compiled);
 	return compiled;
 }
 /**
@@ -91,8 +99,7 @@ function matchPatternCaptures(pattern, pathname) {
 	return match.groups ?? {};
 }
 /**
-* Match a pattern against a pathname (boolean form). Header-rule callers only
-* need a yes/no — they don't care about captures. Malformed patterns yield
+* Match a pattern against a pathname (boolean form). Malformed patterns yield
 * `false` rather than throwing (see `matchPatternCaptures`).
 */
 function matchPattern(pattern, pathname) {
@@ -108,32 +115,21 @@ const literalRegexCache = /* @__PURE__ */ new Map();
 * captures. Only `*` is special (matches any characters including `/`); every
 * other character (including `:`) is treated as a literal.
 *
-* This preserves the pre-`feat/rewrites` semantics of header rules,
-* `routing.revalidate` keys, and `routing.revalidateQueryAllowlist` keys —
-* those callers never had `:name` capture syntax and existing tenant configs
-* may include literal `:` (e.g. `/api/v1:health`, `:batchGet`-style URLs).
-*
-* The capture-aware `matchPattern` above continues to be used by routing
-* rules (`redirects`/`rewrites`/`fallbacks`) where `:name` capture syntax was
-* intentionally introduced (see design-doc 0064).
+* Used for header rules and `routing.revalidateQueryAllowlist` keys, which
+* never had `:name` capture syntax; existing tenant configs may include literal
+* `:` (e.g. `/api/v1:health`, `:batchGet`-style URLs). Routing rules
+* (`redirects`/`rewrites`/`fallbacks`) use the capture-aware `compilePattern`.
 */
 function matchLiteralPattern(pattern, pathname) {
-	let regex = literalRegexCache.get(pattern);
-	if (regex) {
-		literalRegexCache.delete(pattern);
-		literalRegexCache.set(pattern, regex);
-	} else {
+	let regex = lruGet(literalRegexCache, pattern);
+	if (!regex) {
 		try {
 			const escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replaceAll("*", ".*");
 			regex = new RegExp(`^${escaped}$`);
 		} catch {
 			return false;
 		}
-		if (literalRegexCache.size >= MAX_CACHE) {
-			const first = literalRegexCache.keys().next();
-			if (!first.done) literalRegexCache.delete(first.value);
-		}
-		literalRegexCache.set(pattern, regex);
+		lruSet(literalRegexCache, pattern, regex);
 	}
 	try {
 		return regex.test(pathname);
@@ -162,8 +158,7 @@ const segmentRegexCache = /* @__PURE__ */ new Map();
 * from page routes on the deploy write side (`[slug]` → `/blog/:slug`,
 * `[...path]` → `/docs/:path{.+}`), so the `:name` here is a real route param
 * and MUST bind the same way the framework's own client route matcher
-* (`patternToRegex` in `pages/manifest.ts`) binds it — matching the write-side
-* matcher in `packages/api/src/routes/deploy.ts`.
+* (`patternToRegex` in `pages/manifest.ts`) binds it.
 *
 * It is intentionally NOT used for user-authored header rules
 * (`applyHeaderRules`) or `revalidateQueryAllowlist` keys
@@ -176,22 +171,15 @@ const segmentRegexCache = /* @__PURE__ */ new Map();
 * not be shared or they would cross-contaminate.
 */
 function matchSegmentPattern(pattern, pathname) {
-	let regex = segmentRegexCache.get(pattern);
-	if (regex) {
-		segmentRegexCache.delete(pattern);
-		segmentRegexCache.set(pattern, regex);
-	} else {
+	let regex = lruGet(segmentRegexCache, pattern);
+	if (!regex) {
 		try {
 			const escaped = pattern.replace(/(^|\/):[^/{}]+\{\.\+\}(?=\/|$)/g, "$1").replace(/(^|\/):[^/]+(?=\/|$)/g, "$1").replace(/[.+?^${}()|[\]\\]/g, "\\$&").replaceAll("*", ".*").replaceAll("", "[^/]+").replaceAll("", ".+");
 			regex = new RegExp(`^${escaped}$`);
 		} catch {
 			return false;
 		}
-		if (segmentRegexCache.size >= MAX_CACHE) {
-			const first = segmentRegexCache.keys().next();
-			if (!first.done) segmentRegexCache.delete(first.value);
-		}
-		segmentRegexCache.set(pattern, regex);
+		lruSet(segmentRegexCache, pattern, regex);
 	}
 	try {
 		return regex.test(pathname);
@@ -205,9 +193,11 @@ function matchSegmentPattern(pattern, pathname) {
 * because `compilePattern` captures anonymous `*` as `splat`.
 */
 function substituteParams(destination, params) {
-	return destination.replace(/:([A-Za-z0-9_]+)\*?/g, (whole, name) => {
+	const result = destination.replace(/:([A-Za-z0-9_]+)\*?/g, (whole, name) => {
 		return params[name] ?? whole;
 	});
+	if (/^[/\\]{2}/.test(result) && !/^[/\\]{2}/.test(destination)) return "/" + result.replace(/^[/\\]+/, "");
+	return result;
 }
 //#endregion
 //#region src/headers.ts
@@ -412,10 +402,10 @@ function createStaticEdgeHandler(config) {
 		const originalUrl = new URL(request.url);
 		if (request.method === "GET" && originalUrl.pathname === "/__void/ready") {
 			if (!config.versionMetadataBinding) return Response.json({ ready: true });
-			const metadata = config.versionMetadataBinding ? env[config.versionMetadataBinding] : void 0;
+			const metadata = env[config.versionMetadataBinding];
 			return Response.json({
 				ready: true,
-				...config.versionMetadataBinding ? { versionId: metadata?.id } : {}
+				versionId: metadata?.id
 			}, { headers: { "cache-control": "no-store" } });
 		}
 		let effectiveUrl = new URL(originalUrl);
@@ -481,8 +471,7 @@ function rewriteRequest(request, url, originalUrl) {
 *
 * Known limitation: a file whose name contains a literal `%` (e.g. `logo%20.svg`,
 * requested as `logo%2520.svg`) is not resolved — the path encoder leaves `%`
-* as-is, so the round-trip can't reproduce the double-escaped request. Such
-* names 404'd before this change too, so this is not a regression.
+* as-is, so the round-trip can't reproduce the double-escaped request.
 */
 function safeDecodePathname(pathname) {
 	let decoded;

package/package.json

@@ -1,6 +1,12 @@
 {
   "name": "@void/edge",
-  "version": "0.25.0",
+  "version": "0.26.1",
+  "description": "Routing, headers, and static asset helpers for Void runtimes.",
+  "homepage": "https://void.cloud",
+  "bugs": {
+    "url": "https://github.com/voidzero-dev/void/issues"
+  },
+  "license": "MIT",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/voidzero-dev/void.git",
@@ -20,12 +26,12 @@
     "access": "public"
   },
   "dependencies": {
-    "@void/deploy-core": "0.25.0"
+    "@void/deploy-core": "0.26.1"
   },
   "devDependencies": {
-    "@cloudflare/workers-types": "^4.20260702.1",
+    "@cloudflare/workers-types": "^5.20261009.1",
     "typescript": "7.0.2",
-    "vite-plus": "1.0.0"
+    "vite-plus": "1.1.0"
   },
   "scripts": {
     "build": "vp pack",