@void/edge 0.20.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026-present, Cloudflare, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,8 @@
+# @void/edge
+
+Shared edge-runtime primitives for Void deployments.
+
+The hosted dispatch Worker and direct Cloudflare deployments both consume this
+package for path matching, redirects, rewrites, response headers, and static
+asset resolution. The package contains no hosted-platform identity or routing
+state.

package/dist/index.d.mts

@@ -0,0 +1,253 @@
+import { AssetConfig, AssetConfig as AssetConfig$1, HeaderRule, HeaderRule as HeaderRule$1, RedirectRule, RedirectRule as RedirectRule$1 } from "@void/deploy-core";
+//#region src/headers.d.ts
+type HeaderRulePolicy = Readonly<{
+  /**
+   * Protect unrelated tenants that share one registrable domain. Direct
+   * deployments own their hostname and may safely use cookie header rules.
+   */
+  cookieIsolation?: "shared-domain" | "origin";
+}>;
+/** A single member of a `Clear-Site-Data` list. */
+type ClearSiteDataMember = Readonly<{
+  /** The member text, trimmed of surrounding whitespace; kept for re-serialization. */
+  raw: string;
+  /**
+   * The quoted-string content (original case) when the member is a well-formed
+   * quoted-string, else `null`. A browser ignores members that are not
+   * well-formed quoted-strings.
+   */
+  directive: string | null;
+}>;
+/**
+ * Parse a `Clear-Site-Data` header value into its list members. The value is a
+ * comma-separated list of quoted-strings (W3C Clear-Site-Data); a comma inside a
+ * quoted-string does not split a member. Empty members are dropped.
+ */
+export declare function parseClearSiteData(value: string): Array<ClearSiteDataMember>;
+/**
+ * Sanitize a `Clear-Site-Data` value so a tenant rule can't clear cookies across
+ * the shared *.void.app boundary, while still allowing the safe directives.
+ *
+ * Only `"cookies"` and `"*"` clear cookies for the registrable domain (and thus
+ * every tenant's subdomain). `"cache"`, `"storage"`, `"executionContexts"`, and
+ * any future quoted directive are origin-scoped — each subdomain is its own
+ * origin — so they are kept verbatim. Malformed members are dropped (a browser
+ * ignores them, and dropping forecloses a lenient parser honoring them).
+ *
+ * Returns the filtered value, or `null` when nothing safe remains: a `"*"`
+ * includes cookies and can't be expressed without them, and a value that is only
+ * `"cookies"` collapses to empty.
+ */
+export declare function sanitizeClearSiteData(value: string): string | null;
+/**
+ * Apply matching header rules to a response.
+ * All matching rules merge; last match wins for same header name.
+ * Returns the original response unchanged when no rules or no matches.
+ */
+export declare function applyHeaderRules(response: Response, pathname: string, rules?: ReadonlyArray<HeaderRule$1>, policy?: HeaderRulePolicy): Response;
+//#endregion
+//#region src/pattern.d.ts
+type CompiledPattern = Readonly<{
+  regex: RegExp;
+  paramNames: ReadonlyArray<string>;
+}>;
+export declare function compilePattern(source: string): CompiledPattern;
+/**
+ * Match a pattern against a pathname. Returns captured params, or null.
+ *
+ * Returns null (rather than throwing) when the pattern itself is malformed —
+ * e.g. multiple `*` producing duplicate `splat` capture names. Framework and
+ * API ingest both reject those, but a hand-crafted manifest could still reach
+ * the edge, and a single bad rule shouldn't 500 unrelated traffic.
+ */
+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
+ * `false` rather than throwing (see `matchPatternCaptures`).
+ */
+export declare function matchPattern(pattern: string, pathname: string): boolean;
+/**
+ * Match a pattern against a pathname using LITERAL semantics — no named
+ * 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).
+ */
+export declare function matchLiteralPattern(pattern: string, pathname: string): boolean;
+/**
+ * Match a REVALIDATE ROUTE pattern against a pathname using SEGMENT-ANCHORED
+ * semantics. Like `matchLiteralPattern` except a WHOLE-SEGMENT `:name` (a `:`
+ * right after `/` or at the start of the pattern, whose name is any non-empty
+ * run of non-`/` characters — NOT just JS-identifier chars, so `:post-id`,
+ * `:post.id`, etc. all anchor — running up to the next `/` or end of string)
+ * matches exactly ONE non-empty path segment (`[^/]+`). A whole-segment NAMED
+ * CATCH-ALL `:name{.+}` (a named catch-all page `[...path]` → `/docs/:path{.+}`)
+ * matches ONE-OR-MORE characters that MAY cross `/` (`.+`, so `/docs/a` and
+ * `/docs/a/b` both match, but bare `/docs` / `/docs/` do NOT). Only the exact
+ * `{.+}` constraint widens — a REGEX-constrained param like `:path{[0-9]+}`
+ * keeps its single-segment `[^/]+` meaning. `*` still expands to a catch-all
+ * that crosses `/`. A mid-segment `:` (e.g. `/api/v1:health`,
+ * `/api/documents:batchGet`) stays a LITERAL — only whole-segment `:name` /
+ * `:name{.+}` anchors.
+ *
+ * This is for `routing.revalidate` keys ONLY. Those keys are machine-generated
+ * 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`.
+ *
+ * It is intentionally NOT used for user-authored header rules
+ * (`applyHeaderRules`) or `revalidateQueryAllowlist` keys
+ * (`buildVariantOriginalUrl`), where `:name` must stay a literal — those keep
+ * using `matchLiteralPattern`. Sharing the segment behaviour there would make a
+ * user rule like `/:batchGet` over-match every single-segment path.
+ *
+ * NOTE: this matcher has its OWN regex cache — the same pattern string compiles
+ * to a DIFFERENT regex than `matchLiteralPattern` produces, so the caches must
+ * not be shared or they would cross-contaminate.
+ */
+export declare function matchSegmentPattern(pattern: string, pathname: string): boolean;
+/**
+ * Substitute `:name` and `:name*` tokens in a destination string with the
+ * matching named captures from `params`. `:splat` works for legacy `*` patterns
+ * because `compilePattern` captures anonymous `*` as `splat`.
+ */
+export declare function substituteParams(destination: string, params: Record<string, string>): string;
+//#endregion
+//#region src/routing-rules.d.ts
+type RoutingRuleResult = {
+  type: "redirect";
+  destination: string;
+  status: number;
+} | {
+  type: "rewrite";
+  destination: string;
+};
+/**
+ * Check routing rules (redirects + rewrites) against a request pathname.
+ *
+ * **First match wins** — matches Netlify `_redirects` and Vercel `vercel.json`
+ * semantics: users put more-specific rules above more-general ones, and the
+ * first rule whose source matches takes effect. (Header rules in this same
+ * package use last-match-wins for compatibility with Netlify `_headers`,
+ * which is the opposite of `_redirects`. The asymmetry is intentional.)
+ *
+ * `requestHost` is the WHATWG `url.hostname` (lowercase, port-stripped).
+ * Rules with a `host` field are skipped when `rule.host !== requestHost`;
+ * path-only rules apply to every host bound to the project.
+ *
+ * Returns a discriminated result. The caller is responsible for building the
+ * actual `Response` for redirects (so it can merge the request's query string
+ * into the `Location` header).
+ */
+export declare function applyRoutingRules(pathname: string, rules?: ReadonlyArray<RedirectRule$1>, requestHost?: string): RoutingRuleResult | null;
+/**
+ * Merge a request's query string into a redirect destination.
+ *
+ * If the destination already contains a `?`, its parameters take precedence
+ * over the request's. Otherwise the request's query is appended verbatim.
+ *
+ * A `#fragment` on the destination is stripped before the merge and
+ * re-appended afterwards, so `/new#faq` + `?utm=x` becomes `/new?utm=x#faq`
+ * rather than `/new#faq?utm=x` (which browsers treat as fragment text).
+ */
+export declare function mergeQueryIntoLocation(destination: string, requestSearch: string): string;
+//#endregion
+//#region src/runtime.d.ts
+type EdgeAssetFetcher = Readonly<{
+  fetch(request: Request): Promise<Response>;
+}>;
+type StaticEdgeEnv = Readonly<{
+  ASSETS: EdgeAssetFetcher;
+}>;
+type StaticEdgeConfig = Readonly<{
+  assetConfig?: AssetConfig$1;
+  headerRules?: ReadonlyArray<HeaderRule$1>;
+  redirectRules?: ReadonlyArray<RedirectRule$1>;
+  fallbackRules?: ReadonlyArray<RedirectRule$1>;
+}>;
+type StaticEdgeHandler = Readonly<{
+  fetch(request: Request, env: StaticEdgeEnv): Promise<Response>;
+}>;
+/**
+ * Create the thin Worker used by direct static, SPA, and SSG deployments.
+ * Routing semantics intentionally match the hosted dispatch Worker: redirects
+ * and rewrites run before assets, fallback rewrites run only after an asset
+ * miss, and response-header rules apply to the effective pathname.
+ */
+export declare function createStaticEdgeHandler(config: StaticEdgeConfig): StaticEdgeHandler;
+//#endregion
+//#region src/static.d.ts
+type ResolvedAsset = Readonly<{
+  path: string;
+  hash: string;
+  redirect?: string;
+  notFound?: boolean;
+  spa?: boolean;
+}>;
+/**
+ * Percent-decode a request pathname for a manifest lookup, honoring ONLY the
+ * encodings a conformant URL is required to use. Returns the raw value
+ * unchanged on a malformed sequence (e.g. a lone `%`) or on any non-canonical /
+ * over-encoded spelling.
+ *
+ * Request pathnames arrive percent-encoded — WHATWG `URL.pathname` never
+ * decodes — but manifest keys are the asset's decoded on-disk path (a file
+ * named `oxc masthead.riv` is stored under `/assets/oxc masthead.riv`, not
+ * `%20`). Callers try the raw key first, then this decoded form.
+ *
+ * The decoded form is accepted only when re-encoding it reproduces the request
+ * path (up to percent-escape letter case) — i.e. the only encoded bytes were
+ * characters a URL MUST encode (space, `#`, non-ASCII, …). This rejects
+ * over-encoded spellings of ordinary path text (`%2F`→`/`, `%61`→`a`, `%5F`→`_`,
+ * `%2e%2e`→`..`), which a browser would never send and which would otherwise let
+ * a request reconstruct a guarded path (`/assets%2Fx`, `/%61ssets/x`,
+ * `/%5F%5Fvoid/x`) and serve the manifest entry while the raw-`url.pathname`
+ * policy gates — the `/__void/*` reserved-route block, the hashed-asset prefix
+ * gate, and the header/redirect rules — never fire. The URL pathname setter
+ * applies exactly the WHATWG "path percent-encode set", making it the canonical
+ * re-encoder.
+ *
+ * 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.
+ */
+export declare function safeDecodePathname(pathname: string): string;
+/**
+ * Resolve a request pathname to a manifest entry using AssetConfig rules.
+ * Replicates Cloudflare Workers Assets path resolution behavior.
+ */
+export declare function resolveStaticPath(pathname: string, manifest: Record<string, string>, config: AssetConfig$1): ResolvedAsset | null;
+/**
+ * Get the Content-Type header value for a given file path based on its extension.
+ */
+export declare function getContentType(path: string): string;
+/**
+ * Resolve the Content-Type to serve for a stored asset, reconciling the value
+ * persisted at upload time (R2 `httpMetadata.contentType` / KV `ct` metadata)
+ * with a fresh path-based lookup. Returns `undefined` when no Content-Type
+ * header should be emitted.
+ *
+ * `application/null` is a sentinel (matching Wrangler) meaning "omit the
+ * Content-Type header entirely".
+ *
+ * `application/octet-stream` is the uploader's no-information default: older
+ * CLI versions stamped it on any extension their MIME table did not recognize
+ * (e.g. `.md`). Because assets are content-addressed and never re-uploaded,
+ * those stale octet-stream values can't be corrected at the source, so we
+ * treat a stored octet-stream as "unknown" and re-derive from the path here.
+ * Any other stored value is authoritative and honored as-is.
+ */
+export declare function resolveAssetContentType(stored: string | null | undefined, path: string): string | undefined;
+//#endregion
+export type { AssetConfig, ClearSiteDataMember, CompiledPattern, EdgeAssetFetcher, HeaderRule, HeaderRulePolicy, RedirectRule, ResolvedAsset, RoutingRuleResult, StaticEdgeConfig, StaticEdgeEnv, StaticEdgeHandler };

package/dist/index.mjs

@@ -0,0 +1,681 @@
+//#region src/pattern.ts
+/**
+* Shared path-pattern compiler used by header rules and routing rules.
+*
+* Syntax:
+*   `:name`   — single path segment, captured as `name`
+*   `:name*`  — zero or more path segments, captured as `name`
+*   `*`       — zero or more path segments, captured as `splat` (legacy)
+*
+* When a legacy pattern contains multiple anonymous `*`, the first captures
+* as `splat` and later wildcards are non-capturing. Boolean matching remains
+* backward compatible for existing header/revalidate patterns.
+*/
+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;
+	}
+	const paramNames = [];
+	let legacySplatCaptured = false;
+	let pattern = "";
+	let index = 0;
+	while (index < source.length) {
+		const character = source[index];
+		if (character === ":") {
+			let nameEnd = index + 1;
+			while (nameEnd < source.length && PARAM_CHAR.test(source[nameEnd])) nameEnd++;
+			const name = source.slice(index + 1, nameEnd);
+			if (!name) {
+				pattern += "\\:";
+				index++;
+				continue;
+			}
+			if (source[nameEnd] === "*") {
+				paramNames.push(name);
+				pattern += `(?<${name}>.*)`;
+				index = nameEnd + 1;
+			} else {
+				paramNames.push(name);
+				pattern += `(?<${name}>[^/]+)`;
+				index = nameEnd;
+			}
+		} else if (character === "*") {
+			if (legacySplatCaptured) pattern += `.*`;
+			else {
+				paramNames.push("splat");
+				pattern += `(?<splat>.*)`;
+				legacySplatCaptured = true;
+			}
+			index++;
+		} else {
+			if (REGEX_SPECIAL.test(character)) pattern += "\\";
+			pattern += character;
+			index++;
+		}
+	}
+	const compiled = {
+		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);
+	return compiled;
+}
+/**
+* Match a pattern against a pathname. Returns captured params, or null.
+*
+* Returns null (rather than throwing) when the pattern itself is malformed —
+* e.g. multiple `*` producing duplicate `splat` capture names. Framework and
+* API ingest both reject those, but a hand-crafted manifest could still reach
+* the edge, and a single bad rule shouldn't 500 unrelated traffic.
+*/
+function matchPatternCaptures(pattern, pathname) {
+	let compiled;
+	try {
+		compiled = compilePattern(pattern);
+	} catch {
+		return null;
+	}
+	const match = compiled.regex.exec(pathname);
+	if (!match) return null;
+	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
+* `false` rather than throwing (see `matchPatternCaptures`).
+*/
+function matchPattern(pattern, pathname) {
+	try {
+		return compilePattern(pattern).regex.test(pathname);
+	} catch {
+		return false;
+	}
+}
+const literalRegexCache = /* @__PURE__ */ new Map();
+/**
+* Match a pattern against a pathname using LITERAL semantics — no named
+* 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).
+*/
+function matchLiteralPattern(pattern, pathname) {
+	let regex = literalRegexCache.get(pattern);
+	if (regex) {
+		literalRegexCache.delete(pattern);
+		literalRegexCache.set(pattern, regex);
+	} else {
+		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);
+	}
+	try {
+		return regex.test(pathname);
+	} catch {
+		return false;
+	}
+}
+const segmentRegexCache = /* @__PURE__ */ new Map();
+/**
+* Match a REVALIDATE ROUTE pattern against a pathname using SEGMENT-ANCHORED
+* semantics. Like `matchLiteralPattern` except a WHOLE-SEGMENT `:name` (a `:`
+* right after `/` or at the start of the pattern, whose name is any non-empty
+* run of non-`/` characters — NOT just JS-identifier chars, so `:post-id`,
+* `:post.id`, etc. all anchor — running up to the next `/` or end of string)
+* matches exactly ONE non-empty path segment (`[^/]+`). A whole-segment NAMED
+* CATCH-ALL `:name{.+}` (a named catch-all page `[...path]` → `/docs/:path{.+}`)
+* matches ONE-OR-MORE characters that MAY cross `/` (`.+`, so `/docs/a` and
+* `/docs/a/b` both match, but bare `/docs` / `/docs/` do NOT). Only the exact
+* `{.+}` constraint widens — a REGEX-constrained param like `:path{[0-9]+}`
+* keeps its single-segment `[^/]+` meaning. `*` still expands to a catch-all
+* that crosses `/`. A mid-segment `:` (e.g. `/api/v1:health`,
+* `/api/documents:batchGet`) stays a LITERAL — only whole-segment `:name` /
+* `:name{.+}` anchors.
+*
+* This is for `routing.revalidate` keys ONLY. Those keys are machine-generated
+* 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`.
+*
+* It is intentionally NOT used for user-authored header rules
+* (`applyHeaderRules`) or `revalidateQueryAllowlist` keys
+* (`buildVariantOriginalUrl`), where `:name` must stay a literal — those keep
+* using `matchLiteralPattern`. Sharing the segment behaviour there would make a
+* user rule like `/:batchGet` over-match every single-segment path.
+*
+* NOTE: this matcher has its OWN regex cache — the same pattern string compiles
+* to a DIFFERENT regex than `matchLiteralPattern` produces, so the caches must
+* 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 {
+		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);
+	}
+	try {
+		return regex.test(pathname);
+	} catch {
+		return false;
+	}
+}
+/**
+* Substitute `:name` and `:name*` tokens in a destination string with the
+* matching named captures from `params`. `:splat` works for legacy `*` patterns
+* because `compilePattern` captures anonymous `*` as `splat`.
+*/
+function substituteParams(destination, params) {
+	return destination.replace(/:([A-Za-z0-9_]+)\*?/g, (whole, name) => {
+		return params[name] ?? whole;
+	});
+}
+//#endregion
+//#region src/headers.ts
+/**
+* Headers that user header rules may not set at all, because they are always a
+* cookie operation. On the shared *.void.app domain (not on the PSL) void.app
+* is the registrable domain, so a `Set-Cookie` with `Domain=.void.app` is
+* readable by every tenant's subdomain. Dropped wholesale.
+*
+* `Clear-Site-Data` is the other cookie trust-boundary header, but it is NOT a
+* blanket block — see {@link sanitizeClearSiteData}: only its cookie-clearing
+* directives are stripped, since its other directives are origin-scoped.
+*
+* HSTS and other per-host headers are safe — they don't cross subdomain
+* boundaries (includeSubDomains scopes to the responding host's subtree).
+*
+* TODO: Once void.app is registered on the Public Suffix List, these defenses
+* can be removed — browsers will scope cross-subdomain cookies automatically.
+*/
+const BLOCKED_HEADERS = /* @__PURE__ */ new Set(["set-cookie"]);
+/**
+* Parse one list member into its quoted-string content, or `null` when it is not
+* a well-formed quoted-string. Implements RFC 7230's
+* `quoted-string = DQUOTE *( qdtext / quoted-pair ) DQUOTE`: it must be wrapped
+* in double quotes, a backslash escapes the next character, and an unescaped
+* inner quote (or a dangling escape) is malformed.
+*/
+function parseQuotedString(member) {
+	if (member.length < 2 || member[0] !== "\"" || member[member.length - 1] !== "\"") return null;
+	let content = "";
+	for (let i = 1; i < member.length - 1; i += 1) {
+		const char = member[i];
+		if (char === "\\") {
+			i += 1;
+			if (i >= member.length - 1) return null;
+			content += member[i];
+		} else if (char === "\"") return null;
+		else content += char;
+	}
+	return content;
+}
+/**
+* Parse a `Clear-Site-Data` header value into its list members. The value is a
+* comma-separated list of quoted-strings (W3C Clear-Site-Data); a comma inside a
+* quoted-string does not split a member. Empty members are dropped.
+*/
+function parseClearSiteData(value) {
+	const members = [];
+	const pushMember = (slice) => {
+		const raw = slice.trim();
+		if (raw.length > 0) members.push({
+			raw,
+			directive: parseQuotedString(raw)
+		});
+	};
+	let start = 0;
+	let inQuotes = false;
+	for (let i = 0; i < value.length; i += 1) {
+		const char = value[i];
+		if (inQuotes) {
+			if (char === "\\") i += 1;
+			else if (char === "\"") inQuotes = false;
+		} else if (char === "\"") inQuotes = true;
+		else if (char === ",") {
+			pushMember(value.slice(start, i));
+			start = i + 1;
+		}
+	}
+	pushMember(value.slice(start));
+	return members;
+}
+/**
+* Sanitize a `Clear-Site-Data` value so a tenant rule can't clear cookies across
+* the shared *.void.app boundary, while still allowing the safe directives.
+*
+* Only `"cookies"` and `"*"` clear cookies for the registrable domain (and thus
+* every tenant's subdomain). `"cache"`, `"storage"`, `"executionContexts"`, and
+* any future quoted directive are origin-scoped — each subdomain is its own
+* origin — so they are kept verbatim. Malformed members are dropped (a browser
+* ignores them, and dropping forecloses a lenient parser honoring them).
+*
+* Returns the filtered value, or `null` when nothing safe remains: a `"*"`
+* includes cookies and can't be expressed without them, and a value that is only
+* `"cookies"` collapses to empty.
+*/
+function sanitizeClearSiteData(value) {
+	const kept = [];
+	for (const { raw, directive } of parseClearSiteData(value)) {
+		const normalized = directive?.toLowerCase();
+		if (normalized === "*") return null;
+		if (directive === null || normalized === "cookies") continue;
+		kept.push(raw);
+	}
+	return kept.length > 0 ? kept.join(", ") : null;
+}
+/**
+* Apply matching header rules to a response.
+* All matching rules merge; last match wins for same header name.
+* Returns the original response unchanged when no rules or no matches.
+*/
+function applyHeaderRules(response, pathname, rules, policy) {
+	if (!rules || rules.length === 0) return response;
+	const matched = [];
+	for (const rule of rules) if (matchLiteralPattern(rule.pattern, pathname)) matched.push(...rule.headers);
+	if (matched.length === 0) return response;
+	const newResponse = new Response(response.body, response);
+	const isolateSharedDomainCookies = policy?.cookieIsolation !== "origin";
+	const rawOriginClearSiteData = isolateSharedDomainCookies ? response.headers.get("clear-site-data") : null;
+	const originClearSiteData = rawOriginClearSiteData === null ? null : sanitizeClearSiteData(rawOriginClearSiteData);
+	for (const [name, value] of matched) {
+		const lowerName = name.toLowerCase();
+		if (isolateSharedDomainCookies && BLOCKED_HEADERS.has(lowerName)) continue;
+		if (isolateSharedDomainCookies && lowerName === "clear-site-data") {
+			const safe = sanitizeClearSiteData(value);
+			if (safe !== null) newResponse.headers.set(name, safe);
+			else if (originClearSiteData !== null) newResponse.headers.set(name, originClearSiteData);
+			else newResponse.headers.delete(name);
+			continue;
+		}
+		newResponse.headers.set(name, value);
+	}
+	return newResponse;
+}
+//#endregion
+//#region src/routing-rules.ts
+/**
+* Check routing rules (redirects + rewrites) against a request pathname.
+*
+* **First match wins** — matches Netlify `_redirects` and Vercel `vercel.json`
+* semantics: users put more-specific rules above more-general ones, and the
+* first rule whose source matches takes effect. (Header rules in this same
+* package use last-match-wins for compatibility with Netlify `_headers`,
+* which is the opposite of `_redirects`. The asymmetry is intentional.)
+*
+* `requestHost` is the WHATWG `url.hostname` (lowercase, port-stripped).
+* Rules with a `host` field are skipped when `rule.host !== requestHost`;
+* path-only rules apply to every host bound to the project.
+*
+* Returns a discriminated result. The caller is responsible for building the
+* actual `Response` for redirects (so it can merge the request's query string
+* into the `Location` header).
+*/
+function applyRoutingRules(pathname, rules, requestHost) {
+	if (!rules?.length) return null;
+	for (const rule of rules) {
+		if (rule.host && rule.host !== requestHost) continue;
+		let regex;
+		try {
+			({regex} = compilePattern(rule.source));
+		} catch (err) {
+			console.warn(`[dispatch] skipping routing rule with invalid source ${JSON.stringify(rule.source)}: ${err instanceof Error ? err.message : String(err)}`);
+			continue;
+		}
+		const match = regex.exec(pathname);
+		if (!match) continue;
+		const destination = substituteParams(rule.destination, match.groups ?? {});
+		if (rule.status === 200) return {
+			type: "rewrite",
+			destination
+		};
+		return {
+			type: "redirect",
+			destination,
+			status: rule.status
+		};
+	}
+	return null;
+}
+/**
+* Merge a request's query string into a redirect destination.
+*
+* If the destination already contains a `?`, its parameters take precedence
+* over the request's. Otherwise the request's query is appended verbatim.
+*
+* A `#fragment` on the destination is stripped before the merge and
+* re-appended afterwards, so `/new#faq` + `?utm=x` becomes `/new?utm=x#faq`
+* rather than `/new#faq?utm=x` (which browsers treat as fragment text).
+*/
+function mergeQueryIntoLocation(destination, requestSearch) {
+	if (!requestSearch || requestSearch === "?") return destination;
+	const fragIdx = destination.indexOf("#");
+	const base = fragIdx === -1 ? destination : destination.slice(0, fragIdx);
+	const fragment = fragIdx === -1 ? "" : destination.slice(fragIdx);
+	const destQueryIdx = base.indexOf("?");
+	if (destQueryIdx === -1) return base + requestSearch + fragment;
+	if (destQueryIdx === base.length - 1) return base.slice(0, destQueryIdx) + fragment;
+	const reqParams = new URLSearchParams(requestSearch);
+	const destParams = new URLSearchParams(base.slice(destQueryIdx + 1));
+	for (const [key, value] of reqParams) if (!destParams.has(key)) destParams.append(key, value);
+	return base.slice(0, destQueryIdx) + "?" + destParams.toString() + fragment;
+}
+//#endregion
+//#region src/runtime.ts
+/**
+* Create the thin Worker used by direct static, SPA, and SSG deployments.
+* Routing semantics intentionally match the hosted dispatch Worker: redirects
+* and rewrites run before assets, fallback rewrites run only after an asset
+* miss, and response-header rules apply to the effective pathname.
+*/
+function createStaticEdgeHandler(config) {
+	return { async fetch(request, env) {
+		const originalUrl = new URL(request.url);
+		if (request.method === "GET" && originalUrl.pathname === "/__void/ready") return Response.json({ ready: true });
+		let effectiveUrl = new URL(originalUrl);
+		let effectiveRequest = request;
+		const route = applyRoutingRules(effectiveUrl.pathname, config.redirectRules, effectiveUrl.hostname);
+		if (route?.type === "redirect") return applyHeaderRules(new Response(null, {
+			status: route.status,
+			headers: { location: mergeQueryIntoLocation(route.destination, effectiveUrl.search) }
+		}), effectiveUrl.pathname, config.headerRules, { cookieIsolation: "origin" });
+		if (route?.type === "rewrite") {
+			effectiveUrl = rewriteUrl(effectiveUrl, route.destination);
+			effectiveRequest = rewriteRequest(request, effectiveUrl, originalUrl.toString());
+		}
+		let response = await env.ASSETS.fetch(effectiveRequest);
+		if (response.status === 404) {
+			const fallback = applyRoutingRules(effectiveUrl.pathname, config.fallbackRules, effectiveUrl.hostname);
+			if (fallback?.type === "rewrite") {
+				effectiveUrl = rewriteUrl(effectiveUrl, fallback.destination);
+				effectiveRequest = rewriteRequest(request, effectiveUrl, originalUrl.toString());
+				response = await env.ASSETS.fetch(effectiveRequest);
+			}
+		}
+		return applyHeaderRules(response, effectiveUrl.pathname, config.headerRules, { cookieIsolation: "origin" });
+	} };
+}
+function rewriteUrl(url, destination) {
+	const rewritten = new URL(url);
+	const destinationUrl = new URL(destination, url);
+	rewritten.pathname = destinationUrl.pathname;
+	rewritten.search = destinationUrl.search || url.search;
+	return rewritten;
+}
+function rewriteRequest(request, url, originalUrl) {
+	const headers = new Headers(request.headers);
+	headers.set("X-Void-Original-URL", originalUrl);
+	const rewritten = new Request(url.toString(), request);
+	return new Request(rewritten, { headers });
+}
+//#endregion
+//#region src/static.ts
+/**
+* Percent-decode a request pathname for a manifest lookup, honoring ONLY the
+* encodings a conformant URL is required to use. Returns the raw value
+* unchanged on a malformed sequence (e.g. a lone `%`) or on any non-canonical /
+* over-encoded spelling.
+*
+* Request pathnames arrive percent-encoded — WHATWG `URL.pathname` never
+* decodes — but manifest keys are the asset's decoded on-disk path (a file
+* named `oxc masthead.riv` is stored under `/assets/oxc masthead.riv`, not
+* `%20`). Callers try the raw key first, then this decoded form.
+*
+* The decoded form is accepted only when re-encoding it reproduces the request
+* path (up to percent-escape letter case) — i.e. the only encoded bytes were
+* characters a URL MUST encode (space, `#`, non-ASCII, …). This rejects
+* over-encoded spellings of ordinary path text (`%2F`→`/`, `%61`→`a`, `%5F`→`_`,
+* `%2e%2e`→`..`), which a browser would never send and which would otherwise let
+* a request reconstruct a guarded path (`/assets%2Fx`, `/%61ssets/x`,
+* `/%5F%5Fvoid/x`) and serve the manifest entry while the raw-`url.pathname`
+* policy gates — the `/__void/*` reserved-route block, the hashed-asset prefix
+* gate, and the header/redirect rules — never fire. The URL pathname setter
+* applies exactly the WHATWG "path percent-encode set", making it the canonical
+* re-encoder.
+*
+* 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.
+*/
+function safeDecodePathname(pathname) {
+	let decoded;
+	try {
+		decoded = decodeURIComponent(pathname);
+	} catch {
+		return pathname;
+	}
+	if (decoded === pathname) return pathname;
+	const canonical = reencodePathname(decoded);
+	if (canonical === null) return pathname;
+	return normalizePercentCase(canonical) === normalizePercentCase(pathname) ? decoded : pathname;
+}
+/** Uppercase the hex digits of every `%xx` escape so encodings compare equal
+* regardless of the letter case a client used. */
+function normalizePercentCase(pathname) {
+	return pathname.replace(/%[0-9a-fA-F]{2}/g, (escape) => escape.toUpperCase());
+}
+/**
+* Serialize a decoded path back to a safe URL pathname via the WHATWG "path
+* percent-encode set" (the `URL.pathname` setter). Returns null if the value
+* can't be encoded. Used to canonicalize the decoded lookup key and to make a
+* redirect Location URL-safe.
+*/
+function reencodePathname(pathname) {
+	try {
+		const encoder = new URL("https://void.invalid/");
+		encoder.pathname = pathname;
+		return encoder.pathname;
+	} catch {
+		return null;
+	}
+}
+/**
+* Match a pathname against the manifest via exact match + html_handling rules
+* (no not-found fallback). Returns null when nothing matches.
+*/
+function matchManifestEntry(pathname, manifest, htmlHandling) {
+	if (manifest[pathname]) return {
+		path: pathname,
+		hash: manifest[pathname]
+	};
+	switch (htmlHandling) {
+		case "auto-trailing-slash": {
+			const withHtml = pathname + ".html";
+			if (manifest[withHtml]) return {
+				path: withHtml,
+				hash: manifest[withHtml]
+			};
+			const withIndex = (pathname.endsWith("/") ? pathname : pathname + "/") + "index.html";
+			if (manifest[withIndex]) return {
+				path: withIndex,
+				hash: manifest[withIndex]
+			};
+			break;
+		}
+		case "force-trailing-slash": {
+			if (!pathname.endsWith("/") && pathname !== "/") {
+				const withIndex = pathname + "/index.html";
+				if (manifest[withIndex]) return {
+					path: withIndex,
+					hash: manifest[withIndex],
+					redirect: pathname + "/"
+				};
+			}
+			const indexPath = pathname + "index.html";
+			if (manifest[indexPath]) return {
+				path: indexPath,
+				hash: manifest[indexPath]
+			};
+			break;
+		}
+		case "drop-trailing-slash": {
+			if (pathname === "/") {
+				if (manifest["/index.html"]) return {
+					path: "/index.html",
+					hash: manifest["/index.html"]
+				};
+				break;
+			}
+			if (pathname.endsWith("/")) {
+				const withoutSlash = pathname.slice(0, -1);
+				const withHtml = withoutSlash + ".html";
+				if (manifest[withHtml]) return {
+					path: withHtml,
+					hash: manifest[withHtml],
+					redirect: withoutSlash
+				};
+			}
+			const withHtml = pathname + ".html";
+			if (manifest[withHtml]) return {
+				path: withHtml,
+				hash: manifest[withHtml]
+			};
+			break;
+		}
+	}
+	return null;
+}
+/**
+* Resolve a request pathname to a manifest entry using AssetConfig rules.
+* Replicates Cloudflare Workers Assets path resolution behavior.
+*/
+function resolveStaticPath(pathname, manifest, config) {
+	const htmlHandling = config.html_handling ?? "auto-trailing-slash";
+	let matched = matchManifestEntry(pathname, manifest, htmlHandling);
+	if (!matched) {
+		const decoded = safeDecodePathname(pathname);
+		if (decoded !== pathname) {
+			matched = matchManifestEntry(decoded, manifest, htmlHandling);
+			if (matched?.redirect !== void 0) {
+				const safeRedirect = reencodePathname(matched.redirect);
+				if (safeRedirect !== null) matched = {
+					...matched,
+					redirect: safeRedirect
+				};
+			}
+		}
+	}
+	if (matched) return matched;
+	switch (config.not_found_handling ?? "none") {
+		case "single-page-application":
+			if (manifest["/index.html"]) return {
+				path: "/index.html",
+				hash: manifest["/index.html"],
+				spa: true
+			};
+			break;
+		case "404-page": if (manifest["/404.html"]) return {
+			path: "/404.html",
+			hash: manifest["/404.html"],
+			notFound: true
+		};
+	}
+	return null;
+}
+const MIME_TYPES = {
+	html: "text/html; charset=utf-8",
+	htm: "text/html; charset=utf-8",
+	css: "text/css; charset=utf-8",
+	js: "text/javascript; charset=utf-8",
+	mjs: "text/javascript; charset=utf-8",
+	json: "application/json; charset=utf-8",
+	xml: "application/xml; charset=utf-8",
+	svg: "image/svg+xml; charset=utf-8",
+	txt: "text/plain; charset=utf-8",
+	csv: "text/csv; charset=utf-8",
+	md: "text/markdown; charset=utf-8",
+	markdown: "text/markdown; charset=utf-8",
+	yaml: "text/yaml; charset=utf-8",
+	yml: "text/yaml; charset=utf-8",
+	toml: "application/toml",
+	png: "image/png",
+	jpg: "image/jpeg",
+	jpeg: "image/jpeg",
+	gif: "image/gif",
+	ico: "image/x-icon",
+	webp: "image/webp",
+	avif: "image/avif",
+	woff: "font/woff",
+	woff2: "font/woff2",
+	ttf: "font/ttf",
+	otf: "font/otf",
+	eot: "application/vnd.ms-fontobject",
+	pdf: "application/pdf",
+	wasm: "application/wasm",
+	webmanifest: "application/manifest+json; charset=utf-8",
+	map: "application/json; charset=utf-8",
+	mp4: "video/mp4",
+	webm: "video/webm",
+	mp3: "audio/mpeg",
+	ogg: "audio/ogg"
+};
+/**
+* Get the Content-Type header value for a given file path based on its extension.
+*/
+function getContentType(path) {
+	const ext = path.split(".").pop()?.toLowerCase() ?? "";
+	return MIME_TYPES[ext] ?? "application/octet-stream";
+}
+/**
+* Resolve the Content-Type to serve for a stored asset, reconciling the value
+* persisted at upload time (R2 `httpMetadata.contentType` / KV `ct` metadata)
+* with a fresh path-based lookup. Returns `undefined` when no Content-Type
+* header should be emitted.
+*
+* `application/null` is a sentinel (matching Wrangler) meaning "omit the
+* Content-Type header entirely".
+*
+* `application/octet-stream` is the uploader's no-information default: older
+* CLI versions stamped it on any extension their MIME table did not recognize
+* (e.g. `.md`). Because assets are content-addressed and never re-uploaded,
+* those stale octet-stream values can't be corrected at the source, so we
+* treat a stored octet-stream as "unknown" and re-derive from the path here.
+* Any other stored value is authoritative and honored as-is.
+*/
+function resolveAssetContentType(stored, path) {
+	if (stored === "application/null") return;
+	if (!stored || stored === "application/octet-stream") return getContentType(path);
+	return stored;
+}
+//#endregion
+export { applyHeaderRules, applyRoutingRules, compilePattern, createStaticEdgeHandler, getContentType, matchLiteralPattern, matchPattern, matchPatternCaptures, matchSegmentPattern, mergeQueryIntoLocation, parseClearSiteData, resolveAssetContentType, resolveStaticPath, safeDecodePathname, sanitizeClearSiteData, substituteParams };

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@void/edge",
+  "version": "0.20.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/voidzero-dev/void.git",
+    "directory": "packages/edge"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@void/deploy-core": "0.20.0"
+  },
+  "devDependencies": {
+    "@cloudflare/workers-types": "^4.20260702.1",
+    "typescript": "7.0.2",
+    "vite-plus": "0.3.1"
+  },
+  "scripts": {
+    "build": "vp pack",
+    "dev": "vp pack --watch",
+    "typecheck": "tsc --noEmit"
+  }
+}