void 0.1.6 → 0.7.0

package/dist/runtime/handler.mjs

@@ -0,0 +1,85 @@
+import { convertReturnValue } from "./response.mjs";
+import { runValidation } from "./validator.mjs";
+import { i as ValidationError, n as defer } from "../defer-DcxEsVH1.mjs";
+//#region src/runtime/handler.ts
+/**
+* Thrown when `c.rewrite()` is called with a destination whose final path
+* segment ends in a known static-asset extension (e.g. `/hero.png`,
+* `/app.css`). Runtime rewrites only reach routes and SSR entries inside
+* the worker — static asset handlers run in front of the worker, so a
+* `c.rewrite()` into an asset path re-enters the Hono router, matches
+* nothing, and returns a 404. Fail at the call site so users reach for
+* static `routing.rewrites` instead of debugging a mystery 404.
+*/
+var VoidAssetRewriteError = class extends Error {
+	name = "VoidAssetRewriteError";
+	constructor(destination) {
+		super(`c.rewrite() cannot re-dispatch to a static asset path (${JSON.stringify(destination)}). Runtime rewrites only reach routes and SSR entries inside the worker — static asset handlers run in front of the worker. To rewrite into an asset, use a static \`routing.rewrites\` rule in void.json or a \`200!\` entry in _redirects. See https://void.dev/guide/edge/rewrites#runtime-rewrites-cannot-reach-static-assets`);
+	}
+};
+function defineHandler(...args) {
+	if (args.length === 1) return args[0];
+	const middlewares = args.slice(0, -1);
+	const handler = args[args.length - 1];
+	return (async (c) => {
+		let index = 0;
+		const dispatch = async () => {
+			if (index < middlewares.length) {
+				const mw = middlewares[index++];
+				const res = await mw(c, dispatch);
+				if (res instanceof Response) c.res = res;
+			} else c.res = convertReturnValue(await handler(c));
+		};
+		await dispatch();
+		return c.res;
+	});
+}
+(function(_defineHandler) {
+	function withValidator(validators) {
+		return (handler) => {
+			return (async (c) => {
+				const result = await runValidation(validators, c);
+				if (!result.ok) return result.response;
+				return convertReturnValue(await handler(c, result.input));
+			});
+		};
+	}
+	_defineHandler.withValidator = withValidator;
+})(defineHandler || (defineHandler = {}));
+/**
+* Identity function that provides type inference for middleware.
+* At runtime it simply returns the function passed to it.
+*/
+function defineMiddleware(handler) {
+	return handler;
+}
+/**
+* Identity function that provides type inference for scheduled jobs.
+* At runtime it simply returns the function passed to it.
+*/
+function defineScheduled(handler) {
+	return handler;
+}
+/**
+* Identity function that provides type inference for SSR render entry.
+* The second argument includes asset tags for client scripts/styles.
+*/
+function defineRender(handler) {
+	return handler;
+}
+/**
+* Identity function that provides type inference for page `head()` exports.
+* At runtime it simply returns the function passed to it.
+*/
+function defineHead(handler) {
+	return handler;
+}
+/**
+* Identity function that provides type inference for queue consumers.
+* At runtime it simply returns the function passed to it.
+*/
+function defineQueue(handler) {
+	return handler;
+}
+//#endregion
+export { ValidationError, VoidAssetRewriteError, defer, defineHandler, defineHead, defineMiddleware, defineQueue, defineRender, defineScheduled };

package/dist/runtime/isr.d.mts

@@ -0,0 +1,26 @@
+//#region src/runtime/isr.d.ts
+interface RevalidateOptions {
+  paths?: Array<string>;
+  all?: boolean;
+}
+/**
+* Revalidate ISR-cached pages on demand.
+*
+* In production, calls the platform proxy via service binding which forwards
+* to the API for R2 deletion + edge cache purge. In local dev, this is a
+* no-op (no ISR cache to purge).
+*
+* @example
+* ```ts
+* import { revalidate } from "void/isr";
+*
+* // Revalidate specific paths
+* await revalidate({ paths: ["/", "/blog/hello"] });
+*
+* // Revalidate all ISR pages
+* await revalidate({ all: true });
+* ```
+*/
+declare function revalidate(options: RevalidateOptions): Promise<void>;
+//#endregion
+export { RevalidateOptions, revalidate };

package/dist/runtime/isr.mjs

@@ -0,0 +1,43 @@
+import { i as getRawRuntimeEnv } from "../env-raw-BDL4TvdN.mjs";
+//#region src/runtime/isr.ts
+/**
+* Revalidate ISR-cached pages on demand.
+*
+* In production, calls the platform proxy via service binding which forwards
+* to the API for R2 deletion + edge cache purge. In local dev, this is a
+* no-op (no ISR cache to purge).
+*
+* @example
+* ```ts
+* import { revalidate } from "void/isr";
+*
+* // Revalidate specific paths
+* await revalidate({ paths: ["/", "/blog/hello"] });
+*
+* // Revalidate all ISR pages
+* await revalidate({ all: true });
+* ```
+*/
+async function revalidate(options) {
+	const rawEnv = getRawRuntimeEnv();
+	const proxy = rawEnv.__VOID_PROXY;
+	if (!proxy) return;
+	const projectId = rawEnv.__PROJECT_ID;
+	const token = rawEnv.__VOID_PROXY_TOKEN;
+	if (!projectId || !token) throw new Error("isr: Revalidation requires __PROJECT_ID and __VOID_PROXY_TOKEN bindings.");
+	const response = await proxy.fetch("https://proxy/revalidate", {
+		method: "POST",
+		headers: { "content-type": "application/json" },
+		body: JSON.stringify({
+			projectId,
+			aiToken: token,
+			...options
+		})
+	});
+	if (!response.ok) {
+		const text = await response.text();
+		throw new Error(`isr: Revalidation failed with ${response.status}: '${text}'.`);
+	}
+}
+//#endregion
+export { revalidate };

package/dist/runtime/kv.d.mts

@@ -0,0 +1,48 @@
+//#region src/runtime/kv.d.ts
+interface PutOptions {
+  ttl?: number;
+  expiration?: number;
+  metadata?: Record<string, unknown>;
+}
+interface ListOptions {
+  prefix?: string;
+  limit?: number;
+  cursor?: string;
+}
+interface ListKey<M = unknown> {
+  name: string;
+  expiration?: number;
+  metadata?: M;
+}
+interface ListResult<M = unknown> {
+  keys: Array<ListKey<M>>;
+  list_complete: boolean;
+  cursor?: string;
+}
+interface KVMap<T> {
+  get(key: string): Promise<T | null>;
+  put(key: string, value: T, options?: PutOptions): Promise<void>;
+  delete(key: string): Promise<void>;
+  list<M = unknown>(options?: Omit<ListOptions, "prefix">): Promise<ListResult<M>>;
+  getWithMetadata<M = unknown>(key: string): Promise<{
+    value: T | null;
+    metadata: M | null;
+  }>;
+}
+interface KVClient {
+  get<T = string>(key: string): Promise<T | null>;
+  put(key: string, value: unknown, options?: PutOptions): Promise<void>;
+  delete(key: string): Promise<void>;
+  list<M = unknown>(options?: ListOptions): Promise<ListResult<M>>;
+  getWithMetadata<T = string, M = unknown>(key: string): Promise<{
+    value: T | null;
+    metadata: M | null;
+  }>;
+  map<T = unknown>(prefix: string): KVMap<T>;
+}
+/** Create a KV client for a specific KVNamespace instance. */
+declare function createKV(namespace: KVNamespace): KVClient;
+/** Default KV client — resolves `KV` from the active runtime environment. */
+declare const kv: KVClient;
+//#endregion
+export { KVClient, KVMap, ListKey, ListOptions, ListResult, PutOptions, createKV, kv };

package/dist/runtime/kv.mjs

@@ -0,0 +1,106 @@
+import { requireRuntimeBinding } from "./env.mjs";
+//#region src/runtime/kv.ts
+function parseValue(raw) {
+	if (raw === null) return null;
+	try {
+		return JSON.parse(raw);
+	} catch {
+		return raw;
+	}
+}
+function serializeValue(value) {
+	if (typeof value === "string") return value;
+	return JSON.stringify(value);
+}
+function getListCursor(result) {
+	return typeof result.cursor === "string" ? result.cursor : void 0;
+}
+function createKVMap(getNS, prefix) {
+	const prefixed = (key) => `${prefix}:${key}`;
+	return {
+		async get(key) {
+			return parseValue(await getNS().get(prefixed(key)));
+		},
+		async put(key, value, options) {
+			const opts = {};
+			if (options?.ttl) opts.expirationTtl = options.ttl;
+			if (options?.expiration) opts.expiration = options.expiration;
+			if (options?.metadata) opts.metadata = options.metadata;
+			await getNS().put(prefixed(key), serializeValue(value), opts);
+		},
+		async delete(key) {
+			await getNS().delete(prefixed(key));
+		},
+		async list(options) {
+			const result = await getNS().list({
+				prefix: `${prefix}:`,
+				limit: options?.limit,
+				cursor: options?.cursor
+			});
+			const stripLen = prefix.length + 1;
+			return {
+				keys: result.keys.map((k) => ({
+					...k,
+					name: k.name.slice(stripLen)
+				})),
+				list_complete: result.list_complete,
+				cursor: getListCursor(result)
+			};
+		},
+		async getWithMetadata(key) {
+			const result = await getNS().getWithMetadata(prefixed(key));
+			const metadata = result.metadata;
+			return {
+				value: parseValue(result.value),
+				metadata
+			};
+		}
+	};
+}
+function createKVClient(getNS) {
+	return {
+		async get(key) {
+			return parseValue(await getNS().get(key));
+		},
+		async put(key, value, options) {
+			const opts = {};
+			if (options?.ttl) opts.expirationTtl = options.ttl;
+			if (options?.expiration) opts.expiration = options.expiration;
+			if (options?.metadata) opts.metadata = options.metadata;
+			await getNS().put(key, serializeValue(value), opts);
+		},
+		async delete(key) {
+			await getNS().delete(key);
+		},
+		async list(options) {
+			const result = await getNS().list({
+				prefix: options?.prefix,
+				limit: options?.limit,
+				cursor: options?.cursor
+			});
+			return {
+				keys: result.keys,
+				list_complete: result.list_complete,
+				cursor: getListCursor(result)
+			};
+		},
+		async getWithMetadata(key) {
+			const result = await getNS().getWithMetadata(key);
+			return {
+				value: parseValue(result.value),
+				metadata: result.metadata
+			};
+		},
+		map(prefix) {
+			return createKVMap(getNS, prefix);
+		}
+	};
+}
+/** Create a KV client for a specific KVNamespace instance. */
+function createKV(namespace) {
+	return createKVClient(() => namespace);
+}
+/** Default KV client — resolves `KV` from the active runtime environment. */
+const kv = createKVClient(() => requireRuntimeBinding("KV"));
+//#endregion
+export { createKV, kv };

package/dist/runtime/log.d.mts

@@ -0,0 +1,24 @@
+//#region src/runtime/log.d.ts
+/**
+* Structured logger that emits each entry as a single stringified-JSON line
+* to `console.error/warn/info`. The shape `{ msg, ...fields }` is a stable
+* contract: Cloudflare Tail captures each call as one `logs[]` entry with
+* the right `level`, and platform-side log filtering can match on `msg` or
+* any custom field.
+*
+* @example
+* ```ts
+* import { logger } from "void/log";
+*
+* logger.error("websocket failed", { jobId, attempt: 3 });
+* logger.info("user signed in", { userId });
+* ```
+*/
+type Fields = Record<string, unknown>;
+declare const logger: {
+  error(message: string, fields?: Fields): void;
+  warn(message: string, fields?: Fields): void;
+  info(message: string, fields?: Fields): void;
+};
+//#endregion
+export { logger };

package/dist/runtime/log.mjs

@@ -0,0 +1,31 @@
+//#region src/runtime/log.ts
+function format(message, fields) {
+	try {
+		const payload = Object.create(null);
+		payload.msg = message;
+		if (fields) for (const [key, value] of Object.entries(fields)) {
+			if (key === "msg" || key === "toJSON" || key === "__proto__" || key === "constructor") continue;
+			if (typeof value === "function") continue;
+			payload[key] = value;
+		}
+		return JSON.stringify(payload);
+	} catch {
+		return JSON.stringify({
+			msg: message,
+			error: "log: fields not serializable"
+		});
+	}
+}
+const logger = {
+	error(message, fields) {
+		console.error(format(message, fields));
+	},
+	warn(message, fields) {
+		console.warn(format(message, fields));
+	},
+	info(message, fields) {
+		console.info(format(message, fields));
+	}
+};
+//#endregion
+export { logger };

package/dist/runtime/migration-handler-pg.d.mts

@@ -0,0 +1,6 @@
+import { MigrationEntry } from "./migration-handler.mjs";
+
+//#region src/runtime/migration-handler-pg.d.ts
+declare function createMigrationHandler(env: Record<string, unknown>, migrations: Array<MigrationEntry>, _dialect: "sqlite" | "postgresql", runAuthMigrations?: () => Promise<void>): (request: Request) => Promise<Response>;
+//#endregion
+export { createMigrationHandler };

package/dist/runtime/migration-handler-pg.mjs

@@ -0,0 +1,85 @@
+//#region src/runtime/migration-handler-pg.ts
+function createMigrationHandler(env, migrations, _dialect, runAuthMigrations) {
+	return async (request) => {
+		const token = request.headers.get("x-void-internal");
+		if (!token || token !== env.__VOID_PROXY_TOKEN) return Response.json({
+			ok: false,
+			error: "unauthorized",
+			migrations: []
+		}, { status: 401 });
+		try {
+			const result = await runPgMigrations(env, migrations);
+			if (result.ok && runAuthMigrations) await runAuthMigrations();
+			return Response.json(result);
+		} catch (err) {
+			return Response.json({
+				ok: false,
+				error: err instanceof Error ? err.message : String(err),
+				migrations: []
+			}, { status: 500 });
+		}
+	};
+}
+async function runPgMigrations(env, migrations) {
+	const hyperdrive = env.HYPERDRIVE;
+	if (!hyperdrive?.connectionString) return {
+		ok: false,
+		error: "no HYPERDRIVE binding found",
+		migrations: []
+	};
+	const { Client } = await import("pg");
+	const client = new Client({ connectionString: hyperdrive.connectionString });
+	await client.connect();
+	try {
+		await client.query(`CREATE TABLE IF NOT EXISTS _void_migrations (
+        name TEXT PRIMARY KEY,
+        applied_at TEXT NOT NULL
+      )`);
+		const { rows } = await client.query("SELECT name FROM _void_migrations");
+		const applied = new Set(rows.map((r) => r.name));
+		const migrationResults = [];
+		for (const m of migrations) {
+			if (applied.has(m.name)) {
+				migrationResults.push({
+					name: m.name,
+					applied: false,
+					durationMs: 0
+				});
+				continue;
+			}
+			const start = Date.now();
+			try {
+				await client.query("BEGIN");
+				await client.query(m.sql);
+				await client.query("INSERT INTO _void_migrations (name, applied_at) VALUES ($1, $2)", [m.name, (/* @__PURE__ */ new Date()).toISOString()]);
+				await client.query("COMMIT");
+				migrationResults.push({
+					name: m.name,
+					applied: true,
+					durationMs: Date.now() - start
+				});
+			} catch (err) {
+				await client.query("ROLLBACK");
+				migrationResults.push({
+					name: m.name,
+					applied: false,
+					durationMs: Date.now() - start,
+					error: err instanceof Error ? err.message : String(err)
+				});
+				return {
+					ok: false,
+					migrations: migrationResults,
+					error: `migration ${m.name} failed`
+				};
+			}
+		}
+		return {
+			ok: true,
+			migrations: migrationResults
+		};
+	} finally {
+		await client.end();
+	}
+}
+//#endregion
+export { createMigrationHandler };

package/dist/runtime/migration-handler.d.mts

@@ -0,0 +1,19 @@
+//#region src/runtime/migration-handler.d.ts
+interface MigrationEntry {
+  name: string;
+  sql: string;
+}
+interface MigrationResult {
+  name: string;
+  applied: boolean;
+  durationMs: number;
+  error?: string;
+}
+interface MigrationResponse {
+  ok: boolean;
+  migrations: Array<MigrationResult>;
+  error?: string;
+}
+declare function createMigrationHandler(env: Record<string, unknown>, migrations: Array<MigrationEntry> | undefined, _dialect: "sqlite" | "postgresql", runAuthMigrations?: () => Promise<void>): (request: Request) => Promise<Response>;
+//#endregion
+export { MigrationEntry, MigrationResponse, MigrationResult, createMigrationHandler };

package/dist/runtime/migration-handler.mjs

@@ -0,0 +1,92 @@
+//#region src/runtime/migration-handler.ts
+function createMigrationHandler(env, migrations, _dialect, runAuthMigrations) {
+	return async (request) => {
+		const token = request.headers.get("x-void-internal");
+		if (!token || token !== env.__VOID_PROXY_TOKEN) return Response.json({
+			ok: false,
+			error: "unauthorized",
+			migrations: []
+		}, { status: 401 });
+		try {
+			const db = env.DB;
+			if (!db) return Response.json({
+				ok: false,
+				error: "no D1 binding found",
+				migrations: []
+			}, { status: 500 });
+			const result = await runD1Migrations(db, migrations ?? []);
+			if (result.ok && runAuthMigrations) await runAuthMigrations();
+			return Response.json(result);
+		} catch (err) {
+			return Response.json({
+				ok: false,
+				error: err instanceof Error ? err.message : String(err),
+				migrations: []
+			}, { status: 500 });
+		}
+	};
+}
+/**
+* One-time migration: rename legacy `_migrations` table to `_void_migrations`.
+* Copies all rows from the old table to the new one, then drops the old table.
+*/
+async function upgradeTrackingTable(db) {
+	const { results } = await db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='_migrations'").all();
+	if (!results || results.length === 0) return;
+	await db.batch([
+		db.prepare(`CREATE TABLE IF NOT EXISTS _void_migrations (
+        name TEXT PRIMARY KEY,
+        applied_at TEXT NOT NULL
+      )`),
+		db.prepare(`INSERT OR IGNORE INTO _void_migrations (name, applied_at) SELECT name, applied_at FROM _migrations`),
+		db.prepare(`DROP TABLE _migrations`)
+	]);
+}
+async function runD1Migrations(db, migrations) {
+	await db.prepare(`CREATE TABLE IF NOT EXISTS _void_migrations (
+      name TEXT PRIMARY KEY,
+      applied_at TEXT NOT NULL
+    )`).run();
+	await upgradeTrackingTable(db);
+	const { results } = await db.prepare("SELECT name FROM _void_migrations").all();
+	const applied = new Set((results ?? []).map((r) => r.name));
+	const migrationResults = [];
+	for (const m of migrations) {
+		if (applied.has(m.name)) {
+			migrationResults.push({
+				name: m.name,
+				applied: false,
+				durationMs: 0
+			});
+			continue;
+		}
+		const start = Date.now();
+		try {
+			const statements = m.sql.split(";").map((s) => s.trim()).filter((s) => s.length > 0);
+			await db.batch([...statements.map((s) => db.prepare(s)), db.prepare("INSERT INTO _void_migrations (name, applied_at) VALUES (?, ?)").bind(m.name, (/* @__PURE__ */ new Date()).toISOString())]);
+			migrationResults.push({
+				name: m.name,
+				applied: true,
+				durationMs: Date.now() - start
+			});
+		} catch (err) {
+			migrationResults.push({
+				name: m.name,
+				applied: false,
+				durationMs: Date.now() - start,
+				error: err instanceof Error ? err.message : String(err)
+			});
+			return {
+				ok: false,
+				migrations: migrationResults,
+				error: `migration ${m.name} failed`
+			};
+		}
+	}
+	return {
+		ok: true,
+		migrations: migrationResults
+	};
+}
+//#endregion
+export { createMigrationHandler };

package/dist/runtime/queues.d.mts

@@ -0,0 +1,7 @@
+//#region src/runtime/queues.d.ts
+/** Stub interface augmented by generated .void/queues.d.ts */
+interface QueueMap {}
+/** Typed queue producers — resolves `QUEUE_*` bindings from the active runtime environment. */
+declare const queues: QueueMap;
+//#endregion
+export { QueueMap, queues };

package/dist/runtime/queues.mjs

@@ -0,0 +1,8 @@
+import { requireRuntimeBinding } from "./env.mjs";
+//#region src/runtime/queues.ts
+/** Typed queue producers — resolves `QUEUE_*` bindings from the active runtime environment. */
+const queues = new Proxy({}, { get(_, name) {
+	return requireRuntimeBinding(`QUEUE_${name.toUpperCase().replace(/[^A-Z0-9]/g, "_")}`);
+} });
+//#endregion
+export { queues };

package/dist/runtime/remote/binding-handler.d.mts

@@ -0,0 +1,15 @@
+import { Hono } from "hono";
+
+//#region src/runtime/remote/binding-handler.d.ts
+/**
+* Creates a Hono app that handles `/__void/*` routes for native binding access.
+* Deployed user workers expose this so the proxy can dispatch D1/KV/R2 operations
+* via Workers for Platforms instead of the Cloudflare REST API (~1-5ms vs ~50-200ms).
+*
+* Authenticated via `x-void-internal` header against `env.__VOID_PROXY_TOKEN`.
+* Response formats match the proxy's existing REST API responses so the
+* ProxyClient doesn't need changes.
+*/
+declare function createBindingHandler(env: Record<string, unknown>): Hono;
+//#endregion
+export { createBindingHandler };