void 0.20.3 → 0.21.1

package/dist/migrate-BV8qHiCb.mjs

@@ -0,0 +1,285 @@
+import { a as join, n as dirname } from "./dist-4WkAWhWx.mjs";
+import { r as cliTitle } from "./output-CCH48AMM.mjs";
+import { o as TYPED_CONFIG_FILE, s as loadTypedVoidConfigFile } from "./project-paths-CKQ-Q5JS.mjs";
+import { g as validateConfig } from "./config-Dxr6cTXn.mjs";
+import { B as seedCloudflareConfig, I as VOID_LOCK_FILE, V as stashCloudflareDeployPointer } from "./wrangler-D01qs6VB.mjs";
+import { O as intro, P as outro, j as log } from "./dist-Dn6nn2IU.mjs";
+import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, unlinkSync, writeFileSync } from "node:fs";
+import { randomUUID } from "node:crypto";
+import { parse, parseTree } from "jsonc-parser";
+import { isDeepStrictEqual } from "node:util";
+import { parseExpressionAt } from "acorn";
+//#region src/cli/framework-config-migrate.ts
+const GENERATED_PATH = "./.void-wrangler.jsonc";
+const CONFIG_FILES = [
+	"vite.config.ts",
+	"vite.config.js",
+	"vite.config.mts",
+	"vite.config.mjs",
+	"vite.config.cts",
+	"vite.config.cjs",
+	"svelte.config.ts",
+	"svelte.config.js",
+	"astro.config.ts",
+	"astro.config.mjs",
+	"astro.config.js",
+	"astro.config.mts",
+	"nuxt.config.ts",
+	"nuxt.config.mjs",
+	"nuxt.config.js",
+	"nuxt.config.mts"
+];
+/** Find an adapter's explicit root Wrangler JSON file, including custom build filenames. */
+function discoverFrameworkWranglerFiles(root) {
+	const names = /* @__PURE__ */ new Set();
+	for (const file of CONFIG_FILES) {
+		const path = join(root, file);
+		if (!existsSync(path)) continue;
+		const source = readFileSync(path, "utf8");
+		if (!source.includes("@sveltejs/adapter-cloudflare") && !source.includes("@astrojs/cloudflare") && !source.includes("nitro-cloudflare-dev")) continue;
+		for (const match of source.matchAll(/\b(?:configPath|config)\s*:\s*(['"])(?:\.\/)?(wrangler[A-Za-z0-9._-]*\.jsonc?)\1/g)) {
+			const name = match[2];
+			if (existsSync(join(root, name))) names.add(name);
+		}
+	}
+	return [...names];
+}
+function property(object, key) {
+	return object.properties?.find((item) => item.type === "Property" && !item.computed && item.kind === "init" && (item.key?.name === key || item.key?.value === key))?.value;
+}
+function setPath(object, key, file, edits, legacyName) {
+	const value = property(object, key);
+	if (!value) edits.push({
+		start: object.start + 1,
+		end: object.start + 1,
+		text: `${key}: '${GENERATED_PATH}', `
+	});
+	else if (value.type === "Literal" && typeof value.value === "string" && ([
+		"wrangler.jsonc",
+		"wrangler.json",
+		legacyName
+	].includes(value.value.replace(/^\.\//, "")) || value.value === GENERATED_PATH)) edits.push({
+		start: value.start,
+		end: value.end,
+		text: `'${GENERATED_PATH}'`
+	});
+	else throw new Error(`migrate: Update ${file} to pass ${GENERATED_PATH} to its Cloudflare adapter before removing the root Wrangler config.`);
+}
+function patchAdapterCall(source, identifier, file, kind, legacyName) {
+	const candidates = [...source.matchAll(new RegExp(`\\b${identifier}\\s*\\(`, "g"))];
+	const calls = [];
+	for (const candidate of candidates) try {
+		const parsed = parseExpressionAt(source, candidate.index, {
+			ecmaVersion: "latest",
+			sourceType: "module"
+		});
+		const first = parsed.expressions?.[0];
+		const node = parsed.type === "SequenceExpression" && source.slice(0, candidate.index).trimEnd().endsWith(":") && first?.type === "CallExpression" && /^\s*,/.test(source.slice(first.end)) ? first : parsed;
+		if (node.type === "CallExpression" && node.callee?.name === identifier) calls.push(node);
+	} catch {}
+	if (calls.length !== 1) throw new Error(`migrate: Update ${file} to pass ${GENERATED_PATH} to its Cloudflare adapter before removing the root Wrangler config.`);
+	const call = calls[0];
+	const args = call.arguments ?? [];
+	if (args.length > 1 || args.length === 1 && args[0]?.type !== "ObjectExpression") throw new Error(`migrate: Update ${file} to pass ${GENERATED_PATH} to its Cloudflare adapter before removing the root Wrangler config.`);
+	if (args.length === 0) {
+		const options = kind === "svelte" ? `{ config: '${GENERATED_PATH}', platformProxy: { configPath: '${GENERATED_PATH}' } }` : `{ configPath: '${GENERATED_PATH}' }`;
+		return `${source.slice(0, call.end - 1)}${options}${source.slice(call.end - 1)}`;
+	}
+	const options = args[0];
+	const edits = [];
+	if (kind === "astro") setPath(options, "configPath", file, edits, legacyName);
+	else {
+		setPath(options, "config", file, edits, legacyName);
+		const proxy = property(options, "platformProxy");
+		if (!proxy) edits.push({
+			start: options.start + 1,
+			end: options.start + 1,
+			text: `platformProxy: { configPath: '${GENERATED_PATH}' }, `
+		});
+		else if (proxy.type === "ObjectExpression") setPath(proxy, "configPath", file, edits, legacyName);
+		else throw new Error(`migrate: Update ${file} to pass ${GENERATED_PATH} to its Cloudflare adapter before removing the root Wrangler config.`);
+	}
+	return edits.sort((a, b) => b.start - a.start).reduce((result, edit) => `${result.slice(0, edit.start)}${edit.text}${result.slice(edit.end)}`, source);
+}
+/** Plan only edits whose adapter call can be identified without changing authored options. */
+function planFrameworkConfigMigration(root, legacyName) {
+	const patches = [];
+	for (const file of CONFIG_FILES) {
+		const path = join(root, file);
+		if (!existsSync(path)) continue;
+		const original = readFileSync(path, "utf8");
+		let updated = original;
+		const svelteImport = /import\s+(\w+)\s+from\s+['"]@sveltejs\/adapter-cloudflare['"]/.exec(original);
+		if (svelteImport) {
+			const identifier = svelteImport[1];
+			updated = patchAdapterCall(updated, identifier, file, "svelte", legacyName);
+		} else if (/(?:from\s*['"]|require\(\s*['"]|import\(\s*['"])@sveltejs\/adapter-cloudflare['"]/.test(original)) throw new Error(`migrate: Update ${file} to pass ${GENERATED_PATH} to its Cloudflare adapter before removing the root Wrangler config.`);
+		const astroImport = /import\s+(\w+)\s+from\s+['"]@astrojs\/cloudflare['"]/.exec(original);
+		if (astroImport) {
+			const identifier = astroImport[1];
+			updated = patchAdapterCall(updated, identifier, file, "astro", legacyName);
+		} else if (/(?:from\s*['"]|require\(\s*['"]|import\(\s*['"])@astrojs\/cloudflare['"]/.test(original)) throw new Error(`migrate: Update ${file} to pass ${GENERATED_PATH} to its Cloudflare adapter before removing the root Wrangler config.`);
+		if (original.includes("nitro-cloudflare-dev") && !original.includes("cloudflareDev:")) {
+			const preset = /preset:\s*['"]cloudflare-module['"]\s*,/g;
+			if ([...updated.matchAll(preset)].length !== 1) throw new Error(`migrate: Set nitro.cloudflareDev.configPath to ${GENERATED_PATH} in ${file} before removing the root Wrangler config.`);
+			updated = updated.replace(preset, (match) => `${match}\n        cloudflareDev: { configPath: '${GENERATED_PATH}' },`);
+		} else if (original.includes("nitro-cloudflare-dev") && original.includes("cloudflareDev:") && !original.includes(`configPath: '${GENERATED_PATH}'`) && !original.includes(`configPath: "${GENERATED_PATH}"`)) {
+			const rootPath = /configPath:\s*(['"])(?:\.\/)?([^'"]+)\1/g;
+			const names = /* @__PURE__ */ new Set([
+				"wrangler.jsonc",
+				"wrangler.json",
+				legacyName
+			]);
+			const matches = [...updated.matchAll(rootPath)].filter((match) => names.has(match[2]));
+			if (matches.length !== 1) throw new Error(`migrate: Set nitro.cloudflareDev.configPath to ${GENERATED_PATH} in ${file} before removing the root Wrangler config.`);
+			const match = matches[0];
+			updated = updated.slice(0, match.index) + `configPath: '${GENERATED_PATH}'` + updated.slice(match.index + match[0].length);
+		}
+		if (updated !== original) patches.push({
+			file,
+			original,
+			updated
+		});
+	}
+	return patches;
+}
+function applyFrameworkConfigMigration(root, patches) {
+	for (const patch of patches) {
+		const path = join(root, patch.file);
+		if (readFileSync(path, "utf8") !== patch.original) throw new Error(`migrate: ${patch.file} changed during migration. Retry.`);
+		const backup = join(root, ".void", "config-migration", patch.file);
+		mkdirSync(dirname(backup), { recursive: true });
+		if (!existsSync(backup)) writeFileSync(backup, patch.original, { flag: "wx" });
+		writeFileSync(path, patch.updated);
+	}
+	return patches.length > 0;
+}
+function migrateFrameworkAdapterPaths(root) {
+	if (!existsSync(join(root, "void.config.ts"))) return false;
+	return applyFrameworkConfigMigration(root, planFrameworkConfigMigration(root));
+}
+//#endregion
+//#region src/cli/migrate.ts
+const LEGACY_FILE = "void.json";
+const GENERATED_MARKER = "// Generated by void migrate.";
+const OLD_GENERATED_MARKER = "// Generated from void.json by void migrate.";
+const INIT_GENERATED_MARKER = "// Generated by void init.";
+function parseWranglerJsonc(path, raw) {
+	const source = raw.replace(/^\uFEFF/, "");
+	const errors = [];
+	const parsed = parse(source, errors, { allowTrailingComma: true });
+	if (errors.length > 0 || typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) throw new Error(`migrate: Invalid JSON/JSONC in ${path}. Fix it before migrating.`);
+	function assertUnique(node) {
+		if (!node) return;
+		if (node.type === "object") {
+			const seen = /* @__PURE__ */ new Set();
+			for (const property of node.children ?? []) {
+				const key = property.children?.[0]?.value;
+				if (seen.has(key)) throw new Error(`migrate: Duplicate key ${JSON.stringify(key)} in ${path}. Resolve it before migrating.`);
+				seen.add(key);
+				assertUnique(property.children?.[1]);
+			}
+		} else for (const child of node.children ?? []) assertUnique(child);
+	}
+	assertUnique(parseTree(source));
+	return parsed;
+}
+function backup(root, name, content) {
+	const dir = join(root, ".void", "config-migration");
+	mkdirSync(dir, { recursive: true });
+	const path = join(dir, name);
+	if (!existsSync(path)) writeFileSync(path, content, { flag: "wx" });
+}
+function generatedSource(config) {
+	return `${GENERATED_MARKER}\nimport { defineConfig } from 'void/config';\n\nexport default defineConfig(${JSON.stringify(config, null, 2)});\n`;
+}
+function isOrphanedCompatibilityConfig(root, legacy, typed) {
+	if (!isDeepStrictEqual(legacy, { worker: { compatibility_date: "2026-02-24" } })) return false;
+	const backupPath = join(root, ".void", "config-migration", LEGACY_FILE);
+	if (!existsSync(backupPath)) return false;
+	try {
+		const original = JSON.parse(readFileSync(backupPath, "utf8"));
+		delete original.$schema;
+		return isDeepStrictEqual(original, typed);
+	} catch {
+		return false;
+	}
+}
+function ignoreGeneratedCloudflareConfig(root) {
+	const path = join(root, ".gitignore");
+	const source = existsSync(path) ? readFileSync(path, "utf8") : "";
+	if (source.split(/\r?\n/).some((line) => /^\/?\.void-wrangler\.jsonc$/.test(line.trim()))) return;
+	writeFileSync(path, `${source}${source && !source.endsWith("\n") ? "\n" : ""}.void-wrangler.jsonc\n`);
+}
+/** Move Void and Cloudflare JSON/JSONC settings into a typed, checked-in project config. */
+function migrateLegacyVoidConfig(root) {
+	const legacyPath = join(root, LEGACY_FILE);
+	const wranglerFiles = [.../* @__PURE__ */ new Set([...["wrangler.jsonc", "wrangler.json"].filter((name) => existsSync(join(root, name))), ...discoverFrameworkWranglerFiles(root)])];
+	if (wranglerFiles.length > 1) throw new Error(`migrate: Multiple root Wrangler JSON files exist (${wranglerFiles.join(", ")}). Keep one before migrating.`);
+	if (existsSync(join(root, "wrangler.toml"))) throw new Error("migrate: Wrangler TOML is not supported. Convert it to JSON/JSONC first.");
+	const wranglerName = wranglerFiles[0];
+	const typedPath = join(root, TYPED_CONFIG_FILE);
+	if (!existsSync(legacyPath) && !wranglerName) {
+		if (existsSync(typedPath)) stashCloudflareDeployPointer(root);
+		return false;
+	}
+	const frameworkPatches = planFrameworkConfigMigration(root, wranglerName);
+	const raw = existsSync(legacyPath) ? readFileSync(legacyPath, "utf8") : void 0;
+	let legacy = {};
+	if (raw !== void 0) {
+		try {
+			legacy = JSON.parse(raw);
+		} catch {
+			throw new Error(`migrate: Invalid JSON in ${LEGACY_FILE}. Fix it before migrating.`);
+		}
+		validateConfig(legacy);
+	}
+	const withoutSchema = { ...legacy };
+	delete withoutSchema.$schema;
+	const wranglerRaw = wranglerName ? readFileSync(join(root, wranglerName), "utf8") : void 0;
+	const cloudflare = wranglerName && wranglerRaw !== void 0 ? parseWranglerJsonc(wranglerName, wranglerRaw) : void 0;
+	const hadTyped = existsSync(typedPath);
+	let current;
+	if (hadTyped) {
+		const existing = readFileSync(typedPath, "utf8");
+		if (!existing.startsWith(GENERATED_MARKER) && !existing.startsWith(OLD_GENERATED_MARKER) && !existing.startsWith(INIT_GENERATED_MARKER)) throw new Error(`migrate: ${TYPED_CONFIG_FILE} already exists. Move the legacy settings into it before deleting the old files.`);
+		current = validateConfig(loadTypedVoidConfigFile(typedPath), TYPED_CONFIG_FILE);
+		const currentVoid = { ...current };
+		delete currentVoid.cloudflare;
+		if (raw !== void 0 && !isDeepStrictEqual(currentVoid, withoutSchema) && !isOrphanedCompatibilityConfig(root, withoutSchema, currentVoid)) throw new Error(`migrate: ${LEGACY_FILE} and ${TYPED_CONFIG_FILE} differ. Resolve their settings before retrying.`);
+		if (cloudflare && current.cloudflare !== void 0 && !isDeepStrictEqual(current.cloudflare, cloudflare)) throw new Error(`migrate: Cloudflare settings in ${TYPED_CONFIG_FILE} differ from ${wranglerName}. Resolve them before retrying.`);
+	}
+	const next = { ...current ?? withoutSchema };
+	if (cloudflare) next.cloudflare = cloudflare;
+	const needsTypedWrite = !hadTyped || !isDeepStrictEqual(current, next);
+	const temporaryPath = join(root, `.void.config.${randomUUID()}.ts`);
+	if (needsTypedWrite) writeFileSync(temporaryPath, generatedSource(next), { flag: "wx" });
+	try {
+		if (needsTypedWrite) {
+			const loaded = loadTypedVoidConfigFile(temporaryPath);
+			validateConfig(loaded, TYPED_CONFIG_FILE);
+			if (!isDeepStrictEqual(loaded, next)) throw new Error("migrate: The typed config did not reproduce the original settings.");
+		}
+		if (raw !== void 0) backup(root, LEGACY_FILE, raw);
+		if (wranglerName && wranglerRaw !== void 0) backup(root, wranglerName, wranglerRaw);
+		if (cloudflare && wranglerRaw !== void 0) seedCloudflareConfig(root, cloudflare, wranglerRaw);
+		if (needsTypedWrite) renameSync(temporaryPath, typedPath);
+		applyFrameworkConfigMigration(root, frameworkPatches);
+		if (raw !== void 0) unlinkSync(legacyPath);
+		if (wranglerName) unlinkSync(join(root, wranglerName));
+		ignoreGeneratedCloudflareConfig(root);
+		stashCloudflareDeployPointer(root);
+		return true;
+	} finally {
+		rmSync(temporaryPath, { force: true });
+	}
+}
+async function runMigrateCommand(root) {
+	console.log();
+	intro(cliTitle("migrate"));
+	if (migrateLegacyVoidConfig(root)) log.success(`Migrated project settings to ${TYPED_CONFIG_FILE}. Commit it and ${VOID_LOCK_FILE} when present.`);
+	else log.info("No legacy project configuration found.");
+	outro("Configuration migration complete.");
+}
+//#endregion
+export { migrateFrameworkAdapterPaths as i, runMigrateCommand as n, discoverFrameworkWranglerFiles as r, migrateLegacyVoidConfig as t };

package/dist/migrate-BXY3B3m7.mjs

@@ -0,0 +1,2 @@
+import { n as runMigrateCommand } from "./migrate-BV8qHiCb.mjs";
+export { runMigrateCommand };

package/dist/migration-handler-DM4clYj5.d.mts

@@ -0,0 +1,51 @@
+//#region src/runtime/migration-handler.d.ts
+type MigrationEntry = {
+  name: string;
+  sql: string;
+};
+type MigrationResult = {
+  name: string;
+  applied: boolean;
+  durationMs: number;
+  error?: string;
+  status?: "applied" | "skipped" | "failed";
+  stability?: "stable" | "legacy";
+};
+type MigrationResponse = {
+  ok: boolean;
+  migrations: Array<MigrationResult>;
+  error?: string;
+  protocolVersion?: 2;
+  attemptId?: string;
+  confirmedApplied?: Array<string>;
+  confirmedSkipped?: Array<string>;
+  stability?: "stable" | "legacy";
+  warnings?: Array<string>;
+};
+type MigrationExecutionPlan = {
+  name: string;
+  dialect: "sqlite";
+  classifierVersion: number;
+  sqlHash: string;
+  planHash: string;
+  stability: "stable" | "legacy";
+  warnings?: Array<string>;
+} & ({
+  kind: "single-statement";
+} | {
+  kind: "breakpoint-framed";
+  statements: Array<string>;
+} | {
+  kind: "legacy-unsplit-multi-statement";
+  allowLegacy: boolean;
+});
+type MigrationPlanBundle = {
+  protocolVersion: 2;
+  classifierVersion: number;
+  migrationListHash: string;
+  destructiveValidation: "passed";
+  plans: Array<MigrationExecutionPlan>;
+};
+declare function createMigrationHandler(env: Record<string, unknown>, migrations: Array<MigrationEntry> | undefined, _dialect: "sqlite" | "postgresql" | "mysql", runAuthMigrations?: () => Promise<void>, planBundle?: MigrationPlanBundle): (request: Request) => Promise<Response>;
+//#endregion
+export { createMigrationHandler as i, MigrationResponse as n, MigrationResult as r, MigrationEntry as t };

package/dist/{neon-DHwd2zvC.mjs → neon-n74ta1Pr.mjs}

@@ -1,4 +1,4 @@
-import { defineDatabaseProvider } from "./database-provider.mjs";
+import { t as defineDatabaseProvider } from "./database-provider-Cx525bwX.mjs";
 //#region src/database-providers/neon.ts
 function getConnectionString(payload) {
 	if (!payload || typeof payload !== "object") return;

package/dist/{node-Ez5KW5rn.mjs → node-Cupyf7-s.mjs}

@@ -1,9 +1,9 @@
-import { o as join } from "./dist-BrsS7cai.mjs";
-import { c as loadVoidAuthConfig, s as findVoidAuthConfig } from "./scan-BMH4rzlv.mjs";
-import { f as readConfig } from "./config-uNGuFsI2.mjs";
-import { r as getMiniflareDatabasePath } from "./local-d1-D2I6Ox5F.mjs";
-import { a as resolveVoidAuthMigrationSchema } from "./route-types-Da-DpyUp.mjs";
-import { a as loadLocalEnv } from "./env-DBKmK4vc.mjs";
+import { a as join } from "./dist-4WkAWhWx.mjs";
+import { n as loadVoidAuthConfig, t as findVoidAuthConfig } from "./config-uP7ZDtVZ.mjs";
+import { m as readConfig } from "./config-Dxr6cTXn.mjs";
+import { r as getMiniflareDatabasePath } from "./runner-BGVsGgkb.mjs";
+import { a as loadLocalEnv } from "./env-DX_v-Q-v.mjs";
+import { r as resolveVoidAuthMigrationSchema } from "./drizzle-Beb2Am5S.mjs";
 import { n as applyPgAuthMigrations, r as applySqliteAuthMigrations, t as applyMySqlAuthMigrations } from "./auth-migrations-9vif1uj8.mjs";
 //#region src/auth/node.ts
 async function runLocalVoidAuthMigrations(root, dialect, persistRoot = join(root, ".void"), databaseId = "local", configPath = findVoidAuthConfig(root)) {

package/dist/{operator-auth-B3e08unv.mjs → operator-auth-BkVgJqv-.mjs}

@@ -1,5 +1,5 @@
-import { K as getActivePlatformConnection, X as normalizePlatformApiUrl, Y as listPlatformConnections, Z as platformCredentialAccount, dt as writeKeyringPassword, lt as deleteKeyringPassword, ut as readKeyringPassword } from "./output-B0cfNSx5.mjs";
-import { n as OperatorClient, r as OperatorClientError } from "./operator-client-LUZnlnYk.mjs";
+import { S as writeKeyringPassword, b as deleteKeyringPassword, c as platformCredentialAccount, o as listPlatformConnections, r as getActivePlatformConnection, s as normalizePlatformApiUrl, x as readKeyringPassword } from "./platform-registry-BJbgZLS1.mjs";
+import { n as OperatorClient, r as OperatorClientError } from "./operator-client-A0iex2yi.mjs";
 /** Operator authority never comes from repository-controlled metadata. */
 function resolveOperatorOrigin(connection = "") {
 	if (connection) {

package/dist/{operator-client-LUZnlnYk.mjs → operator-client-A0iex2yi.mjs}

@@ -1,5 +1,6 @@
-import { B as ensureCloudflaredToken, X as normalizePlatformApiUrl } from "./output-B0cfNSx5.mjs";
 import { t as cfAccessHeaders } from "./cf-access-DRsQRe6k.mjs";
+import { s as normalizePlatformApiUrl } from "./platform-registry-BJbgZLS1.mjs";
+import { t as ensureCloudflaredToken } from "./cf-access-rAZxzMkL.mjs";
 const OPERATOR_MAX_TIMEOUT_MS = 36e5;
 var OperatorClientError = class extends Error {
 	code;

package/dist/{operator-cmd-CKJ7xIRs.mjs → operator-cmd-BwAS2XZt.mjs}

@@ -1,5 +1,5 @@
-import { n as OperatorClient, r as OperatorClientError } from "./operator-client-LUZnlnYk.mjs";
-import { a as resolveOperatorOrigin, i as removeOperatorToken, n as readOperatorApiTokenStdin, o as saveOperatorToken, r as readOperatorToken, t as exchangeOperatorSession } from "./operator-auth-B3e08unv.mjs";
+import { n as OperatorClient, r as OperatorClientError } from "./operator-client-A0iex2yi.mjs";
+import { a as resolveOperatorOrigin, i as removeOperatorToken, n as readOperatorApiTokenStdin, o as saveOperatorToken, r as readOperatorToken, t as exchangeOperatorSession } from "./operator-auth-BkVgJqv-.mjs";
 import { createHash } from "node:crypto";
 import { createInterface } from "node:readline/promises";
 import { setTimeout } from "node:timers/promises";
@@ -137,9 +137,9 @@ async function runAuth(origin, args) {
 	if (args.action === "login" || args.action === "token" && args.tokenStdin) {
 		if (!args.tokenStdin && !process.stdin.isTTY) throw new OperatorClientError("Browser login requires an interactive terminal. Use --token-stdin to exchange an API session.", "interactive_login_required");
 		const apiToken = args.tokenStdin ? await readOperatorApiTokenStdin() : await (async () => {
-			const { discoverPlatform } = await import("./platform-cmd-5q_k56xS.mjs");
-			const { selectPlatformLoginMethod } = await import("./login-WIjNc77c.mjs").then((n) => n.t);
-			const { runPlatformLogin } = await import("./auth-DPl6kck4.mjs").then((n) => n.t);
+			const { discoverPlatform } = await import("./platform-cmd-DE6dw45v.mjs");
+			const { selectPlatformLoginMethod } = await import("./login-BwiopVdg.mjs");
+			const { runPlatformLogin } = await import("./auth-CAw7zHqj.mjs");
 			return runPlatformLogin(origin, (await selectPlatformLoginMethod(await discoverPlatform(origin), args.providerExplicit ? args.provider : void 0)).id, (url) => process.stderr.write(`Sign in at ${url}\n`));
 		})();
 		const session = await exchangeOperatorSession(origin, apiToken);
@@ -279,7 +279,7 @@ async function followOperatorLogs(client, args, signal, pollIntervalMs = 2e3) {
 }
 async function runOperatorCommand(args) {
 	if (!args.action) {
-		const { printHelpPage } = await import("./help-CwOX-zmI.mjs").then((n) => n.n);
+		const { printHelpPage } = await import("./help-B403BLBB.mjs");
 		printHelpPage(["platform", args.group]);
 		return;
 	}

package/dist/output-CCH48AMM.mjs

@@ -0,0 +1,146 @@
+import { n as __toESM, t as __commonJSMin } from "./rolldown-runtime-DXIUcv95.mjs";
+import { L as spinner, j as log, k as isCI } from "./dist-Dn6nn2IU.mjs";
+//#region ../../node_modules/.pnpm/picocolors@1.1.1/node_modules/picocolors/picocolors.js
+var require_picocolors = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	let p = process || {};
+	let argv = p.argv || [];
+	let env = p.env || {};
+	let isColorSupported = !(!!env.NO_COLOR || argv.includes("--no-color")) && (!!env.FORCE_COLOR || argv.includes("--color") || p.platform === "win32" || (p.stdout || {}).isTTY && env.TERM !== "dumb" || !!env.CI);
+	let formatter = (open, close, replace = open) => (input) => {
+		let string = "" + input, index = string.indexOf(close, open.length);
+		return ~index ? open + replaceClose(string, close, replace, index) + close : open + string + close;
+	};
+	let replaceClose = (string, close, replace, index) => {
+		let result = "", cursor = 0;
+		do {
+			result += string.substring(cursor, index) + replace;
+			cursor = index + close.length;
+			index = string.indexOf(close, cursor);
+		} while (~index);
+		return result + string.substring(cursor);
+	};
+	let createColors = (enabled = isColorSupported) => {
+		let f = enabled ? formatter : () => String;
+		return {
+			isColorSupported: enabled,
+			reset: f("\x1B[0m", "\x1B[0m"),
+			bold: f("\x1B[1m", "\x1B[22m", "\x1B[22m\x1B[1m"),
+			dim: f("\x1B[2m", "\x1B[22m", "\x1B[22m\x1B[2m"),
+			italic: f("\x1B[3m", "\x1B[23m"),
+			underline: f("\x1B[4m", "\x1B[24m"),
+			inverse: f("\x1B[7m", "\x1B[27m"),
+			hidden: f("\x1B[8m", "\x1B[28m"),
+			strikethrough: f("\x1B[9m", "\x1B[29m"),
+			black: f("\x1B[30m", "\x1B[39m"),
+			red: f("\x1B[31m", "\x1B[39m"),
+			green: f("\x1B[32m", "\x1B[39m"),
+			yellow: f("\x1B[33m", "\x1B[39m"),
+			blue: f("\x1B[34m", "\x1B[39m"),
+			magenta: f("\x1B[35m", "\x1B[39m"),
+			cyan: f("\x1B[36m", "\x1B[39m"),
+			white: f("\x1B[37m", "\x1B[39m"),
+			gray: f("\x1B[90m", "\x1B[39m"),
+			bgBlack: f("\x1B[40m", "\x1B[49m"),
+			bgRed: f("\x1B[41m", "\x1B[49m"),
+			bgGreen: f("\x1B[42m", "\x1B[49m"),
+			bgYellow: f("\x1B[43m", "\x1B[49m"),
+			bgBlue: f("\x1B[44m", "\x1B[49m"),
+			bgMagenta: f("\x1B[45m", "\x1B[49m"),
+			bgCyan: f("\x1B[46m", "\x1B[49m"),
+			bgWhite: f("\x1B[47m", "\x1B[49m"),
+			blackBright: f("\x1B[90m", "\x1B[39m"),
+			redBright: f("\x1B[91m", "\x1B[39m"),
+			greenBright: f("\x1B[92m", "\x1B[39m"),
+			yellowBright: f("\x1B[93m", "\x1B[39m"),
+			blueBright: f("\x1B[94m", "\x1B[39m"),
+			magentaBright: f("\x1B[95m", "\x1B[39m"),
+			cyanBright: f("\x1B[96m", "\x1B[39m"),
+			whiteBright: f("\x1B[97m", "\x1B[39m"),
+			bgBlackBright: f("\x1B[100m", "\x1B[49m"),
+			bgRedBright: f("\x1B[101m", "\x1B[49m"),
+			bgGreenBright: f("\x1B[102m", "\x1B[49m"),
+			bgYellowBright: f("\x1B[103m", "\x1B[49m"),
+			bgBlueBright: f("\x1B[104m", "\x1B[49m"),
+			bgMagentaBright: f("\x1B[105m", "\x1B[49m"),
+			bgCyanBright: f("\x1B[106m", "\x1B[49m"),
+			bgWhiteBright: f("\x1B[107m", "\x1B[49m")
+		};
+	};
+	module.exports = createColors();
+	module.exports.createColors = createColors;
+}));
+//#endregion
+//#region src/cli/output.ts
+var import_picocolors = /* @__PURE__ */ __toESM(require_picocolors(), 1);
+/** Keep recovery commands on the same CLI when using the local checkout launcher. */
+function cliCommandName() {
+	const entryName = process.argv[1]?.split(/[\\/]/).at(-1);
+	return entryName === "void-dev" || entryName === "void-dev.cmd" ? "void-dev" : "void";
+}
+/**
+* Terminal-safe spinner wrapper. In CI and redirected output,
+* `@clack/prompts` spinner emits DEC Private Mode cursor hide/show codes
+* (`\x1b[?25l` / `\x1b[?25h`) that render as text artifacts. This wrapper
+* replaces the spinner with plain log output.
+*/
+function createSpinner(options, isTerminal = process.stdout.isTTY === true) {
+	if (!isCI() && isTerminal) return spinner(options);
+	let currentMessage = "";
+	return {
+		start(msg = "") {
+			currentMessage = msg;
+			if (msg) log.step(msg);
+		},
+		stop(msg = "") {
+			if (msg) log.info(msg);
+		},
+		message(msg = "") {
+			if (msg && msg !== currentMessage) {
+				currentMessage = msg;
+				log.step(msg);
+			}
+		},
+		cancel(msg = "") {
+			if (msg) log.warn(msg);
+		},
+		error(msg = "") {
+			if (msg) log.error(msg);
+		},
+		clear() {},
+		get isCancelled() {
+			return false;
+		}
+	};
+}
+function cliTitle(command) {
+	return import_picocolors.default.blue(`void ${command}`);
+}
+function sectionTitle(title) {
+	return import_picocolors.default.reset(import_picocolors.default.blue(title));
+}
+function categoryTitle(title) {
+	return import_picocolors.default.reset(import_picocolors.default.bold(import_picocolors.default.cyan(title)));
+}
+function dim(text) {
+	return import_picocolors.default.dim(text);
+}
+function tablePrefix() {
+	return `${import_picocolors.default.gray("│")}  `;
+}
+function helpLine(command, description) {
+	return `${import_picocolors.default.reset(command.padEnd(34))} ${import_picocolors.default.dim(description)}`;
+}
+/**
+* Ensure a timestamp string will be parsed as UTC by `new Date()`.
+* DB timestamps lack timezone info — appends 'Z' only when no
+* existing indicator (Z, z, or numeric offset) is present.
+*/
+function ensureUtc(s) {
+	const last = s.at(-1);
+	if (last === "Z" || last === "z") return s;
+	if (s.includes("+", 10)) return s;
+	if (s.lastIndexOf("-") > 9) return s;
+	return s + "Z";
+}
+//#endregion
+export { dim as a, import_picocolors as c, require_picocolors as d, createSpinner as i, sectionTitle as l, cliCommandName as n, ensureUtc as o, cliTitle as r, helpLine as s, categoryTitle as t, tablePrefix as u };

package/dist/{package-json-CPoWX79C.mjs → package-json-iCbMg5XF.mjs}

@@ -1,4 +1,4 @@
-import { n as dirname, o as join } from "./dist-BrsS7cai.mjs";
+import { a as join, n as dirname } from "./dist-4WkAWhWx.mjs";
 import { existsSync, readFileSync } from "node:fs";
 //#region src/shared/package-json.ts
 const DEFAULT_DEPENDENCY_FIELDS = ["dependencies", "devDependencies"];

package/dist/pages/client.d.mts

@@ -1,5 +1,5 @@
-import { t as PageObject } from "../protocol-C-pqYJjE.mjs";
-import { CacheForInput, CacheForResult } from "./prefetch.mjs";
+import { t as PageObject } from "../protocol-ZH3jP4a7.mjs";
+import { n as CacheForInput, r as CacheForResult } from "../prefetch-Ce6la4EI.mjs";
 //#region src/pages/action-result.d.ts
 type ActionErrorHandlingScope = "callSite" | "boundary";
 type ActionResult<T = PageObject | undefined> = {
@@ -71,6 +71,8 @@ type PageNavigationEngineConfig = {
   viewTransitions: boolean;
   prefetchHoverDelay: number;
   prefetchDefaultCacheFor: CacheForResult;
+  /** Reuse successful GET page shells on later visits, refreshing stale shells in the background. */
+  cacheVisitedPageData?: boolean;
 };
 type PageNavigationResult = {
   pageData: PageData;
@@ -171,6 +173,7 @@ export type VoidRouterConfig = {
   viewTransitions: boolean;
   prefetchHoverDelay: number;
   prefetchDefaultCacheFor: CacheForResult;
+  cacheVisitedPageData?: boolean;
   onRouteChange?(url: string): void;
   onNavigationChange?(navigation: NavigationState): void;
 };

package/dist/pages/client.mjs

@@ -1,5 +1,5 @@
-import { applyClientHead, initClientHead } from "./head-client.mjs";
-import { PrefetchCache, parseCacheFor } from "./prefetch.mjs";
+import { n as initClientHead, t as applyClientHead } from "../head-client-DzmJGN4C.mjs";
+import { n as parseCacheFor, t as PrefetchCache } from "../prefetch-Bsc_Pb6c.mjs";
 //#region src/pages/action-result.ts
 var VoidActionError = class extends Error {
 	body;
@@ -123,7 +123,7 @@ async function fetchPageResponse(fetchUrl, init) {
 	}
 }
 async function createPageNavigationEngine(config) {
-	const { adapter, components, layoutTree, routeMeta, matchRoute, staticPageData: STATIC_PAGE_DATA_ENABLED = false, staticPageDataFastPath: STATIC_PAGE_DATA_FAST_PATH = STATIC_PAGE_DATA_ENABLED, prefetchHoverDelay: PREFETCH_HOVER_DELAY, prefetchDefaultCacheFor: PREFETCH_DEFAULT_CACHE_FOR } = config;
+	const { adapter, components, layoutTree, routeMeta, matchRoute, staticPageData: STATIC_PAGE_DATA_ENABLED = false, staticPageDataFastPath: STATIC_PAGE_DATA_FAST_PATH = STATIC_PAGE_DATA_ENABLED, prefetchHoverDelay: PREFETCH_HOVER_DELAY, prefetchDefaultCacheFor: PREFETCH_DEFAULT_CACHE_FOR, cacheVisitedPageData: CACHE_VISITED_PAGE_DATA = false } = config;
 	const _prefetchCache = new PrefetchCache();
 	const _staticPageDataCacheKeys = /* @__PURE__ */ new Set();
 	let _nextNavigationId = 0;
@@ -492,6 +492,7 @@ async function createPageNavigationEngine(config) {
 				pageData = await response.json();
 				deferredRegistry.setupPending(pageData);
 			}
+			if (CACHE_VISITED_PAGE_DATA && method === "GET" && response?.ok && response.headers.get("X-VoidPages") && pageData?.component === matchRoute(fetchUrl) && !pageData.deferredKeys) _prefetchCache.set(fetchUrl, method, Promise.resolve(clonePageData(pageData)), PREFETCH_DEFAULT_CACHE_FOR);
 		}
 		if (!pageData) throw new Error("pages: Missing page payload.");
 		if (method !== "GET") deferredRegistry.preserveValuesFrom(_committedDeferredRegistry, pageData);
@@ -553,6 +554,7 @@ async function createPageNavigationEngine(config) {
 	}
 	const initialPageData = readInitialPageData(document.getElementById("app"));
 	const [initialComponent, initialLayouts] = await Promise.all([resolveComponent(initialPageData.component), resolveLayouts(initialPageData.component)]);
+	if (CACHE_VISITED_PAGE_DATA && initialPageData.url === _currentFetchUrl && initialPageData.component === matchRoute(_currentFetchUrl) && initialPageData.errors === null && !initialPageData.deferredKeys) _prefetchCache.set(_currentFetchUrl, "GET", Promise.resolve(clonePageData(initialPageData)), PREFETCH_DEFAULT_CACHE_FOR);
 	const initialDeferredRegistry = new DeferredRegistry();
 	initialDeferredRegistry.setupPending(initialPageData);
 	_committedDeferredRegistry = initialDeferredRegistry;