void 0.10.12 → 0.20.0

package/dist/cli/env-schema-probe.d.mts

@@ -1,68 +1,56 @@
+import "../env-public-D_6u46fX.mjs";
+import "../types-CKWnYgfy.mjs";
 //#region src/cli/env-validation.d.ts
 /**
-* The stable, values-free classification of a self-host schema failure.
-* env.ts evaluation and Standard-Schema validators run ARBITRARY user code that
-* can embed an env value in a thrown/rejected error (its `message`, `stack`, or
-* `cause`), and `VOID_ENV_UNMASK` disables redaction — so the original error is
-* never surfaced. Every {@link SelfHostSchemaError} instead carries only one of
-* these codes plus fixed text, so neither its message, its `reason` field, nor
-* its JSON serialization can echo a value.
-*   - `schema-load-failed`      — importing/evaluating the user's env.ts threw.
-*   - `schema-validation-error` — a registered validator threw or rejected while
-*                                 checking a production value.
-*/
+ * The stable, values-free classification of a self-host schema failure.
+ * env.ts evaluation and Standard-Schema validators run ARBITRARY user code that
+ * can embed an env value in a thrown/rejected error (its `message`, `stack`, or
+ * `cause`), and `VOID_ENV_UNMASK` disables redaction — so the original error is
+ * never surfaced. Every {@link SelfHostSchemaError} instead carries only one of
+ * these codes plus fixed text, so neither its message, its `reason` field, nor
+ * its JSON serialization can echo a value.
+ *   - `schema-load-failed`      — importing/evaluating the user's env.ts threw.
+ *   - `schema-validation-error` — a registered validator threw or rejected while
+ *                                 checking a production value.
+ */
 type SelfHostSchemaFailureReason = "schema-load-failed" | "schema-validation-error";
 /**
-* The env-INSENSITIVE structural facts the self-host secret gate needs from the
-* project's env schema: whether a schema is registered, the REQUIRED key names (a
-* validator that rejects the ABSENT value — {@link requiredSchemaKeys}), and the
-* keys the schema flags `.secret()` ({@link getSecretOverride} === 'secret').
-* NONE of these depend on which `.env` file the build reads — they are fixed by
-* env.ts's structure — so this needs no `loadEnv` and no build env, and the result
-* is the SAME regardless of the build's mode/envDir. That is precisely why the old
-* probe-vs-build divergence class is gone: nothing derived here can diverge from
-* the build over which `.env*` set was loaded.
-*/
+ * The env-INSENSITIVE structural facts the self-host secret gate needs from the
+ * project's env schema: whether a schema is registered, every server key, and the
+ * REQUIRED key names (validators that reject the absent value). These are fixed by
+ * env.ts's structure and require no dotenv loading.
+ */
 type SelfHostSchemaFacts = {
-  /** Whether the project registered an env schema at all (no schema → nothing to gate). */hasSchema: boolean; /** Required key NAMES — validator rejects `undefined`. Values-free. */
-  requiredKeys: Array<string>; /** Keys the schema flags `.secret()`. Values-free. */
-  secretKeys: Array<string>;
+  /** Whether the project registered an env schema at all (no schema → nothing to gate). */
+  hasSchema: boolean;
+  /** Every server-only schema key. These may never be emitted as plaintext vars. */
+  serverKeys: Array<string>;
+  /** Required key NAMES — validator rejects `undefined`. Values-free. */
+  requiredKeys: Array<string>;
 };
 //#endregion
 //#region src/cli/env-schema-probe.d.ts
 /** Input handed to the child (JSON in argv[3]). Path only — no env values cross here. */
-type EnvSchemaProbeInput = {
+export type EnvSchemaProbeInput = {
   root: string;
 };
-/** The reason the `facts` probe rejected the app as unsupported (values-free). */
-type EnvSchemaProbeRejectReason = "custom-envdir" | "non-production-mode";
 /**
-* The structured result of the `facts` operation. `ok` carries the env-insensitive
-* schema facts; `reject` fails the deploy closed pre-account with clear v1-scope
-* guidance; `schema-error` surfaces a values-free env.ts/validator failure.
-*
-* `reject` crosses the process boundary as a FIXED reason CODE only — never the raw
-* resolved `mode` / `envDir` strings. Those are arbitrary Vite-config-derived values
-* (a config could set `envDir`/`mode` from any inherited secret), so echoing them
-* over fd 3 or into a parent log would break the values-free boundary; the parent
-* renders fixed guidance from the code alone.
-*/
-type EnvSchemaProbeResult = {
+ * The structured result of the `facts` operation. `ok` carries the env-insensitive
+ * schema facts; `schema-error` surfaces a values-free env.ts/validator failure.
+ */
+export type EnvSchemaProbeResult = {
   kind: "ok";
   facts: SelfHostSchemaFacts;
-} | {
-  kind: "reject";
-  reason: EnvSchemaProbeRejectReason;
 } | {
   kind: "schema-error";
   reason: SelfHostSchemaFailureReason;
 };
 /**
-* The structured result of the `validate-emitted` operation. `invalid-keys` carries
-* the FAILING key NAMES only (never a value); `schema-error` surfaces a values-free
-* env.ts/validator failure.
-*/
-type EnvSchemaValidateResult = {
+ * The structured result of the `validate-emitted` operation. `invalid-keys` carries
+ * the FAILING key NAMES only (never a value); `schema-error` surfaces a values-free
+ * env.ts/validator failure.
+ */
+export type EnvSchemaValidateResult = {
   kind: "invalid-keys";
   invalidKeys: Array<string>;
 } | {
@@ -70,27 +58,26 @@ type EnvSchemaValidateResult = {
   reason: SelfHostSchemaFailureReason;
 };
 /** Minimal structural shape of a `spawnSync`-style result (injectable in tests). */
-type EnvSchemaProbeSpawnResult = {
-  status: number | null; /** The fd-3 buffer (the framed result) — dedicated so stdout noise can't truncate it. */
+export type EnvSchemaProbeSpawnResult = {
+  status: number | null;
+  /** The fd-3 buffer (the framed result) — dedicated so stdout noise can't truncate it. */
   fd3: string | null;
   error?: Error | null;
   signal?: NodeJS.Signals | null;
 };
-type EnvSchemaProbeSpawn = (command: string, args: Array<string>, options: {
+export type EnvSchemaProbeSpawn = (command: string, args: Array<string>, options: {
   cwd: string;
   env: NodeJS.ProcessEnv;
 }) => EnvSchemaProbeSpawnResult;
 /**
-* PARENT side (`facts`): return the env-insensitive schema facts + the v1 envDir/mode
-* narrowing. Runs pre-build so a custom envDir / non-production mode / broken env.ts
-* fails fast, before any account op.
-*/
-declare function resolveEnvSchemaFactsViaSubprocess(input: EnvSchemaProbeInput, env: NodeJS.ProcessEnv, spawn?: EnvSchemaProbeSpawn): Promise<EnvSchemaProbeResult>;
+ * PARENT side (`facts`): return the env-insensitive schema facts. Runs pre-build so
+ * a broken env.ts fails fast, before any account operation.
+ */
+export declare function resolveEnvSchemaFactsViaSubprocess(input: EnvSchemaProbeInput, env: NodeJS.ProcessEnv, spawn?: EnvSchemaProbeSpawn): Promise<EnvSchemaProbeResult>;
 /**
-* PARENT side (`validate-emitted`): validate the REAL emitted worker `vars` against
-* the schema validators and return the FAILING key NAMES only. Runs post-build so
-* the values validated are exactly what the worker ships.
-*/
-declare function validateEmittedVarsViaSubprocess(input: EnvSchemaProbeInput, env: NodeJS.ProcessEnv, spawn?: EnvSchemaProbeSpawn): Promise<EnvSchemaValidateResult>;
-//#endregion
-export { EnvSchemaProbeInput, EnvSchemaProbeRejectReason, EnvSchemaProbeResult, EnvSchemaProbeSpawn, EnvSchemaProbeSpawnResult, EnvSchemaValidateResult, resolveEnvSchemaFactsViaSubprocess, validateEmittedVarsViaSubprocess };
+ * PARENT side (`validate-emitted`): validate the REAL emitted worker `vars` against
+ * the schema validators and return the FAILING key NAMES only. Runs post-build so
+ * the values validated are exactly what the worker ships.
+ */
+export declare function validateEmittedVarsViaSubprocess(input: EnvSchemaProbeInput, env: NodeJS.ProcessEnv, spawn?: EnvSchemaProbeSpawn): Promise<EnvSchemaValidateResult>;
+//#endregion

package/dist/cli/env-schema-probe.mjs

@@ -1,4 +1,3 @@
-import { a as join } from "../dist-DaKKDf8D.mjs";
 import { writeSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 import { spawnSync } from "node:child_process";
@@ -11,15 +10,8 @@ import { spawnSync } from "node:child_process";
 * token / `CLOUDFLARE_API_TOKEN` in `process.env`) and must NOT evaluate arbitrary
 * project code in-process:
 *
-*   1. `facts` — the env-INSENSITIVE schema facts (required-secret NAMES + the
-*      `.secret()` flags), fixed by env.ts's structure. The child ALSO resolves the
-*      Vite config here purely to read the final `{ envDir, mode }` and reject a
-*      custom `envDir` or a non-`production` build mode (v1 supports neither): the
-*      build generates the auth artifact under the project root while the worker
-*      `vars` come from the build's `envDir`, so a custom `envDir` could validate a
-*      different table set than the worker ships. Resolving the config runs the full
-*      plugin pipeline (arbitrary code, timers/`beforeExit` risk) — safe HERE in the
-*      child (which `process.exit`s), never in the credentialed parent.
+*   1. `facts` — the env-INSENSITIVE server and required key names, fixed by
+*      env.ts's structure.
 *   2. `validate-emitted` — validate the REAL emitted worker `vars` (post-build
 *      ground truth) against the schema's Standard-Schema validators and return the
 *      FAILING key NAMES only. A required var shipped with an INVALID value (fails
@@ -104,9 +96,8 @@ async function spawnEnvSchemaProbe(op, input, env, spawn) {
 	return parsed;
 }
 /**
-* PARENT side (`facts`): return the env-insensitive schema facts + the v1 envDir/mode
-* narrowing. Runs pre-build so a custom envDir / non-production mode / broken env.ts
-* fails fast, before any account op.
+* PARENT side (`facts`): return the env-insensitive schema facts. Runs pre-build so
+* a broken env.ts fails fast, before any account operation.
 */
 async function resolveEnvSchemaFactsViaSubprocess(input, env, spawn = defaultSpawn) {
 	const result = await spawnEnvSchemaProbe("facts", input, env, spawn);
@@ -120,7 +111,7 @@ async function resolveEnvSchemaFactsViaSubprocess(input, env, spawn = defaultSpa
 */
 async function validateEmittedVarsViaSubprocess(input, env, spawn = defaultSpawn) {
 	const result = await spawnEnvSchemaProbe("validate-emitted", input, env, spawn);
-	if (result.kind === "ok" || result.kind === "reject") throw new Error("the env-schema probe returned an unexpected result for the validate-emitted operation.");
+	if (result.kind === "ok") throw new Error("the env-schema probe returned an unexpected result for the validate-emitted operation.");
 	return result;
 }
 /**
@@ -145,10 +136,6 @@ function parseProbeResult(fd3) {
 		kind: "ok",
 		facts: record.facts
 	};
-	if (record.kind === "reject" && (record.reason === "custom-envdir" || record.reason === "non-production-mode")) return {
-		kind: "reject",
-		reason: record.reason
-	};
 	if (record.kind === "invalid-keys" && Array.isArray(record.invalidKeys) && record.invalidKeys.every((k) => typeof k === "string")) return {
 		kind: "invalid-keys",
 		invalidKeys: record.invalidKeys
@@ -162,53 +149,18 @@ function parseProbeResult(fd3) {
 function isSchemaFacts(value) {
 	if (!value || typeof value !== "object") return false;
 	const f = value;
-	return typeof f.hasSchema === "boolean" && Array.isArray(f.requiredKeys) && f.requiredKeys.every((k) => typeof k === "string") && Array.isArray(f.secretKeys) && f.secretKeys.every((k) => typeof k === "string");
+	return typeof f.hasSchema === "boolean" && Array.isArray(f.requiredKeys) && f.requiredKeys.every((k) => typeof k === "string") && Array.isArray(f.serverKeys) && f.serverKeys.every((k) => typeof k === "string");
 }
 /** Write the framed result to the dedicated fd 3 (synchronous → flushed before exit). */
 function emitResult(result) {
 	writeSync(RESULT_FD, JSON.stringify(result));
 }
 /**
-* Read the RAW (root-relative, unnormalized) envDir the build's worker-vars loader
-* actually uses, straight from the `void:env` config hook's captured value (exposed on
-* that plugin's `api.getVoidDeployBuildConfig`). This is the only faithful input to the
-* build's OWN `join(root, rawEnvDir)` computation: Vite's `resolved.envDir` is already
-* normalized (`path.resolve`), which loses the distinction an absolute-root envDir needs.
-* Returns `undefined` when the hook is absent (a non-void config), which the caller
-* treats as "no custom raw envDir" and falls back to Vite's normalized view.
-*/
-function readBuildRawEnvDir(plugins) {
-	return (plugins.find((p) => p.name === "void:env")?.api)?.getVoidDeployBuildConfig?.()?.envDir;
-}
-/**
-* CHILD side (`facts`): resolve the Vite config HERE (the FULL plugin pipeline the
-* real `vite build` runs, under the scrubbed env — never in the parent) purely to
-* read the effective `{ envDir, mode }` and reject a custom envDir / non-production
-* mode; then, when accepted, import the user's env.ts and derive the env-insensitive
-* schema facts. All heavy imports are DYNAMIC so a plain library import of this
-* module (by the CLI, for the parent-side helper) never pulls Vite / env-validation /
-* the user's env.ts in.
+* CHILD side (`facts`): import the user's env.ts and derive its structural schema
+* facts. The import stays isolated because env.ts is arbitrary project code.
 */
 async function runFactsChild(root) {
-	const { resolveConfig } = await import("vite");
-	const resolved = await resolveConfig({ root }, "build", "production", "production");
-	const rawEnvDir = readBuildRawEnvDir(resolved.plugins);
-	const buildVarsDir = rawEnvDir ? join(resolved.root, rawEnvDir) : resolved.root;
-	if (resolved.envDir === false || resolved.envDir !== resolved.root || buildVarsDir !== resolved.root) {
-		emitResult({
-			kind: "reject",
-			reason: "custom-envdir"
-		});
-		return;
-	}
-	if (resolved.mode !== "production") {
-		emitResult({
-			kind: "reject",
-			reason: "non-production-mode"
-		});
-		return;
-	}
-	const { deriveSelfHostSchemaFacts, SelfHostSchemaError } = await import("../env-validation-Dea3v3ej.mjs").then((n) => n.c);
+	const { deriveSelfHostSchemaFacts, SelfHostSchemaError } = await import("../env-validation-ENpMy6Ez.mjs").then((n) => n.s);
 	try {
 		emitResult({
 			kind: "ok",
@@ -233,7 +185,7 @@ async function runFactsChild(root) {
 * fault → fail closed as a values-free schema error.
 */
 async function runValidateEmittedChild(root) {
-	const { computeInvalidEmittedKeys, readEmittedWorkerVars, SelfHostSchemaError } = await import("../env-validation-Dea3v3ej.mjs").then((n) => n.c);
+	const { computeInvalidEmittedKeys, readEmittedWorkerVars, SelfHostSchemaError } = await import("../env-validation-ENpMy6Ez.mjs").then((n) => n.s);
 	const emitted = readEmittedWorkerVars(root);
 	if (!emitted.ok) {
 		emitResult({