void 0.10.8 → 0.10.11

package/dist/preset-BGrvB4Bl.mjs

@@ -0,0 +1,539 @@
+import { a as join, c as resolve, n as dirname } from "./dist-DaKKDf8D.mjs";
+import { n as readProjectPaths } from "./project-paths-BQd7OmIo.mjs";
+import { i as hasSsrEntry } from "./entry-D7yy4xVH.mjs";
+import { i as readPackageJson, n as hasPackageDependency, t as getPackageDependencies } from "./package-json-Cx1osYo6.mjs";
+import { createRequire } from "node:module";
+import { existsSync, readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+//#region src/shared/dotenv.ts
+/**
+* Shared dotenv parser + variable expander used by every CLI path that reads
+* `.env*` files (`void env check`, `void deploy`, `void init` scaffold
+* inference). A single source of truth avoids the drift we hit when two
+* hand-rolled parsers diverged on quoting / expansion semantics.
+*
+* Expansion supports `${VAR}` and `$VAR`, a `\$VAR` literal-escape, and
+* transitive references across earlier entries in the same record. Cycles
+* are detected and fall through to the raw literal rather than looping.
+*
+* Security note: expansion is deliberately scoped to the in-file record.
+* We do NOT consult `process.env` the way `dotenv-expand` does — a shell
+* env leaking into an `.env.example` via expansion would silently reveal
+* developer machine state in committed output, and `void env check` /
+* `void deploy` would then pass with values that aren't present in CI.
+*
+* The runtime path (Vite's own `loadEnv`) DOES consult `process.env` for
+* expansion. That's a deliberate Vite choice; `filterLoadedEnv` strips
+* shell pollution from the final worker vars so the two sides agree on
+* the observable surface even when expansion sources differ.
+*
+* This module is a leaf — it must not import from `../log` or any non-leaf
+* module so that the prerender subprocess's worker bundle doesn't pick up
+* unwanted transitive dependencies. Warnings are surfaced through the
+* `onWarn` callback and left for the caller to route.
+*/
+/** Valid dotenv key — ASCII letter/underscore followed by letters/digits/underscore. */
+const VALID_KEY = /^[A-Za-z_][A-Za-z0-9_]*$/;
+/**
+* Parse a single `KEY=VALUE` line into `{ key, value }`, stripping matching
+* single/double quotes around the value. Returns `null` for blanks, comments,
+* and non-assignment lines.
+*/
+function parseDotenvLine(line) {
+	const trimmed = line.trim();
+	if (!trimmed || trimmed.startsWith("#")) return null;
+	const equalsIndex = trimmed.indexOf("=");
+	if (equalsIndex === -1) return null;
+	const key = trimmed.slice(0, equalsIndex).trim();
+	let value = trimmed.slice(equalsIndex + 1).trim();
+	if (value.startsWith("\"") && value.endsWith("\"") || value.startsWith("'") && value.endsWith("'")) value = value.slice(1, -1);
+	return {
+		key,
+		value
+	};
+}
+/**
+* Parse the raw contents of a dotenv file into a record, optionally
+* expanding `${VAR}` / `$VAR` references against earlier entries.
+*/
+function parseDotenv(content, options = {}) {
+	const { expand: shouldExpand = true, skipInvalidKeys = true, onWarn } = options;
+	const env = {};
+	for (const line of content.split("\n")) {
+		const parsed = parseDotenvLine(line);
+		if (!parsed) continue;
+		if (!VALID_KEY.test(parsed.key)) {
+			if (skipInvalidKeys) continue;
+			throw new Error(`dotenv: Invalid key '${parsed.key}'.`);
+		}
+		env[parsed.key] = parsed.value;
+	}
+	return shouldExpand ? expandDotenv(env, { onWarn }) : env;
+}
+/**
+* Read and parse a dotenv file. Returns `{}` when the file is missing so
+* callers can treat "no file" and "empty file" identically.
+*/
+function parseDotenvFile(filePath, options = {}) {
+	if (!existsSync(filePath)) return {};
+	return parseDotenv(readFileSync(filePath, "utf-8"), options);
+}
+/**
+* Expand `${VAR}` / `$VAR` references in every value of a record against
+* the other entries in that same record. Matches the surface of
+* `dotenv-expand` minus the `process.env` fallback.
+*
+* Semantics:
+*   - `${VAR}` and `$VAR` both resolve (bare form stops at the first
+*     non-identifier character).
+*   - `\$VAR` stays literal; the backslash is consumed.
+*   - Nested refs resolve transitively — `A=${B}`, `B=${C}`, `C=v` → `A=v`.
+*   - Cycles are detected; the offending value keeps its raw literal and
+*     `onWarn` fires once per cycle seen.
+*   - Missing refs expand to the empty string, matching dotenv-expand.
+*
+* The input record is not mutated; a fresh object is returned.
+*/
+function expandDotenv(input, options = {}) {
+	const out = {};
+	const resolving = /* @__PURE__ */ new Set();
+	const warned = /* @__PURE__ */ new Set();
+	function resolveKey(key) {
+		if (!(key in input)) return "";
+		if (key in out) return out[key];
+		if (resolving.has(key)) {
+			if (!warned.has(key) && options.onWarn) {
+				warned.add(key);
+				options.onWarn(`dotenv expansion cycle detected at "${key}" — leaving raw value in place`);
+			}
+			return input[key];
+		}
+		resolving.add(key);
+		const expanded = expandValue(input[key], resolveKey);
+		resolving.delete(key);
+		out[key] = expanded;
+		return expanded;
+	}
+	for (const key of Object.keys(input)) resolveKey(key);
+	return out;
+}
+/**
+* Expand a single value string. `resolve` returns the fully-expanded value
+* for a referenced key (or `''` when missing). Backslash-escapes (`\$VAR`,
+* `\${VAR}`) keep the `$...` literal and consume the backslash.
+*/
+function expandValue(value, resolve) {
+	let result = "";
+	let cursor = 0;
+	while (cursor < value.length) {
+		const character = value[cursor];
+		if (character === "\\" && cursor + 1 < value.length && value[cursor + 1] === "$") {
+			result += "$";
+			cursor += 2;
+			continue;
+		}
+		if (character !== "$") {
+			result += character;
+			cursor++;
+			continue;
+		}
+		const next = value[cursor + 1];
+		if (next === "{") {
+			const endIndex = value.indexOf("}", cursor + 2);
+			if (endIndex === -1) {
+				result += character;
+				cursor++;
+				continue;
+			}
+			const key = value.slice(cursor + 2, endIndex);
+			if (VALID_KEY.test(key)) result += resolve(key);
+			else result += value.slice(cursor, endIndex + 1);
+			cursor = endIndex + 1;
+			continue;
+		}
+		if (next && /[A-Za-z_]/.test(next)) {
+			let keyEndIndex = cursor + 1;
+			while (keyEndIndex < value.length && /[A-Za-z0-9_]/.test(value[keyEndIndex])) keyEndIndex++;
+			const key = value.slice(cursor + 1, keyEndIndex);
+			result += resolve(key);
+			cursor = keyEndIndex;
+			continue;
+		}
+		result += character;
+		cursor++;
+	}
+	return result;
+}
+/**
+* Merge multiple parsed dotenv records with later-entries-win semantics,
+* then expand across the combined set. This is the recommended path for
+* callers reading multiple `.env*` files (Vite-style precedence), since
+* expansion sees every earlier file's keys at once.
+*/
+function mergeAndExpand(records, options = {}) {
+	const merged = {};
+	for (const record of records) Object.assign(merged, record);
+	return expandDotenv(merged, options);
+}
+/**
+* Wrangler 4.107's bundled `dotenv` LINE regex (verbatim), used ONLY to detect the
+* declared KEYS wrangler would load — including the OPTIONAL `export ` prefix, the `KEY: val`
+* form, and single/double/backtick quoting — so a transport-redirect / config-override fence
+* sees exactly what wrangler's per-command dotenv reload would. We read keys, never values.
+*/
+const WRANGLER_DOTENV_LINE = /(?:^|^)\s*(?:export\s+)?([\w.-]+)(?:\s*=\s*?|:\s+?)(\s*'(?:\\'|[^'])*'|\s*"(?:\\"|[^"])*"|\s*`(?:\\`|[^`])*`|[^#\r\n]+)?\s*(?:#.*)?(?:$|$)/gm;
+/**
+* The set of declared dotenv KEYS in `filePath`, parsed the way wrangler does.
+* Lives in this leaf module (no `proper-lockfile` / lifecycle side effects) so both
+* the provisioner's transport fence and the deploy orchestrator's config-override
+* fence can read keys exactly as wrangler's per-command reload would, without either
+* caller pulling in the provision lifecycle just to parse dotenv keys.
+*/
+function scanWranglerDotenvKeys(filePath) {
+	const keys = /* @__PURE__ */ new Set();
+	if (!existsSync(filePath)) return keys;
+	const content = readFileSync(filePath, "utf-8");
+	WRANGLER_DOTENV_LINE.lastIndex = 0;
+	let match;
+	while ((match = WRANGLER_DOTENV_LINE.exec(content)) !== null) {
+		if (match[1]) keys.add(match[1]);
+		if (match.index === WRANGLER_DOTENV_LINE.lastIndex) WRANGLER_DOTENV_LINE.lastIndex++;
+	}
+	return keys;
+}
+//#endregion
+//#region src/cli/preset.ts
+/**
+* Known output conventions for SSGs.
+* Keyed by the SSG name — detection iterates in insertion order.
+*/
+const SSG_PRESETS = {
+	vitepress: {
+		dep: "vitepress",
+		buildCommand: "vitepress build",
+		outputDir: ".vitepress/dist",
+		appType: "static",
+		resolve(root) {
+			if (existsSync(join(root, "docs/.vitepress"))) return {
+				buildCommand: "vitepress build docs",
+				outputDir: "docs/.vitepress/dist"
+			};
+		}
+	},
+	docusaurus: {
+		dep: "@docusaurus/core",
+		buildCommand: "docusaurus build",
+		outputDir: "build",
+		appType: "static"
+	}
+};
+/**
+* Known output conventions for meta-frameworks.
+* Keyed by the framework name from `detectFramework()`.
+*
+* Class A frameworks (tanstack-start, react-router, vinext) use the project's
+* Vite-compatible build command (`vite build` or `vp build`) and have their
+* output structure determined by the framework's Vite plugin.
+*
+* Class B/C frameworks (sveltekit, nuxt, analog, astro) use their own build CLI
+* and have framework-specific output conventions.
+*/
+const FRAMEWORK_PRESETS = {
+	"tanstack-start": {
+		buildCommand: "vite build",
+		workerDir: "dist/server",
+		workerMain: "index.js",
+		assetsDir: "dist/client"
+	},
+	"react-router": {
+		buildCommand: "vite build",
+		workerDir: "build/server",
+		workerMain: "index.js",
+		assetsDir: "build/client"
+	},
+	"vinext-app": {
+		buildCommand: "vite build",
+		workerDir: "dist/rsc",
+		workerMain: "index.js",
+		assetsDir: "dist/client"
+	},
+	"vinext-pages": {
+		buildCommand: "vite build",
+		workerDir: "dist/ssr",
+		workerMain: "index.js",
+		assetsDir: "dist/client"
+	},
+	sveltekit: {
+		buildCommand: "vite build",
+		workerDir: ".svelte-kit/cloudflare",
+		workerMain: "_worker.js",
+		assetsDir: ".svelte-kit/cloudflare",
+		hashedAssetsPrefix: "_app/immutable",
+		bundle: true
+	},
+	nuxt: {
+		buildCommand: "nuxt build",
+		workerDir: ".output/server",
+		workerMain: "index.mjs",
+		assetsDir: ".output/public",
+		hashedAssetsPrefix: "_nuxt"
+	},
+	analog: {
+		buildCommand: "vite build",
+		workerDir: "dist/analog/server",
+		workerMain: "index.mjs",
+		assetsDir: "dist/analog/public",
+		hashedAssetsPrefix: "assets"
+	},
+	astro: {
+		buildCommand: "astro build",
+		workerDir: "dist/server",
+		workerMain: "entry.mjs",
+		assetsDir: "dist/client",
+		hashedAssetsPrefix: "_astro"
+	}
+};
+/**
+* Resolve a project-local command, rewriting `vite` to `vp` when the project
+* depends on Vite+ and preferring node_modules/.bin when available.
+*/
+function resolveProjectCommand(root, command) {
+	const [bin, ...args] = command.trim().split(/\s+/);
+	const resolvedBin = shellQuoteExecutable(localBin(root, resolveCommandBin(root, bin)));
+	return args.length > 0 ? `${resolvedBin} ${args.join(" ")}` : resolvedBin;
+}
+/**
+* Shell-quote a resolved executable path so it survives being concatenated into
+* a command string. The deploy path runs these via `execSync`/`spawnSync`,
+* which invoke a shell, so a bare absolute path containing a space (e.g. a
+* project root like `/tmp/my app`) would be word-split by the shell and try to
+* exec the wrong binary. Paths with no shell-significant characters are returned
+* unchanged, so ordinary paths stay byte-identical and copy-pasteable; only the
+* executable segment is quoted (the trailing subcommand args are known-safe
+* tokens). Platform-aware: cmd.exe (Windows) uses double quotes, POSIX shells
+* use single quotes.
+*/
+function shellQuoteExecutable(value) {
+	if (process.platform === "win32") return /[\s&|<>^()"]/.test(value) ? `"${value}"` : value;
+	if (/^[A-Za-z0-9_@%+=:,./-]+$/.test(value)) return value;
+	return `'${value.replace(/'/g, "'\\''")}'`;
+}
+/**
+* Resolve the project-local `wrangler` as an ARGV LAUNCHER — an array of tokens
+* `[executable, ...prefixArgs]` meant to be spawned with `shell: false` and the
+* real wrangler subcommand appended as further DISCRETE argv elements.
+*
+* Unlike {@link resolveWranglerCommand} (which returns a shell-quoted STRING for
+* `shell: true` callers), this never builds a shell command line, so untrusted
+* values — resource names, a Postgres connection string riddled with `&`/`$`/`;`,
+* a config path containing spaces — can be passed as their own argv elements and
+* are IMMUNE to shell metacharacter injection/splitting.
+*
+* Resolution order — ALWAYS launches the resolved JS entry as
+* `[process.execPath, <wrangler-dist/cli.js>]`, which is shell-free AND
+* cross-platform (it sidesteps the Windows `.cmd`/`.ps1` shim that Node cannot
+* spawn with `shell: false`):
+*   1. MODULE RESOLUTION of `wrangler/package.json` relative to THIS module (the
+*      `void` package). The provisioner targets wrangler 4.107's EXACT flags,
+*      `--json` shapes, and error strings, so void's own pinned wrangler must be
+*      PREFERRED — an app that hoists an older, incompatible wrangler at its root
+*      must not shadow it. Under strict pnpm (void + consumers use pnpm) void's
+*      wrangler is not at the app root anyway; module resolution finds it wherever
+*      pnpm placed it.
+*   2. FALLBACK: the app-root `node_modules/wrangler` probe, used only when void's
+*      own wrangler cannot be resolved (e.g. a bundled/vendored layout).
+*
+* The resolved entry is wrangler's REAL CLI (`wrangler-dist/cli.js`, its
+* package `main`/`exports["."]`), NOT the `bin.wrangler` WRAPPER. The wrapper
+* (`bin/wrangler.js`) merely does a Node-version guard and then RE-SPAWNS
+* `wrangler-dist/cli.js`, forwarding only SIGINT/SIGTERM to the grandchild (via a
+* default `.kill()` = SIGTERM) and mapping a signal-killed grandchild (`code === null`)
+* to `process.exit(0)`. Launching through it defeats the provisioner's hard command
+* timeout: a `SIGKILL` sent to the wrapper cannot be relayed to the inner CLI, which
+* survives holding the inherited stdio pipes so the parent's `close` never fires; and a
+* killed inner CLI is masked as a clean exit 0. Launching `wrangler-dist/cli.js`
+* DIRECTLY removes that layer entirely — the SIGKILL now hits the real process, and no
+* wrapper can swallow the signal or rewrite the exit code. Bypassing the wrapper is
+* safe: its only behaviors are the version guard (we spawn with the SAME `process.execPath`
+* that already passed it) and an IPC-forwarding channel that is inert here (the runner
+* spawns with `stdio: ['ignore','pipe','pipe']`, so the wrapper's `process.send` would be
+* undefined and forward nothing).
+*
+* If wrangler cannot be resolved by EITHER avenue, throws a clear error — it never
+* degrades to a bare `wrangler` (ENOENT in clean CI) or a `.cmd` shim.
+*/
+function resolveWranglerArgv(root, resolveWranglerPackageJson = defaultResolveWranglerPackageJson) {
+	const jsBin = resolveLocalWranglerJsBin(root, resolveWranglerPackageJson);
+	if (jsBin) return [process.execPath, jsBin];
+	throw new Error("provision: could not resolve the \"wrangler\" package. wrangler ships as a dependency of \"void\"; reinstall dependencies (e.g. `pnpm install`) so it is present, then retry.");
+}
+/**
+* Resolve `wrangler/package.json` via Node module resolution, relative to THIS
+* module (the `void` package), so it is found wherever pnpm placed void's own
+* wrangler dependency. wrangler explicitly exports `./package.json`, so both
+* `import.meta.resolve` and `createRequire().resolve()` succeed. Returns the
+* absolute manifest path, or `undefined` when unresolvable.
+*/
+function defaultResolveWranglerPackageJson() {
+	if (typeof import.meta.resolve === "function") try {
+		return fileURLToPath(import.meta.resolve("wrangler/package.json"));
+	} catch {}
+	try {
+		return createRequire(import.meta.url).resolve("wrangler/package.json");
+	} catch {
+		return;
+	}
+}
+/**
+* Absolute path to wrangler's REAL CLI JS entry (its `package.json` `main` /
+* `exports["."]` → `wrangler-dist/cli.js`, NOT the `bin.wrangler` wrapper — see
+* {@link resolveWranglerArgv} for why we bypass the wrapper), trying the injected
+* module resolver (void's OWN wrangler) FIRST, then falling back to the app-root
+* probe. Returns `undefined` when wrangler cannot be located or its manifest is
+* unreadable.
+*/
+function resolveLocalWranglerJsBin(root, resolveWranglerPackageJson) {
+	const fromVoid = wranglerCliEntryFromPackageJson(resolveWranglerPackageJson());
+	if (fromVoid) return fromVoid;
+	return wranglerCliEntryFromPackageJson(join(root, "node_modules", "wrangler", "package.json"));
+}
+/**
+* Resolve wrangler's REAL CLI entry from its `package.json` at `pkgPath`. Reads the
+* `main` field (`wrangler-dist/cli.js`), falling back to `exports["."]` (its `default`
+* condition, or a bare string), and resolves it to an absolute JS entry relative to the
+* manifest's own directory (so it works for BOTH the app-root probe and module
+* resolution). Deliberately does NOT read `bin.wrangler`: that is the signal-swallowing
+* wrapper the provisioner must bypass. Returns `undefined` on any missing/unreadable/
+* absent-entry case.
+*/
+function wranglerCliEntryFromPackageJson(pkgPath) {
+	if (!pkgPath || !existsSync(pkgPath)) return;
+	try {
+		const rel = wranglerCliRelativeEntry(JSON.parse(readFileSync(pkgPath, "utf-8")));
+		if (!rel) return;
+		const jsEntry = join(dirname(pkgPath), rel);
+		return existsSync(jsEntry) ? jsEntry : void 0;
+	} catch {
+		return;
+	}
+}
+/**
+* The relative CLI entry from a wrangler manifest: `main` first (wrangler 4.107 sets it
+* to `wrangler-dist/cli.js`, which equals `exports["."].default`), then the `.` export
+* (`{ default: string }` or a bare string). Returns `undefined` when neither is a string.
+*/
+function wranglerCliRelativeEntry(pkg) {
+	if (typeof pkg.main === "string" && pkg.main.length > 0) return pkg.main;
+	const exports = pkg.exports;
+	if (exports && typeof exports === "object" && !Array.isArray(exports)) {
+		const dot = exports["."];
+		if (typeof dot === "string" && dot.length > 0) return dot;
+		if (dot && typeof dot === "object" && !Array.isArray(dot)) {
+			const dflt = dot.default;
+			if (typeof dflt === "string" && dflt.length > 0) return dflt;
+		}
+	}
+}
+/**
+* Format a user-facing command string, rewriting `vite` to `vp` when the
+* project depends on Vite+ without expanding to an absolute local bin path.
+*/
+function formatProjectCommand(root, command) {
+	const [bin, ...args] = command.trim().split(/\s+/);
+	const formattedBin = resolveCommandBin(root, bin);
+	return args.length > 0 ? `${formattedBin} ${args.join(" ")}` : formattedBin;
+}
+/**
+* Detect a static deploy preset based on the project root.
+* Returns null when the project requires a full worker deploy.
+*/
+function detectPreset(root, options) {
+	if (options?.dir) return {
+		buildCommand: null,
+		outputDir: resolve(root, options.dir),
+		appType: options.spa ? "spa" : "static"
+	};
+	const pkg = readPackageJson(root);
+	if (pkg) {
+		const allDeps = getPackageDependencies(pkg);
+		for (const preset of Object.values(SSG_PRESETS)) if (preset.dep in allDeps) {
+			const overrides = preset.resolve?.(root);
+			const cmd = overrides?.buildCommand ?? preset.buildCommand;
+			const out = overrides?.outputDir ?? preset.outputDir;
+			return {
+				buildCommand: resolveProjectCommand(root, cmd),
+				outputDir: resolve(root, out),
+				appType: preset.appType
+			};
+		}
+	}
+	if (hasBackendFiles(root)) return null;
+	if (pkg && hasViteLike(pkg)) return {
+		buildCommand: resolveProjectScriptCommand(root, "build") ?? resolveProjectCommand(root, "vite build"),
+		outputDir: resolve(root, "dist"),
+		appType: "spa"
+	};
+	if (existsSync(join(root, "dist/index.html"))) return {
+		buildCommand: null,
+		outputDir: resolve(root, "dist"),
+		appType: options?.spa ? "spa" : "static"
+	};
+	if (existsSync(join(root, "index.html"))) return {
+		buildCommand: null,
+		outputDir: root,
+		appType: options?.spa ? "spa" : "static"
+	};
+	return null;
+}
+/**
+* Resolve a local node_modules/.bin executable path.
+* Falls back to bare command name if the bin doesn't exist locally.
+*/
+function localBin(root, name) {
+	const bin = join(root, "node_modules", ".bin", name);
+	return existsSync(bin) ? bin : name;
+}
+function resolveCommandBin(root, name) {
+	if (name === "vite") return detectViteBinary(root);
+	return name;
+}
+function detectPackageManager(root) {
+	if (existsSync(join(root, "pnpm-lock.yaml"))) return "pnpm";
+	if (existsSync(join(root, "yarn.lock"))) return "yarn";
+	if (existsSync(join(root, "bun.lock")) || existsSync(join(root, "bun.lockb"))) return "bun";
+	return "npm";
+}
+function resolveProjectScriptCommand(root, scriptName) {
+	const script = readPackageJson(root)?.scripts;
+	if (!script || typeof script !== "object" || Array.isArray(script)) return null;
+	if (typeof script[scriptName] !== "string") return null;
+	switch (detectPackageManager(root)) {
+		case "pnpm": return `pnpm ${scriptName}`;
+		case "yarn": return `yarn ${scriptName}`;
+		case "bun": return `bun run ${scriptName}`;
+		default: return `npm run ${scriptName}`;
+	}
+}
+function hasViteLike(pkg) {
+	return hasPackageDependency(pkg, "vite") || hasPackageDependency(pkg, "vite-plus");
+}
+function detectViteBinary(root) {
+	const pkg = readPackageJson(root);
+	if (pkg && hasPackageDependency(pkg, "vite-plus")) return "vp";
+	return "vite";
+}
+/**
+* Check whether the project has backend files that require a full worker deploy.
+*/
+function hasBackendFiles(root) {
+	const paths = readProjectPaths(root);
+	if (existsSync(paths.routesDir)) return true;
+	if (existsSync(paths.pagesDir)) return true;
+	if (existsSync(paths.middlewareDir)) return true;
+	if (existsSync(paths.cronsDir)) return true;
+	if (existsSync(paths.queuesDir)) return true;
+	if (hasSsrEntry(root, paths)) return true;
+	return false;
+}
+//#endregion
+export { resolveProjectCommand as a, mergeAndExpand as c, hasBackendFiles as i, parseDotenvFile as l, detectPreset as n, resolveWranglerArgv as o, formatProjectCommand as r, expandDotenv as s, FRAMEWORK_PRESETS as t, scanWranglerDotenvKeys as u };

package/dist/{project-cmd-DnU7u9QF.mjs → project-cmd-D_w-4w5B.mjs}

@@ -1,5 +1,5 @@
-import { D as outro, T as log, a as cliTitle, f as tablePrefix, s as dim, u as import_picocolors, w as intro } from "./agents-Bmr5tFFb.mjs";
-import { d as getSiteDomain, f as getToken, n as PlatformClient } from "./client-Cj96iiBH.mjs";
+import { D as outro, T as log, a as cliTitle, f as tablePrefix, s as dim, u as import_picocolors, w as intro } from "./agents-CtgBYqld.mjs";
+import { d as getSiteDomain, f as getToken, n as PlatformClient } from "./client-Gb71-XkG.mjs";
 //#region src/cli/projects.ts
 async function runProjectsCommand(root) {
 	console.log();
@@ -33,32 +33,36 @@ async function runProjectsCommand(root) {
 //#region src/cli/project-cmd.ts
 async function runProjectCommand(root, args) {
 	if (args.subcommand === "status") {
-		const { runListCommand } = await import("./list-3GEw7b6m.mjs");
+		const { runListCommand } = await import("./list-CPwFDZ_c.mjs");
 		return runListCommand(root, args.name || void 0);
 	}
 	if (args.subcommand === "link") {
-		const { runLink } = await import("./link-CUmiosyb.mjs");
+		const { runLink } = await import("./link-CdGHSIy-.mjs");
 		return runLink(root, args.name || void 0);
 	}
 	if (args.subcommand === "list") return runProjectsCommand(root);
 	if (args.subcommand === "logs") {
-		const { runLogsCommand } = await import("./logs-D-rQ56Lq.mjs");
+		const { runLogsCommand } = await import("./logs-Bt313ax7.mjs");
 		return runLogsCommand(root, args.filter, args.range, args.deployment || void 0, args.level || void 0);
 	}
+	if (args.subcommand === "requests") {
+		const { runRequestsCommand } = await import("./requests-B8sZxaFM.mjs");
+		return runRequestsCommand(root, args.range, args.status || void 0);
+	}
 	if (args.subcommand === "rollback") {
-		const { runRollbackCommand } = await import("./rollback-Yh7bCKob.mjs");
+		const { runRollbackCommand } = await import("./rollback-CkvTFXx5.mjs");
 		return runRollbackCommand(root, args.deployId || void 0);
 	}
 	if (args.subcommand === "cancel") {
-		const { runCancelDeployCommand } = await import("./cancel-deploy-BEBOEgtu.mjs");
+		const { runCancelDeployCommand } = await import("./cancel-deploy-fwFYF04b.mjs");
 		return runCancelDeployCommand(root, args.deployId || void 0);
 	}
 	if (args.subcommand === "delete") {
-		const { runDeleteCommand } = await import("./delete-D2kr3Kmk.mjs");
+		const { runDeleteCommand } = await import("./delete-mh6p-zkQ.mjs");
 		return runDeleteCommand(root, args.name || void 0, { force: args.force });
 	}
 	if (args.subcommand === "purge-cache") {
-		const { runPurgeCacheCommand } = await import("./cache-wH-mP8UE.mjs");
+		const { runPurgeCacheCommand } = await import("./cache-C11V8Fxq.mjs");
 		return runPurgeCacheCommand(root, args.projectSlug || void 0);
 	}
 }

package/dist/{project-paths-tpdR1mJR.mjs → project-paths-BQd7OmIo.mjs}

@@ -1,4 +1,4 @@
-import { a as join, i as isAbsolute, o as normalize, s as relative } from "./pathe.M-eThtNZ-CQzLbt4c.mjs";
+import { a as join, i as isAbsolute, o as normalize, s as relative } from "./dist-DaKKDf8D.mjs";
 import { existsSync, readFileSync } from "node:fs";
 //#region src/project-paths.ts
 const SOURCE_CONVENTION_DIRECTORIES = [

package/dist/project-paths-GpziKeQQ.d.mts

@@ -0,0 +1,25 @@
+import { RewriteDestination } from "void/routes";
+
+//#region src/project-paths.d.ts
+type ProjectPaths = {
+  root: string;
+  sourceDir: string;
+  sourceRoot: string;
+  routesDir: string;
+  middlewareDir: string;
+  cronsDir: string;
+  queuesDir: string;
+  pagesDir: string;
+  dbDir: string;
+  migrationsDir: string;
+  schemaFile: string;
+  schemaDir: string;
+  srcDir: string;
+  ssrDir: string;
+  sourceRelative: (path: string) => string;
+  authConfigCandidates: ReadonlyArray<string>;
+  envFileCandidates: ReadonlyArray<string>;
+};
+declare function resolvePagesDir(root?: string): string;
+//#endregion
+export { resolvePagesDir as n, ProjectPaths as t };

package/dist/{project-tsconfig-D9uSVVpA.mjs → project-tsconfig-B-QtXjLQ.mjs}

@@ -1,5 +1,5 @@
-import { a as join, n as dirname, s as relative } from "./pathe.M-eThtNZ-CQzLbt4c.mjs";
-import { n as readProjectPaths } from "./project-paths-tpdR1mJR.mjs";
+import { a as join, n as dirname, s as relative } from "./dist-DaKKDf8D.mjs";
+import { n as readProjectPaths } from "./project-paths-BQd7OmIo.mjs";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 //#region src/codegen/write-if-changed.ts
 function writeFileIfChanged(path, content) {

package/dist/{protocol-6hTJ04T1.d.mts → protocol-Bnb0LFp3.d.mts}

@@ -1,5 +1,5 @@
 import { n as HeadDescriptor, t as HeadConfig } from "./head-nmvOgFjd.mjs";
-import { n as CloudBindings, r as CloudContext } from "./handler-imD0UVDT.mjs";
+import { n as CloudBindings, r as CloudContext } from "./handler-Cjh8uM3Y.mjs";
 import { a as PageRenderMode, t as DevCssAsset } from "./types-lLjNE9Qp.mjs";
 
 //#region src/pages/protocol.d.ts