void 0.1.6 → 0.7.0

package/dist/runtime/env-public.mjs

@@ -0,0 +1,366 @@
+import { i as getRawRuntimeEnv } from "../env-raw-BDL4TvdN.mjs";
+import { getRuntimeEnv } from "./env.mjs";
+import { boolean, email, getSecretOverride, json, number, oneOf, string, url } from "./env-helpers.mjs";
+//#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
+//#region src/runtime/env-public.ts
+/**
+* Public env API — `void/env`.
+*
+* Canonical usage:
+*
+* ```ts
+* // env.ts at project root
+* import { defineEnv, string, number, oneOf } from "void/env";
+*
+* export default defineEnv({
+*   STRIPE_KEY: string(),
+*   PORT: number().default(3000),
+*   NODE_ENV: oneOf(["development", "production"]),
+*   VITE_APP_TITLE: string(),
+* });
+*
+* // anywhere else
+* import { env } from "void/env";
+* env.STRIPE_KEY;
+* ```
+*
+* The `env` proxy reads from the underlying runtime env (Cloudflare worker
+* bindings, Node `process.env`, Nuxt globals, etc.) via `getRuntimeEnv()`,
+* and validates each key on first access using the registered schema.
+*
+* Bindings (`DB`, `KV`, `STORAGE`, `AI`, queue handlers) and other env keys
+* not declared in the schema pass through unchanged.
+*/
+let registeredSchema = null;
+let hasDefineEnvBeenCalled = false;
+const validatedCache = /* @__PURE__ */ new WeakMap();
+/**
+* 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.
+*/
+function defineEnv(schema) {
+	registeredSchema = schema;
+	hasDefineEnvBeenCalled = true;
+	for (const map of validatedCacheValues()) map.clear();
+	bootValidationState = null;
+	return env;
+}
+let bootValidationState = null;
+/**
+* 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.
+*/
+async function _validateEnvOnce(envValues) {
+	if (bootValidationState) {
+		if (!bootValidationState.ok) throw bootValidationState.error;
+		return;
+	}
+	if (!registeredSchema) {
+		bootValidationState = { ok: true };
+		return;
+	}
+	const report = await validateAllEnvWithValues(registeredSchema, envValues ?? {});
+	if (report.valid) {
+		try {
+			const cacheKey = getRawRuntimeEnv();
+			let cache = validatedCache.get(cacheKey);
+			if (!cache) {
+				cache = /* @__PURE__ */ new Map();
+				validatedCache.set(cacheKey, cache);
+				cacheList.push(cache);
+			}
+			for (const [key, value] of report.values) if (!cache.has(key)) cache.set(key, value);
+		} catch {}
+		bootValidationState = { ok: true };
+		return;
+	}
+	const lines = ["Env validation failed at worker boot:"];
+	for (const key of report.missing) lines.push(`  • ${key} is required but missing`);
+	for (const { key, messages } of report.invalid) lines.push(`  • ${key}: ${messages.join("; ")}`);
+	const error = new EnvValidationError("__init__", [{ message: lines.join("\n") }]);
+	bootValidationState = {
+		ok: false,
+		error
+	};
+	throw error;
+}
+function validatedCacheValues() {
+	return cacheList;
+}
+const cacheList = [];
+/** Internal: framework-only access to the registered schema (for plugin/CLI). */
+function _getRegisteredSchema() {
+	return registeredSchema;
+}
+/**
+* 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".
+*/
+function _hasRegisteredSchema() {
+	return hasDefineEnvBeenCalled;
+}
+/**
+* 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.
+*/
+function _getSchemaDefaults() {
+	const defaults = {};
+	if (!registeredSchema) return defaults;
+	for (const [key, validator] of Object.entries(registeredSchema)) {
+		let result;
+		try {
+			result = validator["~standard"].validate(void 0);
+		} catch {
+			continue;
+		}
+		if (result instanceof Promise) continue;
+		const r = result;
+		if (r.issues) continue;
+		if (r.value === void 0 || r.value === null) continue;
+		defaults[key] = typeof r.value === "string" ? r.value : String(r.value);
+	}
+	return defaults;
+}
+var EnvValidationError = class extends Error {
+	constructor(key, issues) {
+		super(`Invalid env "${key}": ${issues.map((i) => i.message).join(", ")}`);
+		this.key = key;
+		this.issues = issues;
+		this.name = "EnvValidationError";
+	}
+};
+function readKey(key) {
+	const rawValue = getRuntimeEnv()[key];
+	if (!registeredSchema) return rawValue;
+	const validator = registeredSchema[key];
+	if (!validator) return rawValue;
+	const cacheKey = getRawRuntimeEnv();
+	let cache = validatedCache.get(cacheKey);
+	if (!cache) {
+		cache = /* @__PURE__ */ new Map();
+		validatedCache.set(cacheKey, cache);
+		cacheList.push(cache);
+	}
+	if (cache.has(key)) return cache.get(key);
+	const result = validator["~standard"].validate(rawValue);
+	if (result instanceof Promise) throw new Error(`env: Async validator for '${key}' cannot be resolved synchronously. Proxy property access is synchronous, so async Standard Schema validators must be pre-resolved by calling \`_validateEnvOnce(env)\` at worker boot (Void splices this into the generated entry) or by awaiting \`validateAllEnv(env)\` before the first \`env.${key}\` read. Once pre-validated, the resolved value is cached and served synchronously here.`);
+	if (result.issues) {
+		const unmask = isUnmaskActive();
+		const override = getSecretOverride(validator);
+		throw new EnvValidationError(key, result.issues.map((i) => ({
+			...i,
+			message: redactMessage(key, rawValue, i.message, {
+				override,
+				unmask
+			})
+		})));
+	}
+	cache.set(key, result.value);
+	return result.value;
+}
+/**
+* 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.
+*/
+const env = new Proxy({}, {
+	get(_target, key) {
+		if (typeof key === "symbol") return;
+		return readKey(key);
+	},
+	has(_target, key) {
+		if (typeof key === "symbol") return false;
+		return Reflect.has(getRuntimeEnv(), key);
+	},
+	ownKeys() {
+		return Reflect.ownKeys(getRuntimeEnv());
+	},
+	getOwnPropertyDescriptor(_target, key) {
+		if (typeof key === "symbol") return;
+		return {
+			enumerable: true,
+			configurable: true,
+			value: readKey(String(key))
+		};
+	}
+});
+/**
+* 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.
+*/
+async function validateAllEnv(envValues) {
+	if (!registeredSchema) return {
+		valid: true,
+		missing: [],
+		invalid: [],
+		values: /* @__PURE__ */ new Map()
+	};
+	return await validateAllEnvWithValues(registeredSchema, envValues);
+}
+/**
+* Internal: shared core that validates a schema against values and also
+* returns the resolved values (for cache seeding).
+*/
+async function validateAllEnvWithValues(schema, envValues) {
+	const report = {
+		valid: true,
+		missing: [],
+		invalid: [],
+		values: /* @__PURE__ */ new Map()
+	};
+	const unmask = isUnmaskActive();
+	for (const [key, validator] of Object.entries(schema)) {
+		const raw = envValues[key];
+		const resultMaybe = validator["~standard"].validate(raw);
+		const result = resultMaybe instanceof Promise ? await resultMaybe : resultMaybe;
+		if (result.issues) {
+			report.valid = false;
+			if (raw === void 0 || raw === null || raw === "") report.missing.push(key);
+			else {
+				const override = getSecretOverride(validator);
+				report.invalid.push({
+					key,
+					messages: result.issues.map((i) => redactMessage(key, raw, i.message, {
+						override,
+						unmask
+					}))
+				});
+			}
+		} else report.values.set(key, result.value);
+	}
+	return report;
+}
+//#endregion
+export { EnvValidationError, _getRegisteredSchema, _getSchemaDefaults, _hasRegisteredSchema, _validateEnvOnce, boolean, defineEnv, email, env, json, number, oneOf, string, url, validateAllEnv };

package/dist/runtime/env.d.mts

@@ -0,0 +1,13 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+
+//#region src/runtime/env-raw.d.ts
+type RuntimeEnv = Record<string, unknown>;
+//#endregion
+//#region src/runtime/env.d.ts
+declare function withRuntimeEnv<T>(env: unknown, fn: () => T): T;
+/** Returns the runtime env with internal platform bindings hidden. */
+declare function getRuntimeEnv(): RuntimeEnv;
+declare function getRuntimeBinding<T = unknown>(name: string): T | undefined;
+declare function requireRuntimeBinding<T = unknown>(name: string): T;
+//#endregion
+export { type RuntimeEnv, getRuntimeBinding, getRuntimeEnv, requireRuntimeBinding, withRuntimeEnv };

package/dist/runtime/env.mjs

@@ -0,0 +1,51 @@
+import { i as getRawRuntimeEnv, n as asEnv, r as envContext, t as INTERNAL_BINDING_PREFIXES } from "../env-raw-BDL4TvdN.mjs";
+//#region src/runtime/env.ts
+/**
+* Public runtime env API — exposed via "void/_env".
+*
+* All exports from this module are accessible to user code.
+* Internal platform bindings (__VOID_*, __PROJECT_*) are filtered
+* from getRuntimeEnv() and blocked in getRuntimeBinding().
+*/
+function withRuntimeEnv(env, fn) {
+	const resolved = asEnv(env);
+	if (!resolved) return fn();
+	return envContext.run(resolved, fn);
+}
+function isInternalBinding(name) {
+	return INTERNAL_BINDING_PREFIXES.some((p) => name.startsWith(p));
+}
+function filterEnvProxy(env) {
+	return new Proxy(env, {
+		get(target, prop, receiver) {
+			if (typeof prop === "string" && isInternalBinding(prop)) return;
+			return Reflect.get(target, prop, receiver);
+		},
+		has(target, prop) {
+			if (typeof prop === "string" && isInternalBinding(prop)) return false;
+			return Reflect.has(target, prop);
+		},
+		ownKeys(target) {
+			return Reflect.ownKeys(target).filter((key) => typeof key !== "string" || !isInternalBinding(key));
+		},
+		getOwnPropertyDescriptor(target, prop) {
+			if (typeof prop === "string" && isInternalBinding(prop)) return;
+			return Reflect.getOwnPropertyDescriptor(target, prop);
+		}
+	});
+}
+/** Returns the runtime env with internal platform bindings hidden. */
+function getRuntimeEnv() {
+	return filterEnvProxy(getRawRuntimeEnv());
+}
+function getRuntimeBinding(name) {
+	if (isInternalBinding(name)) return;
+	return getRawRuntimeEnv()[name];
+}
+function requireRuntimeBinding(name) {
+	const value = getRuntimeBinding(name);
+	if (value !== void 0 && value !== null) return value;
+	throw new Error(`env: Missing Cloudflare binding '${name}'.`);
+}
+//#endregion
+export { getRuntimeBinding, getRuntimeEnv, requireRuntimeBinding, withRuntimeEnv };

package/dist/runtime/fetch-stream.d.mts

@@ -0,0 +1,51 @@
+import { t as FetchError } from "../fetch-error-CVZ5CGA-.mjs";
+import { RouteMap } from "void/routes";
+
+//#region src/runtime/fetch-stream.d.ts
+type MethodsOf<P extends keyof RouteMap> = keyof RouteMap[P] & string;
+type InputOf<P extends keyof RouteMap, M extends MethodsOf<P>> = RouteMap[P][M] extends {
+  input: infer I;
+} ? I : {};
+type BodyOption<I> = "body" extends keyof I ? {
+  body: I["body" & keyof I];
+} : {
+  body?: Record<string, unknown> | BodyInit | null;
+};
+type QueryOption<I> = "query" extends keyof I ? {
+  query: I["query" & keyof I];
+} : {
+  query?: Record<string, string>;
+};
+type ParamsOption<I> = "params" extends keyof I ? {
+  params: I["params" & keyof I];
+} : {
+  params?: Record<string, string>;
+};
+type StreamOptions<P extends keyof RouteMap, M extends MethodsOf<P>> = BodyOption<InputOf<P, M>> & QueryOption<InputOf<P, M>> & ParamsOption<InputOf<P, M>> & {
+  method?: M;
+  headers?: HeadersInit;
+  signal?: AbortSignal;
+  baseURL?: string;
+};
+/**
+* Consume an SSE endpoint as an async generator of text chunks.
+*
+* Parses Workers AI SSE format (`data: {"response":"chunk"}` + `data: [DONE]`)
+* and plain text SSE (`data: some text`).
+*
+* ```ts
+* import { fetchStream } from "void/client";
+*
+* for await (const chunk of fetchStream("/api/ai/chat", {
+*   method: "POST",
+*   body: { messages: [{ role: "user", content: "Hello" }] },
+* })) {
+*   output += chunk;
+* }
+* ```
+*
+* @yields {string} Text chunks from SSE data frames.
+*/
+declare function fetchStream<P extends keyof RouteMap & string, M extends MethodsOf<P> = ("POST" extends MethodsOf<P> ? "POST" : MethodsOf<P>)>(path: P, options?: StreamOptions<P, M>): AsyncGenerator<string, void, undefined>;
+//#endregion
+export { FetchError as StreamError, fetchStream };

package/dist/runtime/fetch-stream.mjs

@@ -0,0 +1,81 @@
+import { n as ofetch, t as FetchError } from "../fetch-error-BQ8sZ5Nd.mjs";
+//#region src/runtime/fetch-stream.ts
+/**
+* Consume an SSE endpoint as an async generator of text chunks.
+*
+* Parses Workers AI SSE format (`data: {"response":"chunk"}` + `data: [DONE]`)
+* and plain text SSE (`data: some text`).
+*
+* ```ts
+* import { fetchStream } from "void/client";
+*
+* for await (const chunk of fetchStream("/api/ai/chat", {
+*   method: "POST",
+*   body: { messages: [{ role: "user", content: "Hello" }] },
+* })) {
+*   output += chunk;
+* }
+* ```
+*
+* @yields {string} Text chunks from SSE data frames.
+*/
+async function* fetchStream(path, options) {
+	let url = path;
+	if (options?.params) for (const [key, value] of Object.entries(options.params)) url = url.replace(`:${key}`, encodeURIComponent(value));
+	const body = (await ofetch.raw(url, {
+		method: options?.method ?? "POST",
+		body: options?.body,
+		query: options?.query,
+		headers: options?.headers,
+		signal: options?.signal,
+		baseURL: options?.baseURL,
+		responseType: "stream"
+	}))._data;
+	if (!body) return;
+	const reader = body.getReader();
+	const decoder = new TextDecoder();
+	let buffer = "";
+	try {
+		while (true) {
+			const { done, value } = await reader.read();
+			if (done) break;
+			buffer += decoder.decode(value, { stream: true });
+			const lines = buffer.split("\n");
+			buffer = lines.pop();
+			for (const line of lines) {
+				const trimmed = line.trim();
+				if (!trimmed || trimmed.startsWith(":")) continue;
+				if (trimmed.startsWith("data: ")) {
+					const data = trimmed.slice(6);
+					if (data === "[DONE]") return;
+					try {
+						const parsed = JSON.parse(data);
+						if (typeof parsed.response === "string") {
+							yield parsed.response;
+							continue;
+						}
+						if ("response" in parsed) continue;
+					} catch {}
+					yield data;
+				}
+			}
+		}
+		if (buffer.trim()) {
+			const trimmed = buffer.trim();
+			if (trimmed.startsWith("data: ")) {
+				const data = trimmed.slice(6);
+				if (data !== "[DONE]") try {
+					const parsed = JSON.parse(data);
+					if (typeof parsed.response === "string") yield parsed.response;
+					else if (!("response" in parsed)) yield data;
+				} catch {
+					yield data;
+				}
+			}
+		}
+	} finally {
+		reader.releaseLock();
+	}
+}
+//#endregion
+export { FetchError as StreamError, fetchStream };

package/dist/runtime/fetch.d.mts

@@ -0,0 +1,59 @@
+import { t as FetchError } from "../fetch-error-CVZ5CGA-.mjs";
+import { RouteMap } from "void/routes";
+
+//#region src/runtime/fetch.d.ts
+type MethodsOf<P extends keyof RouteMap> = keyof RouteMap[P] & string;
+type DefaultMethod<P extends keyof RouteMap> = "GET" extends MethodsOf<P> ? "GET" : never;
+type RouteEntry<P extends keyof RouteMap, M extends MethodsOf<P>> = RouteMap[P][M] extends {
+  input: infer I;
+  output: infer O;
+} ? {
+  input: I;
+  output: O;
+} : {
+  input: {};
+  output: unknown;
+};
+type OutputOf<P extends keyof RouteMap, M extends MethodsOf<P>> = RouteEntry<P, M>["output"];
+type InputOf<P extends keyof RouteMap, M extends MethodsOf<P>> = RouteEntry<P, M>["input"];
+type BodyOption<I> = "body" extends keyof I ? {
+  body: I["body" & keyof I];
+} : {
+  body?: Record<string, unknown> | BodyInit | null;
+};
+type QueryOption<I> = "query" extends keyof I ? {
+  query: I["query" & keyof I];
+} : {
+  query?: Record<string, string>;
+};
+type ParamsOption<I> = "params" extends keyof I ? {
+  params: I["params" & keyof I];
+} : {
+  params?: Record<string, string>;
+};
+type HasRequiredInput<P extends keyof RouteMap, M extends MethodsOf<P>> = "body" extends keyof InputOf<P, M> ? true : "query" extends keyof InputOf<P, M> ? true : "params" extends keyof InputOf<P, M> ? true : false;
+type FetchOptions<P extends keyof RouteMap, M extends MethodsOf<P>> = BodyOption<InputOf<P, M>> & QueryOption<InputOf<P, M>> & ParamsOption<InputOf<P, M>> & {
+  method?: M;
+  headers?: HeadersInit;
+  signal?: AbortSignal;
+  baseURL?: string;
+  retry?: number;
+  timeout?: number;
+};
+/**
+* Typed fetch client for Void API routes.
+*
+* Built on top of ofetch. Supports baseURL, retry, timeout, and all
+* ofetch features while providing full route type safety.
+*
+* ```ts
+* import { fetch } from "void/client";
+*
+* const users = await fetch("/api/users"); // typed!
+* const user = await fetch("/api/users/:id", { params: { id: "1" } });
+* ```
+*/
+declare function fetch<P extends keyof RouteMap & string>(path: HasRequiredInput<P, DefaultMethod<P>> extends false ? P : never): Promise<OutputOf<P, DefaultMethod<P>>>;
+declare function fetch<P extends keyof RouteMap & string, M extends MethodsOf<P> = DefaultMethod<P>>(path: P, options: FetchOptions<P, M>): Promise<OutputOf<P, M>>;
+//#endregion
+export { FetchError, fetch };

package/dist/runtime/fetch.mjs

@@ -0,0 +1,18 @@
+import { n as ofetch, t as FetchError } from "../fetch-error-BQ8sZ5Nd.mjs";
+//#region src/runtime/fetch.ts
+async function fetch(path, options) {
+	let url = path;
+	if (options?.params) for (const [key, value] of Object.entries(options.params)) url = url.replace(`:${key}`, encodeURIComponent(value));
+	return ofetch(url, {
+		method: options?.method ?? "GET",
+		body: options?.body,
+		query: options?.query,
+		headers: options?.headers,
+		signal: options?.signal,
+		baseURL: options?.baseURL,
+		retry: options?.retry,
+		timeout: options?.timeout
+	});
+}
+//#endregion
+export { FetchError, fetch };

package/dist/runtime/handler.d.mts

@@ -0,0 +1,3 @@
+/// <reference types="@cloudflare/workers-types" />
+import { C as HandlerInput, S as ValidationError, _ as defineScheduled, a as QueueBatch, b as InferProps, c as RenderAssetTags, d as VoidAssetRewriteError, f as defineHandler, g as defineRender, h as defineQueue, i as CloudEnv, l as TypedHandler, m as defineMiddleware, n as CloudContext, o as QueueMessage, p as defineHead, r as CloudContextVariables, s as QueueRetryOptions, t as CloudBindings, u as TypedQueueHandler, v as Deferred, w as ValidatorSlots, x as defer } from "../handler-B0ds0OHJ.mjs";
+export { CloudBindings, CloudContext, CloudContextVariables, CloudEnv, Deferred, HandlerInput, InferProps, QueueBatch, QueueMessage, QueueRetryOptions, RenderAssetTags, TypedHandler, TypedQueueHandler, ValidationError, ValidatorSlots, VoidAssetRewriteError, defer, defineHandler, defineHead, defineMiddleware, defineQueue, defineRender, defineScheduled };