void 0.27.0 → 0.28.0

package/dist/deploy-transport-BiicfoQW.mjs

@@ -0,0 +1,180 @@
+import { a as join } from "./dist-ipQi0Q8y.mjs";
+import { n as scanWranglerDotenvKeys } from "./dotenv-CNazY3-w.mjs";
+import { t as CLOUDFLARE_DEPLOY_BUILD_ENV } from "./env-BJjULvL0.mjs";
+import { i as WRANGLER_AUTH_CREDENTIAL_ENV_VARS, t as CLOUDFLARE_PRESERVE_BINDINGS_BUILD_ENV } from "./version-metadata-DIrqEHQo.mjs";
+import { a as deleteEnvVarCaseAware, d as resolvePinnedApiBaseUrl, t as assertNoTransportRedirectInProjectDotenv, u as provisionEnv } from "./provision-DDh7ITVS.mjs";
+import { readWranglerTopLevelString } from "@void/deploy-cloudflare";
+//#region src/cli/deploy-transport.ts
+/**
+* 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` (`--platform cloudflare`): that flow
+* deploys the built output to the user's own account and IS the self-host path the
+* warning is about.
+*/
+const MANAGED_DEPLOY_BUILD_ENV = { VOID_DEPLOY_BUILD: "1" };
+/** Remove managed-only build markers from an explicit native Cloudflare child. */
+function scrubManagedDeployBuildMarkers(env) {
+	deleteEnvVarCaseAware(env, "VOID_DEPLOY_PROJECT_ID");
+	deleteEnvVarCaseAware(env, CLOUDFLARE_PRESERVE_BINDINGS_BUILD_ENV);
+	for (const name of Object.keys(MANAGED_DEPLOY_BUILD_ENV)) deleteEnvVarCaseAware(env, name);
+	return env;
+}
+/**
+* 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
+* scrub/fence which owns the endpoint-redirect + `CLOUDFLARE_ENV` vars:
+*   - `WRANGLER_CI_OVERRIDE_NAME` — wrangler 4.131 applies it AFTER config load
+*     (`mergeSharedConfigArgs` → `getCIOverrideName()`), REPLACING the upload name, so a
+*     bare `wrangler deploy` uploads a worker whose name the generated-config check never
+*     validated.
+*   - `CLOUDFLARE_VITE_WRANGLER_CONFIG_PATH` — the CF Vite plugin points the build at an
+*     ALTERNATE wrangler config, flattening a different binding set into
+*     `dist/ssr/wrangler.json`.
+*/
+const DEPLOY_CONFIG_OVERRIDE_ENV_VARS = ["WRANGLER_CI_OVERRIDE_NAME", "CLOUDFLARE_VITE_WRANGLER_CONFIG_PATH"];
+/**
+* The dotenv files wrangler 4.131 reloads into `process.env` (`override: true`) for
+* the orchestrator's `--env=` calls (`getDefaultEnvFiles("")`), so a repo dotenv here
+* would resurrect `WRANGLER_CI_OVERRIDE_NAME` at the DEPLOY step after the child-env
+* scrub removed it.
+*/
+const DEPLOY_WRANGLER_DOTENV_FILES = [
+	".env",
+	".env.local",
+	".env.",
+	".env..local"
+];
+/**
+* The dotenv files Vite's `loadEnv(mode, …)` reads for a production `vite build`
+* (`.env`, `.env.local`, `.env.production`, `.env.production.local`), where the CF Vite
+* plugin picks up `CLOUDFLARE_ENV` / `CLOUDFLARE_VITE_WRANGLER_CONFIG_PATH` — a set
+* DISJOINT from wrangler's `--env=` files, so it is fenced separately for the build.
+*/
+const DEPLOY_VITE_DOTENV_FILES = [
+	".env",
+	".env.local",
+	".env.production",
+	".env.production.local"
+];
+/** The first non-blank ambient selector of a non-top-level worker/config, if any. */
+function findAmbientConfigOverride() {
+	return ["CLOUDFLARE_ENV", "CLOUDFLARE_VITE_WRANGLER_CONFIG_PATH"].find((name) => process.env[name]?.trim());
+}
+/**
+* FAIL CLOSED when the AMBIENT env selects a non-top-level worker/config for the
+* Cloudflare backend, which deploys the top-level environment of the canonical root
+* config ONLY. `CLOUDFLARE_ENV` picks a named env block (different account/name/bindings);
+* `CLOUDFLARE_VITE_WRANGLER_CONFIG_PATH` points the build at a different config. We refuse
+* rather than silently deploy a target the drift-check / provision never reasoned about.
+*/
+function assertNoAmbientConfigOverride() {
+	const override = findAmbientConfigOverride();
+	if (override === "CLOUDFLARE_ENV") throw new Error("CLOUDFLARE_ENV is set. --platform cloudflare deploys the TOP-LEVEL environment of your root wrangler config only (a named environment can carry a different account, worker name, or binding set). Unset CLOUDFLARE_ENV and retry.");
+	if (override) throw new Error("CLOUDFLARE_VITE_WRANGLER_CONFIG_PATH is set. --platform cloudflare builds from the canonical root wrangler config only. Unset it and retry.");
+}
+/** Which of `names` the project dotenv `file` declares; win32 keys match case-insensitively. */
+function findDotenvDeclaration(root, file, names, platform) {
+	const caseInsensitive = platform === "win32";
+	const rawKeys = scanWranglerDotenvKeys(join(root, file));
+	const keys = caseInsensitive ? new Set([...rawKeys].map((key) => key.toLowerCase())) : rawKeys;
+	return names.find((name) => keys.has(caseInsensitive ? name.toLowerCase() : name));
+}
+/** The first dotenv file wrangler reloads that declares `WRANGLER_CI_OVERRIDE_NAME`. */
+function findWranglerCiOverrideDotenvFile(root, platform = process.platform) {
+	return DEPLOY_WRANGLER_DOTENV_FILES.find((file) => findDotenvDeclaration(root, file, ["WRANGLER_CI_OVERRIDE_NAME"], platform));
+}
+/**
+* FAIL CLOSED when the project's dotenv files declare a deploy-time config-override
+* selector. wrangler / Vite reload dotenv on every command, so a repo dotenv would
+* reintroduce a scrubbed var AFTER the child-env scrub — reselecting the upload worker
+* name (wrangler `--env=` files) or the build's wrangler config (Vite production files).
+* The provisioner's transport fence ({@link assertNoTransportRedirectInProjectDotenv})
+* owns `CLOUDFLARE_ENV` + the endpoint-redirect vars; this closes the deploy-specific
+* name/config-path selectors it does not cover, across BOTH consumers' file sets.
+* Exported for direct unit testing of the file-set + win32 case rule.
+*/
+function assertNoConfigOverrideInProjectDotenv(root, platform = process.platform) {
+	const ciOverrideFile = findWranglerCiOverrideDotenvFile(root, platform);
+	if (ciOverrideFile) throw new Error(`the project file "${ciOverrideFile}" sets WRANGLER_CI_OVERRIDE_NAME, which wrangler reloads on every command and applies AFTER config load to REPLACE the deployed worker name — so \`wrangler deploy\` would upload a worker whose name was never validated. Remove it from "${ciOverrideFile}" (set it in your shell/CI only if you truly need a CI name override).`);
+	for (const file of DEPLOY_VITE_DOTENV_FILES) {
+		const offender = findDotenvDeclaration(root, file, ["CLOUDFLARE_ENV", "CLOUDFLARE_VITE_WRANGLER_CONFIG_PATH"], platform);
+		if (offender) throw new Error(`the project file "${file}" sets ${offender}, which the Cloudflare Vite plugin reads at build time to select a named environment or an ALTERNATE wrangler config — flattening a different binding set into dist/ssr/wrangler.json than this deploy provisioned. Remove ${offender} from "${file}".`);
+	}
+}
+/**
+* Resolve + validate the ONE pinned transport for the whole deploy, and FAIL CLOSED
+* on any ambient/dotenv redirect that would move the target out from under the pinned
+* top-level config. Reuses the provisioner's resolver + dotenv fence so provision AND
+* the deploy tail (build / whoami / migrate / deploy) share one source of truth.
+* Returns the single resolved API base URL to pin into every child env.
+*/
+function resolveDeployTransport(root, rootConfig) {
+	assertNoAmbientConfigOverride();
+	assertNoTransportRedirectInProjectDotenv(root);
+	assertNoConfigOverrideInProjectDotenv(root);
+	return resolvePinnedApiBaseUrl(process.env, readWranglerTopLevelString(rootConfig, "compliance_region"));
+}
+/**
+* Build a child env for an orchestrator-owned wrangler / build invocation. Reuses the
+* provisioner's {@link provisionEnv} (scrubs the CF Access pair + EVERY transport
+* selector incl. `CLOUDFLARE_ENV` + win32 case variants, pins ONE account + API base),
+* then scrubs the deploy-specific config-override selectors on top.
+*
+* {@link createDeployWranglerRunner} runs the deploy's Cloudflare operations with this
+* env, so it KEEPS the Cloudflare credentials; only children that run project code layer
+* {@link scrubWranglerAuthCredentials} on top.
+*/
+function deployChildEnv(accountId, apiBaseUrl) {
+	const env = provisionEnv({
+		accountId,
+		apiBaseUrl
+	});
+	for (const name of DEPLOY_CONFIG_OVERRIDE_ENV_VARS) deleteEnvVarCaseAware(env, name);
+	deleteEnvVarCaseAware(env, "WRANGLER_LOG");
+	env.WRANGLER_LOG = "log";
+	env.CLOUDFLARE_AUTH_USE_KEYRING = "true";
+	return env;
+}
+/**
+* Delete every {@link WRANGLER_AUTH_CREDENTIAL_ENV_VARS} entry from `env` IN PLACE and
+* return it, for a Cloudflare-fork child that executes UNTRUSTED project code.
+*/
+function scrubWranglerAuthCredentials(env) {
+	for (const name of WRANGLER_AUTH_CREDENTIAL_ENV_VARS) deleteEnvVarCaseAware(env, name);
+	deleteEnvVarCaseAware(env, "DATABASE_URL");
+	deleteEnvVarCaseAware(env, "VOID_TOKEN");
+	return env;
+}
+/**
+* Build the child env for the isolated env-schema probe. Starts from
+* {@link deployChildEnv} (CF Access + every transport selector scrubbed, one account +
+* API base pinned), then (1) scrubs the FULL wrangler-auth credential set case-aware —
+* the probe needs no credentials — and (2) pins `NODE_ENV=production` so the child
+* evaluates env.ts under the SAME environment the build uses (`vite build` sets
+* `NODE_ENV=production`), keeping the required-key set the probe derives identical to
+* the built worker's. Used by BOTH the pre-build facts probe and the post-build
+* `validate-emitted` probe.
+*/
+function buildSchemaProbeEnv(accountId, apiBaseUrl) {
+	const env = scrubManagedDeployBuildMarkers(scrubWranglerAuthCredentials(deployChildEnv(accountId, apiBaseUrl)));
+	deleteEnvVarCaseAware(env, CLOUDFLARE_DEPLOY_BUILD_ENV);
+	env[CLOUDFLARE_DEPLOY_BUILD_ENV] = "1";
+	deleteEnvVarCaseAware(env, "NODE_ENV");
+	env.NODE_ENV = "production";
+	return env;
+}
+//#endregion
+export { findWranglerCiOverrideDotenvFile as a, scrubWranglerAuthCredentials as c, findAmbientConfigOverride as i, buildSchemaProbeEnv as n, resolveDeployTransport as o, deployChildEnv as r, scrubManagedDeployBuildMarkers as s, MANAGED_DEPLOY_BUILD_ENV as t };

package/dist/deploy.d.mts

@@ -0,0 +1,10 @@
+import { DeployArtifact } from "@void/deploy-core";
+//#region src/deploy.d.ts
+export type PreparedDeployArtifact = {
+  artifact: DeployArtifact;
+  /** Static asset bytes keyed by URL path, encoded as base64. */
+  assets: Record<string, string>;
+};
+/** Package an already-built Void app for managed deployment, without platform credentials. */
+export declare function prepareDeployArtifact(root?: string): Promise<PreparedDeployArtifact>;
+//#endregion

package/dist/deploy.mjs

@@ -0,0 +1,82 @@
+import { a as join, c as resolve } from "./dist-ipQi0Q8y.mjs";
+import { c as isNodeTarget, d as readConfig } from "./config-Bx_1SpnO.mjs";
+import { o as validateSsrEntry } from "./entry-ehmBvs5w.mjs";
+import { r as hasEmailHandlers } from "./email-BcjSyAL0.mjs";
+import { a as resolveDistDir, c as hasApiRoutes, l as hasDocumentRoutes, n as collectRevalidate, o as resolveWorkerDirName, u as resolveAssetConfig } from "./isr-config-DPjXM8J2.mjs";
+import { t as analyzeApplication } from "./application-routing-Dy589Vgn.mjs";
+import { I as toManifestSchedulesAndQueues, L as validateDeployMigrations, M as resolveDeployWranglerCompat, b as assertWorkerMainUploaded, f as mergeAndLintRoutingRules, h as assertDeploySchemaDriftFree, j as resolveDeployWorkerMain, o as collectAndHashAssets, r as assertManagedDurableStateSupported, s as collectWorkerFiles, t as assembleVoidManifest } from "./deploy-managed-static-CGswbcay.mjs";
+import { existsSync } from "node:fs";
+import { createDeployArtifact } from "@void/deploy-core";
+//#region src/deploy.ts
+/** Package an already-built Void app for managed deployment, without platform credentials. */
+async function prepareDeployArtifact(root = process.cwd()) {
+	root = resolve(root);
+	const config = readConfig(root);
+	if (isNodeTarget(config.target) || config.output === "static") throw new Error("Artifact preparation requires a Void Cloudflare Worker build.");
+	assertManagedDurableStateSupported(root);
+	const analysis = await analyzeApplication(root, {
+		config,
+		environment: "prod"
+	});
+	if (analysis.bindings.needsSandbox || analysis.bindings.needsLive) throw new Error("Artifact preparation does not yet support Sandbox or Live resources. Use void deploy for those apps.");
+	if (config.routing?.prerender?.length || config.remote) throw new Error("Artifact preparation requires a build without remote data or deploy-time prerendering.");
+	const dist = resolveDistDir(root);
+	const workerDir = join(dist, resolveWorkerDirName(dist));
+	const clientDir = join(dist, "client");
+	const { paths, dialect, bindings, authEnabled, scan, websockets } = analysis;
+	assertDeploySchemaDriftFree(root, dialect);
+	const migrations = validateDeployMigrations(paths.migrationsDir, analysis.migrations);
+	const { schedules, queues } = toManifestSchedulesAndQueues(analysis.jobs, analysis.queues);
+	const pages = existsSync(paths.pagesDir);
+	const ssr = Boolean(validateSsrEntry(root, paths)) || pages;
+	const compat = resolveDeployWranglerCompat(root, config, workerDir, {
+		authEnabled,
+		dialect
+	});
+	const workerMain = resolveDeployWorkerMain(config, workerDir);
+	const workerFiles = collectWorkerFiles(workerDir);
+	if (!workerFiles.size) throw new Error("Worker build output is missing. Run the app build first.");
+	assertWorkerMainUploaded(workerFiles, workerMain);
+	const rules = mergeAndLintRoutingRules(clientDir, config.routing);
+	const manifest = assembleVoidManifest(pages ? scan.pages : null, false, {
+		bindings,
+		hasEmailHandlers: scan.email !== void 0 && hasEmailHandlers(scan.email),
+		migrations,
+		schedules,
+		queues,
+		dialect,
+		webSockets: websockets,
+		ssr: ssr || scan.routes.length > 0 || scan.middleware.length > 0 || websockets.length > 0 || authEnabled,
+		revalidate: collectRevalidate(config, pages ? scan.pages : null),
+		assetConfig: resolveAssetConfig({
+			isSsr: ssr,
+			hasPages: pages,
+			hasApiRoutes: hasApiRoutes(scan.routes) || hasApiRoutes(websockets) || authEnabled,
+			hasDocumentRoutes: hasDocumentRoutes(scan.routes),
+			hasMiddleware: scan.middleware.length > 0,
+			hasWebSockets: hasDocumentRoutes(websockets),
+			authEnabled,
+			liveEnabled: false,
+			notFound: config.routing?.notFound
+		}),
+		options: {
+			compatibilityDate: compat?.compatibilityDate,
+			compatibilityFlags: compat?.compatibilityFlags,
+			cpuMs: config.worker?.limits?.cpu_ms,
+			workerMain,
+			revalidateQueryAllowlist: config.routing?.revalidateQueryAllowlist
+		},
+		...rules
+	}, config.routing?.revalidate, config.routing?.isr !== false);
+	const { assetManifest, assetFiles } = await collectAndHashAssets(clientDir);
+	return {
+		artifact: createDeployArtifact({
+			manifest,
+			assetManifest,
+			workerFiles: Object.fromEntries([...workerFiles].map(([path, bytes]) => [path, bytes.toString("base64")]))
+		}),
+		assets: Object.fromEntries([...assetFiles].map(([path, bytes]) => [path, bytes.toString("base64")]))
+	};
+}
+//#endregion
+export { prepareDeployArtifact };

package/dist/dev-inbox-Rd6j_8vM.mjs

@@ -0,0 +1,217 @@
+import { n as bytesToBase64, t as base64ToBytes } from "./base64-DVrOndmI.mjs";
+import { a as newId, t as MAX_MESSAGE_BYTES } from "./mime-srOklVVv.mjs";
+//#region src/runtime/email/dev-inbox.ts
+/**
+* In-memory email capture for `void dev` and tests. The inbox buffer lives in
+* the Vite dev server's Node process; `sendEmail` runs in workerd, a separate
+* process, so it POSTs each capture to {@link DEV_INBOX_CAPTURE_URL} over the
+* dev assets binding. The sink registry serves only sends in the same
+* isolate, such as `createEmailTestHarness`.
+*/
+/** Mount point of the dev inbox on the Vite dev server. */
+const DEV_INBOX_PREFIX = "/__void/inbox";
+/** Capture endpoint, relative to {@link DEV_INBOX_PREFIX} (connect strips the mount). */
+const DEV_INBOX_CAPTURE_PATH = "/_capture";
+/** Absolute path the worker POSTs a captured message to. */
+const DEV_INBOX_CAPTURE_URL = `${DEV_INBOX_PREFIX}${DEV_INBOX_CAPTURE_PATH}`;
+/**
+* Serve-only var naming the binding that loops back to the Vite dev server.
+* Its presence is the dev gate (`shouldInjectEmailDevInboxVar` in index.ts).
+*/
+const DEV_INBOX_ENV_VAR = "__VOID_EMAIL_DEV_INBOX";
+/**
+* Serve-only var carrying the dev-trigger token for the capture POST: the
+* router's token const is not importable from `void/email`.
+*/
+const DEV_INBOX_TOKEN_ENV_VAR = "__VOID_EMAIL_DEV_INBOX_TOKEN";
+/**
+* Every inbox route requires the dev-trigger token, as this header or, for
+* browser links, this query parameter.
+*/
+const DEV_INBOX_TOKEN_HEADER = "x-void-dev-trigger";
+const DEV_INBOX_TOKEN_QUERY = "token";
+/**
+* Marks a capture response: over the assets binding, a plain 200 could also
+* be a static asset.
+*/
+const DEV_INBOX_ACK_HEADER = "x-void-email-inbox";
+const DEV_INBOX_ACK_VALUE = "captured";
+/**
+* Capture body cap. 6x covers the base64 MIME plus the JSON copy of every
+* rendered caller string for a max-size message. Strings with no MIME
+* footprint (a bcc name, a reserved header, folded-away whitespace) are not
+* bounded by it, so a message padded with them is still refused.
+*/
+const DEV_INBOX_MAX_CAPTURE_BYTES = 6 * MAX_MESSAGE_BYTES;
+/** Encode a captured message for the worker -> dev-server hop (`raw` as base64). */
+function serializeCapturedMessage(message) {
+	return JSON.stringify({
+		...message,
+		raw: bytesToBase64(message.raw)
+	});
+}
+function asAddress(value) {
+	if (typeof value !== "object" || value === null) return;
+	const v = value;
+	if (typeof v.email !== "string") return;
+	return typeof v.name === "string" ? {
+		email: v.email,
+		name: v.name
+	} : { email: v.email };
+}
+function asAddressList(value) {
+	if (!Array.isArray(value)) return;
+	const out = [];
+	for (const entry of value) {
+		const address = asAddress(entry);
+		if (!address) return;
+		out.push(address);
+	}
+	return out;
+}
+/**
+* Decode a capture payload. Returns `undefined` for anything malformed — the
+* endpoint is reachable from the dev server's own origin, so it must reject
+* junk rather than throw inside the middleware.
+*/
+function parseCapturedMessage(value) {
+	if (typeof value !== "object" || value === null) return;
+	const v = value;
+	if (typeof v.id !== "string" || typeof v.raw !== "string") return;
+	let raw;
+	try {
+		raw = base64ToBytes(v.raw);
+	} catch {
+		return;
+	}
+	const from = asAddress(v.from);
+	const to = asAddressList(v.to);
+	const cc = asAddressList(v.cc);
+	const bcc = asAddressList(v.bcc);
+	if (!from || !to || !cc || !bcc) return;
+	const attachments = [];
+	if (!Array.isArray(v.attachments)) return;
+	for (const entry of v.attachments) {
+		if (typeof entry !== "object" || entry === null) return;
+		const a = entry;
+		attachments.push({
+			filename: typeof a.filename === "string" ? a.filename : "",
+			contentType: typeof a.contentType === "string" ? a.contentType : "application/octet-stream",
+			size: typeof a.size === "number" ? a.size : 0,
+			...typeof a.contentId === "string" && { contentId: a.contentId },
+			disposition: a.disposition === "inline" ? "inline" : "attachment"
+		});
+	}
+	const headers = {};
+	if (typeof v.headers === "object" && v.headers !== null) {
+		for (const [k, hv] of Object.entries(v.headers)) if (typeof hv === "string") headers[k] = hv;
+	}
+	const replyTo = asAddress(v.replyTo);
+	return {
+		id: v.id,
+		capturedAt: typeof v.capturedAt === "number" ? v.capturedAt : Date.now(),
+		raw,
+		messageId: typeof v.messageId === "string" ? v.messageId : "",
+		from,
+		to,
+		cc,
+		bcc,
+		...replyTo && { replyTo },
+		subject: typeof v.subject === "string" ? v.subject : "",
+		...typeof v.text === "string" && { text: v.text },
+		...typeof v.html === "string" && { html: v.html },
+		headers,
+		attachments
+	};
+}
+const SINK_KEY = "__voidEmailSinks__";
+const BUFFER_KEY = "__voidEmailDevBuffer__";
+const DEFAULT_BUFFER_LIMIT = 100;
+/** Retained-byte budget: 100 messages of up to 5 MiB each would fill the dev server's heap. */
+const DEFAULT_BUFFER_BYTES = 67108864;
+const inboxGlobal = globalThis;
+function registry() {
+	let r = inboxGlobal[SINK_KEY];
+	if (!r) {
+		r = { sinks: /* @__PURE__ */ new Set() };
+		inboxGlobal[SINK_KEY] = r;
+	}
+	return r;
+}
+function registerEmailSink(sink) {
+	const r = registry();
+	r.sinks.add(sink);
+	return () => r.sinks.delete(sink);
+}
+function dispatchToSinks(message) {
+	for (const sink of registry().sinks) try {
+		sink(message);
+	} catch (err) {
+		console.warn("[email-dev-inbox] sink error:", err);
+	}
+}
+function hasActiveSink() {
+	return registry().sinks.size > 0;
+}
+/** Get or create the shared dev-server ring buffer. */
+function getDevBuffer() {
+	let b = inboxGlobal[BUFFER_KEY];
+	if (!b) {
+		b = {
+			bytes: 0,
+			items: []
+		};
+		inboxGlobal[BUFFER_KEY] = b;
+	}
+	return b;
+}
+/** What a retained message costs: the raw MIME plus both decoded bodies. */
+function messageBytes(message) {
+	return message.raw.byteLength + (message.text?.length ?? 0) + (message.html?.length ?? 0);
+}
+function pushToDevBuffer(message) {
+	const b = getDevBuffer();
+	b.items.push(message);
+	b.bytes += messageBytes(message);
+	while (b.items.length > DEFAULT_BUFFER_LIMIT || b.bytes > DEFAULT_BUFFER_BYTES && b.items.length > 1) {
+		const evicted = b.items.shift();
+		if (evicted) b.bytes -= messageBytes(evicted);
+	}
+}
+function listDevMessages() {
+	return [...getDevBuffer().items].reverse();
+}
+function findDevMessage(id) {
+	return getDevBuffer().items.find((m) => m.id === id);
+}
+function clearDevBuffer() {
+	const b = getDevBuffer();
+	b.items.length = 0;
+	b.bytes = 0;
+}
+function captureMessage(email, raw, messageId) {
+	return {
+		id: newId("dev"),
+		capturedAt: Date.now(),
+		raw,
+		messageId,
+		from: email.from,
+		to: email.to,
+		cc: email.cc,
+		bcc: email.bcc,
+		replyTo: email.replyTo,
+		subject: email.subject,
+		text: email.text,
+		html: email.html,
+		headers: { ...email.headers },
+		attachments: email.attachments.map((a) => ({
+			filename: a.filename,
+			contentType: a.contentType,
+			size: a.bytes.byteLength,
+			contentId: a.contentId,
+			disposition: a.disposition
+		}))
+	};
+}
+//#endregion
+export { parseCapturedMessage as _, DEV_INBOX_ENV_VAR as a, serializeCapturedMessage as b, DEV_INBOX_TOKEN_ENV_VAR as c, captureMessage as d, clearDevBuffer as f, listDevMessages as g, hasActiveSink as h, DEV_INBOX_CAPTURE_URL as i, DEV_INBOX_TOKEN_HEADER as l, findDevMessage as m, DEV_INBOX_ACK_VALUE as n, DEV_INBOX_MAX_CAPTURE_BYTES as o, dispatchToSinks as p, DEV_INBOX_CAPTURE_PATH as r, DEV_INBOX_PREFIX as s, DEV_INBOX_ACK_HEADER as t, DEV_INBOX_TOKEN_QUERY as u, pushToDevBuffer as v, registerEmailSink as y };

package/dist/discover-CTUiSsfG.mjs

@@ -0,0 +1,2 @@
+import { t as discoverSchema } from "./discover-D2PGT63u.mjs";
+export { discoverSchema };

package/dist/{discover-CkCYv9T_.mjs → discover-D2PGT63u.mjs}

@@ -1,5 +1,5 @@
-import { l as relative } from "./dist-BVqXeR_h.mjs";
-import { n as readProjectPaths } from "./project-paths-GgcMozYz.mjs";
+import { s as relative } from "./dist-ipQi0Q8y.mjs";
+import { n as readProjectPaths } from "./project-paths-DMvEeSau.mjs";
 import { existsSync, statSync } from "node:fs";
 //#region src/drizzle/discover.ts
 /**

package/dist/{dist-BVqXeR_h.mjs → dist-ipQi0Q8y.mjs}

@@ -44,7 +44,6 @@ const win32 = {
 const posix = { ...nodePath.posix };
 posix.posix = win32.posix = posix;
 posix.win32 = win32.win32 = win32;
-const path = isWindows ? win32 : posix;
-const { basename, delimiter, dirname, extname, format, isAbsolute, join, matchesGlob, normalize, parse, relative, resolve, sep, toNamespacedPath } = path;
+const { basename, delimiter, dirname, extname, format, isAbsolute, join, matchesGlob, normalize, parse, relative, resolve, sep, toNamespacedPath } = isWindows ? win32 : posix;
 //#endregion
-export { join as a, posix as c, toSlash as d, win32 as f, isAbsolute as i, relative as l, dirname as n, normalize as o, extname as r, path as s, basename as t, resolve as u };
+export { join as a, resolve as c, isAbsolute as i, toSlash as l, dirname as n, normalize as o, extname as r, relative as s, basename as t };

package/dist/{domain-BsDUBAvt.mjs → domain-Bfq9n03H.mjs}

@@ -1,8 +1,9 @@
-import { n as readDeploymentPlatform, r as readProjectConfig } from "./project-BAm2aB6Q.mjs";
-import { c as getToken } from "./auth-Dn2vw-SG.mjs";
+import { n as readDeploymentPlatform } from "./project-rqDnVsJN.mjs";
+import { c as getToken } from "./auth-B6iOCjKI.mjs";
 import { L as log } from "./dist-D3m88sjf.mjs";
-import { d as printSuccess, l as import_picocolors, u as note } from "./output-C50ag2r3.mjs";
-import { r as PlatformClient } from "./client-DlDJuY0s.mjs";
+import { f as import_picocolors, m as printSuccess, p as note } from "./output-FNHKw5Ac.mjs";
+import { r as PlatformClient } from "./client-DM9Kcf4e.mjs";
+import { i as resolveCommandProjectId } from "./resolve-project-C_Cu7E8a.mjs";
 //#region src/cli/domain.ts
 async function runDomainCommand(root, args) {
 	const platform = readDeploymentPlatform(root);
@@ -14,23 +15,7 @@ async function runDomainCommand(root, args) {
 		process.exit(1);
 	}
 	const client = new PlatformClient(token, { root });
-	const requestedSlug = args.projectSlug ?? process.env.VOID_PROJECT?.trim();
-	let projectId;
-	if (requestedSlug) {
-		const project = (await client.listProjects()).find((p) => p.slug === requestedSlug);
-		if (!project) {
-			log.error(`project: No project found with slug '${requestedSlug}'.`);
-			process.exit(1);
-		}
-		projectId = project.id;
-	} else {
-		const config = readProjectConfig(root);
-		if (!config) {
-			log.error("No linked project. Run `void project link` or pass --project <name>.");
-			process.exit(1);
-		}
-		projectId = config.projectId;
-	}
+	const projectId = await resolveCommandProjectId(client, root, args.projectSlug);
 	switch (args.subcommand) {
 		case "add": return domainAdd(client, projectId, args.hostname);
 		case "delete": return domainRemove(client, projectId, args.hostname);
@@ -40,7 +25,7 @@ async function runDomainCommand(root, args) {
 }
 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-BlYLlowZ.mjs");
+	const { changeCloudflareDomain, listCloudflareDomains } = await import("./cloudflare-operations-Ds-lX3Ts.mjs");
 	if (args.subcommand === "add") {
 		const result = await changeCloudflareDomain(root, args.hostname, "add");
 		note("Cloudflare Custom Domains manages the DNS record and TLS certificate in the zone on your account.", "Cloudflare Domain");

package/dist/{dotenv-BfU6eqFt.mjs → dotenv-CNazY3-w.mjs}

@@ -28,21 +28,13 @@ import { parseEnv } from "node:util";
 /** Valid dotenv key — ASCII letter/underscore followed by letters/digits/underscore. */
 const VALID_KEY = /^[A-Za-z_][A-Za-z0-9_]*$/;
 /**
-* Parse the raw contents of a dotenv file into a record, optionally
-* expanding `${VAR}` / `$VAR` references against earlier entries.
+* Parse the raw contents of a dotenv file into a record, skipping invalid
+* keys and expanding `${VAR}` / `$VAR` references against earlier entries.
 */
 function parseDotenv(content, options = {}) {
-	const { expand: shouldExpand = true, skipInvalidKeys = true, onWarn } = options;
 	const env = {};
-	for (const [key, value] of Object.entries(parseEnv(content))) {
-		if (value === void 0) continue;
-		if (!VALID_KEY.test(key)) {
-			if (skipInvalidKeys) continue;
-			throw new Error(`dotenv: Invalid key '${key}'.`);
-		}
-		env[key] = value;
-	}
-	return shouldExpand ? expandDotenv(env, { onWarn }) : env;
+	for (const [key, value] of Object.entries(parseEnv(content))) if (value !== void 0 && VALID_KEY.test(key)) env[key] = value;
+	return expandDotenv(env, options);
 }
 /**
 * Read and parse a dotenv file. Returns `{}` when the file is missing so
@@ -148,10 +140,6 @@ function expandValue(value, resolve) {
 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();

package/dist/{email-d_Aux1vM.mjs → email-BcjSyAL0.mjs}

@@ -1,5 +1,5 @@
-import { a as join } from "./dist-BVqXeR_h.mjs";
-import { n as globSync, t as glob } from "./dist-Bn8Kodjp.mjs";
+import { a as join } from "./dist-ipQi0Q8y.mjs";
+import { n as globSync } from "./dist-Bn8Kodjp.mjs";
 //#region src/router/email.ts
 /**
 * Scan `email/` for inbound email handlers.
@@ -155,28 +155,12 @@ function parseEmailFiles(files) {
 		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);
+	return parseEmailFiles(globSync(pattern, { cwd: join(root, emailDir) }));
 }
 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 };
+export { scanEmailHandlersSync as i, compileEmailPattern as n, hasEmailHandlers as r, compareEmailRoutes as t };