void 0.10.10 → 0.10.11

package/dist/{discover-BuVVSAum.mjs → discover-CJHyvYfR.mjs}

@@ -1,6 +1,6 @@
 import { n as __exportAll } from "./rolldown-runtime-DJK8HYOj.mjs";
-import { s as relative } from "./pathe.M-eThtNZ-CQzLbt4c.mjs";
-import { n as readProjectPaths } from "./project-paths-tpdR1mJR.mjs";
+import { s as relative } from "./dist-DaKKDf8D.mjs";
+import { n as readProjectPaths } from "./project-paths-BQd7OmIo.mjs";
 import { existsSync, statSync } from "node:fs";
 //#region src/drizzle/discover.ts
 var discover_exports = /* @__PURE__ */ __exportAll({

package/dist/dist-DaKKDf8D.mjs

@@ -0,0 +1,41 @@
+import nodePath from "node:path";
+//#region ../../node_modules/.pnpm/pathslash@0.1.0/node_modules/pathslash/dist/index.mjs
+const BACKSLASH_RE = /\\/g;
+const isWindows = process.platform === "win32";
+/**
+* Flip backslashes to forward slashes, used to slash-ify `node:path.win32`
+* output. `\\?\` (extended-length) paths are left untouched: there a forward
+* slash is a literal character, not a separator.
+*/
+const toForwardSlash = (path) => path.startsWith("\\\\?\\") ? path : path.replace(BACKSLASH_RE, "/");
+const w = nodePath.win32;
+function slashed(fn) {
+	return (...args) => toForwardSlash(fn(...args));
+}
+const win32 = {
+	resolve: slashed(w.resolve),
+	normalize: slashed(w.normalize),
+	join: slashed(w.join),
+	relative: slashed(w.relative),
+	dirname: slashed(w.dirname),
+	format: slashed(w.format),
+	parse: (path) => {
+		const parsed = w.parse(path);
+		parsed.root = toForwardSlash(parsed.root);
+		parsed.dir = toForwardSlash(parsed.dir);
+		return parsed;
+	},
+	basename: w.basename,
+	extname: w.extname,
+	isAbsolute: w.isAbsolute,
+	matchesGlob: w.matchesGlob,
+	toNamespacedPath: w.toNamespacedPath,
+	delimiter: w.delimiter,
+	sep: "/"
+};
+const posix = { ...nodePath.posix };
+posix.posix = win32.posix = posix;
+posix.win32 = win32.win32 = win32;
+const { basename, delimiter, dirname, extname, format, isAbsolute, join, matchesGlob, normalize, parse, relative, resolve, sep, toNamespacedPath } = isWindows ? win32 : posix;
+//#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 };

package/dist/{domain-DMrBabBQ.mjs → domain-DiaNQbrl.mjs}

@@ -1,5 +1,5 @@
-import { E as note, T as log, u as import_picocolors } from "./agents-Bmr5tFFb.mjs";
-import { b as readProjectConfig, f as getToken, n as PlatformClient } from "./client-C9FG6Vzc.mjs";
+import { E as note, T as log, u as import_picocolors } from "./agents-CtgBYqld.mjs";
+import { b as readProjectConfig, f as getToken, n as PlatformClient } from "./client-Gb71-XkG.mjs";
 //#region src/cli/domain.ts
 async function runDomainCommand(root, args) {
 	const token = getToken(root);

package/dist/entry-D7yy4xVH.mjs

@@ -0,0 +1,100 @@
+import { a as join, s as relative } from "./dist-DaKKDf8D.mjs";
+import { n as readProjectPaths } from "./project-paths-BQd7OmIo.mjs";
+import { existsSync, readFileSync } from "node:fs";
+import { parseSync } from "vite";
+//#region src/shared/ast.ts
+function isIdentifier(node) {
+	return node?.type === "Identifier" && typeof node.name === "string";
+}
+function isLiteral(node) {
+	return node?.type === "Literal";
+}
+function isMemberExpression(node) {
+	return node?.type === "MemberExpression";
+}
+function isCallExpression(node) {
+	return node?.type === "CallExpression";
+}
+function isObjectExpression(node) {
+	return node?.type === "ObjectExpression";
+}
+//#endregion
+//#region src/ssr/entry.ts
+const SSR_SERVER_ENTRY_RELATIVE_PATHS = ["src/main.ssr.ts", "src/main.ssr.tsx"];
+const SSR_CLIENT_ENTRY_RELATIVE_PATHS = ["src/main.client.ts", "src/main.client.tsx"];
+function resolveSingleEntry(root, entries, label, paths = readProjectPaths(root)) {
+	const matches = entries.map((entryName) => ({
+		relativePath: relative(root, join(paths.ssrDir, entryName)),
+		absolutePath: join(paths.ssrDir, entryName)
+	})).filter((entry) => existsSync(entry.absolutePath));
+	if (matches.length === 0) return null;
+	if (matches.length > 1) {
+		const names = matches.map((entry) => entry.relativePath).join(", ");
+		throw new Error(`ssr: Multiple ${label} entry files found: ${names}. Keep only one.`);
+	}
+	return matches[0];
+}
+const SSR_SERVER_ENTRY_NAMES = ["main.ssr.ts", "main.ssr.tsx"];
+const SSR_CLIENT_ENTRY_NAMES = ["main.client.ts", "main.client.tsx"];
+function getSsrServerEntryPath(root, paths = readProjectPaths(root)) {
+	return resolveSingleEntry(root, SSR_SERVER_ENTRY_NAMES, "SSR", paths)?.absolutePath ?? null;
+}
+function hasSsrEntry(root, paths = readProjectPaths(root)) {
+	return getSsrServerEntryPath(root, paths) !== null;
+}
+function validateServerRenderExport(entry) {
+	const { absolutePath, relativePath } = entry;
+	const source = readFileSync(absolutePath, "utf-8");
+	if (/\bexport\s+(?:async\s+)?function\s+render\b/.test(source) || /\bexport\s+const\s+render\b/.test(source) || /\bexport\s+default\s+(?:defineRender\b|(?:async\s+)?function\b)/.test(source)) return;
+	let parsed;
+	try {
+		parsed = parseSync(relativePath, source);
+	} catch (err) {
+		throw new Error(`ssr: Invalid entry '${relativePath}'. Could not parse source: '${err instanceof Error ? err.message : String(err)}'.`);
+	}
+	if (!(parsed.program.body ?? []).some((node) => {
+		if (node.type === "ExportDefaultDeclaration") {
+			const declaration = node.declaration;
+			if (declaration?.type === "FunctionDeclaration" || declaration?.type === "FunctionExpression" || declaration?.type === "ArrowFunctionExpression") return true;
+			if (declaration?.type === "CallExpression") {
+				const call = declaration;
+				return isIdentifier(call.callee) && call.callee.name === "defineRender";
+			}
+			return false;
+		}
+		if (node.type !== "ExportNamedDeclaration") return false;
+		if (node.exportKind === "type") return false;
+		const declaration = node.declaration;
+		if (declaration?.type === "FunctionDeclaration") {
+			const fn = declaration;
+			return isIdentifier(fn.id) && fn.id.name === "render";
+		}
+		if (declaration?.type === "VariableDeclaration") return (declaration.declarations ?? []).some((decl) => isIdentifier(decl.id) && decl.id.name === "render");
+		return (node.specifiers ?? []).some((specifier) => {
+			if (specifier.exportKind === "type") return false;
+			const exported = specifier.exported;
+			return isIdentifier(exported) && exported.name === "render";
+		});
+	})) throw new Error(`ssr: Invalid entry '${relativePath}'. Export \`render(c, assetTags)\` or \`export default defineRender(...)\`.`);
+}
+/**
+* Validate SSR mode entry conventions.
+* Returns null when SSR mode is not used.
+*/
+function validateSsrEntries(root, paths = readProjectPaths(root)) {
+	const server = resolveSingleEntry(root, SSR_SERVER_ENTRY_NAMES, "SSR", paths);
+	const client = resolveSingleEntry(root, SSR_CLIENT_ENTRY_NAMES, "SSR client", paths);
+	if (!server && !client) return null;
+	if (server && !client) throw new Error(`ssr: Missing client entry. Add one of: ${SSR_CLIENT_ENTRY_RELATIVE_PATHS.join(", ")}.`);
+	if (!server && client) throw new Error(`ssr: Missing server entry. Add one of: ${SSR_SERVER_ENTRY_RELATIVE_PATHS.join(", ")}.`);
+	validateServerRenderExport(server);
+	return {
+		server,
+		client
+	};
+}
+function validateSsrEntry(root, paths = readProjectPaths(root)) {
+	return validateSsrEntries(root, paths)?.server.absolutePath ?? null;
+}
+//#endregion
+export { validateSsrEntries as a, isIdentifier as c, isObjectExpression as d, hasSsrEntry as i, isLiteral as l, SSR_SERVER_ENTRY_RELATIVE_PATHS as n, validateSsrEntry as o, getSsrServerEntryPath as r, isCallExpression as s, SSR_CLIENT_ENTRY_RELATIVE_PATHS as t, isMemberExpression as u };

package/dist/{env-BfG7O71F.mjs → env-AAHU02L6.mjs}

@@ -1,8 +1,8 @@
-import { a as join } from "./pathe.M-eThtNZ-CQzLbt4c.mjs";
-import { D as outro, E as note, T as log, a as cliTitle, w as intro } from "./agents-Bmr5tFFb.mjs";
-import { b as readProjectConfig, f as getToken, n as PlatformClient } from "./client-C9FG6Vzc.mjs";
-import { r as generateEnvTypes, t as findEnvFile } from "./env-types-D51bnR-c.mjs";
-import { a as loadUserEnvFile, i as validateProdEnv, n as formatEnvReport, t as fetchRemoteSecretNames } from "./env-validation-CeC2FL66.mjs";
+import { a as join } from "./dist-DaKKDf8D.mjs";
+import { D as outro, E as note, T as log, a as cliTitle, w as intro } from "./agents-CtgBYqld.mjs";
+import { b as readProjectConfig, f as getToken, n as PlatformClient } from "./client-Gb71-XkG.mjs";
+import { r as generateEnvTypes, t as findEnvFile } from "./env-types-QBj-ndax.mjs";
+import { h as loadUserEnvFile, l as fetchRemoteSecretNames, m as validateProdEnv, u as formatEnvReport } from "./env-validation-BdDlGhbN.mjs";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 //#region src/cli/env-example.ts
 /**

package/dist/env-mask-Dd47NbR6.mjs

@@ -0,0 +1,90 @@
+//#region src/shared/env-mask.ts
+/**
+* Secret redaction helpers for env-validation output.
+*
+* Values are redacted (replaced with `<redacted>`) whenever they flow into
+* a user-visible string — `EnvValidationError` messages, CLI reports, the
+* dev-server warning block. The key name is never masked (the user needs
+* it to locate the offending entry).
+*
+* Redaction is belt-and-braces:
+*   1. An explicit `.secret()` / `.public()` flag on a schema entry wins.
+*   2. Otherwise, a key-name regex (`KEY|TOKEN|SECRET|…`) redacts anything
+*      that looks like credentials.
+*   3. Even on non-secret keys, a value that itself looks high-entropy
+*      (`sk_…`, `ghp_…`, ≥24 characters of mixed alphanumerics) is redacted
+*      — catches wrong-file typos like `PORT=sk_live_abc123`.
+*
+* Users can opt out of the guard for local debugging via
+* `VOID_ENV_UNMASK=1` in the environment; that path prints a one-shot
+* notice on stderr so the loosened output is visibly attributed.
+*
+* This module is a leaf — no imports from non-leaf modules, safe to reach
+* from both the runtime (worker bundle) and the CLI host.
+*/
+/** Sentinel emitted in place of a redacted value. */
+const REDACTED = "<redacted>";
+/** Environment variable that disables redaction when set to `1`. */
+const UNMASK_ENV_VAR = "VOID_ENV_UNMASK";
+/**
+* Regex matching env key names that almost always carry secrets.
+* Case-insensitive; matched as a substring anywhere in the key.
+*/
+const SECRET_KEY_RE = /KEY|TOKEN|SECRET|PASSWORD|PASS(WD)?|CREDENTIAL|PRIVATE|AUTH|BEARER|APIKEY|DSN/i;
+/** Common secret value prefixes (Stripe, GitHub, Slack, AWS, …). */
+const SECRET_VALUE_PREFIX_RE = /^(sk|pk|ghp|xoxb|AKIA)/i;
+/** High-entropy alphanumeric string of ≥24 chars. */
+const HIGH_ENTROPY_RE = /^[A-Za-z0-9_\-+/=.:]{24,}$/;
+/** `true` when the key name heuristically denotes a secret. */
+function isLikelySecretKey(name) {
+	return SECRET_KEY_RE.test(name);
+}
+/**
+* `true` when the value looks like a credential regardless of key name.
+* Err on the side of redacting — a false positive hides one non-secret
+* debugging hint, a false negative pastes a token into a GitHub issue.
+*/
+function isLikelySecretValue(value) {
+	if (typeof value !== "string" || value.length === 0) return false;
+	return SECRET_VALUE_PREFIX_RE.test(value) || HIGH_ENTROPY_RE.test(value);
+}
+/**
+* Redact every occurrence of `raw` inside a validator-produced `message`
+* when the key should be masked. Built-in helpers embed the raw value in
+* their error strings (e.g. `Expected a number, got "not-a-number"`); we
+* scrub those after the fact so third-party Standard Schema libraries —
+* which have their own message format — also get reasonable redaction as
+* long as the offending value was a secret-looking literal.
+*/
+function redactMessage(key, rawValue, message, options = {}) {
+	if (options.unmask) return message;
+	if (!(options.override === "secret" || options.override !== "public" && (isLikelySecretKey(key) || isLikelySecretValue(rawValue)))) return message;
+	if (typeof rawValue !== "string" || rawValue.length === 0) return message;
+	return message.split(rawValue).join(REDACTED);
+}
+let unmaskResolved = null;
+let unmaskNoticeShown = false;
+/**
+* Resolve the effective unmask flag, consulting `process.env` exactly once
+* per process. On the first affirmative read, we print a one-shot notice to
+* stderr so CI logs clearly show the guard is off.
+*/
+function isUnmaskActive() {
+	if (unmaskResolved !== null) return unmaskResolved;
+	let active = false;
+	try {
+		active = globalThis.process?.env?.[UNMASK_ENV_VAR] === "1";
+	} catch {
+		active = false;
+	}
+	unmaskResolved = active;
+	if (active && !unmaskNoticeShown) {
+		unmaskNoticeShown = true;
+		try {
+			console.error(`[void/env] ${UNMASK_ENV_VAR}=1 is set — env validation errors will include raw values. Unset it before sharing logs.`);
+		} catch {}
+	}
+	return active;
+}
+//#endregion
+export { isUnmaskActive as n, redactMessage as r, isLikelySecretKey as t };

package/dist/env-public-BfiLcMBk.d.mts

@@ -0,0 +1,140 @@
+import { t as StandardSchemaV1 } from "./standard-schema-DJ0HW7QP.mjs";
+
+//#region src/runtime/env-public.d.ts
+type AnyValidator = StandardSchemaV1<unknown, unknown>;
+type AnySchema = Record<string, AnyValidator>;
+/**
+* Type-only stub for the validated env shape. Augmented by the generated
+* `.void/env.d.ts` so `env.X` is typed per the user's schema. Includes an
+* index signature so untyped property access returns `unknown` (rather than
+* a hard error) for bindings and keys not declared in the schema.
+*/
+interface ValidatedEnv {
+  readonly [key: string]: unknown;
+}
+type InferEnv<S extends AnySchema> = { readonly [K in keyof S]: StandardSchemaV1.InferOutput<S[K]> };
+/**
+* Register an env schema and return the typed `env` proxy.
+*
+* Calling `defineEnv` is the only required step — Void auto-discovers
+* `env.ts` at project root, imports it, and uses the schema for runtime
+* validation, type generation, and deploy-time secret checks.
+*
+* The return value is identical to the `env` export from `void/env`.
+* Re-export it from your `env.ts` if you prefer the explicit
+* `import { env } from "~/env"` pattern.
+*/
+declare function defineEnv<S extends AnySchema>(schema: S): InferEnv<S>;
+/**
+* Internal: validate the entire schema against the worker's actual env on
+* the first request per isolate. Catches bad remote-secret values and
+* post-deploy drift that the deploy CLI can't see (it only knows secret
+* names, not their values).
+*
+* Spliced into the generated worker entry by `compileWorkerEntry`. Cached
+* after the first call so subsequent requests pay no cost.
+*
+* Async lifecycle: this function awaits any async Standard Schema
+* validators (zod `refine`, arktype async narrows, etc.) and seeds the
+* per-key cache with the resolved values. Subsequent reads via `env.X`
+* hit the sync cache — async work only happens here, at boot. If a user
+* accesses `env.X` for a key with an async validator *before* this
+* function has run (e.g. during module-top-level code), the proxy will
+* throw with guidance pointing back to this boot-time pre-validation.
+*/
+declare function _validateEnvOnce(envValues: unknown): Promise<void>;
+/** Internal: framework-only access to the registered schema (for plugin/CLI). */
+declare function _getRegisteredSchema(): AnySchema | null;
+/**
+* Internal: returns `true` once `defineEnv()` has been called at least once,
+* regardless of whether the caller passed an empty schema. Gives tooling a
+* reliable signal — `_getRegisteredSchema()` alone can't distinguish
+* `defineEnv({})` (an intentional empty schema) from "never called".
+*/
+declare function _hasRegisteredSchema(): boolean;
+/**
+* Internal: extract `.default(value)` values from the registered schema as
+* stringified env values. Used by the plugin and deploy CLI to seed worker
+* `vars` so `c.env.X` and `process.env.X` see the same fallback that the
+* typed `env.X` proxy returns.
+*
+* Detection is schema-agnostic: probe each validator with `undefined` and,
+* if it succeeds with a non-undefined value, that value is the default.
+* Works for our built-in `.default(...)` helpers and for any Standard
+* Schema validator with intrinsic default behaviour. Async validators are
+* skipped (we can't get a sync default).
+*
+* Keys with no default — required keys, plain `.optional()` — are omitted
+* from the result so they don't shadow user `.env*` entries with empty
+* strings.
+*/
+declare function _getSchemaDefaults(): Record<string, string>;
+declare class EnvValidationError extends Error {
+  readonly key: string;
+  readonly issues: Array<StandardSchemaV1.Issue>;
+  constructor(key: string, issues: Array<StandardSchemaV1.Issue>);
+}
+/**
+* Typed env proxy. Reads from the runtime env, validating declared keys
+* on first access and passing through bindings / unknown keys unchanged.
+*
+* Sync-only: the `get` trap must be synchronous, so validators that return
+* a `Promise` cannot be awaited here. For async Standard Schema validators,
+* `_validateEnvOnce()` pre-resolves them at worker boot and seeds the
+* per-env cache; property reads then serve the cached value synchronously.
+* If an async validator is encountered here without a prior pre-validation,
+* the trap throws with guidance on how to resolve it.
+*/
+declare const env: ValidatedEnv;
+/** Aggregate report from validating an entire env object against the schema. */
+type EnvValidationReport = {
+  valid: boolean;
+  missing: Array<string>;
+  invalid: Array<{
+    key: string;
+    messages: Array<string>;
+  }>;
+  /**
+  * Resolved values for keys that validated successfully. Used to seed the
+  * per-env cache after async pre-validation so sync `env.X` reads hit the
+  * cache.
+  */
+  values: Map<string, unknown>;
+};
+/**
+* Validate an env record (e.g. merged `.env*` + remote secret list) against
+* the registered schema. Used by the dev plugin (warnings), the deploy CLI
+* (hard error), and `_validateEnvOnce` at worker boot.
+*
+* Async: awaits any validators that return a `Promise` (zod async refines,
+* arktype narrows, etc.). Callers already run in async contexts.
+*/
+declare function validateAllEnv(envValues: Record<string, unknown>): Promise<EnvValidationReport>;
+declare global {
+  namespace Cloudflare {
+    interface Env {
+      DB: D1Database;
+      KV: KVNamespace;
+      STORAGE: R2Bucket;
+      AI: Ai;
+      SANDBOX: DurableObjectNamespace<import("@cloudflare/sandbox").Sandbox>;
+      /** @internal Service binding to proxy worker (AI, revalidation, future features) */
+      __VOID_PROXY?: Fetcher;
+      /** @internal Custom proxy URL override */
+      __VOID_PROXY_URL?: string;
+      /** @internal Auth token for HTTP proxy (local dev) */
+      __VOID_TOKEN?: string;
+      /** @internal Project ID for HTTP proxy (local dev) */
+      __VOID_PROJECT_ID?: string;
+      /** @internal Staging environment flag */
+      __VOID_STAGING?: string;
+      /** @internal Project ID (service binding path) */
+      __PROJECT_ID?: string;
+      /** @internal Proxy token (service binding path) */
+      __VOID_PROXY_TOKEN?: string;
+      [key: `QUEUE_${string}`]: Queue<unknown> | undefined;
+    }
+  }
+}
+//#endregion
+export { _getSchemaDefaults as a, defineEnv as c, _getRegisteredSchema as i, env as l, EnvValidationReport as n, _hasRegisteredSchema as o, ValidatedEnv as r, _validateEnvOnce as s, EnvValidationError as t, validateAllEnv as u };

package/dist/{env-types-D51bnR-c.mjs → env-types-QBj-ndax.mjs}

@@ -1,5 +1,5 @@
-import { s as relative } from "./pathe.M-eThtNZ-CQzLbt4c.mjs";
-import { n as readProjectPaths } from "./project-paths-tpdR1mJR.mjs";
+import { s as relative } from "./dist-DaKKDf8D.mjs";
+import { n as readProjectPaths } from "./project-paths-BQd7OmIo.mjs";
 import { i as voidWarn } from "./log-ChfPKsVd.mjs";
 import { existsSync } from "node:fs";
 //#region src/codegen/env-types.ts