void 1.1.0 → 1.1.12

package/dist/{provision-BnSSkiED.mjs → provision-DZKYCEJg.mjs}

@@ -1,8 +1,8 @@
 import { a as join, c as resolve$2, n as dirname, o as normalize, t as basename } from "./dist-ipQi0Q8y.mjs";
 import { i as voidWarn, r as voidLog } from "./log-vqY3pqwI.mjs";
-import { _ as persistMaterializedWranglerConfig, j as writeProvisionedWranglerConfig, s as assertNoDuplicateMembers, y as readProvisionedBindingEntry } from "./wrangler-BYs07Rxy.mjs";
+import { _ as persistMaterializedWranglerConfig, j as writeProvisionedWranglerConfig, s as assertNoDuplicateMembers, y as readProvisionedBindingEntry } from "./wrangler-C9XSzrju.mjs";
 import { n as scanWranglerDotenvKeys } from "./dotenv-CNazY3-w.mjs";
-import { l as resolveCloudflareOperationArgv, n as decodeCloudflareOperationResult, r as encodeCloudflareOperation } from "./cloudflare-process-CeDWJRhj.mjs";
+import { l as resolveCloudflareOperationArgv, n as decodeCloudflareOperationResult, r as encodeCloudflareOperation } from "./cloudflare-process-CZJ4viYl.mjs";
 import { createRequire } from "node:module";
 import { closeSync, existsSync, fsyncSync, lstatSync, openSync, readFileSync, readlinkSync, realpathSync, renameSync, unlinkSync, writeSync } from "node:fs";
 import { isRecord } from "@void/deploy-core";
@@ -102,9 +102,8 @@ const TRANSPORT_REDIRECT_ENV_VARS = [
 	"CLOUDFLARE_ENV"
 ];
 /**
-* Wrangler session-output sinks. When set, wrangler writes the raw argv to disk, which can
-* include a Hyperdrive password. They are scrubbed from the child env and rejected in project
-* dotenv, which wrangler reloads before writing.
+* Session-output file variables. Provisioning keeps operation output off disk, so they are
+* scrubbed from the child env and rejected in project dotenv. Secrets travel over stdin.
 */
 const OUTPUT_FILE_ENV_VARS = ["WRANGLER_OUTPUT_FILE_PATH", "WRANGLER_OUTPUT_FILE_DIRECTORY"];
 /**
@@ -140,7 +139,7 @@ function resolveComplianceRegion(env, configRegion) {
 	if (envRegion !== void 0 && configRegion !== void 0 && envRegion !== configRegion) throw new Error(`provision: the Cloudflare compliance region is set to conflicting values — the CLOUDFLARE_COMPLIANCE_REGION environment variable is ${JSON.stringify(envRegion)} but the wrangler config "compliance_region" is ${JSON.stringify(configRegion)}. wrangler refuses to run with a mismatched compliance region; reconcile them (remove one, or set them equal) and retry.`);
 	return envRegion ?? configRegion ?? "public";
 }
-/** Dotenv files wrangler loads for `--env=<env>`; provisioning always passes an empty env. */
+/** Project dotenv files the fence scans for `env`; provisioning selects no named env (`''`). */
 function defaultWranglerEnvFiles(env) {
 	return [
 		".env",
@@ -151,8 +150,8 @@ function defaultWranglerEnvFiles(env) {
 }
 /**
 * Fail when a project dotenv file sets a transport-redirect or session-output variable.
-* Wrangler reloads these files on every command, which would move its authenticated transport
-* away from the pinned base. Values exported in the shell are honored instead.
+* Cloudflare tooling reads these files from the project, which would move its authenticated
+* transport away from the pinned base. Values exported in the shell are honored instead.
 */
 function assertNoTransportRedirectInProjectDotenv(root, platform = process.platform) {
 	const dotenvCaseInsensitive = platform === "win32";
@@ -169,9 +168,9 @@ function assertNoTransportRedirectInProjectDotenv(root, platform = process.platf
 		const lowerKeys = caseInsensitive ? new Set([...keys].map((key) => key.toLowerCase())) : void 0;
 		const declares = (name) => lowerKeys !== void 0 ? lowerKeys.has(name.toLowerCase()) : keys.has(name);
 		const offenders = TRANSPORT_REDIRECT_ENV_VARS.filter(declares);
-		if (offenders.length > 0) throw new Error(`provision: refusing to provision — the project file "${file}" sets ${offenders.join(", ")}, which wrangler reloads on every command and would redirect its authenticated Cloudflare API transport (and credentials) to a different endpoint/account than this provision is pinned to (the Hyperdrive existence check would then run against a DIFFERENT endpoint, risking cross-environment writes or duplicate resources). Remove ${offenders.join(", ")} from "${file}" and, if you truly need a non-default endpoint, export it in your shell/CI environment instead — that pin IS honored for both wrangler and the existence check.`);
+		if (offenders.length > 0) throw new Error(`provision: refusing to provision — the project file "${file}" sets ${offenders.join(", ")}, which Cloudflare tooling reads from project files and would redirect its authenticated Cloudflare API transport (and credentials) to a different endpoint/account than this provision is pinned to (the Hyperdrive existence check would then run against a DIFFERENT endpoint, risking cross-environment writes or duplicate resources). Remove ${offenders.join(", ")} from "${file}" and, if you truly need a non-default endpoint, export it in your shell/CI environment instead — that pin IS honored for both the Cloudflare operations and the existence check.`);
 		const outputOffenders = OUTPUT_FILE_ENV_VARS.filter(declares);
-		if (outputOffenders.length > 0) throw new Error(`provision: refusing to provision — the project file "${file}" sets ${outputOffenders.join(", ")}, which wrangler reloads on every command and which makes wrangler persist its session diagnostics — including the verbatim command line, where a Hyperdrive connection string's password would appear — to that output file. Remove ${outputOffenders.join(", ")} from "${file}" (set it in your shell only for non-provisioning wrangler commands if you need session output).`);
+		if (outputOffenders.length > 0) throw new Error(`provision: refusing to provision — the project file "${file}" sets ${outputOffenders.join(", ")}. Void does not allow Cloudflare session output files during provisioning. Remove ${outputOffenders.join(", ")} from "${file}".`);
 	}
 }
 /**
@@ -245,7 +244,7 @@ var WranglerQuarantineError = class extends Error {
 	pid;
 	constructor(pid, detail) {
 		const pidLabel = pid !== void 0 ? ` (pid ${pid})` : "";
-		super(`provision: the spawned wrangler could not be confirmed terminated${pidLabel} — ${detail}. It may still be running and creating resources, so the cross-process provision lock is intentionally RETAINED (not released) and its owner is recorded in a quarantine sidecar ("<wrangler config>.void-provision.lock.quarantine.json") that blocks concurrent provisions. Recovery: verify the process${pidLabel} is dead (e.g. \`kill -0 <pid>\`; terminate it if not) — the NEXT provision then confirms the recorded group is gone and clears the quarantine automatically. To clear it manually instead, remove the sidecar and the "<wrangler config>.void-provision.lock.lock" directory, then re-run.`);
+		super(`provision: the spawned Cloudflare operation process could not be confirmed terminated${pidLabel} — ${detail}. It may still be running and creating resources, so the cross-process provision lock is intentionally RETAINED (not released) and its owner is recorded in a quarantine sidecar ("<Cloudflare config>.void-provision.lock.quarantine.json") that blocks concurrent provisions. Recovery: verify the process${pidLabel} is dead (e.g. \`kill -0 <pid>\`; terminate it if not) — the NEXT provision then confirms the recorded group is gone and clears the quarantine automatically. To clear it manually instead, remove the sidecar and the "<Cloudflare config>.void-provision.lock.lock" directory, then re-run.`);
 		this.name = "WranglerQuarantineError";
 		this.pid = pid;
 	}
@@ -253,7 +252,7 @@ var WranglerQuarantineError = class extends Error {
 let activeProvisionSlot;
 function acquireProcessProvisionSlot() {
 	if (activeProvisionSlot !== void 0) throw new Error("provision: a provision is already active in this process — run provisions sequentially. provisionCloudflareResources supports at most one concurrent provision per process; concurrent provisions across PROCESSES are serialized by the on-disk provision lock instead.");
-	if (retentionWatchdog !== void 0) throw new Error(`provision: a previous provision in this process is still retaining its lock — an unconfirmed wrangler child${retentionWatchdog.info.pid !== void 0 ? ` (pid ${retentionWatchdog.info.pid})` : ""} could not be quarantined durably yet. No new provision may start until that retention resolves (the child is confirmed dead, or the quarantine metadata persists durably).`);
+	if (retentionWatchdog !== void 0) throw new Error(`provision: a previous provision in this process is still retaining its lock — an unconfirmed Cloudflare operation process${retentionWatchdog.info.pid !== void 0 ? ` (pid ${retentionWatchdog.info.pid})` : ""} could not be quarantined durably yet. No new provision may start until that retention resolves (the child is confirmed dead, or the quarantine metadata persists durably).`);
 	const token = Symbol("void-provision-slot");
 	activeProvisionSlot = token;
 	return () => {
@@ -307,7 +306,7 @@ function deregisterRunner(registrant) {
 function coordinatorHandleSignal(signal) {
 	if (activeTeardown !== void 0) return;
 	if (retentionWatchdog !== void 0 && activeRegistrations.size === 0) {
-		process.stderr.write(`provision: ignoring ${signal} — a provision lock is retained while an unconfirmed wrangler child may live and its quarantine metadata is not yet durable. The process exits once the child is confirmed dead or the metadata persists.\n`);
+		process.stderr.write(`provision: ignoring ${signal} — a provision lock is retained while an unconfirmed Cloudflare operation process may live and its quarantine metadata is not yet durable. The process exits once the child is confirmed dead or the metadata persists.\n`);
 		return;
 	}
 	const teardown = {
@@ -350,14 +349,14 @@ function coordinatorTearDownRegistrant(teardown, registration) {
 		if (lockQuarantine !== void 0) try {
 			lockQuarantine({
 				pid: registrant.pid(),
-				reason: `the spawned wrangler could not be confirmed terminated after a forwarded ${teardown.signal} — ${detail}`
+				reason: `the spawned Cloudflare operation process could not be confirmed terminated after a forwarded ${teardown.signal} — ${detail}`
 			});
 		} catch (failure) {
 			teardown.persistFailed = true;
 			process.stderr.write(`provision: ${failure.message}\n`);
 		}
 		const pid = registrant.pid();
-		process.stderr.write(`provision: warning — the wrangler child process group${typeof pid === "number" ? ` (pid ${pid})` : ""} could not be confirmed terminated after ${teardown.signal} (${detail}). It may still be running; the provision lock is retained (quarantined) — verify the process is dead before re-running provision.\n`);
+		process.stderr.write(`provision: warning — the Cloudflare operation process group${typeof pid === "number" ? ` (pid ${pid})` : ""} could not be confirmed terminated after ${teardown.signal} (${detail}). It may still be running; the provision lock is retained (quarantined) — verify the process is dead before re-running provision.\n`);
 		registrant.quarantine(detail);
 		complete();
 	};
@@ -381,7 +380,7 @@ function finishCoordinatorTeardown(teardown) {
 	if (teardown.persistFailed || retentionWatchdog !== void 0) {
 		activeTeardown = void 0;
 		installCoordinatorListeners();
-		process.stderr.write(`provision: NOT re-raising ${teardown.signal} — a provision lock's quarantine metadata could not be persisted, so the lock is intentionally still held by this process to keep it from being stolen while the unconfirmed wrangler child may live.\n`);
+		process.stderr.write(`provision: NOT re-raising ${teardown.signal} — a provision lock's quarantine metadata could not be persisted, so the lock is intentionally still held by this process to keep it from being stolen while the unconfirmed Cloudflare operation process may live.\n`);
 		return;
 	}
 	if (reRaisedOnce) return;
@@ -403,7 +402,7 @@ function retainQuarantinedLock(lock, info) {
 }
 function armRetentionWatchdog(lock, info) {
 	if (retentionWatchdog !== void 0) return;
-	process.stderr.write(`provision: warning — quarantine metadata for the unconfirmed wrangler child${info.pid !== void 0 ? ` (pid ${info.pid})` : ""} could not be persisted, so the provision lock "${lock.lockTargetPath}.lock" is RETAINED by this process, which stays alive until the child is confirmed dead or the metadata persists durably.\n`);
+	process.stderr.write(`provision: warning — quarantine metadata for the unconfirmed Cloudflare operation process${info.pid !== void 0 ? ` (pid ${info.pid})` : ""} could not be persisted, so the provision lock "${lock.lockTargetPath}.lock" is RETAINED by this process, which stays alive until the child is confirmed dead or the metadata persists durably.\n`);
 	installCoordinatorListeners();
 	let attempt = 0;
 	const resolveWatchdog = () => {
@@ -456,12 +455,13 @@ function createDefaultRunWrangler(root, options) {
 	const teardownDeadlineMs = options?.signalTeardownDeadlineMs ?? confirmGraceMs + SIGNAL_TEARDOWN_DEADLINE_MARGIN_MS;
 	return (args, opts) => new Promise((resolvePromise, rejectPromise) => {
 		const parallelWorkerUpload = options?.parallelWorkerUpload === true && args.type === "versions.upload";
+		const interactive = (args.type === "versions.upload" || args.type === "worker.deploy") && args.interactive === true;
 		if (activeTeardown !== void 0) {
-			rejectPromise(/* @__PURE__ */ new Error(`provision: refusing to spawn wrangler — a fatal ${activeTeardown.signal} is being handled and this process is terminating; no new wrangler work may start.`));
+			rejectPromise(/* @__PURE__ */ new Error(`provision: refusing to spawn a Cloudflare operation process — a fatal ${activeTeardown.signal} is being handled and this process is terminating; no new Cloudflare operation may start.`));
 			return;
 		}
 		if (!canRegisterRunner(parallelWorkerUpload)) {
-			rejectPromise(/* @__PURE__ */ new Error("provision: refusing to spawn wrangler — another wrangler child is already active in this process (only two immutable Worker uploads may overlap; all other Cloudflare commands and provisions remain sequential)."));
+			rejectPromise(/* @__PURE__ */ new Error("provision: refusing to spawn a Cloudflare operation process — another one is already active in this process (only two immutable Worker uploads may overlap; all other Cloudflare commands and provisions remain sequential)."));
 			return;
 		}
 		const child = spawn(command, [...prefix, ...encodeCloudflareOperation(args)], {
@@ -475,7 +475,7 @@ function createDefaultRunWrangler(root, options) {
 				}),
 				...opts.suppressLogs ? { WRANGLER_WRITE_LOGS: "false" } : {}
 			},
-			stdio: [
+			stdio: interactive ? "inherit" : [
 				opts.input === void 0 ? "ignore" : "pipe",
 				"pipe",
 				"pipe"
@@ -548,7 +548,7 @@ function createDefaultRunWrangler(root, options) {
 		};
 		const timeoutStderr = (extra) => [
 			stderr,
-			`provision: wrangler exceeded the ${timeoutMs}ms command timeout`,
+			`provision: the Cloudflare operation process exceeded the ${timeoutMs}ms command timeout`,
 			extra
 		].filter(Boolean).join("\n");
 		const deregisterSelf = () => deregisterRunner(registrant);
@@ -557,7 +557,7 @@ function createDefaultRunWrangler(root, options) {
 			settled = true;
 			clearTimeout(commandTimer);
 			deregisterSelf();
-			resolvePromise(decodeCloudflareOperationResult(result));
+			resolvePromise(interactive ? result : decodeCloudflareOperationResult(result));
 		};
 		const quarantine = (detail) => {
 			if (settled) return;
@@ -652,7 +652,7 @@ function createDefaultRunWrangler(root, options) {
 			if (outcome === "gone") groupGone = true;
 			confirmThenSettle(() => normalizeRunWranglerResult({
 				stdout,
-				stderr: [stderr, `provision: the spawned wrangler child emitted an error after spawn: ${error.message}`].filter(Boolean).join("\n"),
+				stderr: [stderr, `provision: the spawned Cloudflare operation process emitted an error after spawn: ${error.message}`].filter(Boolean).join("\n"),
 				status: null,
 				signal: "SIGKILL"
 			}), `a post-spawn child error (${error.message}; the group was SIGKILLed)`);
@@ -697,8 +697,8 @@ function createDefaultRunWrangler(root, options) {
 function normalizeRunWranglerResult(result) {
 	const stdout = result.stdout ?? "";
 	const notes = [];
-	if (result.signal != null) notes.push(`provision: wrangler was terminated by signal ${result.signal}`);
-	if (result.error != null) notes.push(`provision: wrangler could not be spawned: ${result.error.message}`);
+	if (result.signal != null) notes.push(`provision: the Cloudflare operation process was terminated by signal ${result.signal}`);
+	if (result.error != null) notes.push(`provision: the Cloudflare operation process could not be spawned: ${result.error.message}`);
 	const status = typeof result.status !== "number" || result.signal != null || result.error != null ? typeof result.status === "number" && result.status !== 0 ? result.status : 1 : result.status;
 	const baseStderr = result.stderr ?? "";
 	return {
@@ -903,7 +903,7 @@ function assertQuarantineClearedOrClear(lockTarget, onBeforeClear) {
 	}
 	if (!confirmedDead) {
 		const who = pid !== void 0 || pgid !== void 0 ? `process group ${String(pgid ?? pid)}` : "an unrecorded process";
-		throw new Error(`provision: refusing to provision — a previous provision QUARANTINED this config's lock because a spawned wrangler child could not be confirmed terminated (${who}${quarantinedAt ? `, quarantined at ${quarantinedAt}` : ""}${reason ? `; reason: ${reason}` : ""}). It may still be creating resources. Verify the process is dead (e.g. \`kill -0 ${String(pid ?? "<pid>")}\`; terminate it if not) and re-run — the quarantine then clears automatically. If you are CERTAIN the recorded process is unrelated (pid reuse) or gone, remove "${sidecarPath}" and the "${lockTarget}.lock" directory manually, then retry.`);
+		throw new Error(`provision: refusing to provision — a previous provision QUARANTINED this config's lock because a spawned Cloudflare operation process could not be confirmed terminated (${who}${quarantinedAt ? `, quarantined at ${quarantinedAt}` : ""}${reason ? `; reason: ${reason}` : ""}). It may still be creating resources. Verify the process is dead (e.g. \`kill -0 ${String(pid ?? "<pid>")}\`; terminate it if not) and re-run — the quarantine then clears automatically. If you are CERTAIN the recorded process is unrelated (pid reuse) or gone, remove "${sidecarPath}" and the "${lockTarget}.lock" directory manually, then retry.`);
 	}
 	const inspectedGeneration = typeof recorded?.generation === "string" ? recorded.generation : void 0;
 	onBeforeClear?.();
@@ -1090,7 +1090,7 @@ async function acquireProvisionLock(configPath, lockOptions) {
 			try {
 				writeQuarantineSidecar(quarantineSidecarPath(lockTarget), info, lockOptions?.dirDurability);
 			} catch (error) {
-				throw new Error(`provision: could not persist quarantine metadata to "${quarantineSidecarPath(lockTarget)}" (${error.message}). The cross-process provision lock "${lockTarget}.lock" is intentionally STILL HELD by this process (tracked, heartbeat running) so it cannot go stale and be stolen while the unconfirmed wrangler child${info.pid !== void 0 ? ` (pid ${info.pid})` : ""} may still be running. Manual recovery: verify the process is dead${info.pid !== void 0 ? ` (e.g. \`kill -0 ${info.pid}\`)` : ""} and terminate it if not; the lock is freed when this process exits — remove the "${lockTarget}.lock" directory if it persists, then re-run.`);
+				throw new Error(`provision: could not persist quarantine metadata to "${quarantineSidecarPath(lockTarget)}" (${error.message}). The cross-process provision lock "${lockTarget}.lock" is intentionally STILL HELD by this process (tracked, heartbeat running) so it cannot go stale and be stolen while the unconfirmed Cloudflare operation process${info.pid !== void 0 ? ` (pid ${info.pid})` : ""} may still be running. Manual recovery: verify the process is dead${info.pid !== void 0 ? ` (e.g. \`kill -0 ${info.pid}\`)` : ""} and terminate it if not; the lock is freed when this process exits — remove the "${lockTarget}.lock" directory if it persists, then re-run.`);
 			}
 			releasePromise = Promise.resolve();
 			const locks = loadProperLockfileInternals()?.getLocks?.();
@@ -1125,7 +1125,7 @@ function readRootConfig(configPath) {
 }
 /** Throw unless a discovery call exited cleanly, so a failed list never means "absent". */
 function assertDiscoverySucceeded(result, label) {
-	if (!isCleanSuccess(result)) throw new Error(`provision: "${label}" failed (exit ${String(result.status)}): ${result.stderr || result.stdout || "no output"}. Cannot verify existing resources; refusing to create a possible duplicate.`);
+	if (!isCleanSuccess(result)) throw new Error(`provision: ${label} failed (exit ${String(result.status)}): ${result.stderr || result.stdout || "no output"}. Cannot verify existing resources; refusing to create a possible duplicate.`);
 }
 /**
 * Reject the whole list if any member lacks a non-empty name or a valid id. A malformed member
@@ -1134,12 +1134,12 @@ function assertDiscoverySucceeded(result, label) {
 function validateResourceList(list, spec) {
 	const validated = [];
 	for (const member of list) {
-		if (!isRecord(member)) throw new Error(`provision: "${spec.command}" returned a malformed ${spec.resource} entry (not an object). Cannot verify existing resources; refusing to create a possible duplicate.`);
+		if (!isRecord(member)) throw new Error(`provision: ${spec.command} returned a malformed ${spec.resource} entry (not an object). Cannot verify existing resources; refusing to create a possible duplicate.`);
 		const rawName = member[spec.nameField];
 		const nameValid = typeof rawName === "string" && rawName.length > 0;
 		const idValid = spec.hasValidId(member);
-		if (nameValid && !idValid) throw new Error(`provision: "${spec.command}" returned a ${spec.resource} ${spec.nameLabel} ${JSON.stringify(rawName)} with no valid id (${spec.idRule}). Cannot verify existing resources; refusing to create a possible duplicate.`);
-		if (!nameValid) throw new Error(`provision: "${spec.command}" returned a malformed ${spec.resource} entry with no valid ${spec.nameField}. Cannot verify existing resources; refusing to create a possible duplicate.`);
+		if (nameValid && !idValid) throw new Error(`provision: ${spec.command} returned a ${spec.resource} ${spec.nameLabel} ${JSON.stringify(rawName)} with no valid id (${spec.idRule}). Cannot verify existing resources; refusing to create a possible duplicate.`);
+		if (!nameValid) throw new Error(`provision: ${spec.command} returned a malformed ${spec.resource} entry with no valid ${spec.nameField}. Cannot verify existing resources; refusing to create a possible duplicate.`);
 		validated.push(member);
 	}
 	return validated;
@@ -1200,13 +1200,13 @@ function assertD1MigrationsDirApplied(result, binding, configPath) {
 }
 /**
 * After a create reports success, re-read the config and require a real id, plus the exact
-* name where the name is the identity. A killed child can still report exit 0.
+* name where the name is the identity. A success status alone is not trusted.
 */
 function assertCreateWroteRealId(configPath, spec, binding, name) {
 	const entry = readBindingEntry(configPath, spec.field, binding);
 	const idOk = !!entry && spec.idValidator(entry[spec.idField]);
 	const nameOk = spec.nameField === void 0 || !!entry && entry[spec.nameField] === name;
-	if (!idOk || !nameOk) throw new Error(`provision: "${spec.command} ${name}" reported success but "${configPath}" does not hold the expected ${spec.resource} for binding ${JSON.stringify(binding)} afterward (need a real ${spec.idField}${spec.nameField ? ` and ${spec.nameField} === ${JSON.stringify(name)}` : ""}). The create may have been interrupted or written a different resource — wrangler's launcher can mask a signal-killed child as exit 0. Refusing to record a wrong/unprovisioned resource; inspect the account/config and retry.`);
+	if (!idOk || !nameOk) throw new Error(`provision: ${spec.command} ${name} reported success but "${configPath}" does not hold the expected ${spec.resource} for binding ${JSON.stringify(binding)} afterward (need a real ${spec.idField}${spec.nameField ? ` and ${spec.nameField} === ${JSON.stringify(name)}` : ""}). The create may have been interrupted or written a different resource. Refusing to record a wrong/unprovisioned resource; inspect the account/config and retry.`);
 }
 /** True when `value` contains an ASCII control character (0x00–0x1F or 0x7F). */
 function hasControlChar(value) {
@@ -1216,9 +1216,9 @@ function hasControlChar(value) {
 	}
 	return false;
 }
-/** The universal option-injection guard for ANY wrangler ARGV positional. */
+/** The universal option-injection guard for ANY Cloudflare operation ARGV positional. */
 function assertNoOptionInjection(kind, name) {
-	if (typeof name !== "string" || name.length === 0 || name.startsWith("-") || hasControlChar(name)) throw new Error(`provision: refusing to pass an unsafe ${kind} name ${JSON.stringify(name)} to wrangler. A name may not be empty, begin with "-" (it would be parsed as a CLI flag), or contain control characters. Rename the resource and retry.`);
+	if (typeof name !== "string" || name.length === 0 || name.startsWith("-") || hasControlChar(name)) throw new Error(`provision: refusing to pass an unsafe ${kind} name ${JSON.stringify(name)} to a Cloudflare operation. A name may not be empty, begin with "-" (it would be parsed as a CLI flag), or contain control characters. Rename the resource and retry.`);
 }
 /** Per-resource Cloudflare naming grammar. KV titles may contain spaces and mixed case. */
 const RESOURCE_NAME_GRAMMARS = {
@@ -1252,7 +1252,7 @@ const RESOURCE_NAME_GRAMMARS = {
 function assertValidResourceName(kind, name) {
 	assertNoOptionInjection(RESOURCE_NAME_GRAMMARS[kind].label, name);
 	const grammar = RESOURCE_NAME_GRAMMARS[kind];
-	if (!grammar.re.test(name)) throw new Error(`provision: refusing to pass an invalid ${grammar.label} name ${JSON.stringify(name)} to wrangler. A ${grammar.label} name must ${grammar.rule}. Rename the resource and retry.`);
+	if (!grammar.re.test(name)) throw new Error(`provision: refusing to pass an invalid ${grammar.label} name ${JSON.stringify(name)} to a Cloudflare operation. A ${grammar.label} name must ${grammar.rule}. Rename the resource and retry.`);
 }
 /** Redactor that replaces the exact connection string and masks any URL userinfo password. */
 function createSecretRedactor(connectionString) {
@@ -1306,7 +1306,7 @@ async function provisionWithProcessSlot(root, rootWranglerPath, desired, opts) {
 					reason: typeof bodyError.message === "string" ? bodyError.message : String(bodyError)
 				});
 			} catch (quarantineError) {
-				throw new AggregateError([bodyError, quarantineError], `provision failed with an unconfirmed wrangler child AND its quarantine metadata could not be persisted — the cross-process provision lock is intentionally still held by this process (not released, not stealable) while the child may live. Primary error: ${bodyError instanceof Error ? bodyError.message : String(bodyError)}; quarantine error: ${quarantineError instanceof Error ? quarantineError.message : String(quarantineError)}.`, { cause: bodyError });
+				throw new AggregateError([bodyError, quarantineError], `provision failed with an unconfirmed Cloudflare operation process AND its quarantine metadata could not be persisted — the cross-process provision lock is intentionally still held by this process (not released, not stealable) while the child may live. Primary error: ${bodyError instanceof Error ? bodyError.message : String(bodyError)}; quarantine error: ${quarantineError instanceof Error ? quarantineError.message : String(quarantineError)}.`, { cause: bodyError });
 			}
 			throw bodyError;
 		}
@@ -1359,19 +1359,19 @@ async function reconcileD1(desired, configPath, runWrangler, write, persistCreat
 				type: "d1.list",
 				configPath
 			}, {});
-			assertDiscoverySucceeded(listResult, "wrangler d1 list");
+			assertDiscoverySucceeded(listResult, "Cloudflare d1 list");
 			const rawList = listResult.data;
-			if (!Array.isArray(rawList)) throw new Error(`provision: "wrangler d1 list --json" did not return a JSON array; cannot verify whether D1 database ${JSON.stringify(name)} exists. Refusing to create a possible duplicate.`);
+			if (!Array.isArray(rawList)) throw new Error(`provision: Cloudflare d1 list did not return a JSON array; cannot verify whether D1 database ${JSON.stringify(name)} exists. Refusing to create a possible duplicate.`);
 			const claimants = validateResourceList(rawList, {
 				resource: "D1 database",
-				command: "wrangler d1 list",
+				command: "Cloudflare d1 list",
 				hasValidId: (member) => reconcileD1IdAliases(member).kind === "id",
 				idRule: "its uuid/database_id aliases must be present, well-formed D1 UUIDs agreeing on one id",
 				nameField: "name",
 				nameLabel: "named"
 			}).map((db) => normalizeD1(db, name)).filter((m) => m.kind !== "other");
-			if (claimants.length > 1) throw new Error(`provision: "wrangler d1 list" returned ${claimants.length} D1 databases named ${JSON.stringify(name)}. D1 database names are account-unique, so this is ambiguous; cannot pick one to adopt and refusing to create a possible duplicate. Inspect the account and retry.`);
-			if (claimants.length === 1 && claimants[0].kind === "claimed-but-invalid") throw new Error(`provision: "wrangler d1 list" returned a D1 database named ${JSON.stringify(name)} with an ambiguous or empty id (conflicting/blank uuid/database_id, or conflicting name aliases). Cannot adopt it, and refusing to create a possible duplicate; inspect the account and retry.`);
+			if (claimants.length > 1) throw new Error(`provision: Cloudflare d1 list returned ${claimants.length} D1 databases named ${JSON.stringify(name)}. D1 database names are account-unique, so this is ambiguous; cannot pick one to adopt and refusing to create a possible duplicate. Inspect the account and retry.`);
+			if (claimants.length === 1 && claimants[0].kind === "claimed-but-invalid") throw new Error(`provision: Cloudflare d1 list returned a D1 database named ${JSON.stringify(name)} with an ambiguous or empty id (conflicting/blank uuid/database_id, or conflicting name aliases). Cannot adopt it, and refusing to create a possible duplicate; inspect the account and retry.`);
 			const existing = claimants.length === 1 && claimants[0].kind === "match" ? claimants[0] : void 0;
 			if (existing) {
 				log.info(`adopted existing D1 database ${name} (${existing.id})`);
@@ -1407,7 +1407,7 @@ async function reconcileD1(desired, configPath, runWrangler, write, persistCreat
 						idValidator: isRealD1Id,
 						nameField: "database_name",
 						resource: "D1 database",
-						command: "wrangler d1 create"
+						command: "Cloudflare d1 create"
 					}, binding, name);
 					persistCreatedConfig();
 					assertD1MigrationsDirApplied(write({ d1MigrationsDir: {
@@ -1426,9 +1426,9 @@ async function reconcileD1(desired, configPath, runWrangler, write, persistCreat
 						name,
 						configPath
 					}, {});
-					assertDiscoverySucceeded(infoResult, `wrangler d1 info ${name}`);
+					assertDiscoverySucceeded(infoResult, `Cloudflare d1 info ${name}`);
 					const info = normalizeD1(isRecord(infoResult.data) ? infoResult.data : void 0, name);
-					if (info.kind !== "match") throw new Error(`provision: "wrangler d1 create ${name}" reported the database already exists, but "wrangler d1 info ${name} --json" did not return a database with a matching name and an unambiguous id. Refusing to adopt an unverified database.`);
+					if (info.kind !== "match") throw new Error(`provision: Cloudflare d1 create ${name} reported the database already exists, but Cloudflare d1 info ${name} did not return a database with a matching name and an unambiguous id. Refusing to adopt an unverified database.`);
 					log.info(`adopted existing D1 database ${name} (${info.id})`);
 					assertD1MigrationsDirApplied(write({
 						d1: {
@@ -1448,7 +1448,7 @@ async function reconcileD1(desired, configPath, runWrangler, write, persistCreat
 						action: "adopted",
 						id: info.id
 					});
-				} else throw new Error(`provision: "wrangler d1 create ${name}" failed: ${created.stderr || created.stdout}`);
+				} else throw new Error(`provision: Cloudflare d1 create ${name} failed: ${created.stderr || created.stdout}`);
 			}
 		}
 		const databaseId = readBindingEntry(configPath, "d1_databases", binding)?.database_id;
@@ -1491,12 +1491,12 @@ async function reconcileKv(desired, configPath, runWrangler, write, persistCreat
 			type: "kv.namespace.list",
 			configPath
 		}, {});
-		assertDiscoverySucceeded(listResult, "wrangler kv namespace list");
+		assertDiscoverySucceeded(listResult, "Cloudflare kv namespace list");
 		const rawList = listResult.data;
-		if (!Array.isArray(rawList)) throw new Error(`provision: "wrangler kv namespace list" did not return a JSON array; cannot verify whether KV namespace ${JSON.stringify(title)} exists. Refusing to create a possible duplicate.`);
+		if (!Array.isArray(rawList)) throw new Error(`provision: Cloudflare kv namespace list did not return a JSON array; cannot verify whether KV namespace ${JSON.stringify(title)} exists. Refusing to create a possible duplicate.`);
 		const matches = validateResourceList(rawList, {
 			resource: "KV namespace",
-			command: "wrangler kv namespace list",
+			command: "Cloudflare kv namespace list",
 			hasValidId: (member) => isRealKvId(member.id),
 			idRule: "its id is missing or not a well-formed 32-hex namespace id",
 			nameField: "title",
@@ -1524,13 +1524,13 @@ async function reconcileKv(desired, configPath, runWrangler, write, persistCreat
 				binding,
 				configPath
 			});
-			if (!isCleanSuccess(created)) throw new Error(`provision: "wrangler kv namespace create ${title}" failed: ${created.stderr || created.stdout}`);
+			if (!isCleanSuccess(created)) throw new Error(`provision: Cloudflare kv namespace create ${title} failed: ${created.stderr || created.stdout}`);
 			assertCreateWroteRealId(configPath, {
 				field: "kv_namespaces",
 				idField: "id",
 				idValidator: isRealKvId,
 				resource: "KV namespace",
-				command: "wrangler kv namespace create"
+				command: "Cloudflare kv namespace create"
 			}, binding, title);
 			persistCreatedConfig();
 			resources.push({
@@ -1563,7 +1563,7 @@ async function reconcileR2(desired, configPath, runWrangler, write, persistCreat
 			}, {});
 			if (isCleanSuccess(info)) {
 				const payload = info.data;
-				if (!isRecord(payload) || payload.name !== bucketName) throw new Error(`provision: "wrangler r2 bucket info ${bucketName} --json" exited 0 but did not identify the requested bucket (expected name ${JSON.stringify(bucketName)}). Refusing to adopt an unverified bucket. Output: ${info.stdout || info.stderr}`);
+				if (!isRecord(payload) || payload.name !== bucketName) throw new Error(`provision: Cloudflare r2 bucket info ${bucketName} exited 0 but did not identify the requested bucket (expected name ${JSON.stringify(bucketName)}). Refusing to adopt an unverified bucket. Output: ${info.stdout || info.stderr}`);
 				log.info(`adopted existing R2 bucket ${bucketName}`);
 				write({ r2: {
 					binding,
@@ -1582,14 +1582,14 @@ async function reconcileR2(desired, configPath, runWrangler, write, persistCreat
 					binding,
 					configPath
 				});
-				if (!isCleanSuccess(created)) throw new Error(`provision: "wrangler r2 bucket create ${bucketName}" failed: ${created.stderr || created.stdout}`);
+				if (!isCleanSuccess(created)) throw new Error(`provision: Cloudflare r2 bucket create ${bucketName} failed: ${created.stderr || created.stdout}`);
 				assertCreateWroteRealId(configPath, {
 					field: "r2_buckets",
 					idField: "bucket_name",
 					idValidator: isValidR2BucketNameFormat,
 					nameField: "bucket_name",
 					resource: "R2 bucket",
-					command: "wrangler r2 bucket create"
+					command: "Cloudflare r2 bucket create"
 				}, binding, bucketName);
 				if (bucketName === R2_BUCKET_NAME_PLACEHOLDER) {
 					const verify = await runWrangler({
@@ -1597,7 +1597,7 @@ async function reconcileR2(desired, configPath, runWrangler, write, persistCreat
 						name: bucketName,
 						configPath
 					}, {});
-					if (!isCleanSuccess(verify) || !isRecord(verify.data) || verify.data.name !== bucketName) throw new Error(`provision: "wrangler r2 bucket create ${bucketName}" reported success but a follow-up "wrangler r2 bucket info ${bucketName}" did not confirm the bucket exists. The create may have been interrupted — wrangler's launcher can mask a signal-killed child as exit 0, and the config entry is indistinguishable from the local-dev placeholder for this name. Refusing to record an unprovisioned bucket; inspect the account and retry.`);
+					if (!isCleanSuccess(verify) || !isRecord(verify.data) || verify.data.name !== bucketName) throw new Error(`provision: Cloudflare r2 bucket create ${bucketName} reported success but a follow-up Cloudflare r2 bucket info ${bucketName} did not confirm the bucket exists. The create may have been interrupted, and the config entry is indistinguishable from the local-dev placeholder for this name. Refusing to record an unprovisioned bucket; inspect the account and retry.`);
 				}
 				persistCreatedConfig();
 				resources.push({
@@ -1606,7 +1606,7 @@ async function reconcileR2(desired, configPath, runWrangler, write, persistCreat
 					name: bucketName,
 					action: "created"
 				});
-			} else throw new Error(`provision: "wrangler r2 bucket info ${bucketName}" failed: ${info.stderr || info.stdout}. Cannot determine whether the bucket exists; refusing to create a possible duplicate.`);
+			} else throw new Error(`provision: Cloudflare r2 bucket info ${bucketName} failed: ${info.stderr || info.stdout}. Cannot determine whether the bucket exists; refusing to create a possible duplicate.`);
 		}
 	}
 }
@@ -1663,7 +1663,7 @@ async function reconcileHyperdrive(desired, configPath, runWrangler, write, pers
 					action: "skipped",
 					reason
 				});
-			} else if (existenceUnknown) throw new Error(`provision: cannot verify whether Hyperdrive config ${JSON.stringify(name)} already exists (no existence check available — provide an accountId + API token, or inject a listHyperdriveConfigs seam). "wrangler hyperdrive create" silently duplicates a same-named config, so provisioning refuses to create it blindly.`);
+			} else if (existenceUnknown) throw new Error(`provision: could not check whether Hyperdrive config ${JSON.stringify(name)} already exists (see the warning above). A create would duplicate a config with the same name, so Void did not create it. Check that CLOUDFLARE_API_TOKEN can read Hyperdrive configs, then retry.`);
 			else {
 				const created = await runWrangler({
 					type: "hyperdrive.create",
@@ -1671,13 +1671,13 @@ async function reconcileHyperdrive(desired, configPath, runWrangler, write, pers
 					binding,
 					configPath
 				}, { input: connectionString });
-				if (!isCleanSuccess(created)) throw new Error(`provision: "wrangler hyperdrive create ${name}" failed: ${created.stderr || created.stdout}`);
+				if (!isCleanSuccess(created)) throw new Error(`provision: Cloudflare hyperdrive create ${name} failed: ${created.stderr || created.stdout}`);
 				assertCreateWroteRealId(configPath, {
 					field: "hyperdrive",
 					idField: "id",
 					idValidator: isRealHyperdriveId,
 					resource: "Hyperdrive config",
-					command: "wrangler hyperdrive create"
+					command: "Cloudflare hyperdrive create"
 				}, binding, name);
 				persistCreatedConfig();
 				resources.push({
@@ -1705,18 +1705,18 @@ async function reconcileQueues(desired, configPath, runWrangler, resources) {
 			});
 			continue;
 		}
-		if (!isConfirmedAbsent(info, "queue")) throw new Error(`provision: "wrangler queues info ${name}" failed or did not confirm the queue exists: ${info.stderr || info.stdout || "no output"}`);
+		if (!isConfirmedAbsent(info, "queue")) throw new Error(`provision: Cloudflare queues info ${name} failed or did not confirm the queue exists: ${info.stderr || info.stdout || "no output"}`);
 		const created = await runWrangler({
 			type: "queues.create",
 			name,
 			configPath
 		});
-		if (!isCleanSuccess(created)) throw new Error(`provision: "wrangler queues create ${name}" failed: ${created.stderr || created.stdout}`);
+		if (!isCleanSuccess(created)) throw new Error(`provision: Cloudflare queues create ${name} failed: ${created.stderr || created.stdout}`);
 		if (!queueInfoConfirmsExists(await runWrangler({
 			type: "queues.info",
 			name,
 			configPath
-		}), name)) throw new Error(`provision: "wrangler queues create ${name}" reported success but "wrangler queues info ${name}" did not confirm the queue exists afterward. The create may have been interrupted — wrangler's launcher can mask a signal-killed child as exit 0. Refusing to record an unprovisioned queue; inspect the account and retry.`);
+		}), name)) throw new Error(`provision: Cloudflare queues create ${name} reported success but Cloudflare queues info ${name} did not confirm the queue exists afterward. The create may have been interrupted. Refusing to record an unprovisioned queue; inspect the account and retry.`);
 		resources.push({
 			kind: "queue",
 			name,
@@ -1750,14 +1750,14 @@ async function provisionCloudflareResourcesLocked(root, configPath, desired, opt
 	const write = (patch) => writeProvisionedWranglerConfig(root, patch, { configPath });
 	const persistCreatedConfig = () => persistMaterializedWranglerConfig(configPath);
 	const hasRemoteWork = !!desired.d1 || desired.kvNamespaces.length > 0 || !!desired.r2 || !!desired.hyperdrive || desired.queues.length > 0;
-	if (hasRemoteWork && !effectiveAccountId) throw new Error("provision: no Cloudflare account is resolvable — set \"account_id\" in your root wrangler config or export CLOUDFLARE_ACCOUNT_ID before deploying. Refusing to provision resources without a pinned account (wrangler would otherwise fall back to an ambient/interactive account that is never persisted, so a later retry could rebind them elsewhere).");
+	if (hasRemoteWork && !effectiveAccountId) throw new Error("provision: no Cloudflare account is resolvable. Set `cloudflare.account_id` in void.config.ts or export CLOUDFLARE_ACCOUNT_ID, then rerun `void deploy`. Void does not provision resources without a pinned account.");
 	if (hasRemoteWork) assertNoTransportRedirectInProjectDotenv(root);
 	if (desired.hyperdrive && !opts?.listHyperdriveConfigs) {
 		const { binding, name, connectionString } = desired.hyperdrive;
 		const entry = readBindingEntry(configPath, "hyperdrive", binding);
 		if (!(entry !== void 0 && isRealHyperdriveId(entry.id)) && !resolveHyperdriveApiToken(opts?.apiToken)) {
-			if (connectionString) throw new Error(`provision: Hyperdrive config ${JSON.stringify(name)} is not in "${configPath}" yet, and creating it needs a Cloudflare API token. wrangler exposes no machine-readable Hyperdrive list, so Void checks the account over the Cloudflare REST API, which a Cloudflare browser OAuth cannot authenticate. Without that check a create would silently duplicate an existing same-named config, so nothing was provisioned. Either (a) export CLOUDFLARE_API_TOKEN with Hyperdrive edit permission and rerun, or (b) create the Hyperdrive config yourself (dashboard / "wrangler hyperdrive create") and add its id to the ${JSON.stringify(binding)} hyperdrive binding in "${configPath}" — deploying an already-provisioned Hyperdrive needs no token.`);
-			throw new Error(`provision: Hyperdrive config ${JSON.stringify(name)} is not in "${configPath}" yet, and there is no DATABASE_URL to create it from. Nothing was provisioned. Either (a) export DATABASE_URL with your PostgreSQL connection string and rerun (Void reads it from the shell — a value in .env/.env.local is NOT used here, so it never ships as a plaintext worker var), or (b) create the Hyperdrive config yourself (dashboard / "wrangler hyperdrive create") and add its id to the ${JSON.stringify(binding)} hyperdrive binding in "${configPath}" — deploying an already-provisioned Hyperdrive needs neither DATABASE_URL nor an API token.`);
+			if (connectionString) throw new Error(`provision: Hyperdrive config ${JSON.stringify(name)} has no ID yet. Before Void creates one, it checks for an existing config with the Cloudflare API. That check needs an API token; a browser login cannot call it. Without the check, a create could duplicate an existing config with the same name, so nothing was provisioned. Either (a) export CLOUDFLARE_API_TOKEN with Hyperdrive edit permission and rerun, or (b) create the Hyperdrive config in the Cloudflare dashboard and add its ID to the ${JSON.stringify(binding)} entry in \`cloudflare.hyperdrive\` in void.config.ts. Deploying an already-provisioned Hyperdrive needs no token.`);
+			throw new Error(`provision: Hyperdrive config ${JSON.stringify(name)} has no ID yet, and there is no DATABASE_URL to create it from. Nothing was provisioned. Either (a) export DATABASE_URL with your PostgreSQL connection string and rerun (Void reads it from the shell — a value in .env/.env.local is NOT used here, so it never ships as a plaintext worker var), or (b) create the Hyperdrive config in the Cloudflare dashboard and add its ID to the ${JSON.stringify(binding)} entry in \`cloudflare.hyperdrive\` in void.config.ts. Deploying an already-provisioned Hyperdrive needs neither DATABASE_URL nor an API token.`);
 		}
 	}
 	let accountIdWritten = false;
@@ -1794,4 +1794,4 @@ async function provisionCloudflareResourcesLocked(root, configPath, desired, opt
 	};
 }
 //#endregion
-export { deleteEnvVarCaseAware as a, isRealKvId as c, resolvePinnedApiBaseUrl as d, createDefaultRunWrangler as i, provisionCloudflareResources as l, assertValidResourceName as n, isQueueConfirmedAbsent as o, checkCloudflareProvisionDrift as r, isRealD1Id as s, assertNoTransportRedirectInProjectDotenv as t, provisionEnv as u };
+export { provisionEnv as _, checkCloudflareProvisionDrift as a, enableD1ReadReplicationViaApi as c, isQueueConfirmedAbsent as d, isRealD1Id as f, provisionCloudflareResources as g, normalizeRunWranglerResult as h, assertValidResourceName as i, isAlreadyGoneKillError as l, isRealKvId as m, acquireProvisionLock as n, createDefaultRunWrangler as o, isRealHyperdriveId as p, assertNoTransportRedirectInProjectDotenv as r, deleteEnvVarCaseAware as s, WranglerQuarantineError as t, isQuarantineError as u, resolvePinnedApiBaseUrl as v, resolveProperLockfileKey as y };

package/dist/r2-conditions-B8xUgJRc.mjs

@@ -0,0 +1,61 @@
+//#region src/runtime/remote/r2-conditions.ts
+/** URI-encoded JSON object metadata that the binding handler sends with a streamed `/r2/get` body. */
+const R2_OBJECT_HEADER = "x-void-r2-object";
+const HTTP_METADATA_FIELDS = /* @__PURE__ */ new Set([
+	"contentType",
+	"contentLanguage",
+	"contentDisposition",
+	"contentEncoding",
+	"cacheControl"
+]);
+function serializeR2Conditional(value) {
+	if (value instanceof Headers) return Array.from(value.entries());
+	return {
+		...value,
+		uploadedBefore: value.uploadedBefore?.toISOString(),
+		uploadedAfter: value.uploadedAfter?.toISOString()
+	};
+}
+function serializeR2HttpMetadata(value) {
+	if (value instanceof Headers) return Array.from(value.entries());
+	return {
+		...value,
+		cacheExpiry: value.cacheExpiry?.toISOString()
+	};
+}
+function parseHeaderEntries(value, message) {
+	if (!value.every((pair) => Array.isArray(pair) && pair.length === 2 && pair.every((item) => typeof item === "string"))) throw new Error(message);
+	return new Headers(value);
+}
+function parseR2Conditional(value) {
+	if (Array.isArray(value)) return parseHeaderEntries(value, "Invalid R2 conditional headers");
+	if (!value || typeof value !== "object") throw new Error("Invalid R2 conditional options");
+	const result = {};
+	for (const [key, entry] of Object.entries(value)) if (key === "etagMatches" || key === "etagDoesNotMatch") {
+		if (typeof entry !== "string") throw new Error(`Invalid R2 condition: ${key}`);
+		result[key] = entry;
+	} else if (key === "uploadedBefore" || key === "uploadedAfter") {
+		if (typeof entry !== "string" || !Number.isFinite(Date.parse(entry))) throw new Error(`Invalid R2 condition: ${key}`);
+		result[key] = new Date(entry);
+	} else if (key === "secondsGranularity") {
+		if (typeof entry !== "boolean") throw new Error(`Invalid R2 condition: ${key}`);
+		result[key] = entry;
+	} else throw new Error(`Unsupported R2 condition: ${key}`);
+	return result;
+}
+/** Like native R2, unknown metadata fields are ignored. */
+function parseR2HttpMetadata(value) {
+	if (Array.isArray(value)) return parseHeaderEntries(value, "Invalid R2 HTTP metadata headers");
+	if (!value || typeof value !== "object") throw new Error("Invalid R2 HTTP metadata");
+	const result = {};
+	for (const [key, entry] of Object.entries(value)) if (key === "cacheExpiry") {
+		if (typeof entry !== "string" || !Number.isFinite(Date.parse(entry))) throw new Error(`Invalid R2 HTTP metadata: ${key}`);
+		result[key] = new Date(entry);
+	} else if (HTTP_METADATA_FIELDS.has(key)) {
+		if (typeof entry !== "string") throw new Error(`Invalid R2 HTTP metadata: ${key}`);
+		result[key] = entry;
+	}
+	return result;
+}
+//#endregion
+export { serializeR2HttpMetadata as a, serializeR2Conditional as i, parseR2Conditional as n, parseR2HttpMetadata as r, R2_OBJECT_HEADER as t };

package/dist/{requests-7W1Pygt2.mjs → requests-Vk5Zyhcy.mjs}

@@ -1,8 +1,8 @@
 import { r as readProjectConfig } from "./project-rqDnVsJN.mjs";
 import { c as getToken } from "./auth-B6iOCjKI.mjs";
 import { H as outro, L as log } from "./dist-BVdsO7Py.mjs";
-import { f as import_picocolors, i as dim } from "./output-Ba6ZbrzY.mjs";
-import { r as PlatformClient } from "./client-DM9Kcf4e.mjs";
+import { f as import_picocolors, i as dim } from "./output-CKguMgr7.mjs";
+import { r as PlatformClient } from "./client-BdzxubTS.mjs";
 //#region src/cli/requests.ts
 async function runRequestsCommand(root, range, status) {
 	console.log();

package/dist/{rollback-BcASVnwP.mjs → rollback-CH4yMQys.mjs}

@@ -1,13 +1,13 @@
 import { n as readDeploymentPlatform, r as readProjectConfig } from "./project-rqDnVsJN.mjs";
 import { c as getToken } from "./auth-B6iOCjKI.mjs";
 import { A as confirm, H as outro, K as select, L as log, O as cancel, tt as isCancel } from "./dist-BVdsO7Py.mjs";
-import { c as formatRelativeTime, i as dim, m as printSuccess, o as formatCount, r as createSpinner } from "./output-Ba6ZbrzY.mjs";
-import { r as PlatformClient } from "./client-DM9Kcf4e.mjs";
+import { c as formatRelativeTime, i as dim, m as printSuccess, o as formatCount, r as createSpinner } from "./output-CKguMgr7.mjs";
+import { r as PlatformClient } from "./client-BdzxubTS.mjs";
 //#region src/cli/rollback.ts
-async function runRollbackCommand(root, deployId) {
+async function runRollbackCommand(root, deployId, explicitPlatform) {
 	console.log();
 	const platform = readDeploymentPlatform(root);
-	if (platform === "cloudflare") return runCloudflareRollback(root, deployId);
+	if (explicitPlatform === "cloudflare" || platform === "cloudflare") return runCloudflareRollback(root, deployId, platform !== "cloudflare");
 	if (platform === "none") throw new Error("rollback: Deployment is disabled. Run `void init` to choose a platform.");
 	const token = getToken(root);
 	if (!token) {
@@ -73,8 +73,8 @@ async function runRollbackCommand(root, deployId) {
 		process.exit(1);
 	}
 }
-async function runCloudflareRollback(root, deployId) {
-	const { activateCloudflareExistingVersion, readCloudflareWorkerStatus, resolveCloudflareOperationContext } = await import("./cloudflare-operations-CrSUFRzJ.mjs");
+async function runCloudflareRollback(root, deployId, restorePlatformFlag) {
+	const { activateCloudflareExistingVersion, readCloudflareWorkerStatus, resolveCloudflareOperationContext } = await import("./cloudflare-operations-BFLCpUCV.mjs");
 	const context = resolveCloudflareOperationContext(root);
 	const status = await readCloudflareWorkerStatus(context);
 	const deployedVersionIds = new Set(status.deployedVersionIds);
@@ -116,7 +116,7 @@ async function runCloudflareRollback(root, deployId) {
 		await confirmRollbackOrExit();
 	} else {
 		const targetSet = new Set(target.metadata.migrations);
-		await confirmUnrevertedMigrations(current.metadata.migrations.filter((migration) => !targetSet.has(migration)), "version");
+		await confirmUnrevertedMigrations(current.metadata.migrations.filter((migration) => !targetSet.has(migration)), "version", restorePlatformFlag);
 	}
 	const spinner = createSpinner();
 	spinner.start("Rolling back...");
@@ -139,11 +139,12 @@ async function confirmRollbackOrExit() {
 	}
 }
 /** List migrations the rollback will not revert and ask before continuing. */
-async function confirmUnrevertedMigrations(migrationDiff, noun) {
+async function confirmUnrevertedMigrations(migrationDiff, noun, restorePlatformFlag = false) {
 	if (migrationDiff.length === 0) return;
 	log.warn(`The current database has ${formatCount(migrationDiff.length, "migration")} applied after this ${noun}:`);
 	for (const migration of migrationDiff) log.message(`  ${dim("•")} ${migration}`);
 	log.message(dim("Rolling back will NOT revert these migrations. The older code will run against the current schema."));
+	if (noun === "version") log.message(dim(`For D1, \`void db restore${restorePlatformFlag ? " --platform cloudflare" : ""} --bookmark <bookmark>\` undoes them with the restore point deploy printed before migrating. Restore points expire after 7 days on Workers Free and 30 days on Paid; undo older migrations with a new migration.`));
 	await confirmRollbackOrExit();
 }
 //#endregion