void 0.20.2 → 0.21.0

package/dist/{list-DEE2S6mY.mjs → list-0wQs0oYg.mjs}

@@ -1,7 +1,9 @@
-import { A as outro, D as log, E as intro, a as dim, c as import_picocolors, o as ensureUtc, r as cliTitle, u as tablePrefix } from "./output-B0cfNSx5.mjs";
-import { S as readProjectConfig, l as getToken, x as readDeploymentPlatform } from "./auth-DPl6kck4.mjs";
-import { n as PlatformClient } from "./client-dHfSJvAN.mjs";
-import { r as resolveProjectBySlug } from "./resolve-project--Vxawf7z.mjs";
+import { a as dim, c as import_picocolors, o as ensureUtc, r as cliTitle, u as tablePrefix } from "./output-urU86XeT.mjs";
+import { c as getToken } from "./auth-B9_D6ygs.mjs";
+import { i as readDeploymentPlatform, o as readProjectConfig } from "./project-CWNIPoXc.mjs";
+import { O as intro, P as outro, j as log } from "./dist-Dn6nn2IU.mjs";
+import { n as PlatformClient } from "./client-PdAJ-F0t.mjs";
+import { r as resolveProjectBySlug } from "./resolve-project-Xvis70DG.mjs";
 //#region src/cli/list.ts
 async function runListCommand(root, slug) {
 	console.log();
@@ -41,7 +43,7 @@ async function runListCommand(root, slug) {
 }
 async function showCloudflareDeployments(root, slug) {
 	if (slug) throw new Error("project: A project name selects a Void platform project and is not used for direct Cloudflare apps.");
-	const { readCloudflareWorkerStatus, resolveCloudflareOperationContext } = await import("./cloudflare-operations-BzWnlC1_.mjs").then((n) => n.t);
+	const { readCloudflareWorkerStatus, resolveCloudflareOperationContext } = await import("./cloudflare-operations-BHNJVDbN.mjs");
 	const status = await readCloudflareWorkerStatus(resolveCloudflareOperationContext(root));
 	if (status.versions.length === 0) {
 		outro(`No deployments for ${status.workerName}.`);

package/dist/live-CB1y5IuC.mjs

@@ -0,0 +1,411 @@
+import { a as getRawRuntimeEnv } from "./env-raw-Cx8ElDdj.mjs";
+import { i as getUser } from "./auth-3sGB0zJ1.mjs";
+//#region src/runtime/live.ts
+let liveBindingName = "VOID_LIVE";
+const registeredStreamIds = /* @__PURE__ */ new Set();
+const DEFAULT_LIMITS = {
+	maxSubscriptionsPerConnection: 256,
+	maxSubscriptionsPerTopic: 256,
+	maxOperationsPerControlRequest: 100,
+	maxQueuedEventsPerConnection: 100,
+	maxEncodedEventSize: 65536,
+	deliveryAttemptTimeoutMs: 1500
+};
+const MAX_SUBSCRIPTIONS_PER_TOPIC = 256;
+function __setLiveBindingName(name) {
+	liveBindingName = assertBindingName(name);
+}
+function __getLiveBindingName() {
+	return liveBindingName;
+}
+function defineLiveStream(options) {
+	const streamId = assertStreamId(options.id);
+	const limits = resolveLiveLimits(options.limits);
+	if (registeredStreamIds.has(streamId)) throw new Error(`live: duplicate stream id "${streamId}".`);
+	registeredStreamIds.add(streamId);
+	async function resolveOwner(ctx, request, connectOptions) {
+		const resolvedUser = connectOptions && "user" in connectOptions ? connectOptions.user : getContextUser(ctx) ?? getUser();
+		const hookContext = {
+			request,
+			env: ctx.env,
+			user: resolvedUser ?? null,
+			owner: connectOptions?.owner ?? null
+		};
+		const owner = (connectOptions && "owner" in connectOptions ? connectOptions.owner : await options.identifyConnection?.(hookContext)) ?? defaultOwner(resolvedUser);
+		if (owner == null && !options.allowAnonymousControl) throw liveResponseError("FORBIDDEN", "live: anonymous control is not enabled.", 403);
+		assertOwner(owner);
+		return {
+			owner,
+			user: resolvedUser ?? null
+		};
+	}
+	async function publishWithEnv(env, topic, data, publishOptions = {}) {
+		const binding = getLiveBinding(env);
+		assertTopic(topic);
+		assertOptionalString("type", publishOptions.type);
+		assertOptionalString("eventId", publishOptions.eventId);
+		assertJsonSerializable(data);
+		const topicKey = await topicDigest(streamId, topic);
+		const id = binding.idFromName(topicInstanceName(streamId, topicKey));
+		const response = await binding.get(id).fetch(internalUrl("/publish"), {
+			method: "POST",
+			body: JSON.stringify({
+				streamId,
+				topic,
+				topicKey,
+				data,
+				type: publishOptions.type,
+				eventId: publishOptions.eventId,
+				limits
+			})
+		});
+		if (!response.ok) {
+			const body = await response.text();
+			const parsed = parseLiveControlResponse(body);
+			if (parsed && !parsed.accepted) throw new Error(`${parsed.error.code}: ${parsed.error.message}`);
+			throw new Error(body || response.statusText);
+		}
+	}
+	return {
+		async connect(ctx, connectOptions) {
+			try {
+				const request = ctx.req.raw;
+				const connectionId = getConnectionId(request);
+				const { owner, user } = await resolveOwner(ctx, request, connectOptions);
+				const decision = await options.onConnect?.({
+					request,
+					env: ctx.env,
+					user,
+					owner,
+					connection: { id: connectionId }
+				});
+				if (decision instanceof Response) return decision;
+				const binding = getLiveBinding(ctx.env);
+				const id = binding.idFromName(connectionInstanceName(streamId, connectionId));
+				return binding.get(id).fetch(internalUrl("/connect"), {
+					method: "POST",
+					body: JSON.stringify({
+						streamId,
+						connectionId,
+						owner,
+						limits
+					})
+				});
+			} catch (error) {
+				return errorToResponse(error);
+			}
+		},
+		async control(ctx, controlOptions) {
+			try {
+				const request = ctx.req.raw;
+				const body = await readControlRequest(request, limits);
+				const { owner, user } = await resolveOwner(ctx, request, controlOptions);
+				const authorized = [];
+				const results = [];
+				for (const entry of body.operations) {
+					if (!entry.ok) {
+						results[entry.index] = entry.result;
+						continue;
+					}
+					const { operation, index } = entry;
+					if (operation.kind === "unsubscribe") {
+						authorized.push({
+							operation,
+							index
+						});
+						continue;
+					}
+					const decision = await options.onSubscribe?.({
+						request,
+						env: ctx.env,
+						user,
+						owner,
+						connection: { id: body.connectionId },
+						subscription: { id: operation.id },
+						topic: operation.topic,
+						lastEventId: operation.lastEventId
+					});
+					if (decision instanceof Response) {
+						results[index] = {
+							ok: false,
+							kind: "subscribe",
+							id: operation.id,
+							error: await responseToControlError(decision)
+						};
+						continue;
+					}
+					authorized.push({
+						operation,
+						index
+					});
+				}
+				if (authorized.length > 0) {
+					const binding = getLiveBinding(ctx.env);
+					const id = binding.idFromName(connectionInstanceName(streamId, body.connectionId));
+					const response = await binding.get(id).fetch(internalUrl("/control"), {
+						method: "POST",
+						body: JSON.stringify({
+							streamId,
+							connectionId: body.connectionId,
+							owner,
+							operations: authorized.map((entry) => entry.operation),
+							limits
+						})
+					});
+					const controlResponse = await response.json();
+					if (!controlResponse.accepted) return Response.json(controlResponse, { status: response.status });
+					for (const [resultIndex, result] of controlResponse.results.entries()) {
+						const operation = authorized[resultIndex];
+						if (operation) results[operation.index] = result;
+					}
+				}
+				for (const entry of body.operations) {
+					if (!entry.ok) continue;
+					const { operation, index } = entry;
+					results[index] ??= {
+						ok: false,
+						kind: operation.kind,
+						id: operation.id,
+						error: {
+							code: "INTERNAL_ERROR",
+							message: "live: missing control result."
+						}
+					};
+				}
+				return Response.json({
+					accepted: true,
+					connectionId: body.connectionId,
+					results
+				});
+			} catch (error) {
+				return errorToResponse(error);
+			}
+		},
+		publish(topic, data, publishOptions) {
+			let env;
+			try {
+				env = getRawRuntimeEnv();
+			} catch {
+				throw new Error("live: publish() was called outside a Void server runtime context. Pass an explicit env with stream.withEnv(env).publish(...).");
+			}
+			return publishWithEnv(env, topic, data, publishOptions);
+		},
+		withEnv(env) {
+			return { publish(topic, data, publishOptions) {
+				return publishWithEnv(env, topic, data, publishOptions);
+			} };
+		}
+	};
+}
+function defaultOwner(user) {
+	if (user && typeof user === "object" && "id" in user && typeof user.id === "string") return `user:${user.id}`;
+	return null;
+}
+function getContextUser(ctx) {
+	try {
+		return ctx.get("user");
+	} catch {
+		return null;
+	}
+}
+function parseLiveControlResponse(body) {
+	try {
+		const parsed = JSON.parse(body);
+		return typeof parsed === "object" && parsed !== null && "accepted" in parsed ? parsed : null;
+	} catch {
+		return null;
+	}
+}
+async function readControlRequest(request, limits) {
+	let body;
+	try {
+		body = await request.json();
+	} catch {
+		throw liveResponseError("BAD_REQUEST", "live: control request body must be JSON.", 400);
+	}
+	if (typeof body !== "object" || body === null || Array.isArray(body)) throw liveResponseError("BAD_REQUEST", "live: control request body must be an object.", 400);
+	const record = body;
+	const connectionId = assertConnectionId(record.connectionId);
+	if (!Array.isArray(record.operations)) throw liveResponseError("BAD_REQUEST", "live: operations must be an array.", 400);
+	if (record.operations.length > limits.maxOperationsPerControlRequest) throw liveResponseError("BAD_REQUEST", "live: too many operations in one control request.", 400);
+	return {
+		connectionId,
+		operations: record.operations.map(parseOperation)
+	};
+}
+function parseOperation(value, index) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) throw liveResponseError("BAD_REQUEST", "live: operation must be an object.", 400);
+	const record = value;
+	if (record.kind === "subscribe") {
+		const id = parseBoundedString(record.id, 1, 256);
+		if (id == null) return invalidOperation(index, "subscribe", record.id, "INVALID_SUBSCRIPTION_ID");
+		const topic = parseBoundedString(record.topic, 1, 512);
+		if (topic == null) return invalidOperation(index, "subscribe", id, "INVALID_TOPIC");
+		let lastEventId;
+		if (record.lastEventId !== void 0) {
+			lastEventId = parseBoundedString(record.lastEventId, 0, 512) ?? void 0;
+			if (lastEventId === void 0) return invalidOperation(index, "subscribe", id, "BAD_REQUEST");
+		}
+		return {
+			ok: true,
+			index,
+			operation: {
+				kind: "subscribe",
+				id,
+				topic,
+				...lastEventId !== void 0 && { lastEventId }
+			}
+		};
+	}
+	if (record.kind === "unsubscribe") {
+		const id = parseBoundedString(record.id, 1, 256);
+		if (id == null) return invalidOperation(index, "unsubscribe", record.id, "INVALID_SUBSCRIPTION_ID");
+		return {
+			ok: true,
+			index,
+			operation: {
+				kind: "unsubscribe",
+				id
+			}
+		};
+	}
+	throw liveResponseError("BAD_REQUEST", "live: operation kind is invalid.", 400);
+}
+function invalidOperation(index, kind, id, code) {
+	return {
+		ok: false,
+		index,
+		result: {
+			ok: false,
+			kind,
+			id: typeof id === "string" ? id : "",
+			error: {
+				code,
+				message: {
+					BAD_REQUEST: "live: invalid control operation.",
+					CONNECTION_CLOSED: "live: connection closed.",
+					CONNECTION_NOT_FOUND: "live: connection not found.",
+					FORBIDDEN: "Forbidden",
+					INVALID_SUBSCRIPTION_ID: "live: invalid subscription id.",
+					INVALID_TOPIC: "live: invalid topic.",
+					OWNER_MISMATCH: "live: owner mismatch.",
+					SUBSCRIPTION_LIMIT: "live: subscription limit reached.",
+					TOPIC_FULL: "live: topic subscription limit reached.",
+					PAYLOAD_TOO_LARGE: "live: payload too large.",
+					INTERNAL_ERROR: "live: internal error."
+				}[code]
+			}
+		}
+	};
+}
+function getLiveBinding(env) {
+	if (typeof env !== "object" || env === null) throw new Error("live: Cloudflare env is unavailable.");
+	const binding = env[liveBindingName];
+	if (!binding) throw new Error(`live: Missing Durable Object binding "${liveBindingName}".`);
+	return binding;
+}
+function getConnectionId(request) {
+	return assertConnectionId(new URL(request.url).searchParams.get("connectionId"));
+}
+function assertStreamId(value) {
+	return assertBoundedString("stream id", value, 1, 128);
+}
+function assertBindingName(value) {
+	if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(value)) throw new Error(`live: invalid Durable Object binding name "${value}".`);
+	return value;
+}
+function assertConnectionId(value) {
+	return assertBoundedString("connectionId", value, 16, 256);
+}
+function assertTopic(value) {
+	return assertBoundedString("topic", value, 1, 512);
+}
+function assertOwner(value) {
+	if (value !== null) assertBoundedString("owner", value, 1, 512);
+}
+function assertOptionalString(name, value) {
+	if (value !== void 0) assertBoundedString(name, value, 1, 512);
+}
+function resolveLiveLimits(input) {
+	const limits = { ...DEFAULT_LIMITS };
+	for (const key of Object.keys(limits)) {
+		const value = input?.[key];
+		if (value === void 0) continue;
+		if (!Number.isFinite(value) || !Number.isInteger(value) || value <= 0) throw new Error(`live: limits.${key} must be a positive finite integer.`);
+		limits[key] = value;
+	}
+	if (limits.maxSubscriptionsPerTopic > MAX_SUBSCRIPTIONS_PER_TOPIC) throw new Error(`live: limits.maxSubscriptionsPerTopic must be at most ${MAX_SUBSCRIPTIONS_PER_TOPIC}.`);
+	return limits;
+}
+function assertBoundedString(name, value, min, max) {
+	const parsed = parseBoundedString(value, min, max);
+	if (parsed == null) throw liveResponseError("BAD_REQUEST", `live: invalid ${name}.`, 400);
+	return parsed;
+}
+function parseBoundedString(value, min, max) {
+	if (typeof value !== "string" || value.length < min || value.length > max || /[\r\n]/.test(value) || value.includes("\0")) return null;
+	return value;
+}
+function assertJsonSerializable(value) {
+	try {
+		if (typeof JSON.stringify(value) !== "string") throw new Error("unsupported value");
+	} catch (error) {
+		throw new Error(`live: payload must be JSON-serializable. ${error instanceof Error ? error.message : String(error)}`);
+	}
+}
+async function topicDigest(streamId, topic) {
+	const bytes = new TextEncoder().encode(`${streamId}\u0000${topic}`);
+	const digest = await crypto.subtle.digest("SHA-256", bytes);
+	const binary = String.fromCharCode(...new Uint8Array(digest));
+	return btoa(binary).replaceAll("+", "-").replaceAll("/", "_").replace(/=+$/, "");
+}
+function connectionInstanceName(streamId, connectionId) {
+	return `live:${streamId}:connection:${connectionId}`;
+}
+function topicInstanceName(streamId, topicKey) {
+	return `live:${streamId}:topic:${topicKey}`;
+}
+function internalUrl(path) {
+	return `https://void.live${path}`;
+}
+var LiveResponseError = class extends Error {
+	code;
+	status;
+	constructor(code, message, status) {
+		super(message);
+		this.code = code;
+		this.status = status;
+	}
+};
+function liveResponseError(code, message, status) {
+	throw new LiveResponseError(code, message, status);
+}
+function errorToResponse(error) {
+	if (error instanceof LiveResponseError) return Response.json({
+		accepted: false,
+		error: {
+			code: error.code,
+			message: error.message
+		}
+	}, { status: error.status });
+	return Response.json({
+		accepted: false,
+		error: {
+			code: "INTERNAL_ERROR",
+			message: error instanceof Error ? error.message : String(error)
+		}
+	}, { status: 500 });
+}
+async function responseToControlError(response) {
+	const message = await response.text().catch(() => "") || response.statusText;
+	if (response.status === 403 || response.status === 401) return {
+		code: "FORBIDDEN",
+		message: message || "Forbidden"
+	};
+	return {
+		code: "BAD_REQUEST",
+		message: message || "Subscription rejected"
+	};
+}
+//#endregion
+export { __setLiveBindingName as n, defineLiveStream as r, __getLiveBindingName as t };

package/dist/live-CKiJilLr.d.mts

@@ -0,0 +1,105 @@
+import { r as AuthUser } from "./auth-DkcFflXV.mjs";
+import { a as CloudEnv, r as CloudContext } from "./handler-BXJTXd02.mjs";
+//#region src/runtime/live.d.ts
+type MaybePromise<T> = T | Promise<T>;
+type LiveControlRequest = {
+  connectionId: string;
+  operations: Array<LiveControlOperation>;
+};
+type LiveControlOperation = {
+  kind: "subscribe";
+  id: string;
+  topic: string;
+  lastEventId?: string;
+} | {
+  kind: "unsubscribe";
+  id: string;
+};
+type LiveControlErrorCode = "BAD_REQUEST" | "CONNECTION_CLOSED" | "CONNECTION_NOT_FOUND" | "FORBIDDEN" | "INVALID_SUBSCRIPTION_ID" | "INVALID_TOPIC" | "OWNER_MISMATCH" | "SUBSCRIPTION_LIMIT" | "TOPIC_FULL" | "PAYLOAD_TOO_LARGE" | "INTERNAL_ERROR";
+type LiveControlError = {
+  code: LiveControlErrorCode;
+  message: string;
+};
+type LiveControlOperationResult = {
+  ok: true;
+  kind: "subscribe" | "unsubscribe";
+  id: string;
+  topic?: string;
+} | {
+  ok: false;
+  kind: "subscribe" | "unsubscribe";
+  id: string;
+  error: LiveControlError;
+};
+type LiveControlResponse = {
+  accepted: true;
+  connectionId: string;
+  results: Array<LiveControlOperationResult>;
+} | {
+  accepted: false;
+  error: LiveControlError;
+};
+type LiveClientEvent<Data = unknown> = {
+  subscriptionId: string;
+  topic: string;
+  type?: string;
+  eventId?: string;
+  data: Data;
+};
+type LivePublishOptions = {
+  type?: string;
+  eventId?: string;
+};
+type LiveConnectOptions = {
+  owner?: string | null;
+  user?: unknown;
+};
+type LiveControlOptions = LiveConnectOptions;
+type LiveHookContext = {
+  request: Request;
+  env: CloudEnv["Bindings"];
+  user: AuthUser | unknown | null;
+  owner: string | null;
+};
+type LiveConnectHookContext = LiveHookContext & {
+  connection: {
+    id: string;
+  };
+};
+type LiveSubscribeHookContext = LiveHookContext & {
+  connection: {
+    id: string;
+  };
+  subscription: {
+    id: string;
+  };
+  topic: string;
+  lastEventId?: string;
+};
+type LiveStreamOptions = {
+  id: string;
+  allowAnonymousControl?: boolean;
+  identifyConnection?: (ctx: LiveHookContext) => MaybePromise<string | null | undefined>;
+  onConnect?: (ctx: LiveConnectHookContext) => MaybePromise<Response | void>;
+  onSubscribe?: (ctx: LiveSubscribeHookContext) => MaybePromise<Response | void>;
+  limits?: Partial<LiveLimits>;
+};
+type LiveLimits = {
+  maxSubscriptionsPerConnection: number;
+  maxSubscriptionsPerTopic: number;
+  maxOperationsPerControlRequest: number;
+  maxQueuedEventsPerConnection: number;
+  maxEncodedEventSize: number;
+  deliveryAttemptTimeoutMs: number;
+};
+type LiveStream = {
+  connect(ctx: CloudContext, options?: LiveConnectOptions): Promise<Response>;
+  control(ctx: CloudContext, options?: LiveControlOptions): Promise<Response>;
+  publish(topic: string, data: unknown, options?: LivePublishOptions): Promise<void>;
+  withEnv(env: unknown): Pick<LiveStream, "publish">;
+};
+declare function __setLiveBindingName(name: string): void;
+declare function __getLiveBindingName(): string;
+declare function defineLiveStream(options: LiveStreamOptions): LiveStream;
+//#endregion
+export { __getLiveBindingName as _, LiveControlErrorCode as a, LiveControlOptions as c, LiveHookContext as d, LiveLimits as f, LiveSubscribeHookContext as g, LiveStreamOptions as h, LiveControlError as i, LiveControlRequest as l, LiveStream as m, LiveConnectHookContext as n, LiveControlOperation as o, LivePublishOptions as p, LiveConnectOptions as r, LiveControlOperationResult as s, LiveClientEvent as t, LiveControlResponse as u, __setLiveBindingName as v, defineLiveStream as y };

package/dist/local-d1-DzykTWY8.mjs

@@ -0,0 +1,104 @@
+import { a as join, i as isAbsolute, u as resolve } from "./dist-4WkAWhWx.mjs";
+import { v as readRootWranglerConfig } from "./wrangler-D01qs6VB.mjs";
+import { r as getMiniflareDatabasePath } from "./runner-BGVsGgkb.mjs";
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { createHash } from "node:crypto";
+//#region src/local-d1.ts
+const LOCAL_D1_STATE_FILE = "local-d1.json";
+const VITE_CONFIG_NAMES = [
+	"vite.config.ts",
+	"vite.config.mts",
+	"vite.config.js",
+	"vite.config.mjs",
+	"vite.config.cts",
+	"vite.config.cjs"
+];
+function readConfiguredDatabaseId(root, bindingName) {
+	let rootConfig;
+	try {
+		rootConfig = readRootWranglerConfig(root);
+	} catch {
+		throw new Error(`db: cannot read malformed Wrangler configuration in ${root}.`);
+	}
+	if (!rootConfig) return;
+	const { configPath, config } = rootConfig;
+	const rawDatabases = config.d1_databases;
+	if (rawDatabases === void 0) return;
+	if (!Array.isArray(rawDatabases)) throw new Error(`db: cannot read ${configPath}: "d1_databases" must be an array.`);
+	if (rawDatabases.some((entry) => entry === null || typeof entry !== "object" || Array.isArray(entry) || typeof entry.binding !== "string" || entry.binding === "")) throw new Error(`db: cannot read ${configPath}: every "d1_databases" entry needs a non-empty binding.`);
+	const matches = rawDatabases.filter((entry) => entry !== null && typeof entry === "object" && !Array.isArray(entry) && entry.binding === bindingName);
+	if (matches.length > 1) throw new Error(`db: cannot select local D1 database: binding ${JSON.stringify(bindingName)} is declared ${matches.length} times in ${configPath}.`);
+	const match = matches[0];
+	if (!match) return;
+	for (const value of [
+		match.preview_database_id,
+		match.database_id,
+		match.binding
+	]) if (typeof value === "string" && value.length > 0) return value;
+}
+function statePath(root) {
+	return join(root, ".void", LOCAL_D1_STATE_FILE);
+}
+function hashFile(path) {
+	return createHash("sha256").update(readFileSync(path)).digest("hex");
+}
+function findViteConfig(root) {
+	return VITE_CONFIG_NAMES.map((name) => join(root, name)).find(existsSync);
+}
+/**
+* Record the persistence directory selected by voidPlugin({ persistTo }). The binding and
+* database ID are deliberately not cached: CLI commands always reread Wrangler configuration.
+*/
+function writeLocalD1PersistState(root, persistTo) {
+	const path = statePath(root);
+	if (persistTo === void 0) {
+		rmSync(path, { force: true });
+		return;
+	}
+	const projectRoot = resolve(root);
+	const viteConfigPath = findViteConfig(projectRoot);
+	const state = {
+		version: 1,
+		projectRoot,
+		persistRoot: isAbsolute(persistTo) ? persistTo : resolve(projectRoot, persistTo),
+		...viteConfigPath ? { viteConfig: {
+			path: viteConfigPath,
+			hash: hashFile(viteConfigPath)
+		} } : {}
+	};
+	mkdirSync(join(projectRoot, ".void"), { recursive: true });
+	writeFileSync(path, `${JSON.stringify(state, null, 2)}\n`);
+}
+function readLocalD1PersistState(root) {
+	const path = statePath(root);
+	if (!existsSync(path)) return;
+	let state;
+	try {
+		state = JSON.parse(readFileSync(path, "utf-8"));
+	} catch {
+		throw new Error(`db: local D1 state in ${path} is invalid. Run \`void dev\` to refresh it.`);
+	}
+	const projectRoot = resolve(root);
+	if (state.version !== 1 || state.projectRoot !== projectRoot || typeof state.persistRoot !== "string" || state.persistRoot.length === 0) throw new Error(`db: local D1 state in ${path} is stale. Run \`void dev\` to refresh it.`);
+	if (state.viteConfig) {
+		const { path: configPath, hash } = state.viteConfig;
+		if (!existsSync(configPath) || hashFile(configPath) !== hash) throw new Error("db: voidPlugin persistence configuration changed since the local D1 state was written. Run `void dev` to refresh it before using `void db`.");
+	}
+	return state;
+}
+function resolveLocalD1Target(root, options = {}) {
+	const projectRoot = resolve(root);
+	const bindingName = options.bindingName ?? "DB";
+	const state = options.readPersistState ? readLocalD1PersistState(projectRoot) : void 0;
+	const selectedPersistRoot = options.persistRoot ?? state?.persistRoot ?? options.defaultPersistRoot ?? join(projectRoot, ".void");
+	const persistRoot = isAbsolute(selectedPersistRoot) ? selectedPersistRoot : resolve(projectRoot, selectedPersistRoot);
+	const databaseId = readConfiguredDatabaseId(projectRoot, bindingName) ?? "local";
+	return {
+		bindingName,
+		databaseId,
+		persistRoot,
+		databasePath: getMiniflareDatabasePath(persistRoot, databaseId)
+	};
+}
+//#endregion
+export { writeLocalD1PersistState as n, resolveLocalD1Target as t };

package/dist/{login-Uvferzmm.mjs → login-CKk5NX4d.mjs}

@@ -1,13 +1,8 @@
-import { n as __exportAll } from "./rolldown-runtime-rQ84J-ij.mjs";
-import { A as outro, C as cancel, D as log, E as intro, I as isCancel, M as select, c as import_picocolors, i as createSpinner, r as cliTitle } from "./output-B0cfNSx5.mjs";
-import { _ as savePlatformToken, d as isStagingMode, g as runPlatformLogin, h as runLogin, l as getToken, m as removeToken, o as getApiUrl, u as getTokenSource, v as saveToken } from "./auth-DPl6kck4.mjs";
-import { a as isExpiredTokenError, n as PlatformClient } from "./client-dHfSJvAN.mjs";
+import { c as import_picocolors, i as createSpinner, r as cliTitle } from "./output-urU86XeT.mjs";
+import { _ as saveToken, a as getApiUrl, c as getToken, g as savePlatformToken, h as runPlatformLogin, l as getTokenSource, m as runLogin, p as removeToken, u as isStagingMode } from "./auth-B9_D6ygs.mjs";
+import { I as select, O as intro, P as outro, T as cancel, W as isCancel, j as log } from "./dist-Dn6nn2IU.mjs";
+import { i as isExpiredTokenError, n as PlatformClient } from "./client-PdAJ-F0t.mjs";
 //#region src/cli/login.ts
-var login_exports = /* @__PURE__ */ __exportAll({
-	promptForLoginToken: () => promptForLoginToken,
-	runLoginCommand: () => runLoginCommand,
-	selectPlatformLoginMethod: () => selectPlatformLoginMethod
-});
 async function selectPlatformLoginMethod(platform, requestedId) {
 	const providers = platform?.authenticationProviders ?? ["github", "google"];
 	const methods = platform?.authentication?.methods ?? providers.map((id) => ({
@@ -34,7 +29,7 @@ async function selectPlatformLoginMethod(platform, requestedId) {
 	return methods.find((method) => method.id === provider);
 }
 async function promptForLoginToken(root = process.cwd(), platform) {
-	const { id: provider, label: providerName } = await selectPlatformLoginMethod(platform ?? await import("./platform-cmd-BFhieCdV.mjs").then(({ discoverPlatform }) => discoverPlatform(getApiUrl(root))));
+	const { id: provider, label: providerName } = await selectPlatformLoginMethod(platform ?? await import("./platform-cmd-C9Vt7m-d.mjs").then(({ discoverPlatform }) => discoverPlatform(getApiUrl(root))));
 	const s = createSpinner();
 	s.start(`Opening browser for ${providerName} login...`);
 	try {
@@ -88,4 +83,4 @@ async function runLoginCommand(root = process.cwd()) {
 	outro(isStagingMode(root) ? "Staging token saved." : "Token saved.");
 }
 //#endregion
-export { selectPlatformLoginMethod as i, promptForLoginToken as n, runLoginCommand as r, login_exports as t };
+export { runLoginCommand as n, selectPlatformLoginMethod as r, promptForLoginToken as t };

package/dist/login-Ch9cgWRF.mjs

@@ -0,0 +1,2 @@
+import { r as selectPlatformLoginMethod } from "./login-CKk5NX4d.mjs";
+export { selectPlatformLoginMethod };