void 0.10.8 → 0.10.11

package/dist/dotenv-D_UbC_vc.mjs

@@ -1,173 +0,0 @@
-import { existsSync, readFileSync } from "node:fs";
-//#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);
-}
-//#endregion
-export { mergeAndExpand as n, parseDotenvFile as r, expandDotenv as t };

package/dist/env-raw-CoS20LHP.mjs

@@ -1,32 +0,0 @@
-import { AsyncLocalStorage } from "node:async_hooks";
-//#region src/runtime/env-raw.ts
-/**
-* Raw runtime env resolution — framework-internal only.
-*
-* This module is NOT exported in package.json, so it cannot be imported
-* via "void/..." subpaths. Only framework modules using relative imports
-* (isr.ts, ai.ts, env.ts) can access it.
-*/
-/** Prefixes for platform-internal bindings that must be hidden from user code. */
-const INTERNAL_BINDING_PREFIXES = ["__VOID_", "__PROJECT_"];
-const envContext = new AsyncLocalStorage();
-let cloudflareEnv;
-if (typeof navigator !== "undefined" && navigator.userAgent === "Cloudflare-Workers") import("cloudflare:workers").then((mod) => {
-	cloudflareEnv = asEnv(mod.env) ?? void 0;
-}).catch(() => {});
-function asEnv(value) {
-	if (typeof value !== "object" || value === null) return null;
-	if ("then" in value && typeof value.then === "function") return null;
-	return value;
-}
-function getNuxtEnv() {
-	return asEnv(globalThis.__env__);
-}
-/** Resolve raw env from AsyncLocalStorage, Nuxt globals, or CF module env. */
-function getRawRuntimeEnv() {
-	return envContext.getStore() ?? getNuxtEnv() ?? cloudflareEnv ?? (() => {
-		throw new Error("env: Cloudflare env is unavailable. Use void runtime bindings inside Nuxt/SvelteKit/Analog server request handlers or Worker handlers.");
-	})();
-}
-//#endregion
-export { getRawRuntimeEnv as i, asEnv as n, envContext as r, INTERNAL_BINDING_PREFIXES as t };

package/dist/env-validation-CeC2FL66.mjs

@@ -1,163 +0,0 @@
-import { a as join } from "./pathe.M-eThtNZ-CQzLbt4c.mjs";
-import { i as voidWarn } from "./log-ChfPKsVd.mjs";
-import { n as mergeAndExpand, r as parseDotenvFile } from "./dotenv-D_UbC_vc.mjs";
-import { t as findEnvFile } from "./env-types-D51bnR-c.mjs";
-import { pathToFileURL } from "node:url";
-//#region src/host/load-user-env.ts
-/**
-* Loader for the user's `env.ts`.
-*
-* Uses Node's native `import()` (type-stripping is on by default in the
-* supported Node version), so only relative imports and bare package
-* specifiers resolve. tsconfig path aliases (`@/foo`, `~/foo`) are NOT
-* supported — if the user writes one, we detect the resulting resolution
-* error and re-throw with guidance pointing at the offending specifier.
-*
-* Used by:
-*   - `plugin-env-schema.ts` (dev plugin, HMR re-imports)
-*   - `cli/env-validation.ts` (deploy + `void env check`)
-*
-* Side-effect contract: loading the file evaluates the user's `defineEnv`
-* call, which registers the schema in the singleton state in
-* `runtime/env-public.ts`. Callers read the result from there.
-*
-* Node-only (lives under `host/`). Must not be imported from anything
-* that ships in worker bundles.
-*/
-let loadCounter = 0;
-/**
-* Returns the specifier from a Node resolution error if the error looks
-* like one — otherwise `null`. Both `ERR_MODULE_NOT_FOUND` and
-* `ERR_UNSUPPORTED_DIR_IMPORT` have the specifier embedded in the message.
-*/
-function extractFailedSpecifier(err) {
-	if (!(err instanceof Error)) return null;
-	const code = err.code;
-	if (code !== "ERR_MODULE_NOT_FOUND" && code !== "ERR_PACKAGE_PATH_NOT_EXPORTED") return null;
-	const match = /Cannot find (?:package|module) '([^']+)'/.exec(err.message);
-	return match ? match[1] ?? null : null;
-}
-/** A specifier is alias-shaped if it isn't relative, absolute, a node: URL, or a valid bare package name. */
-function looksLikeAlias(specifier) {
-	if (specifier.startsWith("./") || specifier.startsWith("../") || specifier.startsWith("/") || specifier.startsWith("node:") || specifier.startsWith("file:")) return false;
-	if (specifier.startsWith("@")) return !/^@[^/]+\/[^/]+/.test(specifier);
-	return specifier.startsWith("~") || specifier.startsWith("#");
-}
-/**
-* Load the user's env.ts via native `import()`. The URL gets a cache-busting
-* query param so HMR re-imports re-evaluate the file.
-*
-* On resolution failures, wraps the error with the source file path, and if
-* the failed specifier looks like a tsconfig path alias, appends guidance
-* explaining that env.ts doesn't resolve aliases.
-*/
-async function loadUserEnvFile(envFile) {
-	const url = pathToFileURL(envFile).href + `?t=${Date.now()}-${++loadCounter}`;
-	try {
-		await import(
-			/* @vite-ignore */
-			url
-);
-	} catch (err) {
-		const specifier = extractFailedSpecifier(err);
-		const base = `env: Failed to load '${envFile}': '${err.message}'.`;
-		if (specifier && looksLikeAlias(specifier)) throw new Error(`${base}\n\nHint: '${specifier}' looks like a tsconfig path alias. env.ts is loaded directly by Node and does not resolve tsconfig "paths" — use a relative import (e.g. "./shared/...") instead.`);
-		throw new Error(base);
-	}
-}
-//#endregion
-//#region src/cli/env-validation.ts
-/**
-* Shared env-schema validation for CLI commands.
-*
-* Loads the user's `env.ts` (which calls `defineEnv` as a side effect),
-* collects sources of env values (`.env*` files, remote secrets), and
-* validates each declared key against the registered schema.
-*
-* Used by both `void deploy` (hard error on missing prod env) and
-* `void env check` (CI/pre-push validation).
-*/
-/**
-* After the user's env.ts has been imported (via `validateProdEnv` or
-* `loadSchema`), read the registered schema's `.default(value)` entries.
-* Returns `{}` if no schema was registered.
-*/
-async function getDeployEnvDefaults(root) {
-	const envFile = findEnvFile(root);
-	if (!envFile) return {};
-	const mod = await loadSchema(envFile);
-	if (!mod) return {};
-	return mod._getSchemaDefaults();
-}
-/** Load the registered schema by importing the user's env.ts. */
-async function loadSchema(envFile) {
-	await loadUserEnvFile(envFile);
-	const mod = await import("./runtime/env-public.mjs");
-	if (!mod._hasRegisteredSchema()) return null;
-	return mod;
-}
-function emptyReport() {
-	return {
-		valid: true,
-		missing: [],
-		invalid: [],
-		values: /* @__PURE__ */ new Map()
-	};
-}
-/**
-* Validate the user's env schema against the union of .env files and
-* remote secret names. Remote secrets are treated as "present" (we can't
-* fetch their values), which is sufficient for the missing-key check.
-*/
-async function validateProdEnv(root, options) {
-	const envFile = findEnvFile(root);
-	if (!envFile) return {
-		hasSchema: false,
-		report: emptyReport()
-	};
-	const mod = await loadSchema(envFile);
-	if (!mod) return {
-		hasSchema: false,
-		report: emptyReport()
-	};
-	const merged = mergeAndExpand((options.productionOnly ? [".env", ".env.production"] : [
-		".env",
-		".env.local",
-		".env.production",
-		".env.production.local"
-	]).map((file) => parseDotenvFile(join(root, file), { expand: false })), { onWarn: (msg) => voidWarn(msg) });
-	const report = await mod.validateAllEnv(merged);
-	const remoteSet = new Set(options.remoteSecrets ?? []);
-	if (remoteSet.size > 0 && report.missing.length > 0) {
-		report.missing = report.missing.filter((key) => !remoteSet.has(key));
-		if (report.missing.length === 0 && report.invalid.length === 0) report.valid = true;
-	}
-	return {
-		hasSchema: true,
-		report
-	};
-}
-/** Format an EnvValidationReport into a human-readable multi-line string. */
-function formatEnvReport(report) {
-	const lines = [];
-	if (report.missing.length > 0) {
-		lines.push("Missing required env vars:");
-		for (const key of report.missing) lines.push(`  • ${key}`);
-	}
-	if (report.invalid.length > 0) {
-		if (lines.length > 0) lines.push("");
-		lines.push("Invalid env vars:");
-		for (const { key, messages } of report.invalid) lines.push(`  • ${key}: ${messages.join("; ")}`);
-	}
-	return lines.join("\n");
-}
-/** Convenience: fetch remote secret names from the platform. */
-async function fetchRemoteSecretNames(client, projectId) {
-	try {
-		return (await client.listSecrets(projectId)).map((s) => s.name);
-	} catch {
-		return [];
-	}
-}
-//#endregion
-export { loadUserEnvFile as a, validateProdEnv as i, formatEnvReport as n, getDeployEnvDefaults as r, fetchRemoteSecretNames as t };

package/dist/pathe.M-eThtNZ-CQzLbt4c.mjs

@@ -1,150 +0,0 @@
-//#region ../../node_modules/.pnpm/pathe@2.0.3/node_modules/pathe/dist/shared/pathe.M-eThtNZ.mjs
-const _DRIVE_LETTER_START_RE = /^[A-Za-z]:\//;
-function normalizeWindowsPath(input = "") {
-	if (!input) return input;
-	return input.replace(/\\/g, "/").replace(_DRIVE_LETTER_START_RE, (r) => r.toUpperCase());
-}
-const _UNC_REGEX = /^[/\\]{2}/;
-const _IS_ABSOLUTE_RE = /^[/\\](?![/\\])|^[/\\]{2}(?!\.)|^[A-Za-z]:[/\\]/;
-const _DRIVE_LETTER_RE = /^[A-Za-z]:$/;
-const _ROOT_FOLDER_RE = /^\/([A-Za-z]:)?$/;
-const _EXTNAME_RE = /.(\.[^./]+|\.)$/;
-const normalize = function(path) {
-	if (path.length === 0) return ".";
-	path = normalizeWindowsPath(path);
-	const isUNCPath = path.match(_UNC_REGEX);
-	const isPathAbsolute = isAbsolute(path);
-	const trailingSeparator = path[path.length - 1] === "/";
-	path = normalizeString(path, !isPathAbsolute);
-	if (path.length === 0) {
-		if (isPathAbsolute) return "/";
-		return trailingSeparator ? "./" : ".";
-	}
-	if (trailingSeparator) path += "/";
-	if (_DRIVE_LETTER_RE.test(path)) path += "/";
-	if (isUNCPath) {
-		if (!isPathAbsolute) return `//./${path}`;
-		return `//${path}`;
-	}
-	return isPathAbsolute && !isAbsolute(path) ? `/${path}` : path;
-};
-const join = function(...segments) {
-	let path = "";
-	for (const seg of segments) {
-		if (!seg) continue;
-		if (path.length > 0) {
-			const pathTrailing = path[path.length - 1] === "/";
-			const segLeading = seg[0] === "/";
-			if (pathTrailing && segLeading) path += seg.slice(1);
-			else path += pathTrailing || segLeading ? seg : `/${seg}`;
-		} else path += seg;
-	}
-	return normalize(path);
-};
-function cwd() {
-	if (typeof process !== "undefined" && typeof process.cwd === "function") return process.cwd().replace(/\\/g, "/");
-	return "/";
-}
-const resolve = function(...arguments_) {
-	arguments_ = arguments_.map((argument) => normalizeWindowsPath(argument));
-	let resolvedPath = "";
-	let resolvedAbsolute = false;
-	for (let index = arguments_.length - 1; index >= -1 && !resolvedAbsolute; index--) {
-		const path = index >= 0 ? arguments_[index] : cwd();
-		if (!path || path.length === 0) continue;
-		resolvedPath = `${path}/${resolvedPath}`;
-		resolvedAbsolute = isAbsolute(path);
-	}
-	resolvedPath = normalizeString(resolvedPath, !resolvedAbsolute);
-	if (resolvedAbsolute && !isAbsolute(resolvedPath)) return `/${resolvedPath}`;
-	return resolvedPath.length > 0 ? resolvedPath : ".";
-};
-function normalizeString(path, allowAboveRoot) {
-	let res = "";
-	let lastSegmentLength = 0;
-	let lastSlash = -1;
-	let dots = 0;
-	let char = null;
-	for (let index = 0; index <= path.length; ++index) {
-		if (index < path.length) char = path[index];
-		else if (char === "/") break;
-		else char = "/";
-		if (char === "/") {
-			if (lastSlash === index - 1 || dots === 1);
-			else if (dots === 2) {
-				if (res.length < 2 || lastSegmentLength !== 2 || res[res.length - 1] !== "." || res[res.length - 2] !== ".") {
-					if (res.length > 2) {
-						const lastSlashIndex = res.lastIndexOf("/");
-						if (lastSlashIndex === -1) {
-							res = "";
-							lastSegmentLength = 0;
-						} else {
-							res = res.slice(0, lastSlashIndex);
-							lastSegmentLength = res.length - 1 - res.lastIndexOf("/");
-						}
-						lastSlash = index;
-						dots = 0;
-						continue;
-					} else if (res.length > 0) {
-						res = "";
-						lastSegmentLength = 0;
-						lastSlash = index;
-						dots = 0;
-						continue;
-					}
-				}
-				if (allowAboveRoot) {
-					res += res.length > 0 ? "/.." : "..";
-					lastSegmentLength = 2;
-				}
-			} else {
-				if (res.length > 0) res += `/${path.slice(lastSlash + 1, index)}`;
-				else res = path.slice(lastSlash + 1, index);
-				lastSegmentLength = index - lastSlash - 1;
-			}
-			lastSlash = index;
-			dots = 0;
-		} else if (char === "." && dots !== -1) ++dots;
-		else dots = -1;
-	}
-	return res;
-}
-const isAbsolute = function(p) {
-	return _IS_ABSOLUTE_RE.test(p);
-};
-const extname = function(p) {
-	if (p === "..") return "";
-	const match = _EXTNAME_RE.exec(normalizeWindowsPath(p));
-	return match && match[1] || "";
-};
-const relative = function(from, to) {
-	const _from = resolve(from).replace(_ROOT_FOLDER_RE, "$1").split("/");
-	const _to = resolve(to).replace(_ROOT_FOLDER_RE, "$1").split("/");
-	if (_to[0][1] === ":" && _from[0][1] === ":" && _from[0] !== _to[0]) return _to.join("/");
-	const _fromCopy = [..._from];
-	for (const segment of _fromCopy) {
-		if (_to[0] !== segment) break;
-		_from.shift();
-		_to.shift();
-	}
-	return [..._from.map(() => ".."), ..._to].join("/");
-};
-const dirname = function(p) {
-	const segments = normalizeWindowsPath(p).replace(/\/$/, "").split("/").slice(0, -1);
-	if (segments.length === 1 && _DRIVE_LETTER_RE.test(segments[0])) segments[0] += "/";
-	return segments.join("/") || (isAbsolute(p) ? "/" : ".");
-};
-const basename = function(p, extension) {
-	const segments = normalizeWindowsPath(p).split("/");
-	let lastSegment = "";
-	for (let i = segments.length - 1; i >= 0; i--) {
-		const val = segments[i];
-		if (val) {
-			lastSegment = val;
-			break;
-		}
-	}
-	return extension && lastSegment.endsWith(extension) ? lastSegment.slice(0, -extension.length) : lastSegment;
-};
-//#endregion
-export { join as a, resolve as c, isAbsolute as i, dirname as n, normalize as o, extname as r, relative as s, basename as t };