void 1.5.0 → 1.6.0

package/dist/headers-CuTEdP9C.mjs

@@ -0,0 +1,445 @@
+import { a as join } from "./dist-DMYe8CZJ.mjs";
+import { a as convertRewritesConfig, d as isProtocolRelative, f as parseHostPrefixedSource, i as convertRedirectsConfig, n as convertFallbacksConfig, o as countSplats, r as convertHeadersConfig, t as VALID_REDIRECT_STATUSES } from "./config-BITKQ3O6.mjs";
+import { i as voidWarn } from "./log-D9hwSySP.mjs";
+import { existsSync, readFileSync } from "node:fs";
+// src/asset-routing.ts
+function isApiRoutePattern(pattern) {
+	return pattern === "/api" || pattern.startsWith("/api/");
+}
+function hasDocumentRoutes(routes) {
+	return routes.some((route) => !isApiRoutePattern(route.pattern));
+}
+function hasApiRoutes(routes) {
+	return routes.some((route) => isApiRoutePattern(route.pattern));
+}
+/**
+* Returns true when browser document navigations must reach the worker before
+* a static asset fallback can serve HTML.
+*/
+function workerOwnsHtmlRouting(inputs) {
+	return inputs.isSsr || inputs.hasPages || inputs.hasDocumentRoutes || inputs.hasMiddleware || inputs.hasWebSockets === true || inputs.liveEnabled === true;
+}
+/**
+* Returns true when native edge rules must run in the worker before Cloudflare
+* Static Assets can answer: native builds compile HTTPS redirects and header,
+* redirect, rewrite and fallback rules into the worker.
+*/
+function edgeRulesNeedWorker(rules) {
+	return rules.alwaysUseHttps === true || (rules.headerRules?.length ?? 0) > 0 || (rules.redirectRules?.length ?? 0) > 0 || (rules.fallbackRules?.length ?? 0) > 0;
+}
+function resolveAssetConfig(inputs) {
+	return resolveAssetRoutingPolicy(inputs).assetConfig;
+}
+const VOID_INTERNAL_WORKER_FIRST = ["/__void", "/__void/*"];
+function resolveAssetRoutingPolicy(inputs) {
+	const workerFirst = workerOwnsHtmlRouting(inputs);
+	const apiWorkerFirst = !workerFirst && (inputs.hasApiRoutes === true || inputs.authEnabled === true);
+	const assetConfig = workerFirst ? {
+		not_found_handling: "none",
+		run_worker_first: ["/**"]
+	} : apiWorkerFirst ? {
+		not_found_handling: "single-page-application",
+		run_worker_first: [
+			"/api",
+			"/api/*",
+			...VOID_INTERNAL_WORKER_FIRST
+		]
+	} : {
+		not_found_handling: "single-page-application",
+		run_worker_first: [...VOID_INTERNAL_WORKER_FIRST]
+	};
+	if (inputs.notFound !== void 0) assetConfig.not_found_handling = inputs.notFound;
+	return {
+		assetConfig,
+		apiWorkerFirst,
+		workerFirst,
+		workerSpaFallback: workerFirst && !inputs.isSsr && !inputs.hasPages && (inputs.notFound === void 0 || inputs.notFound === "single-page-application")
+	};
+}
+// src/asset-worker-bypass.ts
+/**
+* Build-time decision for letting Cloudflare serve fingerprinted build files
+* without starting the Worker. Native Cloudflare builds of apps with no global
+* middleware and no edge rules gain nothing from running the Worker for those
+* files: the Worker would only copy the asset response. Skipping it makes
+* those requests free static requests and keeps auth and its session read off
+* them. Each file gets its own negative `run_worker_first` rule, because a
+* request matching a negative rule never reaches the Worker, even when the
+* file is missing. Misses and other paths in the folder keep the Worker's
+* not-found, SPA and page handling.
+* `routing.alwaysUseHttps` alone does not block this: hashed files are only
+* linked from pages the Worker has already moved to HTTPS.
+*
+* The asset layer does not know which files are fingerprinted, so a generated
+* `_headers` file gives every bypassed chunk the immutable policy the Worker
+* would have set.
+*
+* An `output: "static"` Pages build goes further when nothing site-wide must
+* run first (auth, live, `routing.alwaysUseHttps`): every file answers first,
+* and only paths with server code reach the Worker first. A page without a
+* server module prerenders the HTML the Worker would render, so its file can
+* answer. Hashed files keep their
+* immutable policy from the generated `_headers`, or stay on the Worker when
+* it cannot list them.
+*/
+const GENERATED_ASSET_HEADERS_MARKER = "# Generated by Void: immutable caching for fingerprinted build files. Do not edit.";
+/** Cloudflare accepts at most 100 `run_worker_first` rules. */
+const MAX_RUN_WORKER_FIRST_RULES = 100;
+/** Cloudflare limits each `run_worker_first` rule to 100 characters. */
+const MAX_RUN_WORKER_FIRST_RULE_LENGTH = 100;
+/** Cloudflare accepts at most 100 `_headers` rules. */
+const MAX_HEADERS_RULES = 100;
+const AUTH_PATTERNS = ["/api/auth/*"];
+/** Trim surrounding slashes; null when nothing is left. */
+function normalizeAssetsDir(dir) {
+	let start = 0;
+	let end = dir.length;
+	while (start < end && dir[start] === "/") start++;
+	while (end > start && dir[end - 1] === "/") end--;
+	const trimmed = dir.slice(start, end);
+	return trimmed === "" || trimmed === "." ? null : trimmed;
+}
+/**
+* Whether a route pattern can match a path below `/<dir>/`. Parameters,
+* wildcards and patterns with more segments than the directory count as a
+* match, so the answer errs towards keeping the Worker in front.
+*/
+function patternCanReachUnder(pattern, dir) {
+	const patternSegments = (pattern.startsWith("/") ? pattern.slice(1) : pattern).split("/");
+	const dirSegments = (dir.startsWith("/") ? dir.slice(1) : dir).split("/");
+	for (let i = 0; i < dirSegments.length; i++) {
+		const segment = patternSegments[i];
+		if (segment === void 0) return false;
+		if (segment.includes("*") || segment.includes("{")) return true;
+		if (segment.startsWith(":")) continue;
+		if (segment.toLowerCase() !== dirSegments[i].toLowerCase()) return false;
+	}
+	return patternSegments.length > dirSegments.length;
+}
+/**
+* Characters that are plain text in both a `_headers` path and a
+* `run_worker_first` rule. `*`, `:` and `!` have meaning there, and anything
+* that needs URL encoding would not match the request path as written.
+*/
+function isPlainPath(path) {
+	for (const char of path) if (!(char >= "a" && char <= "z" || char >= "A" && char <= "Z" || char >= "0" && char <= "9" || char === "-" || char === "_" || char === "." || char === "~" || char === "/")) return false;
+	return path.split("/").every((segment) => segment !== "" && segment !== "." && segment !== "..");
+}
+/**
+* Whether `run_worker_first` is the rule an earlier bypass wrote. A watch
+* rebuild of only the client still finds it, because the Worker build that
+* would write `['/**']` again did not run.
+*/
+function isAssetBypassRule(runWorkerFirst, assetsDir) {
+	const dir = normalizeAssetsDir(assetsDir);
+	return dir !== null && Array.isArray(runWorkerFirst) && runWorkerFirst.length > 1 && runWorkerFirst[0] === "/**" && runWorkerFirst.slice(1).every((rule) => typeof rule === "string" && rule.startsWith("!/" + dir + "/"));
+}
+/** The bypass this build can use, or null when any rule keeps the Worker in front. */
+function resolveAssetWorkerBypass(facts) {
+	const { runWorkerFirst } = facts;
+	if (!(Array.isArray(runWorkerFirst) && runWorkerFirst.length === 1 && runWorkerFirst[0] === "/**") || facts.notFoundHandling !== "none" || facts.base !== "/" || facts.hasMiddleware || facts.headerRuleCount > 0 || facts.redirectRuleCount > 0 || facts.fallbackRuleCount > 0 || facts.publicEdgeFiles) return null;
+	const assetsDir = normalizeAssetsDir(facts.assetsDir);
+	const files = assetsDir === null ? [] : [...new Set(facts.immutableFiles)].filter((file) => file.startsWith(assetsDir + "/")).sort();
+	return resolveStaticPageBypass(facts, assetsDir, files) ?? resolveHashedFileBypass(facts, assetsDir, files);
+}
+/** One negative rule per hashed file, so only those files skip the Worker. */
+function resolveHashedFileBypass(facts, assetsDir, files) {
+	if (!assetsDir || !isPlainPath(assetsDir)) return null;
+	if ([
+		...facts.patterns,
+		...VOID_INTERNAL_WORKER_FIRST,
+		...facts.authEnabled ? AUTH_PATTERNS : []
+	].some((pattern) => patternCanReachUnder(pattern, assetsDir))) return null;
+	const rules = ["/**", ...files.map((file) => "!/" + file)];
+	if (files.length === 0 || files.some((file) => !isPlainPath(file)) || !fitsRunWorkerFirstLimits(rules)) return null;
+	return {
+		runWorkerFirst: rules,
+		headers: renderGeneratedAssetHeaders(files)
+	};
+}
+/**
+* Void's own paths, then every server pattern widened to the static prefix
+* before its first parameter: matching too much only keeps the Worker in
+* front. A request that matches no file still reaches the Worker, since these
+* builds use `not_found_handling: 'none'`. Hashed files get the generated
+* `_headers`, or stay on the Worker when it cannot list them all. Null when
+* site-wide behavior must run first or a pattern covers every path.
+*/
+function resolveStaticPageBypass(facts, assetsDir, files) {
+	if (!facts.serverPatterns || facts.authEnabled || facts.liveEnabled || facts.alwaysUseHttps) return null;
+	const rules = /* @__PURE__ */ new Set();
+	for (const pattern of facts.serverPatterns) {
+		const patternRules = workerPathRules(pattern);
+		if (patternRules === null) return null;
+		for (const rule of patternRules) rules.add(rule);
+	}
+	let headers = null;
+	if (files.length > MAX_HEADERS_RULES || !files.every(isPlainPath)) {
+		if (!assetsDir || !isPlainPath(assetsDir)) return null;
+		rules.add("/" + assetsDir + "/*");
+	} else if (files.length > 0) headers = renderGeneratedAssetHeaders(files);
+	const runWorkerFirst = [...VOID_INTERNAL_WORKER_FIRST, ...[...rules].sort()];
+	return fitsRunWorkerFirstLimits(runWorkerFirst) ? {
+		runWorkerFirst,
+		headers
+	} : null;
+}
+/**
+* The rules covering every path `pattern` matches; null when that is every
+* path. A trailing `*` also matches the path before it: `/api/*` matches `/api`.
+*/
+function workerPathRules(pattern) {
+	if (pattern === "/") return ["/"];
+	const segments = (pattern.startsWith("/") ? pattern.slice(1) : pattern).split("/");
+	const dynamic = segments.findIndex((segment) => segment.startsWith(":") || segment.includes("*") || segment.includes("{"));
+	if (dynamic === 0) return null;
+	const prefix = (dynamic === -1 ? segments : segments.slice(0, dynamic)).join("/");
+	if (!isPlainPath(prefix)) return null;
+	if (dynamic === -1) return ["/" + prefix];
+	const rule = "/" + prefix + "/*";
+	return dynamic === segments.length - 1 && segments[dynamic] === "*" ? ["/" + prefix, rule] : [rule];
+}
+function fitsRunWorkerFirstLimits(rules) {
+	return rules.length <= MAX_RUN_WORKER_FIRST_RULES && rules.every((rule) => rule.length <= MAX_RUN_WORKER_FIRST_RULE_LENGTH);
+}
+/** One immutable rule per file after the marker line. */
+function renderGeneratedAssetHeaders(files) {
+	const lines = [GENERATED_ASSET_HEADERS_MARKER];
+	for (const file of files) lines.push("/" + file, "  Cache-Control: public, max-age=31536000, immutable");
+	return lines.join("\n") + "\n";
+}
+/** Whether a `_headers` file is the one Void generated. */
+function isGeneratedAssetHeaders(text) {
+	const newline = text.indexOf("\n");
+	let firstLine = newline === -1 ? text : text.slice(0, newline);
+	if (firstLine.endsWith("\r")) firstLine = firstLine.slice(0, -1);
+	return firstLine === GENERATED_ASSET_HEADERS_MARKER;
+}
+// src/cli/headers.ts
+/**
+* Parse a Cloudflare/Netlify `_headers` file into HeaderRule[].
+*
+* Format:
+*   - Non-indented lines = path pattern (starts a new block)
+*   - Indented lines = `Header-Name: value` (split on first `:`)
+*   - Lines starting with `#` are comments
+*   - `! Header-Name` unset directives are skipped (last-match-wins handles this)
+*
+* Output is sorted by pattern length ascending (shortest first) so that
+* more-specific patterns come last — matching dispatch's last-match-wins semantics.
+*
+* Returns `undefined` if the file doesn't exist or yields no valid rules.
+*/
+function parseHeadersFile(dir) {
+	const filePath = join(dir, "_headers");
+	if (!existsSync(filePath)) return;
+	const content = readFileSync(filePath, "utf-8");
+	const rules = [];
+	let current = null;
+	for (const line of content.split("\n")) {
+		const trimmed = line.trimEnd();
+		if (trimmed === "" || trimmed.startsWith("#")) continue;
+		if (line[0] === " " || line[0] === "	") {
+			if (!current) continue;
+			const stripped = trimmed.trimStart();
+			if (stripped.startsWith("!")) continue;
+			const colonIdx = stripped.indexOf(":");
+			if (colonIdx === -1) continue;
+			const name = stripped.slice(0, colonIdx).trim();
+			const value = stripped.slice(colonIdx + 1).trim();
+			if (name) current.headers.push([name, value]);
+		} else {
+			if (current && current.headers.length > 0) rules.push(current);
+			current = {
+				pattern: trimmed,
+				headers: []
+			};
+		}
+	}
+	if (current && current.headers.length > 0) rules.push(current);
+	if (rules.length === 0) return;
+	rules.sort((a, b) => a.pattern.length - b.pattern.length);
+	return rules;
+}
+/** The `_headers` text in `dir` when Void generated it, otherwise undefined. */
+function readGeneratedAssetHeadersFile(dir) {
+	const filePath = join(dir, "_headers");
+	if (!existsSync(filePath)) return;
+	const content = readFileSync(filePath, "utf-8");
+	return isGeneratedAssetHeaders(content) ? content : void 0;
+}
+/**
+* Parse a `_redirects` file: `source destination [status]` per line (status
+* defaults to 302, `#` starts a comment). Keeps 3xx redirects and 200 rewrites.
+*
+* A `!` suffix on 200 sets `force`, so the rewrite applies even when a static
+* asset matches. On a 3xx it is a no-op, stripped and counted in
+* `redundantForceOn3xx`.
+*
+* Returns `undefined` when the file doesn't exist or yields no valid rules.
+*/
+function parseRedirectsFile(dir) {
+	const filePath = join(dir, "_redirects");
+	if (!existsSync(filePath)) return;
+	const content = readFileSync(filePath, "utf-8");
+	const rules = [];
+	let redundantForceOn3xx = 0;
+	const rawLines = content.split("\n");
+	for (let i = 0; i < rawLines.length; i++) {
+		const lineNumber = i + 1;
+		const trimmed = rawLines[i].trim();
+		if (!trimmed || trimmed.startsWith("#")) continue;
+		const parts = trimmed.split(/\s+/);
+		if (parts.length < 2) continue;
+		const origin = `_redirects:${lineNumber}`;
+		const [rawSource, destination, statusStr] = parts;
+		const parsedSource = parseHostPrefixedSource(rawSource);
+		if ("error" in parsedSource) {
+			voidWarn(`Skipping _redirects entry "${rawSource} ${destination}${statusStr ? ` ${statusStr}` : ""}" (line ${lineNumber}): source ${parsedSource.error}.`);
+			continue;
+		}
+		const { host, path: source } = parsedSource;
+		if (countSplats(source) > 1) {
+			voidWarn(`Skipping _redirects entry "${rawSource} ${destination}${statusStr ? ` ${statusStr}` : ""}" (line ${lineNumber}): source must contain at most one "*" wildcard (captured as :splat).`);
+			continue;
+		}
+		let status;
+		let force = false;
+		if (statusStr) {
+			if (statusStr.endsWith("!")) {
+				const numericPart = statusStr.slice(0, -1);
+				status = parseInt(numericPart, 10);
+				if (status === 200) force = true;
+				else if (status >= 300 && status < 400) redundantForceOn3xx++;
+			} else status = parseInt(statusStr, 10);
+		} else status = 302;
+		if (status === 200) {
+			if (!destination.startsWith("/")) {
+				voidWarn(`Skipping _redirects rewrite "${rawSource} ${destination} ${force ? "200!" : "200"}": destination must start with "/" (only internal paths are supported).`);
+				continue;
+			}
+			if (isProtocolRelative(destination)) {
+				voidWarn(`Skipping _redirects rewrite "${rawSource} ${destination} ${force ? "200!" : "200"}": destination must not start with "//" (protocol-relative URLs parse as cross-origin; only internal paths are supported).`);
+				continue;
+			}
+			if (destination.includes("?")) {
+				voidWarn(`Skipping _redirects rewrite "${rawSource} ${destination} ${force ? "200!" : "200"}": destination must not contain "?" (query strings are not supported in rewrite destinations; the incoming request's query is preserved automatically).`);
+				continue;
+			}
+			rules.push({
+				source,
+				destination,
+				status,
+				force,
+				origin,
+				...host && { host }
+			});
+		} else if (status >= 300 && status < 400) {
+			if (!VALID_REDIRECT_STATUSES.has(status)) {
+				voidWarn(`Skipping _redirects entry "${rawSource} ${destination} ${statusStr}" (line ${lineNumber}): redirect status must be 301, 302, 303, 307, or 308.`);
+				continue;
+			}
+			rules.push({
+				source,
+				destination,
+				status,
+				origin,
+				...host && { host }
+			});
+		}
+	}
+	if (rules.length === 0 && redundantForceOn3xx === 0) return;
+	return {
+		rules,
+		redundantForceOn3xx
+	};
+}
+/**
+* Split `_redirects` rules into rules that always apply and fallbacks: unforced
+* 200 rewrites, which apply only when no static asset matches.
+*/
+function splitRedirectRulesByForce(rules) {
+	const always = [];
+	const fallbacks = [];
+	if (!rules) return {
+		always,
+		fallbacks
+	};
+	for (const rule of rules) if (rule.status === 200 && rule.force !== true) fallbacks.push(rule);
+	else always.push(rule);
+	return {
+		always,
+		fallbacks
+	};
+}
+/**
+* Merge `_redirects` and `_headers` in `dir` with `routing` from void.config.ts.
+* Deploy and dev share it so both build the same rule tables; callers lint them.
+*/
+function mergeRoutingRules(opts) {
+	const { dir, routing } = opts;
+	const fileDir = dir !== null && existsSync(dir) ? dir : null;
+	const fileHeaders = fileDir !== null ? parseHeadersFile(fileDir) : void 0;
+	const fileParsed = fileDir !== null ? parseRedirectsFile(fileDir) : void 0;
+	const { always: fileAlways, fallbacks: fileFallbacks } = splitRedirectRulesByForce(fileParsed?.rules);
+	const cfgHeaders = convertHeadersConfig(routing?.headers);
+	const cfgRedirects = convertRedirectsConfig(routing?.redirects);
+	const cfgRewrites = convertRewritesConfig(routing?.rewrites);
+	const cfgFallbacks = convertFallbacksConfig(routing?.fallbacks);
+	const headerRules = [...fileHeaders ?? [], ...cfgHeaders ?? []];
+	const redirectRules = [
+		...cfgRedirects ?? [],
+		...cfgRewrites ?? [],
+		...fileAlways
+	];
+	const mergedFallbacks = [...cfgFallbacks ?? [], ...fileFallbacks];
+	return {
+		headerRules,
+		redirectRules,
+		fallbackRules: mergedFallbacks.length > 0 ? mergedFallbacks : void 0,
+		redundantForceOn3xx: fileParsed?.redundantForceOn3xx ?? 0
+	};
+}
+/**
+* Lint each phase on its own: only duplicates within a phase shadow each other,
+* so a redirect and a fallback with the same source are fine.
+*/
+function lintRoutingPhases(rules) {
+	lintDuplicateSources(rules.redirectRules, "redirects/rewrites (pre-asset)");
+	lintDuplicateSources(rules.fallbackRules, "fallbacks (post-asset)");
+	lintDestinationSplats(rules.redirectRules, "redirects/rewrites (pre-asset)");
+	lintDestinationSplats(rules.fallbackRules, "fallbacks (post-asset)");
+}
+/**
+* Warn about a literal `*` in a destination. Destinations substitute only
+* `:name` params such as `:splat`, so a `*` passes through unchanged.
+*/
+function lintDestinationSplats(rules, phaseName) {
+	if (!rules || rules.length === 0) return;
+	const affected = rules.filter((r) => r.destination.includes("*"));
+	if (affected.length === 0) return;
+	const lines = affected.map((r) => `  ${r.source} → ${r.destination}  (${r.origin ?? "<unknown>"})`);
+	voidWarn(`destinations in ${phaseName} contain a literal "*" — splat tokens are not substituted in destinations; use ":splat" (or other named params) or rewrite the destination:\n${lines.join("\n")}`);
+}
+/**
+* Warn when one phase repeats an exact `source`: first match wins, so the later
+* rule never applies. Phases run separately, so callers lint each one.
+*/
+function lintDuplicateSources(rules, phaseName) {
+	if (!rules || rules.length < 2) return;
+	const bySource = /* @__PURE__ */ new Map();
+	for (const rule of rules) {
+		const existing = bySource.get(rule.source);
+		if (existing) existing.push(rule);
+		else bySource.set(rule.source, [rule]);
+	}
+	const lines = [];
+	for (const [source, occurrences] of bySource) {
+		if (occurrences.length < 2) continue;
+		const origins = occurrences.map((r) => r.origin ?? "<unknown>").join(", ");
+		lines.push(`  ${source}  — ${origins}`);
+	}
+	if (lines.length === 0) return;
+	voidWarn(`duplicate rule sources detected in ${phaseName} (first match wins — the earlier entry takes effect):\n${lines.join("\n")}`);
+}
+export { isAssetBypassRule as a, VOID_INTERNAL_WORKER_FIRST as c, hasDocumentRoutes as d, resolveAssetConfig as f, readGeneratedAssetHeadersFile as i, edgeRulesNeedWorker as l, mergeRoutingRules as n, isGeneratedAssetHeaders as o, resolveAssetRoutingPolicy as p, parseRedirectsFile as r, resolveAssetWorkerBypass as s, lintRoutingPhases as t, hasApiRoutes as u };

package/dist/{help-EWDNxST-.mjs → help-1OCFDsRr.mjs}

@@ -688,6 +688,10 @@ const HELP_TREE = {
 						command: "--runtime <path>",
 						description: "Deploy an integrity-checked runtime directory instead of the package"
 					},
+					{
+						command: "--runtime-logs <full|minimal>",
+						description: "minimal keeps request URLs, console and exception messages out of runtime logs"
+					},
 					{
 						command: "--yes",
 						description: "Acknowledge changes without an interactive prompt"
@@ -1780,7 +1784,7 @@ function withProjectOption(summary, usage) {
 function lifecycleHelp(command, summary) {
 	return {
 		summary,
-		usage: [`void platform ${command} [id] [--plan]${command === "disable" ? "" : " [--runtime <path>]"}${command === "upgrade" || command === "repair" ? " [--dashboard-url <origin>] [--custom-domains]" : ""}${command === "repair" ? " [--auth-config <path>]" : ""} [--yes]`],
+		usage: [`void platform ${command} [id] [--plan]${command === "disable" ? "" : " [--runtime <path>]"}${command === "upgrade" || command === "repair" ? " [--dashboard-url <origin>] [--custom-domains]" : ""}${command === "upgrade" ? " [--runtime-logs <full|minimal>]" : ""}${command === "repair" ? " [--auth-config <path>]" : ""} [--yes]`],
 		options: [
 			{
 				command: "--plan",
@@ -1797,6 +1801,10 @@ function lifecycleHelp(command, summary) {
 				command: "--custom-domains",
 				description: "Turn on project custom domains; omission keeps the saved setting"
 			}] : [],
+			...command === "upgrade" ? [{
+				command: "--runtime-logs <full|minimal>",
+				description: "minimal keeps request URLs, console and exception messages out of runtime logs; omission keeps the saved setting"
+			}] : [],
 			...command === "repair" ? [{
 				command: "--auth-config <path>",
 				description: "While first administrator setup is pending, replace its login settings (install file format)"

package/dist/help-Ba8Dq5-r.mjs

@@ -0,0 +1 @@
+export { r as printHelpPage } from "./help-1OCFDsRr.mjs";

package/dist/{inbound-DSKSHDUj.d.mts → inbound-BHt4dIlL.d.mts}

@@ -33,8 +33,21 @@ interface SendEmailOptions {
   replyTo?: Address;
   cc?: Address | Array<Address>;
   bcc?: Address | Array<Address>;
+  /** Custom headers. Reserved names such as `From`, `Date` and the threading headers are ignored. */
   headers?: Record<string, string>;
   attachments?: Array<Attachment>;
+  /**
+   * Threads this email under an earlier message, such as a reply sent from a
+   * queue job after the inbound handler returned. `inReplyTo` is the parent's
+   * `Message-ID`. `references` lists the thread's ids, oldest first, ending
+   * with the parent; it defaults to `inReplyTo`. An id that cannot be sent,
+   * such as one with a control character, is left out. If `references`
+   * cannot be sent, it falls back to `inReplyTo`. The email still sends.
+   */
+  threading?: {
+    inReplyTo?: string;
+    references?: string;
+  };
   /**
    * Deduplicates a platform send for 30 days. Reuse the same key and message
    * when checking an uncertain attempt; a changed message is a conflict.
@@ -145,11 +158,9 @@ interface NormalizedEmail {
   headers: Record<string, string>;
   attachments: Array<NormalizedAttachment>;
   /**
-   * Internal-only threading headers, set by `replyEmail`/`buildReplyMessage`.
-   * The MIME builder emits these as proper `In-Reply-To` / `References`
-   * top-level headers. User-supplied `headers` with these names are
-   * always dropped (they're in `RESERVED_HEADERS`); this field is the
-   * supported channel for the trusted reply path.
+   * `In-Reply-To` / `References` after the ids were checked, from the
+   * `threading` option or `replyEmail`. User-supplied `headers` with these
+   * names are always dropped (they're in `RESERVED_HEADERS`).
    */
   threading?: {
     inReplyTo?: string;

package/dist/{inbound-DQfekMtz.mjs → inbound-CdO-qY0w.mjs}

@@ -1,5 +1,5 @@
 import { t as base64ToBytes } from "./base64-ikl9yBy3.mjs";
-import { c as validateAddressParts, i as indexOfControl, n as MimeError, o as normalizeEmail, r as buildMime } from "./mime-DKkO7ZtA.mjs";
+import { a as normalizeEmail, c as fitsHeaderLine, l as replyReferences, n as MimeError, r as buildMime, s as validateAddressParts, u as threadingId } from "./mime-CtP6-qAF.mjs";
 import { a as getRawRuntimeEnv } from "./env-raw-e8qgqAzQ.mjs";
 import { o as withTimeout } from "./email-protocol-DTs_TjCS.mjs";
 import { EMAIL_MAX_ACTIONS, EMAIL_MAX_INBOUND_BYTES, EMAIL_MAX_INBOUND_HEADERS, EMAIL_MAX_METADATA_BYTES, EMAIL_MAX_REPLY_BYTES, EMAIL_MAX_RESPONSE_BYTES } from "@void/platform/email-protocol";
@@ -349,52 +349,6 @@ function createMessageProxy(envelope, opts = {}) {
 	};
 }
 /**
-* Whether `Name: value` fits RFC 5322's 998-octet line. Folding happens only
-* at SP or HTAB, so the widest unbroken run decides.
-*/
-function fitsHeaderLine(name, value) {
-	if (!value) return false;
-	const budget = 998 - (name.length + 2);
-	let run = 0;
-	for (let i = 0; i < value.length; i++) {
-		const c = value.charCodeAt(i);
-		if (c === 32 || c === 9) {
-			run = 0;
-			continue;
-		}
-		if (c < 128) run += 1;
-		else if (c < 2048) run += 2;
-		else if (c >= 55296 && c <= 56319 && i + 1 < value.length && (value.charCodeAt(i + 1) & 64512) === 56320) {
-			run += 4;
-			i++;
-		} else run += 3;
-		if (run > budget) return false;
-	}
-	return true;
-}
-/**
-* `chain` without the ids that hold a control character, joined by single
-* spaces. Called only on a chain already cut to `MAX_REPLY_REFERENCES_CHARS`.
-*/
-function dropControlIds(chain) {
-	if (indexOfControl(chain) === -1) return chain;
-	const kept = [];
-	let start = -1;
-	let tainted = false;
-	for (let i = 0; i <= chain.length; i++) {
-		const c = i < chain.length ? chain.charCodeAt(i) : 32;
-		if (c === 32 || c === 9) {
-			if (start >= 0 && !tainted) kept.push(chain.slice(start, i));
-			start = -1;
-			tainted = false;
-		} else {
-			if (start < 0) start = i;
-			if (c < 32 || c === 127) tainted = true;
-		}
-	}
-	return kept.join(" ");
-}
-/**
 * Longest decoded inbound subject the default reply subject is built from;
 * longer falls back to a bare `Re:`. Real subjects are far shorter, and the
 * bound keeps the control-character replacement cheap.
@@ -410,34 +364,6 @@ function prefixReplySubject(original) {
 	return prefixed;
 }
 /**
-* Longest `References` value a reply carries, in UTF-16 code units. 8 KiB
-* keeps any real thread whole; past it the newest ids are kept, since mail
-* clients thread on any id they recognise and the parent is `In-Reply-To`.
-*/
-const MAX_REPLY_REFERENCES_CHARS = 8192;
-/**
-* The reply's `References`, or `''`: the inbound chain plus the parent's id,
-* trimmed to its newest whole ids, or the parent's id alone when an id
-* cannot fit a line.
-*/
-function replyReferences(originalReferences, messageId) {
-	const parent = messageId ? ` ${messageId}` : "";
-	let chain = originalReferences;
-	const budget = MAX_REPLY_REFERENCES_CHARS - parent.length;
-	if (chain.length > budget) {
-		let cut = chain.length - budget;
-		while (cut < chain.length) {
-			const c = chain.charCodeAt(cut);
-			if (c === 32 || c === 9) break;
-			cut++;
-		}
-		chain = chain.slice(cut);
-	}
-	chain = dropControlIds(chain);
-	chain = `${chain}${parent}`.trim();
-	return fitsHeaderLine("References", chain) ? chain : messageId;
-}
-/**
 * Minimal RFC 2047 decoder for the reply subject: B and Q encoded-words,
 * unknown charsets read as UTF-8, malformed input returned unchanged.
 */
@@ -504,7 +430,7 @@ async function buildReplyMessage(message, opts) {
 	const toAddr = opts.to ?? message.from;
 	const subject = opts.subject ?? prefixReplySubject(originalSubject);
 	const threading = {};
-	const messageId = fitsHeaderLine("In-Reply-To", originalMessageId) && indexOfControl(originalMessageId) === -1 ? originalMessageId : "";
+	const messageId = threadingId("In-Reply-To", originalMessageId);
 	if (messageId) threading.inReplyTo = messageId;
 	const references = replyReferences(originalReferences, messageId);
 	if (references) threading.references = references;

package/dist/index.d.mts

@@ -1,7 +1,7 @@
 import { n as HeadDescriptor } from "./head-MeF_5M_3.mjs";
 import { r as AuthUser } from "./auth-CH4PLAX1.mjs";
 import { s as RouteEnvironment } from "./types-agfx0alu.mjs";
-import { C as defer, E as ValidatorSlots, S as InferProps, T as HandlerInput, _ as defineQueue, a as CloudEnv, b as Deferred, c as QueueRetryOptions, d as TypedQueueHandler, f as VoidAssetRewriteError, g as defineMiddleware, h as defineHead, i as CloudContextVariables, l as RenderAssetTags, m as defineHandler, o as QueueBatch, p as basicAuth, r as CloudContext, s as QueueMessage, t as BasicAuthOptions, u as TypedHandler, v as defineRender, x as DeferredState, y as defineScheduled } from "./handler-Drm_lyrV.mjs";
+import { C as defer, E as ValidatorSlots, S as InferProps, T as HandlerInput, _ as defineQueue, a as CloudEnv, b as Deferred, c as QueueRetryOptions, d as TypedQueueHandler, f as VoidAssetRewriteError, g as defineMiddleware, h as defineHead, i as CloudContextVariables, l as RenderAssetTags, m as defineHandler, o as QueueBatch, p as basicAuth, r as CloudContext, s as QueueMessage, t as BasicAuthOptions, u as TypedHandler, v as defineRender, x as DeferredState, y as defineScheduled } from "./handler-BR6Tvjkp.mjs";
 import { t as QueueMap } from "./queues-DdM42xXW.mjs";
 import { Plugin } from "vite";
 import { convertToWranglerConfig } from "@cloudflare/config";