void 0.10.12 → 0.20.0

package/dist/{dist-DaKKDf8D.mjs → dist-BrsS7cai.mjs}

@@ -1,5 +1,19 @@
+import { n as __exportAll } from "./rolldown-runtime-rQ84J-ij.mjs";
 import nodePath from "node:path";
 //#region ../../node_modules/.pnpm/pathslash@0.1.0/node_modules/pathslash/dist/index.mjs
+var dist_exports = /* @__PURE__ */ __exportAll({
+	basename: () => basename,
+	default: () => path,
+	dirname: () => dirname,
+	extname: () => extname,
+	isAbsolute: () => isAbsolute,
+	join: () => join,
+	normalize: () => normalize,
+	posix: () => posix,
+	relative: () => relative,
+	resolve: () => resolve,
+	win32: () => win32
+});
 const BACKSLASH_RE = /\\/g;
 const isWindows = process.platform === "win32";
 /**
@@ -36,6 +50,7 @@ const win32 = {
 const posix = { ...nodePath.posix };
 posix.posix = win32.posix = posix;
 posix.win32 = win32.win32 = win32;
-const { basename, delimiter, dirname, extname, format, isAbsolute, join, matchesGlob, normalize, parse, relative, resolve, sep, toNamespacedPath } = isWindows ? win32 : posix;
+const path = isWindows ? win32 : posix;
+const { basename, delimiter, dirname, extname, format, isAbsolute, join, matchesGlob, normalize, parse, relative, resolve, sep, toNamespacedPath } = path;
 //#endregion
-export { join as a, resolve as c, isAbsolute as i, dirname as n, normalize as o, extname as r, relative as s, basename as t };
+export { isAbsolute as a, relative as c, extname as i, resolve as l, dirname as n, join as o, dist_exports as r, normalize as s, basename as t };

package/dist/{dist-BuiRJkTd.mjs → dist-m40_XgNh.mjs}

@@ -1,10 +1,10 @@
-import { r as __toESM, t as __commonJSMin } from "./rolldown-runtime-DJK8HYOj.mjs";
+import { r as __toESM, t as __commonJSMin } from "./rolldown-runtime-rQ84J-ij.mjs";
 import * as nativeFs from "fs";
 import { readdir, readdirSync, realpath, realpathSync, stat, statSync } from "fs";
 import { basename, dirname, isAbsolute, normalize, posix, relative, resolve, sep } from "path";
 import { fileURLToPath } from "url";
 import { createRequire } from "module";
-//#region ../../node_modules/.pnpm/fdir@6.5.0_picomatch@4.0.5/node_modules/fdir/dist/index.mjs
+//#region ../../node_modules/.pnpm/fdir@6.5.0_picomatch@4.0.7/node_modules/fdir/dist/index.mjs
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 function cleanPath(path) {
 	let normalized = normalize(path);
@@ -512,7 +512,7 @@ var Builder = class {
 	}
 };
 //#endregion
-//#region ../../node_modules/.pnpm/picomatch@4.0.5/node_modules/picomatch/lib/constants.js
+//#region ../../node_modules/.pnpm/picomatch@4.0.7/node_modules/picomatch/lib/constants.js
 var require_constants = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	const WIN_SLASH = "\\\\/";
 	const WIN_NO_SLASH = `[^${WIN_SLASH}]`;
@@ -567,7 +567,7 @@ var require_constants = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	};
 	module.exports = {
 		DEFAULT_MAX_EXTGLOB_RECURSION,
-		MAX_LENGTH: 1024 * 64,
+		MAX_LENGTH: 65536,
 		POSIX_REGEX_SOURCE: {
 			__proto__: null,
 			alnum: "a-zA-Z0-9",
@@ -681,7 +681,7 @@ var require_constants = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	};
 }));
 //#endregion
-//#region ../../node_modules/.pnpm/picomatch@4.0.5/node_modules/picomatch/lib/utils.js
+//#region ../../node_modules/.pnpm/picomatch@4.0.7/node_modules/picomatch/lib/utils.js
 var require_utils = /* @__PURE__ */ __commonJSMin(((exports) => {
 	const { REGEX_BACKSLASH, REGEX_REMOVE_BACKSLASH, REGEX_SPECIAL_CHARS, REGEX_SPECIAL_CHARS_GLOBAL } = require_constants();
 	exports.isObject = (val) => val !== null && typeof val === "object" && !Array.isArray(val);
@@ -729,7 +729,7 @@ var require_utils = /* @__PURE__ */ __commonJSMin(((exports) => {
 	};
 }));
 //#endregion
-//#region ../../node_modules/.pnpm/picomatch@4.0.5/node_modules/picomatch/lib/scan.js
+//#region ../../node_modules/.pnpm/picomatch@4.0.7/node_modules/picomatch/lib/scan.js
 var require_scan = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	const utils = require_utils();
 	const { CHAR_ASTERISK, CHAR_AT, CHAR_BACKWARD_SLASH, CHAR_COMMA, CHAR_DOT, CHAR_EXCLAMATION_MARK, CHAR_FORWARD_SLASH, CHAR_LEFT_CURLY_BRACE, CHAR_LEFT_PARENTHESES, CHAR_LEFT_SQUARE_BRACKET, CHAR_PLUS, CHAR_QUESTION_MARK, CHAR_RIGHT_CURLY_BRACE, CHAR_RIGHT_PARENTHESES, CHAR_RIGHT_SQUARE_BRACKET } = require_constants();
@@ -758,7 +758,7 @@ var require_scan = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	const scan = (input, options) => {
 		const opts = options || {};
 		const length = input.length - 1;
-		const scanToEnd = opts.parts === true || opts.scanToEnd === true;
+		const scanToEnd = opts.parts === true || opts.tokens === true || opts.scanToEnd === true;
 		const slashes = [];
 		const tokens = [];
 		const parts = [];
@@ -861,14 +861,18 @@ var require_scan = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 					finished = true;
 					if (code === CHAR_EXCLAMATION_MARK && index === start) negatedExtglob = true;
 					if (scanToEnd === true) {
+						let parens = 0;
 						while (eos() !== true && (code = advance())) {
 							if (code === CHAR_BACKWARD_SLASH) {
 								backslashes = token.backslashes = true;
-								code = advance();
+								advance();
+								continue;
+							}
+							if (code === CHAR_LEFT_PARENTHESES) {
+								parens++;
 								continue;
 							}
-							if (code === CHAR_RIGHT_PARENTHESES) {
-								isGlob = token.isGlob = true;
+							if (code === CHAR_RIGHT_PARENTHESES && --parens === 0) {
 								finished = true;
 								break;
 							}
@@ -916,13 +920,18 @@ var require_scan = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 			if (opts.noparen !== true && code === CHAR_LEFT_PARENTHESES) {
 				isGlob = token.isGlob = true;
 				if (scanToEnd === true) {
+					let parens = 1;
 					while (eos() !== true && (code = advance())) {
-						if (code === CHAR_LEFT_PARENTHESES) {
+						if (code === CHAR_BACKWARD_SLASH) {
 							backslashes = token.backslashes = true;
-							code = advance();
+							advance();
+							continue;
+						}
+						if (code === CHAR_LEFT_PARENTHESES) {
+							parens++;
 							continue;
 						}
-						if (code === CHAR_RIGHT_PARENTHESES) {
+						if (code === CHAR_RIGHT_PARENTHESES && --parens === 0) {
 							finished = true;
 							break;
 						}
@@ -985,7 +994,7 @@ var require_scan = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 		if (opts.parts === true || opts.tokens === true) {
 			let prevIndex;
 			for (let idx = 0; idx < slashes.length; idx++) {
-				const n = prevIndex ? prevIndex + 1 : start;
+				const n = prevIndex !== void 0 ? prevIndex + 1 : start;
 				const i = slashes[idx];
 				const value = input.slice(n, i);
 				if (opts.tokens) {
@@ -996,18 +1005,19 @@ var require_scan = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 					depth(tokens[idx]);
 					state.maxDepth += tokens[idx].depth;
 				}
-				if (idx !== 0 || value !== "") parts.push(value);
-				prevIndex = i;
-			}
-			if (prevIndex && prevIndex + 1 < input.length) {
-				const value = input.slice(prevIndex + 1);
-				parts.push(value);
-				if (opts.tokens) {
-					tokens[tokens.length - 1].value = value;
-					depth(tokens[tokens.length - 1]);
-					state.maxDepth += tokens[tokens.length - 1].depth;
+				if (i >= start) {
+					parts.push(value);
+					prevIndex = i;
 				}
 			}
+			const n = prevIndex !== void 0 ? prevIndex + 1 : start;
+			const value = input.slice(n);
+			parts.push(value);
+			if (opts.tokens && prevIndex && prevIndex + 1 < input.length) {
+				tokens[tokens.length - 1].value = value;
+				depth(tokens[tokens.length - 1]);
+				state.maxDepth += tokens[tokens.length - 1].depth;
+			}
 			state.slashes = slashes;
 			state.parts = parts;
 		}
@@ -1016,7 +1026,7 @@ var require_scan = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	module.exports = scan;
 }));
 //#endregion
-//#region ../../node_modules/.pnpm/picomatch@4.0.5/node_modules/picomatch/lib/parse.js
+//#region ../../node_modules/.pnpm/picomatch@4.0.7/node_modules/picomatch/lib/parse.js
 var require_parse = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	const constants = require_constants();
 	const utils = require_utils();
@@ -1446,10 +1456,12 @@ var require_parse = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 				}
 				return esc ? m : `\\${m}`;
 			});
-			if (backslashes === true) if (opts.unescape === true) output = output.replace(/\\/g, "");
-			else output = output.replace(/\\+/g, (m) => {
-				return m.length % 2 === 0 ? "\\\\" : m ? "\\" : "";
-			});
+			if (backslashes === true) {
+				if (opts.unescape === true) output = output.replace(/\\/g, "");
+				else output = output.replace(/\\+/g, (m) => {
+					return m.length % 2 === 0 ? "\\\\" : m ? "\\" : "";
+				});
+			}
 			if (output === input && opts.contains === true) {
 				state.output = input;
 				return state;
@@ -1916,6 +1928,7 @@ var require_parse = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 					rest = rest.slice(3);
 					consume("/**", 3);
 				}
+				const isEnd = eos() || state.parens > 0 && rest === ")".repeat(state.parens) && !extglobs.some((extglob) => extglob.type === "negate");
 				if (prior.type === "bos" && eos()) {
 					prev.type = "globstar";
 					prev.value += value;
@@ -1925,7 +1938,7 @@ var require_parse = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 					consume(value);
 					continue;
 				}
-				if (prior.type === "slash" && prior.prev.type !== "bos" && !afterStar && eos()) {
+				if (prior.type === "slash" && prior.prev.type !== "bos" && !afterStar && isEnd) {
 					state.output = state.output.slice(0, -(prior.output + prev.output).length);
 					prior.output = `(?:${prior.output}`;
 					prev.type = "globstar";
@@ -2090,7 +2103,7 @@ var require_parse = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	module.exports = parse;
 }));
 //#endregion
-//#region ../../node_modules/.pnpm/picomatch@4.0.5/node_modules/picomatch/lib/picomatch.js
+//#region ../../node_modules/.pnpm/picomatch@4.0.7/node_modules/picomatch/lib/picomatch.js
 var require_picomatch$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	const scan = require_scan();
 	const parse = require_parse();
@@ -2220,8 +2233,10 @@ var require_picomatch$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 			output = format ? format(input) : input;
 			match = output === glob;
 		}
-		if (match === false || opts.capture === true) if (opts.matchBase === true || opts.basename === true) match = picomatch.matchBase(input, regex, options, posix);
-		else match = regex.exec(output);
+		if (match === false || opts.capture === true) {
+			if (opts.matchBase === true || opts.basename === true) match = picomatch.matchBase(input, regex, options, posix);
+			else match = regex.exec(output);
+		}
 		return {
 			isMatch: Boolean(match),
 			match,

package/dist/{domain-DiaNQbrl.mjs → domain-gu_iaHmn.mjs}

@@ -1,7 +1,11 @@
-import { E as note, T as log, u as import_picocolors } from "./agents-CtgBYqld.mjs";
-import { b as readProjectConfig, f as getToken, n as PlatformClient } from "./client-Gb71-XkG.mjs";
+import { D as log, O as note, c as import_picocolors } from "./output-tFQLLj26.mjs";
+import { b as readDeploymentPlatform, c as getToken, x as readProjectConfig } from "./auth-W9WII-mN.mjs";
+import { n as PlatformClient } from "./client-CyCHWSO_.mjs";
 //#region src/cli/domain.ts
 async function runDomainCommand(root, args) {
+	const platform = readDeploymentPlatform(root);
+	if (platform === "cloudflare") return runCloudflareDomainCommand(root, args);
+	if (platform === "none") throw new Error("domain: Deployment is disabled. Run `void init` to choose a platform.");
 	const token = getToken(root);
 	if (!token) {
 		log.error("Not logged in. Run `void auth login` first.");
@@ -32,6 +36,38 @@ async function runDomainCommand(root, args) {
 		case "status": return domainStatus(client, projectId, args.hostname, args.verbose === true);
 	}
 }
+async function runCloudflareDomainCommand(root, args) {
+	if (args.projectSlug) throw new Error("domain: --project selects a Void platform project and is not used for direct Cloudflare apps.");
+	const { changeCloudflareDomain, listCloudflareDomains } = await import("./cloudflare-operations-CPTpRW6d.mjs").then((n) => n.t);
+	if (args.subcommand === "add") {
+		const result = await changeCloudflareDomain(root, args.hostname, "add");
+		log.success(result.modified ? `Domain ${args.hostname} added and activated on Cloudflare.` : `Domain ${args.hostname} is already configured.`);
+		note("Cloudflare Custom Domains manages the DNS record and TLS certificate in the zone on your account.", "Cloudflare Domain");
+		return;
+	}
+	if (args.subcommand === "delete") {
+		if ((await changeCloudflareDomain(root, args.hostname, "delete")).modified) log.success(`Domain ${args.hostname} removed from Cloudflare.`);
+		else log.info(`Domain ${args.hostname} is not configured.`);
+		return;
+	}
+	const domains = listCloudflareDomains(root);
+	if (args.subcommand === "list") {
+		if (domains.length === 0) {
+			log.info("No custom domains configured.");
+			return;
+		}
+		note(domains.map((domain) => `  ${domain.pattern}  ${import_picocolors.default.green("configured")}`).join("\n"), "Custom Domains");
+		return;
+	}
+	const domain = domains.find((entry) => entry.pattern === args.hostname);
+	if (!domain) {
+		log.error(`domain: Domain '${args.hostname}' is not configured for this Worker.`);
+		process.exit(1);
+	}
+	const lines = [`Hostname: ${domain.pattern}`, "Status:   configured locally — present in wrangler.jsonc; remote certificate state is managed by Cloudflare."];
+	if (args.verbose) lines.push("", "Details:", "  Type:        Cloudflare Custom Domain", "  TLS:         managed");
+	note(lines.join("\n"), "Domain Status");
+}
 async function domainAdd(client, projectId, hostname) {
 	const domain = await client.addDomain(projectId, hostname);
 	log.success(`Domain ${hostname} added (status: ${domain.status})`);
@@ -60,10 +96,11 @@ async function domainList(client, projectId) {
 		log.info("No custom domains configured.");
 		return;
 	}
-	note(domains.map((d) => {
+	const lines = domains.map((d) => {
 		const status = d.status === "active" ? import_picocolors.default.green("active") : import_picocolors.default.yellow(d.status);
 		return `  ${d.hostname}  ${status}`;
-	}).join("\n"), "Custom Domains");
+	});
+	note(lines.join("\n"), "Custom Domains");
 }
 function computeRollup(status) {
 	if (status.verification_errors && status.verification_errors.length > 0) return {

package/dist/dotenv-VQxupEUv.mjs

@@ -0,0 +1,181 @@
+import { existsSync, readFileSync } from "node:fs";
+//#region src/shared/dotenv.ts
+/**
+* Shared dotenv parser + variable expander used by local `.env` consumers and
+* explicit `void secret sync <file>` input. A single source of truth avoids drift when two
+* hand-rolled parsers diverged on quoting / expansion semantics.
+*
+* Expansion supports `${VAR}` and `$VAR`, a `\$VAR` literal-escape, and
+* transitive references across earlier entries in the same record. Cycles
+* are detected and fall through to the raw literal rather than looping.
+*
+* Security note: expansion is deliberately scoped to the in-file record.
+* We do NOT consult `process.env` the way `dotenv-expand` does — a shell
+* env leaking into a parsed dotenv file would silently change its meaning
+* across machines.
+*
+* This module is a leaf — it must not import from `../log` or any non-leaf
+* module so that the prerender subprocess's worker bundle doesn't pick up
+* unwanted transitive dependencies. Warnings are surfaced through the
+* `onWarn` callback and left for the caller to route.
+*/
+/** Valid dotenv key — ASCII letter/underscore followed by letters/digits/underscore. */
+const VALID_KEY = /^[A-Za-z_][A-Za-z0-9_]*$/;
+/**
+* Parse a single `KEY=VALUE` line into `{ key, value }`, stripping matching
+* single/double quotes around the value. Returns `null` for blanks, comments,
+* and non-assignment lines.
+*/
+function parseDotenvLine(line) {
+	const trimmed = line.trim();
+	if (!trimmed || trimmed.startsWith("#")) return null;
+	const equalsIndex = trimmed.indexOf("=");
+	if (equalsIndex === -1) return null;
+	const key = trimmed.slice(0, equalsIndex).trim();
+	let value = trimmed.slice(equalsIndex + 1).trim();
+	if (value.startsWith("\"") && value.endsWith("\"") || value.startsWith("'") && value.endsWith("'")) value = value.slice(1, -1);
+	return {
+		key,
+		value
+	};
+}
+/**
+* Parse the raw contents of a dotenv file into a record, optionally
+* expanding `${VAR}` / `$VAR` references against earlier entries.
+*/
+function parseDotenv(content, options = {}) {
+	const { expand: shouldExpand = true, skipInvalidKeys = true, onWarn } = options;
+	const env = {};
+	for (const line of content.split("\n")) {
+		const parsed = parseDotenvLine(line);
+		if (!parsed) continue;
+		if (!VALID_KEY.test(parsed.key)) {
+			if (skipInvalidKeys) continue;
+			throw new Error(`dotenv: Invalid key '${parsed.key}'.`);
+		}
+		env[parsed.key] = parsed.value;
+	}
+	return shouldExpand ? expandDotenv(env, { onWarn }) : env;
+}
+/**
+* Read and parse a dotenv file. Returns `{}` when the file is missing so
+* callers can treat "no file" and "empty file" identically.
+*/
+function parseDotenvFile(filePath, options = {}) {
+	if (!existsSync(filePath)) return {};
+	return parseDotenv(readFileSync(filePath, "utf-8"), options);
+}
+/**
+* Expand `${VAR}` / `$VAR` references in every value of a record against
+* the other entries in that same record. Matches the surface of
+* `dotenv-expand` minus the `process.env` fallback.
+*
+* Semantics:
+*   - `${VAR}` and `$VAR` both resolve (bare form stops at the first
+*     non-identifier character).
+*   - `\$VAR` stays literal; the backslash is consumed.
+*   - Nested refs resolve transitively — `A=${B}`, `B=${C}`, `C=v` → `A=v`.
+*   - Cycles are detected; the offending value keeps its raw literal and
+*     `onWarn` fires once per cycle seen.
+*   - Missing refs expand to the empty string, matching dotenv-expand.
+*
+* The input record is not mutated; a fresh object is returned.
+*/
+function expandDotenv(input, options = {}) {
+	const out = {};
+	const resolving = /* @__PURE__ */ new Set();
+	const warned = /* @__PURE__ */ new Set();
+	function resolveKey(key) {
+		if (!(key in input)) return "";
+		if (key in out) return out[key];
+		if (resolving.has(key)) {
+			if (!warned.has(key) && options.onWarn) {
+				warned.add(key);
+				options.onWarn(`dotenv expansion cycle detected at "${key}" — leaving raw value in place`);
+			}
+			return input[key];
+		}
+		resolving.add(key);
+		const expanded = expandValue(input[key], resolveKey);
+		resolving.delete(key);
+		out[key] = expanded;
+		return expanded;
+	}
+	for (const key of Object.keys(input)) resolveKey(key);
+	return out;
+}
+/**
+* Expand a single value string. `resolve` returns the fully-expanded value
+* for a referenced key (or `''` when missing). Backslash-escapes (`\$VAR`,
+* `\${VAR}`) keep the `$...` literal and consume the backslash.
+*/
+function expandValue(value, resolve) {
+	let result = "";
+	let cursor = 0;
+	while (cursor < value.length) {
+		const character = value[cursor];
+		if (character === "\\" && cursor + 1 < value.length && value[cursor + 1] === "$") {
+			result += "$";
+			cursor += 2;
+			continue;
+		}
+		if (character !== "$") {
+			result += character;
+			cursor++;
+			continue;
+		}
+		const next = value[cursor + 1];
+		if (next === "{") {
+			const endIndex = value.indexOf("}", cursor + 2);
+			if (endIndex === -1) {
+				result += character;
+				cursor++;
+				continue;
+			}
+			const key = value.slice(cursor + 2, endIndex);
+			if (VALID_KEY.test(key)) result += resolve(key);
+			else result += value.slice(cursor, endIndex + 1);
+			cursor = endIndex + 1;
+			continue;
+		}
+		if (next && /[A-Za-z_]/.test(next)) {
+			let keyEndIndex = cursor + 1;
+			while (keyEndIndex < value.length && /[A-Za-z0-9_]/.test(value[keyEndIndex])) keyEndIndex++;
+			const key = value.slice(cursor + 1, keyEndIndex);
+			result += resolve(key);
+			cursor = keyEndIndex;
+			continue;
+		}
+		result += character;
+		cursor++;
+	}
+	return result;
+}
+/**
+* Wrangler 4.131's bundled `dotenv` LINE regex (verbatim), used ONLY to detect the
+* declared KEYS wrangler would load — including the OPTIONAL `export ` prefix, the `KEY: val`
+* form, and single/double/backtick quoting — so a transport-redirect / config-override fence
+* sees exactly what wrangler's per-command dotenv reload would. We read keys, never values.
+*/
+const WRANGLER_DOTENV_LINE = /(?:^|^)\s*(?:export\s+)?([\w.-]+)(?:\s*=\s*?|:\s+?)(\s*'(?:\\'|[^'])*'|\s*"(?:\\"|[^"])*"|\s*`(?:\\`|[^`])*`|[^#\r\n]+)?\s*(?:#.*)?(?:$|$)/gm;
+/**
+* The set of declared dotenv KEYS in `filePath`, parsed the way wrangler does.
+* Lives in this leaf module (no `proper-lockfile` / lifecycle side effects) so both
+* the provisioner's transport fence and the deploy orchestrator's config-override
+* fence can read keys exactly as wrangler's per-command reload would, without either
+* caller pulling in the provision lifecycle just to parse dotenv keys.
+*/
+function scanWranglerDotenvKeys(filePath) {
+	const keys = /* @__PURE__ */ new Set();
+	if (!existsSync(filePath)) return keys;
+	const content = readFileSync(filePath, "utf-8");
+	WRANGLER_DOTENV_LINE.lastIndex = 0;
+	let match;
+	while ((match = WRANGLER_DOTENV_LINE.exec(content)) !== null) {
+		if (match[1]) keys.add(match[1]);
+		if (match.index === WRANGLER_DOTENV_LINE.lastIndex) WRANGLER_DOTENV_LINE.lastIndex++;
+	}
+	return keys;
+}
+//#endregion
+export { parseDotenvFile as n, scanWranglerDotenvKeys as r, expandDotenv as t };

package/dist/edge.d.mts

@@ -0,0 +1,2 @@
+import { EdgeAssetFetcher, StaticEdgeConfig, StaticEdgeEnv, StaticEdgeHandler, createStaticEdgeHandler } from "@void/edge";
+export { type EdgeAssetFetcher, type StaticEdgeConfig, type StaticEdgeEnv, type StaticEdgeHandler, createStaticEdgeHandler };

package/dist/edge.mjs

@@ -0,0 +1,2 @@
+import { createStaticEdgeHandler } from "@void/edge";
+export { createStaticEdgeHandler };

package/dist/email-Ce6SQq-i.mjs

@@ -0,0 +1,182 @@
+import { o as join } from "./dist-BrsS7cai.mjs";
+import { n as globSync, t as glob } from "./dist-m40_XgNh.mjs";
+//#region src/router/email.ts
+/**
+* Scan `email/` for inbound email handlers.
+*
+* The `email/` directory sits at the project root alongside `crons/` and
+* `queues/` — non-HTTP handlers all live at the top level, since each is
+* wired into a separate worker export (`scheduled`, `queue`, `email`).
+*
+*   email/<local-part>.ts        per-recipient handler matched against the
+*                                 local-part of the To address
+*   email/<local-part>+[tag].ts  same, with a `+suffix` capture exposed as
+*                                 `info.params.<tag>`
+*   email/[name].ts              dynamic local-part — captures the whole
+*                                 local-part as `info.params.<name>`
+*   email/[name]+[tag].ts        dynamic + tag
+*   email/_default.ts            fallback when no per-address pattern matches
+*
+* Match precedence (most specific wins):
+*   static + tag → static → dynamic + tag → dynamic → _default
+* Within a kind a literal tag beats a captured tag (`support+vip` before
+* `support+[tag]`, `[user]+vip` before `[user]+[tag]`); the same shape sorts
+* alphabetically. See `compareEmailRoutes`.
+*
+* Local-part matching is case-insensitive: the compiled patterns carry the `i`
+* flag and run against the recipient in its original case, so a captured tag
+* such as a ticket id keeps the case it arrived with. Nested folders are
+* intentionally ignored — the recipient address is a single string, not a path.
+*/
+const EMAIL_EXTENSIONS = [
+	"ts",
+	"mts",
+	"js",
+	"mjs"
+];
+const PARAM_RE = /^\[([a-z][a-z0-9]*)\]$/;
+const LITERAL_RE = /^[a-z0-9._-]+$/;
+function compileSegment(part) {
+	const param = PARAM_RE.exec(part);
+	if (param) return {
+		kind: "param",
+		name: param[1]
+	};
+	if (!LITERAL_RE.test(part)) return null;
+	return {
+		kind: "literal",
+		value: part
+	};
+}
+function escapeLiteral(value) {
+	return value.replace(/\./g, "\\.");
+}
+function segmentRegex(s) {
+	return s.kind === "literal" ? escapeLiteral(s.value) : "([^+@]+)";
+}
+function patternKind(prefix, tag) {
+	const prefixDynamic = prefix.kind === "param";
+	if (tag) return prefixDynamic ? "dynamic-tag" : "static-tag";
+	return prefixDynamic ? "dynamic" : "static";
+}
+/**
+* Compile a basename like `support`, `support+[ticket]`, `[user]`, or
+* `[user]+[tag]` into a match pattern, or return `null` if the basename
+* uses characters or shapes outside the supported grammar.
+*/
+function compileEmailPattern(basename) {
+	const parts = basename.toLowerCase().split("+");
+	if (parts.length > 2) return null;
+	const prefix = compileSegment(parts[0] ?? "");
+	if (!prefix) return null;
+	let tag;
+	if (parts.length === 2) {
+		const compiled = compileSegment(parts[1] ?? "");
+		if (!compiled) return null;
+		tag = compiled;
+	}
+	const paramNames = [];
+	if (prefix.kind === "param") paramNames.push(prefix.name);
+	if (tag?.kind === "param") paramNames.push(tag.name);
+	if (new Set(paramNames).size !== paramNames.length) {
+		const dupes = paramNames.filter((n, i) => paramNames.indexOf(n) !== i);
+		throw new Error(`email handler "${basename}" has duplicate param names: ${dupes.join(", ")}. Each [name] segment must be unique within a single handler filename.`);
+	}
+	const segments = [segmentRegex(prefix)];
+	if (tag) segments.push("\\+", segmentRegex(tag));
+	return {
+		kind: patternKind(prefix, tag),
+		regexSource: `^${segments.join("")}$`,
+		paramNames
+	};
+}
+/**
+* Kind order: most specific first. static-tag beats static (more
+* constraints), dynamic-tag beats dynamic. Matches the precedence list in
+* the file header.
+*/
+const DISPATCH_ORDER = {
+	"static-tag": 0,
+	static: 1,
+	"dynamic-tag": 2,
+	dynamic: 3
+};
+/**
+* The ONE dispatch comparator. The generated `__emailHandler` and the
+* `createInboundTestHarness` route table both return on the first pattern
+* that matches, so whatever sorts first owns every address it matches.
+*
+*   1. kind, per `DISPATCH_ORDER`
+*   2. fewer captures first — `support+vip` and `support+[tag]` are both
+*      `static-tag` and both match `support+vip@`; the literal tag must be
+*      tried first or the exact handler is dead code. Same for
+*      `[user]+vip` over `[user]+[tag]`.
+*   3. alphabetical, so the table is deterministic across filesystems.
+*
+* Two patterns with the same regex source share a kind and a capture count,
+* so the collision check below can still name the alphabetically-first one.
+*/
+function compareEmailRoutes(a, b) {
+	const kind = DISPATCH_ORDER[a.pattern.kind] - DISPATCH_ORDER[b.pattern.kind];
+	if (kind !== 0) return kind;
+	const captures = a.pattern.paramNames.length - b.pattern.paramNames.length;
+	if (captures !== 0) return captures;
+	return a.address.localeCompare(b.address);
+}
+function parseEmailFiles(files) {
+	const addresses = [];
+	let defaultHandler;
+	for (const filePath of files) {
+		if (filePath.includes("/")) continue;
+		const basename = filePath.replace(/\.[^.]+$/, "");
+		if (basename === "_default") {
+			if (defaultHandler !== void 0) throw new Error(`email handler "${filePath}" is a second default handler next to "${defaultHandler}" — keep exactly one email/_default.* file.`);
+			defaultHandler = filePath;
+			continue;
+		}
+		if (basename.startsWith("_")) continue;
+		const pattern = compileEmailPattern(basename);
+		if (!pattern) continue;
+		addresses.push({
+			address: basename.toLowerCase(),
+			filePath,
+			pattern
+		});
+	}
+	addresses.sort(compareEmailRoutes);
+	const seenRegex = /* @__PURE__ */ new Map();
+	for (const def of addresses) {
+		const prior = seenRegex.get(def.pattern.regexSource);
+		if (prior !== void 0) throw new Error(`email handler "${def.filePath}" matches the same address shape as "${prior}" (both compile to ${def.pattern.regexSource}). Rename one of them — only the alphabetically-first would ever fire.`);
+		seenRegex.set(def.pattern.regexSource, def.filePath);
+	}
+	return {
+		addresses,
+		defaultHandler
+	};
+}
+async function scanEmailHandlers(root, emailDir = "email") {
+	const pattern = `*.{${EMAIL_EXTENSIONS.join(",")}}`;
+	return parseEmailFiles(await glob(pattern, {
+		cwd: join(root, emailDir),
+		absolute: false
+	}).catch(() => []));
+}
+function scanEmailHandlersSync(root, emailDir = "email") {
+	const pattern = `*.{${EMAIL_EXTENSIONS.join(",")}}`;
+	let files;
+	try {
+		files = globSync(pattern, {
+			cwd: join(root, emailDir),
+			absolute: false
+		});
+	} catch {
+		files = [];
+	}
+	return parseEmailFiles(files);
+}
+function hasEmailHandlers(scan) {
+	return scan.addresses.length > 0 || Boolean(scan.defaultHandler);
+}
+//#endregion
+export { scanEmailHandlersSync as a, scanEmailHandlers as i, compileEmailPattern as n, hasEmailHandlers as r, compareEmailRoutes as t };