void 0.10.11 → 0.10.13

package/dist/{deploy-DT8wsPZd.mjs → deploy-jBJT1fUT.mjs}

@@ -1,26 +1,26 @@
-import { n as __exportAll } from "./rolldown-runtime-DJK8HYOj.mjs";
+import { n as __exportAll, r as __toESM } from "./rolldown-runtime-DJK8HYOj.mjs";
 import { a as join, c as resolve, i as isAbsolute, n as dirname, o as normalize, r as extname, s as relative, t as basename } from "./dist-DaKKDf8D.mjs";
-import { D as outro, E as note, S as confirm, T as log, a as cliTitle, j as isCancel, o as createSpinner, u as import_picocolors, w as intro } from "./agents-CtgBYqld.mjs";
+import { D as outro, E as note, M as require_picocolors, S as confirm, T as log, a as cliTitle, j as isCancel, o as createSpinner, u as import_picocolors$1, w as intro } from "./agents-CtgBYqld.mjs";
 import { i as resolveProjectPaths, n as readProjectPaths, t as assertNoRootSourceConventionConflicts } from "./project-paths-BQd7OmIo.mjs";
-import { a as scanQueuesSync, i as scanWebSocketRoutesSync, o as scanJobsSync, r as scanRoutes, s as findVoidAuthConfig } from "./scan-DYXkrasO.mjs";
+import { a as scanQueuesSync, i as scanWebSocketRoutesSync, o as scanJobsSync, r as scanRoutes, s as findVoidAuthConfig } from "./scan-ChWt4pX1.mjs";
 import { t as cfAccessHeaders } from "./cf-access-Bqw81xAf.mjs";
 import { C as ensureCloudflaredToken, S as writeProjectConfig, a as isExpiredTokenError, b as readProjectConfig, f as getToken, i as isCliOutdatedError, m as isStagingMode, n as PlatformClient, o as parsePlatformErrorBody, p as getTokenSource, t as PlatformApiError, u as getApiUrl } from "./client-Gb71-XkG.mjs";
-import { c as getDatabaseDialect, f as readConfig, l as isNodeTarget, p as resolveBindingNames } from "./config-E03l1C_h.mjs";
+import { c as getDatabaseDialect, f as readConfig, l as isNodeTarget, p as resolveBindingNames } from "./config-qHGgPuWT.mjs";
 import { i as inferProjectBindings, n as FRAMEWORK_SCAN_DIRS, r as detectFramework } from "./plugin-inference-DMeavIJ6.mjs";
 import { o as validateSsrEntry } from "./entry-D7yy4xVH.mjs";
 import { i as voidWarn, r as voidLog } from "./log-ChfPKsVd.mjs";
-import { a as resolveProjectCommand, c as mergeAndExpand, i as hasBackendFiles, l as parseDotenvFile, n as detectPreset, o as resolveWranglerArgv, r as formatProjectCommand, t as FRAMEWORK_PRESETS, u as scanWranglerDotenvKeys } from "./preset-BGrvB4Bl.mjs";
+import { a as resolveProjectCommand, c as mergeAndExpand, i as hasBackendFiles, l as parseDotenvFile, n as detectPreset, o as resolveWranglerArgv, r as formatProjectCommand, t as FRAMEWORK_PRESETS, u as scanWranglerDotenvKeys } from "./preset-BjyR3lzz.mjs";
 import { t as discoverSchema } from "./discover-CJHyvYfR.mjs";
 import { t as findEnvFile } from "./env-types-QBj-ndax.mjs";
-import { a as collectPlaintextVarWarningsFromVars, d as getDeployEnvDefaults, f as readEmittedWorkerVars, i as SelfHostSecretListError, l as fetchRemoteSecretNames, m as validateProdEnv, n as SelfHostFirstDeployError, o as deriveSelfHostEnvContextFromVars, p as selfHostSchemaFailureMessage, r as SelfHostSchemaError, s as dischargeSelfHostEnvContext, t as SelfHostEnvValidationError, u as formatEnvReport } from "./env-validation-BdDlGhbN.mjs";
+import { a as collectPlaintextVarWarningsFromVars, d as getDeployEnvDefaults, f as readEmittedWorkerVars, i as SelfHostSecretListError, l as fetchRemoteSecretNames, m as validateProdEnv, n as SelfHostFirstDeployError, o as deriveSelfHostEnvContextFromVars, p as selfHostSchemaFailureMessage, r as SelfHostSchemaError, s as dischargeSelfHostEnvContext, t as SelfHostEnvValidationError, u as formatEnvReport } from "./env-validation-Dea3v3ej.mjs";
 import { n as writeDrizzleConfig } from "./config-CutEMNGJ.mjs";
 import { a as buildMigrationPlanBundle, c as collectMigrations, r as validateMigrations, t as assertJournalCoherence } from "./validate-Cw_RLeTj.mjs";
-import { t as scanPages } from "./scan-DEwlM_Xy.mjs";
+import { t as scanPages } from "./scan-NU4xKGci.mjs";
 import { n as STAGING_PROXY_URL, t as DEFAULT_PROXY_URL } from "./proxy-D-3_D-Gl.mjs";
 import { i as promptProjectSetupAction, n as promptAndCreateProject, r as promptProjectSelection } from "./create-project-DsYvl3TB.mjs";
 import { r as resolveProjectBySlug, t as getRequestedProjectSlug } from "./resolve-project-BBMtLLV9.mjs";
-import { t as collectGitDeployMetadata } from "./git-metadata-CBKaL0v5.mjs";
-import { n as lintDuplicateSources, r as mergeRoutingRules, t as lintDestinationSplats } from "./headers-BQknpzkn.mjs";
+import { t as collectGitDeployMetadata } from "./git-metadata-D-gurjzG.mjs";
+import { n as lintDuplicateSources, r as mergeRoutingRules, t as lintDestinationSplats } from "./headers-ChAADPQu.mjs";
 import { t as promptForLoginToken } from "./login-BT3H8PN3.mjs";
 import { createRequire } from "node:module";
 import { copyFileSync, cpSync, createWriteStream, existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, renameSync, rmSync, unlinkSync, writeFileSync } from "node:fs";
@@ -56,24 +56,26 @@ 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: 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]
-		},
+		assetConfig,
 		apiWorkerFirst,
 		workerFirst,
-		workerSpaFallback: workerFirst && !inputs.isSsr && !inputs.hasPages
+		workerSpaFallback: workerFirst && !inputs.isSsr && !inputs.hasPages && (inputs.notFound === void 0 || inputs.notFound === "single-page-application")
 	};
 }
 const SANDBOX_MIGRATION_TAG = "void-sandbox-v1";
@@ -2113,7 +2115,7 @@ async function uploadOne(item, cliLog, fetchImpl) {
 				path: item.path,
 				attempt: attempt + 1,
 				status: res.status,
-				body: truncate(errBody)
+				body: truncate$1(errBody)
 			});
 			await sleep(RETRY_BACKOFF_MS[attempt]);
 			attempt++;
@@ -2124,9 +2126,9 @@ async function uploadOne(item, cliLog, fetchImpl) {
 			path: item.path,
 			durationMs: Date.now() - startedAt,
 			status: res.status,
-			body: truncate(errBody)
+			body: truncate$1(errBody)
 		});
-		throw new DirectR2PutError(res.status, item.hash, item.path, truncate(errBody));
+		throw new DirectR2PutError(res.status, item.hash, item.path, truncate$1(errBody));
 	}
 }
 async function safeReadText(res) {
@@ -2136,7 +2138,7 @@ async function safeReadText(res) {
 		return "";
 	}
 }
-function truncate(s) {
+function truncate$1(s) {
 	return s.length > 500 ? `${s.slice(0, 500)}...` : s;
 }
 function sleep(ms) {
@@ -2268,6 +2270,23 @@ async function safeText(res) {
 //#endregion
 //#region src/cli/log-file.ts
 /**
+* Flatten an already-serialized `ErrChainNode` (as read back out of a JSONL
+* record) to a single inline string. Mirrors `formatErrorChainInline`, which
+* does the same job for a live `Error` before it is written.
+*/
+function formatErrorNodeInline(node, depth = 0) {
+	if (node == null || typeof node !== "object") return String(node);
+	const message = node.message == null ? "" : String(node.message);
+	if (depth > 5) return message;
+	let head = node.name ? `${String(node.name)}: ${message}` : message;
+	const tags = [];
+	if (node.code !== void 0) tags.push(`code=${node.code}`);
+	if (node.errno !== void 0) tags.push(`errno=${node.errno}`);
+	if (tags.length > 0) head = `${head} (${tags.join(" ")})`;
+	if (node.cause != null) return `${head} -> ${formatErrorNodeInline(node.cause, depth + 1)}`;
+	return head;
+}
+/**
 * Walk `err.cause` up to 6 levels and return a plain JSON-friendly chain.
 * Skips stack traces deliberately — keeps output line-oriented and readable.
 */
@@ -2420,6 +2439,160 @@ function openDeployLog(opts) {
 	};
 }
 //#endregion
+//#region src/cli/log-summary.ts
+var import_picocolors = /* @__PURE__ */ __toESM(require_picocolors(), 1);
+const FIELD_VALUE_MAX = 80;
+const LINE_MAX = 160;
+const MSG_COLUMN_MAX = 28;
+const ELAPSED_WIDTH = 7;
+const LEVEL_WIDTH = 5;
+/** Width of `'  ' + elapsed + '  '`, used to indent the error sub-lines. */
+const DETAIL_INDENT = " ".repeat(11);
+/**
+* `runDeploy` writes this record last, and its `err` field is the very message
+* printed above the summary. Keeping it out of the error block avoids echoing
+* the same text twice; it still shows up as one line in the tail.
+*/
+const TERMINAL_ERROR_MSG = "deploy_end";
+const RESERVED_KEYS = /* @__PURE__ */ new Set([
+	"ts",
+	"elapsedMs",
+	"lvl",
+	"msg",
+	"err"
+]);
+/**
+* The trace was a file the user opened by hand; the summary publishes it to
+* whatever reads stderr, which in CI is a stored, often public, log.
+*
+* Scrubbing here covers only credentials this code emits itself — a presigned
+* URL it built, an auth header it set, a field it named. Scrubbing user data is
+* left to the CI platform, which owns the secrets and masks them before the log
+* is written. GitHub Actions does this for everything under `secrets.*`. Void
+* does not guess at credential-shaped names or at credentials embedded in
+* values the user supplied.
+*/
+/** Query parameters whose value must never reach a CI log. */
+const SIGNED_QUERY_RE = /([?&](?:X-Amz-[A-Za-z0-9-]+|[Ss]ignature|sig|token|access_token|key)=)[^&\s]+/g;
+const BEARER_RE = /\b(Bearer\s+)\S+/g;
+/**
+* Field keys whose value is masked whole, whatever it looks like. `auth` is
+* deliberately absent — it matches metadata keys such as `authMethod` far more
+* often than credentials.
+*/
+const SECRET_KEY_RE = /token|secret|password|passwd|credential|cookie|signature|api[-_]?key|private[-_]?key/i;
+function redact(text) {
+	return text.replace(SIGNED_QUERY_RE, "$1[redacted]").replace(BEARER_RE, "$1[redacted]");
+}
+function truncate(text, max) {
+	return text.length <= max ? text : `${text.slice(0, max)}...`;
+}
+/** Collapse every run of whitespace so one record always renders as one line. */
+function oneLine(text) {
+	return text.replace(/\s+/g, " ").trim();
+}
+function stringifyValue(value) {
+	if (typeof value === "string") return value;
+	if (value === null || typeof value === "number" || typeof value === "boolean") return String(value);
+	try {
+		return JSON.stringify(value) ?? String(value);
+	} catch {
+		return String(value);
+	}
+}
+/** Render one `key=value` pair, collapsed, redacted, and length-capped. */
+function formatField(key, value) {
+	if (SECRET_KEY_RE.test(key)) return `${key}=[redacted]`;
+	return `${key}=${truncate(redact(oneLine(stringifyValue(value))), FIELD_VALUE_MAX)}`;
+}
+function fieldPairs(record) {
+	const pairs = [];
+	for (const [key, value] of Object.entries(record)) {
+		if (RESERVED_KEYS.has(key) || value === void 0) continue;
+		pairs.push(formatField(key, value));
+	}
+	if (record.err !== void 0) pairs.push(`err=${truncate(redact(oneLine(formatErrorNodeInline(record.err))), FIELD_VALUE_MAX)}`);
+	return pairs;
+}
+function formatElapsed(elapsedMs) {
+	return `${((typeof elapsedMs === "number" && Number.isFinite(elapsedMs) ? elapsedMs : 0) / 1e3).toFixed(1)}s`.padStart(ELAPSED_WIDTH);
+}
+function colorLevel(level, padded) {
+	if (level === "error") return import_picocolors.default.red(padded);
+	if (level === "warn") return import_picocolors.default.yellow(padded);
+	return import_picocolors.default.dim(padded);
+}
+function parseRecords(lines) {
+	const records = [];
+	for (const raw of lines) {
+		const trimmed = raw.trim();
+		if (!trimmed) continue;
+		try {
+			const parsed = JSON.parse(trimmed);
+			if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) records.push(parsed);
+		} catch {}
+	}
+	return records;
+}
+/** One aligned line: `  8.9s  error  deploy_server_error  message=...`. */
+function formatTailLine(record, msgWidth) {
+	const level = typeof record.lvl === "string" ? record.lvl : "info";
+	const msg = typeof record.msg === "string" ? record.msg : "";
+	const elapsed = formatElapsed(record.elapsedMs);
+	const paddedLevel = level.padEnd(LEVEL_WIDTH);
+	const paddedMsg = msg.padEnd(msgWidth);
+	const head = `  ${elapsed}  ${paddedLevel}  ${paddedMsg}`;
+	const fields = fieldPairs(record).join(" ");
+	if (!fields) return `  ${elapsed}  ${colorLevel(level, paddedLevel)}  ${msg}`;
+	const budget = Math.max(20, LINE_MAX - head.length);
+	return `  ${elapsed}  ${colorLevel(level, paddedLevel)}  ${paddedMsg}  ${truncate(fields, budget)}`;
+}
+/** An error entry: a headline, then one indented line per field. */
+function formatErrorEntry(record) {
+	const msg = typeof record.msg === "string" ? record.msg : "error";
+	const lines = [`  ${formatElapsed(record.elapsedMs)}  ${import_picocolors.default.red(msg)}`];
+	for (const pair of fieldPairs(record)) lines.push(`${DETAIL_INDENT}${pair}`);
+	return lines;
+}
+/**
+* Turn raw JSONL lines into the block appended to a failed deploy's error
+* message. Returns `null` when there is nothing worth printing.
+*
+* The block has two parts: every `error` record with its flattened cause
+* chain, then the last `LOG_TAIL_LIMIT` records for timeline context.
+*/
+function formatDeployLogSummary(lines) {
+	const records = parseRecords(lines);
+	if (records.length === 0) return null;
+	const blocks = [];
+	const errors = records.filter((r) => r.lvl === "error" && r.msg !== TERMINAL_ERROR_MSG);
+	if (errors.length > 0) {
+		const shown = errors.slice(0, 5);
+		const errorLines = shown.flatMap((record) => formatErrorEntry(record));
+		if (errors.length > shown.length) errorLines.push(`${DETAIL_INDENT}(+${errors.length - shown.length} more)`);
+		blocks.push([import_picocolors.default.bold("Errors"), ...errorLines].join("\n"));
+	}
+	const tail = records.slice(-20);
+	const msgWidth = Math.min(MSG_COLUMN_MAX, tail.reduce((max, r) => Math.max(max, typeof r.msg === "string" ? r.msg.length : 0), 0));
+	const heading = records.length > tail.length ? `Last 20 of ${records.length} entries` : `Log (${records.length} ${records.length === 1 ? "entry" : "entries"})`;
+	blocks.push([import_picocolors.default.bold(heading), ...tail.map((record) => formatTailLine(record, msgWidth))].join("\n"));
+	return `\n${blocks.join("\n\n")}`;
+}
+/**
+* Read a deploy JSONL log and format its summary. Returns `null` for a missing
+* path or any read failure — a postmortem aid must never mask the real error.
+*/
+function buildDeployLogSummary(path) {
+	if (!path) return null;
+	let text;
+	try {
+		text = readFileSync(path, "utf-8");
+	} catch {
+		return null;
+	}
+	return formatDeployLogSummary(text.split("\n"));
+}
+//#endregion
 //#region src/shared/utils.ts
 const isWindows = typeof process !== "undefined" && process.platform === "win32";
 function slash(p) {
@@ -2469,11 +2642,24 @@ function stripDevOnlyRuleFields(rules) {
 *
 * When the user has no fallbacks configured, the platform-level SPA switch
 * is left intact (zero worker-side overhead for the common case).
-*/
-function resolveSpaFallbackChain(appType, fallbackRules) {
+*
+* `notFound` is the explicit `routing.notFound` from void.json. It overrides
+* the value this function would otherwise infer from `appType`, mirroring
+* `resolveAssetRoutingPolicy` on the worker-with-assets path. It is resolved
+* *before* the SPA branch, not patched onto the result afterwards: an override
+* away from `single-page-application` must also skip the synthetic
+* `/* -> /index.html` rule below, otherwise the SPA shell would still be
+* served — just through a fallback rule instead of the platform switch — and
+* the override would be a no-op. This matters because `detectPreset`
+* classifies any Vite project without backend files as `spa`, so a plain Vite
+* MPA lands on `appType: 'spa'` and `routing.notFound: '404-page'` is its only
+* escape hatch.
+*/
+function resolveSpaFallbackChain(appType, fallbackRules, notFound) {
 	const userRules = fallbackRules && fallbackRules.length > 0 ? fallbackRules : void 0;
-	if (appType !== "spa") return {
-		assetConfig: { not_found_handling: appType === "static" ? "404-page" : "none" },
+	const handling = notFound ?? (appType === "spa" ? "single-page-application" : appType === "static" ? "404-page" : "none");
+	if (handling !== "single-page-application") return {
+		assetConfig: { not_found_handling: handling },
 		fallbackRules: userRules
 	};
 	if (!userRules) return {
@@ -2724,17 +2910,21 @@ function toLiveManifest(live) {
 	};
 }
 /**
-* If the user configured `routing.fallbacks` on a non-SPA app, the platform
-* still applies the rules but no `/* -> /index.html` SPA shell is synthesised
-* — unmatched paths fall through to the platform 404. Returns the warning
+* If the user configured `routing.fallbacks` on an app whose resolved
+* `not_found_handling` is not `single-page-application`, the platform still
+* applies the rules but no `/* -> /index.html` SPA shell is synthesised —
+* unmatched paths fall through to the platform 404. Returns the warning
 * message string when that mismatch is detected, or `null` otherwise. Pure
 * function; callers decide whether/how to surface the message (CLI progress,
 * `console.warn`, etc.).
+*
+* The message names `not_found_handling` rather than the app type because an
+* explicit `routing.notFound` can land here too — the app may well be a SPA.
 */
 function detectNonSpaFallbackWarning(assetConfig, fallbackRules) {
 	if (assetConfig?.not_found_handling === "single-page-application") return null;
 	if (!fallbackRules || fallbackRules.length === 0) return null;
-	return "routing.fallbacks is set but appType is not \"spa\"; fallbacks will be applied, but no \"/* -> /index.html\" SPA shell fallback is synthesised — unmatched paths fall through to the platform 404.";
+	return "routing.fallbacks is set but not_found_handling is not \"single-page-application\"; fallbacks will be applied, but no \"/* -> /index.html\" SPA shell fallback is synthesised — unmatched paths fall through to the platform 404.";
 }
 /**
 * Build a Void-app deploy manifest from the inferred bindings + per-feature
@@ -2804,6 +2994,7 @@ function buildVoidManifest(opts) {
 	if (options?.workerMain) manifest.workerMain = options.workerMain;
 	if (options?.compatibilityDate) manifest.compatibilityDate = options.compatibilityDate;
 	if (options?.compatibilityFlags && options.compatibilityFlags.length > 0) manifest.compatibilityFlags = options.compatibilityFlags;
+	if (options?.cpuMs) manifest.limits = { cpuMs: options.cpuMs };
 	if (hashedAssetsPrefix) manifest.hashedAssetsPrefix = hashedAssetsPrefix;
 	if (headerRules && headerRules.length > 0) manifest.headerRules = headerRules;
 	if (redirectRules && redirectRules.length > 0) manifest.redirectRules = stripDevOnlyRuleFields(redirectRules);
@@ -2839,8 +3030,8 @@ function collectWorkerFiles(workerDir) {
 * Build a static-deploy manifest. Pure shape transformation — no I/O.
 */
 function buildStaticManifest(opts) {
-	const { appType, hashedAssetsPrefix, headerRules, redirectRules, fallbackRules } = opts;
-	const { assetConfig, fallbackRules: resolvedFallbackRules } = resolveSpaFallbackChain(appType, fallbackRules);
+	const { appType, hashedAssetsPrefix, headerRules, redirectRules, fallbackRules, notFound } = opts;
+	const { assetConfig, fallbackRules: resolvedFallbackRules } = resolveSpaFallbackChain(appType, fallbackRules, notFound);
 	const manifest = {
 		version: 3,
 		assetManifestVersion: 2,
@@ -2897,6 +3088,7 @@ function buildFrameworkManifest(opts) {
 	manifest.workerMain = po?.workerMain ?? opts.workerMain;
 	if (po?.compatibilityDate) manifest.compatibilityDate = po.compatibilityDate;
 	if (po?.compatibilityFlags && po.compatibilityFlags.length > 0) manifest.compatibilityFlags = po.compatibilityFlags;
+	if (po?.cpuMs) manifest.limits = { cpuMs: po.cpuMs };
 	if (opts.hashedAssetsPrefix) manifest.hashedAssetsPrefix = opts.hashedAssetsPrefix;
 	if (opts.headerRules && opts.headerRules.length > 0) manifest.headerRules = opts.headerRules;
 	if (opts.redirectRules && opts.redirectRules.length > 0) manifest.redirectRules = stripDevOnlyRuleFields(opts.redirectRules);
@@ -3335,6 +3527,7 @@ var deploy_exports = /* @__PURE__ */ __exportAll({
 	ensurePreviouslyDeployedLiveBindingConfig: () => ensurePreviouslyDeployedLiveBindingConfig,
 	generateDeployWrapperIfNeeded: () => generateDeployWrapperIfNeeded,
 	hasDeploySchemaDrift: () => hasDeploySchemaDrift,
+	hasPrerenderSources: () => hasPrerenderSources,
 	hashWranglerUploader: () => hashWranglerUploader,
 	loadDeployEnv: () => loadDeployEnv,
 	parseRootWranglerConfig: () => parseRootWranglerConfig,
@@ -3344,6 +3537,7 @@ var deploy_exports = /* @__PURE__ */ __exportAll({
 	resolveDeployWorkerMain: () => resolveDeployWorkerMain,
 	resolveDeployWranglerCompat: () => resolveDeployWranglerCompat,
 	resolveDistDir: () => resolveDistDir,
+	resolveFullDeployBuildCommand: () => resolveFullDeployBuildCommand,
 	resolveStaticBuildCommand: () => resolveStaticBuildCommand,
 	resolveStaticDeployPreset: () => resolveStaticDeployPreset,
 	resolveWorkerDirName: () => resolveWorkerDirName,
@@ -3356,6 +3550,7 @@ var deploy_exports = /* @__PURE__ */ __exportAll({
 	streamDeployEvents: () => streamDeployEvents,
 	validateAuthMigrationSchema: () => validateAuthMigrationSchema,
 	verifyGeneratedDeployConfig: () => verifyGeneratedDeployConfig,
+	warnIgnoredNotFoundForFramework: () => warnIgnoredNotFoundForFramework,
 	warnRedundantForceOn3xx: () => warnRedundantForceOn3xx,
 	warnUnpublishedRouting: () => warnUnpublishedRouting
 });
@@ -3368,7 +3563,7 @@ let loadedProvisionModule;
 * so a managed deploy never imports it — and thus never loads `proper-lockfile`.
 */
 async function loadProvisionModule() {
-	loadedProvisionModule ??= await import("./provision-BLrCEBbI.mjs");
+	loadedProvisionModule ??= await import("./provision-CPx2ZxsH.mjs");
 	return loadedProvisionModule;
 }
 /**
@@ -3490,6 +3685,13 @@ async function runDeploy(root, options) {
 		cliLog.info("deploy_end", { ok: true });
 	} catch (err) {
 		cliLog.error("deploy_end", err, { ok: false });
+		await cliLog.close().catch(() => {});
+		try {
+			if (err instanceof Error) {
+				const summary = buildDeployLogSummary(cliLog.path);
+				if (summary) err.message = `${err.message}\n${summary}`;
+			}
+		} catch {}
 		throw err;
 	} finally {
 		await cliLog.close().catch(() => {});
@@ -3512,17 +3714,67 @@ async function runDeploy(root, options) {
 * `cfAccessHeaders(process.env)` / the cloudflared pair-guard AFTER the build
 * step. Only the service-token pair is scrubbed; the cloudflared
 * `CF_ACCESS_TOKEN` JWT (dev path) is left untouched.
-*/
-function buildEnv(extra) {
+*
+* `localBinRoot` is an explicit OPT-IN, not a default. Build commands are run
+* through a shell (`execSync`) and a user-configured `inference.build` (e.g.
+* `vitepress build && vite build`) names bare binaries that only exist in the
+* project's own `node_modules/.bin`; under the build container's
+* `npx --yes void deploy` that happens to work — npx prepends every ancestor
+* `.bin` itself — but a directly invoked `node_modules/.bin/void deploy` or a
+* globally installed `void` inherits no such PATH and the bare binary fails to
+* resolve. Passing it makes the project's bin dir shadow the system one for
+* that child, so it belongs ONLY on the three build execs. The other callers
+* (`getGitCommit`, the drizzle-kit spawn) exec a system binary or an absolute
+* path and must not hand a dependency-shipped `node_modules/.bin/git` a child
+* process holding `VOID_TOKEN`.
+*/
+function buildEnv(extra, options) {
 	const env = {
 		...process.env,
 		...extra
 	};
 	delete env.CF_ACCESS_CLIENT_ID;
 	delete env.CF_ACCESS_CLIENT_SECRET;
+	return options?.localBinRoot === void 0 ? env : prependLocalBinToPath(env, options.localBinRoot);
+}
+/**
+* Prepend `<root>/node_modules/.bin` to the child env's PATH, preserving
+* whatever was already there.
+*
+* PATH is looked up case-insensitively and written back under the SAME key the
+* env already used: Windows reports it as `Path`, and `{ ...process.env }`
+* drops the case-insensitive lookup that `process.env` itself provides, so
+* hardcoding `PATH` would leave the real variable untouched and add a dead one.
+*/
+function prependLocalBinToPath(env, root) {
+	const binDir = join(root, "node_modules", ".bin");
+	const delimiter = process.platform === "win32" ? ";" : ":";
+	const pathKey = Object.keys(env).find((key) => key.toLowerCase() === "path") ?? "PATH";
+	const existing = env[pathKey];
+	env[pathKey] = existing ? `${binDir}${delimiter}${existing}` : binDir;
 	return env;
 }
 /**
+* Marks a build child as driven by a MANAGED `void deploy`.
+*
+* The platform resolves the asset routing policy out-of-band (`resolveAssetConfig`
+* → `manifest.assetConfig`) and applies it to the uploaded script, so settings the
+* Vite plugin cannot safely write into the built wrangler config — `routing.notFound`
+* for a Class A framework, which needs an `assets` policy Void does not own there —
+* are still honored on this path. `void:framework-build-wrapper` warns about exactly
+* those when this flag is ABSENT, i.e. on a self-hosted `vite build && wrangler deploy`.
+*
+* Passed through the CHILD env only (never `process.env`), the same way
+* `VOID_DEPLOY_PROJECT_ID` is, so it cannot leak into an unrelated child process or a
+* later `void dev` in the same shell.
+*
+* Deliberately NOT set by `runCloudflareDeploy` (`--backend cloudflare`): that flow
+* hands the built output to `wrangler deploy` against the user's own account and IS the
+* self-host path the warning is about. (It rejects framework SSR outright today, so no
+* Class A build reaches it either way.)
+*/
+const MANAGED_DEPLOY_BUILD_ENV = { VOID_DEPLOY_BUILD: "1" };
+/**
 * Deploy-time env selectors that pin the WRONG worker/config out from under the
 * top-level config this flow provisions + preflights. Scrubbed from every child env
 * and fenced in the project dotenv (see below), on top of the provisioner's transport
@@ -5307,7 +5559,7 @@ async function runCloudflareDeploy(root, options, cliLog, deps = {}) {
 		log.error(`deploy: ${getErrorMessage(err)}`);
 		return exit(1);
 	}
-	if (scanWebSocketRoutesSync(root, paths).length > 0) {
+	if (scanWebSocketRoutesSync(root, paths, "prod").length > 0) {
 		log.error([
 			"deploy: --backend cloudflare does not yet support WebSocket / Durable Object routes.",
 			"A `.ws.ts` route makes the build emit a key-value-backed Durable Object namespace",
@@ -5847,7 +6099,7 @@ async function runDeployInner(root, options, cliLog) {
 				name: detected.name,
 				class: detected.class
 			});
-			const gitMetadata = collectGitDeployMetadata(root, options?.skipBuild ? null : getGitCommit(root));
+			const gitMetadata = collectGitDeployMetadata(root, options?.skipBuild ? null : getGitCommit(root), process.env, buildEnv());
 			const fwPreset = FRAMEWORK_PRESETS[detected.name];
 			if (detected.class === "b" || detected.class === "c") {
 				if (!fwPreset) {
@@ -5855,18 +6107,21 @@ async function runDeployInner(root, options, cliLog) {
 					process.exit(1);
 				}
 				await runFrameworkDeploy(root, config, client, detected, fwPreset, voidConfig, options?.skipBuild, gitMetadata, cliLog);
-			} else await runFullDeploy(root, config, client, fwPreset, options?.skipBuild, gitMetadata, detected, cliLog);
+			} else await runFullDeploy(root, config, client, voidConfig, fwPreset, options?.skipBuild, gitMetadata, detected, cliLog);
 			return;
 		}
-		if (!preset && !voidConfig.inference?.appType) preset = detectPreset(root, { spa: options?.spa });
-		const gitMetadata = collectGitDeployMetadata(root, options?.skipBuild ? null : getGitCommit(root));
+		if (!preset && !voidConfig.inference?.appType) preset = detectPreset(root, {
+			spa: options?.spa,
+			strictBackend: true
+		});
+		const gitMetadata = collectGitDeployMetadata(root, options?.skipBuild ? null : getGitCommit(root), process.env, buildEnv());
 		if (preset) {
 			preset = {
 				...preset,
 				buildCommand: resolveStaticBuildCommand(preset, voidConfig.inference?.build, Boolean(options?.dir))
 			};
 			await runStaticDeploy(root, config, client, preset, options?.skipBuild, gitMetadata, void 0, void 0, void 0, void 0, voidConfig.routing, cliLog);
-		} else await runFullDeploy(root, config, client, void 0, options?.skipBuild, gitMetadata, void 0, cliLog);
+		} else await runFullDeploy(root, config, client, voidConfig, void 0, options?.skipBuild, gitMetadata, void 0, cliLog);
 		return;
 	} catch (error) {
 		if (isExpiredTokenError(error)) {
@@ -5894,7 +6149,7 @@ async function promptDeployProjectConfig(root, client, cliLog) {
 		slug: result.project.slug
 	};
 	writeProjectConfig(root, config);
-	log.step(`Linked to ${import_picocolors.default.blue(config.slug)}`);
+	log.step(`Linked to ${import_picocolors$1.default.blue(config.slug)}`);
 	cliLog?.info("project_linked", {
 		projectId: config.projectId,
 		slug: config.slug
@@ -5905,6 +6160,57 @@ function resolveStaticBuildCommand(preset, buildOverride, hasExplicitDir = false
 	if (hasExplicitDir) return null;
 	return buildOverride ?? preset.buildCommand;
 }
+/**
+* Resolve the build command for a FULL (Class A / Void app) deploy.
+*
+* `inference.build` wins when set, matching `runFrameworkDeploy` and the static
+* path's `resolveStaticBuildCommand`. Without it the full path was the only
+* deploy mode that ignored the config and hardcoded `vite build`, so an app that
+* needs more than one build step — an SSG that emits the site, then Void's build
+* packaging it via `publicDir` alongside the worker — had no way to express it
+* and died on the missing `index.html` entry.
+*
+* The two returned strings are deliberately different for the FALLBACK: `label`
+* goes to the user (`formatProjectCommand` rewrites `vite` → `vp` without
+* expanding an absolute bin path), `command` is what actually runs
+* (`resolveProjectCommand` expands to the local bin). A configured command is
+* the user's own text and is used verbatim for both, so what is printed is
+* exactly what is executed.
+*/
+function resolveFullDeployBuildCommand(root, buildOverride) {
+	if (buildOverride) return {
+		label: buildOverride,
+		command: buildOverride
+	};
+	return {
+		label: formatProjectCommand(root, "vite build"),
+		command: resolveProjectCommand(root, "vite build")
+	};
+}
+/**
+* Whether the built worker's `__voidCollectPrerenderPaths` can return anything
+* at all. When it cannot, booting it is pure cost and the deploy skips it.
+*
+* These three are exactly — and only — the sources `compilePrerenderCollector`
+* (`router/compile.ts`) emits a `paths.push(...)` for:
+*   1. `scan.pages.pages` — static patterns + dynamic pages' `getPrerenderPaths()`
+*   2. the custom SSR entry's top-level `getPrerenderPaths()` (`ssr` argument)
+*   3. `options.explicitPrerenderPaths` — void.json `routing.prerender`
+* With none of them present the collector is a generated function whose body
+* returns `[...new Set([])]`, so skipping is result-identical.
+*
+* Skipping matters beyond speed. `collectPrerenderPaths` boots the worker in
+* Miniflare with bindings from `wranglerVars + loadEnv('production', root, '')`
+* only, and the generated fetch handler validates the `env.ts` schema at boot.
+* An app whose secrets live on the platform (never in a committed `.env`) gets
+* an HTTP 500 there and the deploy dies — for an app that had nothing to
+* prerender in the first place. The only workaround was moving the secret into
+* `.env.production`, which `loadDeployEnv` then publishes as a plaintext
+* manifest var. So this guard also removes a real incentive to leak secrets.
+*/
+function hasPrerenderSources(inputs) {
+	return inputs.hasPages || inputs.hasSsrEntry || (inputs.explicitPrerenderPaths?.length ?? 0) > 0;
+}
 function resolveStaticDeployPreset(root, voidConfig, options) {
 	if (options?.dir) return detectPreset(root, {
 		dir: options.dir,
@@ -6165,7 +6471,7 @@ function assembleVoidManifest(pageScan, isFrameworkMode, opts, revalidateConfig)
 		pathRevalidate: isFrameworkMode || revalidateConfig == null || typeof revalidateConfig !== "object" ? void 0 : revalidateConfig
 	});
 }
-async function runStaticDeploy(root, config, client, preset, skipBuild, gitMetadata, hashedAssetsPrefix, headerRules, redirectRules, fallbackRules, routing, cliLog) {
+async function runStaticDeploy(root, config, client, preset, skipBuild, gitMetadata, hashedAssetsPrefix, headerRules, redirectRules, fallbackRules, routing, cliLog, notFound) {
 	const typeLabel = preset.appType === "spa" ? "Static SPA" : "Static Site";
 	log.info(`${typeLabel} deploy`);
 	cliLog?.info("deploy_mode", {
@@ -6179,7 +6485,7 @@ async function runStaticDeploy(root, config, client, preset, skipBuild, gitMetad
 		execSync(preset.buildCommand, {
 			cwd: root,
 			stdio: "inherit",
-			env: buildEnv()
+			env: buildEnv({ ...MANAGED_DEPLOY_BUILD_ENV }, { localBinRoot: root })
 		});
 		cliLog?.info("build_end", { durationMs: Date.now() - buildStartedAt });
 	} else if (skipBuild) cliLog?.info("build_skipped", { reason: "skipBuild" });
@@ -6223,7 +6529,8 @@ async function runStaticDeploy(root, config, client, preset, skipBuild, gitMetad
 		hashedAssetsPrefix: hashedAssetsPrefix ?? "assets",
 		headerRules,
 		redirectRules,
-		fallbackRules
+		fallbackRules,
+		notFound: notFound ?? routing?.notFound
 	});
 	cliLog?.info("package_end", {
 		mode: "static",
@@ -6257,6 +6564,27 @@ function warnRedundantForceOn3xx(count) {
 	log.warn(`Found ${count} redundant "!" on 3xx entries in _redirects (these always force by nature; safe to remove).`);
 }
 /**
+* Class B/C framework deploys pin `not_found_handling: 'none'`, so
+* `routing.notFound` does nothing there — say so instead of dropping it
+* silently.
+*
+* These presets emit no `run_worker_first`, so Cloudflare's default applies and
+* the asset layer answers before the framework worker: real prerendered files
+* already win. `not_found_handling` only governs what the framework's own
+* `env.ASSETS.fetch()` delegation returns, which is framework-internal
+* plumbing. Honoring the override there would be a behavior change, not a fix —
+* `single-page-application` makes an unmatched delegation return
+* `dist/client/index.html` at **200** (Astro/SvelteKit hybrid builds commonly
+* prerender the root, so real 404s silently become the home page), and
+* `404-page` steals the 404 from the framework's own error route.
+*
+* Silenced when unset.
+*/
+function warnIgnoredNotFoundForFramework(notFound, frameworkName) {
+	if (notFound === void 0) return;
+	log.warn(`"routing.notFound" in void.json is ignored for ${frameworkName} deploys (not_found_handling is pinned to "none" — the framework's own worker owns unmatched HTML).`);
+}
+/**
 * Class B/C framework deploy: build with framework CLI, package with preset output paths.
 */
 async function runFrameworkDeploy(root, config, client, detected, fwPreset, voidConfig, skipBuild, gitMetadata, cliLog) {
@@ -6274,7 +6602,7 @@ async function runFrameworkDeploy(root, config, client, detected, fwPreset, void
 		execSync(voidConfig.inference?.build ?? resolveProjectCommand(root, fwPreset.buildCommand), {
 			cwd: root,
 			stdio: "inherit",
-			env: buildEnv()
+			env: buildEnv({ ...MANAGED_DEPLOY_BUILD_ENV }, { localBinRoot: root })
 		});
 		cliLog?.info("build_end", { durationMs: Date.now() - buildStartedAt });
 	} else cliLog?.info("build_skipped", { reason: "skipBuild" });
@@ -6286,6 +6614,7 @@ async function runFrameworkDeploy(root, config, client, detected, fwPreset, void
 		routing: voidConfig.routing
 	});
 	warnRedundantForceOn3xx(redundantForceOn3xx);
+	warnIgnoredNotFoundForFramework(voidConfig.routing?.notFound, detected.name);
 	lintDuplicateSources(redirectRules, "redirects/rewrites (pre-asset)");
 	lintDuplicateSources(fallbackRules, "fallbacks (post-asset)");
 	lintDestinationSplats(redirectRules, "redirects/rewrites (pre-asset)");
@@ -6414,7 +6743,8 @@ async function runFrameworkDeploy(root, config, client, detected, fwPreset, void
 		bindingNames: resolveBindingNames(voidConfig.inference?.bindings),
 		workerMain: actualWorkerMain,
 		compatibilityDate: wranglerCompat?.compatibilityDate,
-		compatibilityFlags: wranglerCompat?.compatibilityFlags
+		compatibilityFlags: wranglerCompat?.compatibilityFlags,
+		cpuMs: voidConfig.worker?.limits?.cpu_ms
 	};
 	const manifest = buildFrameworkManifest({
 		frameworkName: detected.name,
@@ -6454,21 +6784,24 @@ async function runFrameworkDeploy(root, config, client, detected, fwPreset, void
 	warnUnpublishedRouting(result);
 	outro("Done!");
 }
-async function runFullDeploy(root, config, client, fwPreset, skipBuild, gitMetadata, detected, cliLog) {
+async function runFullDeploy(root, config, client, voidConfig, fwPreset, skipBuild, gitMetadata, detected, cliLog) {
 	cliLog?.info("deploy_mode", {
 		mode: "full",
 		framework: detected?.name
 	});
 	if (!skipBuild) {
-		const buildCmd = formatProjectCommand(root, "vite build");
+		const { label: buildCmd, command: buildExec } = resolveFullDeployBuildCommand(root, voidConfig.inference?.build);
 		log.step(`Building (${buildCmd})...`);
 		cliLog?.info("build_start", { command: buildCmd });
 		const buildStartedAt = Date.now();
 		try {
-			execSync(resolveProjectCommand(root, "vite build"), {
+			execSync(buildExec, {
 				cwd: root,
 				stdio: "inherit",
-				env: buildEnv({ VOID_DEPLOY_PROJECT_ID: config.projectId })
+				env: buildEnv({
+					VOID_DEPLOY_PROJECT_ID: config.projectId,
+					...MANAGED_DEPLOY_BUILD_ENV
+				}, { localBinRoot: root })
 			});
 			cliLog?.info("build_end", { durationMs: Date.now() - buildStartedAt });
 		} catch (err) {
@@ -6489,7 +6822,7 @@ async function runFullDeploy(root, config, client, fwPreset, skipBuild, gitMetad
 		}
 	}
 	const isFrameworkMode = detected != null;
-	const deployConfig = readConfig(root);
+	const deployConfig = voidConfig;
 	const paths = resolveProjectPaths(root, deployConfig);
 	const dialect = getDatabaseDialect(deployConfig);
 	const deployScanDirs = deployConfig.inference?.scanDirs ?? (isFrameworkMode ? FRAMEWORK_SCAN_DIRS : void 0);
@@ -6578,9 +6911,10 @@ async function runFullDeploy(root, config, client, fwPreset, skipBuild, gitMetad
 	})));
 	const routeScan = await scanRoutes(root, {
 		output: deployConfig.output,
-		paths
+		paths,
+		environment: "prod"
 	});
-	const webSockets = routeScan.websockets ?? scanWebSocketRoutesSync(root, paths);
+	const webSockets = routeScan.websockets ?? scanWebSocketRoutesSync(root, paths, "prod");
 	const liveConfig = await resolveDeployLiveBindingConfig(root, client, config.projectId, {
 		isFrameworkMode,
 		needsLive: effectiveBindings.needsLive,
@@ -6600,7 +6934,8 @@ async function runFullDeploy(root, config, client, fwPreset, skipBuild, gitMetad
 	const hasDocumentRoutes$1 = hasDocumentRoutes(routeScan.routes);
 	const hasMiddleware = routeScan.middleware.length > 0;
 	const hasWebSockets = webSockets.length > 0;
-	const isSsr = isFrameworkMode ? true : Boolean(validateSsrEntry(root, paths)) || hasPages && deployConfig.output !== "static";
+	const ssrEntry = isFrameworkMode ? null : validateSsrEntry(root, paths);
+	const isSsr = isFrameworkMode ? true : Boolean(ssrEntry) || hasPages && deployConfig.output !== "static";
 	const pageScan = existsSync(paths.pagesDir) ? routeScan.pages.pages.length > 0 ? routeScan.pages : await scanPages(root, {
 		output: deployConfig.output,
 		paths
@@ -6614,10 +6949,15 @@ async function runFullDeploy(root, config, client, fwPreset, skipBuild, gitMetad
 				buildCommand: null,
 				outputDir: clientDir,
 				appType: "static"
-			}, true, gitMetadata, assetsPrefix, headerRules, redirectRules, fallbackRules, void 0, cliLog);
+			}, true, gitMetadata, assetsPrefix, headerRules, redirectRules, fallbackRules, void 0, cliLog, deployConfig.routing?.notFound);
 		}
 	}
-	const uniquePrerenderPaths = deployConfig.output === "static" || isFrameworkMode ? [] : isNodeTarget(deployConfig.target) ? await collectPrerenderPathsNode({
+	const prerenderSourcesPresent = hasPrerenderSources({
+		hasPages,
+		hasSsrEntry: ssrEntry !== null,
+		explicitPrerenderPaths: deployConfig.routing?.prerender
+	});
+	const uniquePrerenderPaths = deployConfig.output === "static" || isFrameworkMode || !prerenderSourcesPresent ? [] : isNodeTarget(deployConfig.target) ? await collectPrerenderPathsNode({
 		root,
 		ssrDir: join(distDir, "ssr"),
 		clientDir
@@ -6648,7 +6988,8 @@ async function runFullDeploy(root, config, client, fwPreset, skipBuild, gitMetad
 		hasMiddleware,
 		hasWebSockets: hasDocumentRoutes(webSockets),
 		authEnabled,
-		liveEnabled: liveConfig !== void 0
+		liveEnabled: liveConfig !== void 0,
+		notFound: deployConfig.routing?.notFound
 	});
 	s.start("Checking for changes...");
 	cliLog?.info("preflight_start", { dir: clientDir });
@@ -6676,6 +7017,7 @@ async function runFullDeploy(root, config, client, fwPreset, skipBuild, gitMetad
 	const voidPackageOptions = {
 		compatibilityDate: wranglerCompat?.compatibilityDate,
 		compatibilityFlags: wranglerCompat?.compatibilityFlags,
+		cpuMs: deployConfig.worker?.limits?.cpu_ms,
 		...workerMain && { workerMain },
 		...sandboxConfig && { sandbox: sandboxConfig },
 		...liveConfig && { live: liveConfig },
@@ -6744,7 +7086,7 @@ async function runFullDeploy(root, config, client, fwPreset, skipBuild, gitMetad
 	outro("Done!");
 }
 async function createProjectFromSlug(root, client, slug, cliLog) {
-	log.step(`Creating project ${import_picocolors.default.blue(slug)}...`);
+	log.step(`Creating project ${import_picocolors$1.default.blue(slug)}...`);
 	cliLog?.info("project_create_start", { slug });
 	const project = await client.createProject(slug);
 	const config = {
@@ -6752,7 +7094,7 @@ async function createProjectFromSlug(root, client, slug, cliLog) {
 		slug: project.slug
 	};
 	writeProjectConfig(root, config);
-	log.success(`Project created: ${import_picocolors.default.blue(config.slug)}`);
+	log.success(`Project created: ${import_picocolors$1.default.blue(config.slug)}`);
 	cliLog?.info("project_create_success", {
 		projectId: config.projectId,
 		slug: config.slug