void 0.1.6 → 0.7.0

package/dist/runtime/remote/binding-handler.mjs

@@ -0,0 +1,208 @@
+import { Hono } from "hono";
+//#region src/runtime/remote/binding-handler.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.
+*/
+function createBindingHandler(env) {
+	const app = new Hono();
+	app.use("*", async (c, next) => {
+		const token = c.req.header("x-void-internal");
+		const expected = env.__VOID_PROXY_TOKEN;
+		if (!token || !expected || token !== expected) return c.json({ error: "unauthorized" }, 403);
+		await next();
+	});
+	app.post("/d1/query", async (c) => {
+		const body = await c.req.json();
+		if (!body.binding || !body.sql) return c.json({ error: "binding and sql required" }, 400);
+		const db = env[body.binding];
+		if (!db) return c.json({ error: `unknown binding "${body.binding}"` }, 404);
+		const stmt = db.prepare(body.sql).bind(...body.params ?? []);
+		switch (body.method) {
+			case "first": {
+				const row = await stmt.first();
+				return c.json(row);
+			}
+			case "raw": {
+				const raw = await stmt.raw({ columnNames: true });
+				const columns = raw.length > 0 ? raw[0] : [];
+				const results = raw.slice(1);
+				return c.json({
+					columns,
+					results,
+					meta: {}
+				});
+			}
+			case "run": {
+				const result = await stmt.run();
+				return c.json({
+					success: true,
+					meta: result.meta
+				});
+			}
+			default: {
+				const result = await stmt.all();
+				return c.json({
+					results: result.results,
+					success: true,
+					meta: result.meta
+				});
+			}
+		}
+	});
+	app.post("/d1/batch", async (c) => {
+		const body = await c.req.json();
+		if (!body.binding || !Array.isArray(body.statements)) return c.json({ error: "binding and statements required" }, 400);
+		const db = env[body.binding];
+		if (!db) return c.json({ error: `unknown binding "${body.binding}"` }, 404);
+		const stmts = body.statements.map((s) => db.prepare(s.sql).bind(...s.params ?? []));
+		const results = await db.batch(stmts);
+		return c.json(results.map((r) => ({
+			results: r.results,
+			success: true,
+			meta: r.meta
+		})));
+	});
+	app.post("/kv/get", async (c) => {
+		const body = await c.req.json();
+		if (!body.binding || !body.key) return c.json({ error: "binding and key required" }, 400);
+		const kv = env[body.binding];
+		if (!kv) return c.json({ error: `unknown binding "${body.binding}"` }, 404);
+		const type = body.type ?? "text";
+		if (type === "json") {
+			const val = await kv.get(body.key, "json");
+			return c.json(val);
+		}
+		if (type === "arrayBuffer") {
+			const val = await kv.get(body.key, "arrayBuffer");
+			if (val === null) return c.json(null);
+			return new Response(val, { headers: { "content-type": "application/octet-stream" } });
+		}
+		if (type === "stream") {
+			const val = await kv.get(body.key, "stream");
+			if (val === null) return c.json(null);
+			return new Response(val, { headers: { "content-type": "application/octet-stream" } });
+		}
+		const val = await kv.get(body.key, "text");
+		if (val === null) return c.json(null);
+		return c.json(val);
+	});
+	app.post("/kv/put", async (c) => {
+		const body = await c.req.json();
+		if (!body.binding || !body.key) return c.json({ error: "binding and key required" }, 400);
+		const kv = env[body.binding];
+		if (!kv) return c.json({ error: `unknown binding "${body.binding}"` }, 404);
+		const opts = {};
+		if (body.expiration) opts.expiration = body.expiration;
+		if (body.expiration_ttl) opts.expirationTtl = body.expiration_ttl;
+		let value;
+		if (body.base64 && typeof body.value === "string") {
+			const binary = atob(body.value);
+			const bytes = new Uint8Array(binary.length);
+			for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
+			value = bytes.buffer;
+		} else value = typeof body.value === "string" ? body.value : JSON.stringify(body.value);
+		await kv.put(body.key, value, opts);
+		return c.json({ success: true });
+	});
+	app.post("/kv/delete", async (c) => {
+		const body = await c.req.json();
+		if (!body.binding || !body.key) return c.json({ error: "binding and key required" }, 400);
+		const kv = env[body.binding];
+		if (!kv) return c.json({ error: `unknown binding "${body.binding}"` }, 404);
+		await kv.delete(body.key);
+		return c.json({ success: true });
+	});
+	app.post("/kv/list", async (c) => {
+		const body = await c.req.json();
+		if (!body.binding) return c.json({ error: "binding required" }, 400);
+		const kv = env[body.binding];
+		if (!kv) return c.json({ error: `unknown binding "${body.binding}"` }, 404);
+		const opts = {};
+		if (body.prefix) opts.prefix = body.prefix;
+		if (body.limit) opts.limit = body.limit;
+		if (body.cursor) opts.cursor = body.cursor;
+		const result = await kv.list(opts);
+		return c.json({
+			keys: result.keys,
+			list_complete: result.list_complete,
+			cursor: result.list_complete ? null : result.cursor
+		});
+	});
+	app.post("/r2/get", async (c) => {
+		const body = await c.req.json();
+		if (!body.binding || !body.key) return c.json({ error: "binding and key required" }, 400);
+		const bucket = env[body.binding];
+		if (!bucket) return c.json({ error: `unknown binding "${body.binding}"` }, 404);
+		const obj = await bucket.get(body.key);
+		if (!obj) return c.json(null);
+		const headers = new Headers();
+		headers.set("content-type", obj.httpMetadata?.contentType ?? "application/octet-stream");
+		if (obj.size !== void 0) headers.set("content-length", String(obj.size));
+		if (obj.httpEtag) headers.set("etag", obj.httpEtag);
+		return new Response(obj.body, { headers });
+	});
+	app.post("/r2/put", async (c) => {
+		const body = await c.req.json();
+		if (!body.binding || !body.key) return c.json({ error: "binding and key required" }, 400);
+		const bucket = env[body.binding];
+		if (!bucket) return c.json({ error: `unknown binding "${body.binding}"` }, 404);
+		const data = body.base64 ? Uint8Array.from(atob(body.base64), (ch) => ch.charCodeAt(0)) : new TextEncoder().encode(body.value ?? "");
+		await bucket.put(body.key, data, { httpMetadata: { contentType: body.contentType ?? "application/octet-stream" } });
+		return c.json({ success: true });
+	});
+	app.post("/r2/delete", async (c) => {
+		const body = await c.req.json();
+		if (!body.binding) return c.json({ error: "binding required" }, 400);
+		const keys = body.keys ? body.keys : body.key ? [body.key] : [];
+		if (keys.length === 0) return c.json({ error: "key or keys required" }, 400);
+		const bucket = env[body.binding];
+		if (!bucket) return c.json({ error: `unknown binding "${body.binding}"` }, 404);
+		await bucket.delete(keys);
+		return c.json({ success: true });
+	});
+	app.post("/r2/list", async (c) => {
+		const body = await c.req.json();
+		if (!body.binding) return c.json({ error: "binding required" }, 400);
+		const bucket = env[body.binding];
+		if (!bucket) return c.json({ error: `unknown binding "${body.binding}"` }, 404);
+		const opts = {};
+		if (body.prefix) opts.prefix = body.prefix;
+		if (body.limit) opts.limit = body.limit;
+		if (body.cursor) opts.cursor = body.cursor;
+		if (body.delimiter) opts.delimiter = body.delimiter;
+		const result = await bucket.list(opts);
+		return c.json({
+			objects: result.objects.map((o) => ({
+				key: o.key,
+				size: o.size,
+				lastModified: o.uploaded?.toISOString() ?? ""
+			})),
+			truncated: result.truncated,
+			cursor: result.truncated ? result.cursor : null
+		});
+	});
+	app.post("/r2/head", async (c) => {
+		const body = await c.req.json();
+		if (!body.binding || !body.key) return c.json({ error: "binding and key required" }, 400);
+		const bucket = env[body.binding];
+		if (!bucket) return c.json({ error: `unknown binding "${body.binding}"` }, 404);
+		const obj = await bucket.head(body.key);
+		if (!obj) return c.json(null);
+		return c.json({
+			key: body.key,
+			size: obj.size,
+			etag: obj.httpEtag ?? "",
+			lastModified: obj.uploaded?.toISOString() ?? "",
+			contentType: obj.httpMetadata?.contentType ?? "application/octet-stream"
+		});
+	});
+	return app;
+}
+//#endregion
+export { createBindingHandler };

package/dist/runtime/remote/index.d.mts

@@ -0,0 +1,8 @@
+//#region src/runtime/remote/index.d.ts
+/**
+* Replace local D1/KV/R2 bindings with proxy-backed versions.
+* Called from the generated worker entry point when `__VOID_REMOTE` is set.
+*/
+declare function createRemoteEnv(env: Record<string, unknown>): Record<string, unknown>;
+//#endregion
+export { createRemoteEnv };

package/dist/runtime/remote/index.mjs

@@ -0,0 +1,461 @@
+import { t as cfAccessHeaders } from "../../cf-access-Dee5cXxL.mjs";
+//#region src/runtime/remote/client.ts
+/**
+* HTTP client for the remote bindings proxy (proxy.void.cloud).
+*
+* Used by ProxyD1Database, ProxyKVNamespace, and ProxyR2Bucket to forward
+* binding operations to the platform proxy during local development.
+*/
+var ProxyClient = class {
+	authHeaders;
+	constructor(proxyUrl, token, projectId, env = {}) {
+		this.proxyUrl = proxyUrl;
+		this.projectId = projectId;
+		this.authHeaders = {
+			Authorization: `Bearer ${token}`,
+			...cfAccessHeaders(env)
+		};
+	}
+	/**
+	* Send a JSON POST request to the proxy and return the response.
+	* Injects `projectId` into the body and `Authorization` header.
+	* Throws on non-OK responses.
+	*/
+	async fetch(path, body) {
+		const res = await globalThis.fetch(`${this.proxyUrl}${path}`, {
+			method: "POST",
+			headers: {
+				...this.authHeaders,
+				"Content-Type": "application/json"
+			},
+			body: JSON.stringify({
+				...body,
+				projectId: this.projectId
+			})
+		});
+		if (!res.ok) {
+			const text = await res.text().catch(() => res.statusText);
+			throw new Error(`remote: Proxy request failed with ${res.status}: '${text}'.`);
+		}
+		return res;
+	}
+	/**
+	* Send a request to the proxy and return the raw Response (for streaming).
+	* Injects `Authorization` header and `projectId` into the JSON body.
+	* Throws on non-OK responses.
+	*/
+	async stream(path, init) {
+		let body = init.body;
+		if (typeof body === "string") try {
+			const parsed = JSON.parse(body);
+			body = JSON.stringify({
+				...parsed,
+				projectId: this.projectId
+			});
+		} catch {}
+		const res = await globalThis.fetch(`${this.proxyUrl}${path}`, {
+			...init,
+			headers: {
+				...init.headers,
+				...this.authHeaders
+			},
+			body
+		});
+		if (!res.ok) {
+			const text = await res.text().catch(() => res.statusText);
+			throw new Error(`remote: Proxy request failed with ${res.status}: '${text}'.`);
+		}
+		return res;
+	}
+};
+//#endregion
+//#region src/runtime/remote/d1.ts
+/**
+* D1Database implementation backed by the remote proxy.
+* Used during local development when `remote: true` is set in void.json.
+*/
+var ProxyD1Database = class {
+	constructor(client, binding) {
+		this.client = client;
+		this.binding = binding;
+	}
+	prepare(sql) {
+		return new ProxyD1PreparedStatement(this.client, this.binding, sql);
+	}
+	async batch(stmts) {
+		const statements = stmts.map((s) => ({
+			sql: s._sql,
+			params: s._params
+		}));
+		return await (await this.client.fetch("/d1/batch", {
+			binding: this.binding,
+			statements
+		})).json();
+	}
+	async exec(sql) {
+		const data = await (await this.client.fetch("/d1/query", {
+			binding: this.binding,
+			sql,
+			method: "run"
+		})).json();
+		return {
+			count: data.meta?.changes ?? 0,
+			duration: data.meta?.duration ?? 0
+		};
+	}
+	dump() {
+		throw new Error("dump() is not supported with remote bindings");
+	}
+};
+/**
+* D1PreparedStatement implementation backed by the remote proxy.
+* Accumulates SQL and params synchronously; terminal methods (all, first, run, raw) make the HTTP call.
+*/
+var ProxyD1PreparedStatement = class {
+	/** @internal */
+	_sql;
+	/** @internal */
+	_params;
+	constructor(client, binding, sql) {
+		this.client = client;
+		this.binding = binding;
+		this._sql = sql;
+		this._params = [];
+	}
+	bind(...values) {
+		this._params = values;
+		return this;
+	}
+	async all() {
+		return await (await this.client.fetch("/d1/query", {
+			binding: this.binding,
+			sql: this._sql,
+			params: this._params,
+			method: "all"
+		})).json();
+	}
+	async first(col) {
+		const row = await (await this.client.fetch("/d1/query", {
+			binding: this.binding,
+			sql: this._sql,
+			params: this._params,
+			method: "first"
+		})).json();
+		if (row === null) return null;
+		if (col) return row[col];
+		return row;
+	}
+	async run() {
+		return await (await this.client.fetch("/d1/query", {
+			binding: this.binding,
+			sql: this._sql,
+			params: this._params,
+			method: "run"
+		})).json();
+	}
+	async raw(options) {
+		const data = await (await this.client.fetch("/d1/query", {
+			binding: this.binding,
+			sql: this._sql,
+			params: this._params,
+			method: "raw"
+		})).json();
+		if (options?.columnNames) return [data.columns, ...data.results];
+		return data.results;
+	}
+};
+//#endregion
+//#region src/runtime/remote/kv.ts
+/**
+* KVNamespace implementation backed by the remote proxy.
+* Used during local development when `remote: true` is set in void.json.
+*/
+var ProxyKVNamespace = class {
+	normalizeGetOptions(options) {
+		if (typeof options === "string") return options;
+		if (options?.type === "json" || options?.type === "text" || options?.type === "arrayBuffer" || options?.type === "stream") return { type: options.type };
+	}
+	constructor(client, binding) {
+		this.client = client;
+		this.binding = binding;
+	}
+	async get(key, options) {
+		const type = typeof options === "string" ? options : options?.type ?? "text";
+		const res = await this.client.fetch("/kv/get", {
+			binding: this.binding,
+			key,
+			type
+		});
+		const ct = res.headers.get("content-type") ?? "";
+		if (type === "arrayBuffer" || type === "stream") {
+			if (ct.includes("application/json")) {
+				const data = await res.json();
+				if (data === null) return null;
+				const encoded = new TextEncoder().encode(JSON.stringify(data));
+				return type === "arrayBuffer" ? encoded.buffer : new ReadableStream({ start(controller) {
+					controller.enqueue(encoded);
+					controller.close();
+				} });
+			}
+			if (type === "arrayBuffer") return res.arrayBuffer();
+			return res.body;
+		}
+		return res.json();
+	}
+	async getWithMetadata(key, options) {
+		const normalized = this.normalizeGetOptions(options);
+		let value;
+		switch (typeof normalized === "string" ? normalized : normalized?.type) {
+			case "json":
+				value = await this.get(key, "json");
+				break;
+			case "text":
+				value = await this.get(key, "text");
+				break;
+			case "arrayBuffer":
+				value = await this.get(key, "arrayBuffer");
+				break;
+			case "stream":
+				value = await this.get(key, "stream");
+				break;
+			default:
+				value = await this.get(key);
+				break;
+		}
+		return {
+			value,
+			metadata: null,
+			cacheStatus: null
+		};
+	}
+	async put(key, value, options) {
+		let serializedValue;
+		let isBase64 = false;
+		if (typeof value === "string") serializedValue = value;
+		else if (value instanceof ArrayBuffer) {
+			const bytes = new Uint8Array(value);
+			let binary = "";
+			for (const byte of bytes) binary += String.fromCharCode(byte);
+			serializedValue = btoa(binary);
+			isBase64 = true;
+		} else {
+			const reader = value.getReader();
+			const chunks = [];
+			while (true) {
+				const { done, value: chunk } = await reader.read();
+				if (done) break;
+				chunks.push(chunk);
+			}
+			const total = chunks.reduce((sum, c) => sum + c.length, 0);
+			const merged = new Uint8Array(total);
+			let offset = 0;
+			for (const chunk of chunks) {
+				merged.set(chunk, offset);
+				offset += chunk.length;
+			}
+			let binary = "";
+			for (const byte of merged) binary += String.fromCharCode(byte);
+			serializedValue = btoa(binary);
+			isBase64 = true;
+		}
+		const body = {
+			binding: this.binding,
+			key,
+			value: serializedValue,
+			...isBase64 && { base64: true }
+		};
+		if (options?.expiration) body.expiration = options.expiration;
+		if (options?.expirationTtl) body.expiration_ttl = options.expirationTtl;
+		if (options?.metadata) body.metadata = options.metadata;
+		await this.client.fetch("/kv/put", body);
+	}
+	async delete(key) {
+		await this.client.fetch("/kv/delete", {
+			binding: this.binding,
+			key
+		});
+	}
+	async list(options) {
+		return await (await this.client.fetch("/kv/list", {
+			binding: this.binding,
+			prefix: options?.prefix,
+			limit: options?.limit,
+			cursor: options?.cursor
+		})).json();
+	}
+};
+//#endregion
+//#region src/runtime/remote/r2.ts
+/**
+* R2Bucket implementation backed by the remote proxy.
+* Used during local development when `remote: true` is set in void.json.
+*/
+var ProxyR2Bucket = class {
+	constructor(client, binding) {
+		this.client = client;
+		this.binding = binding;
+	}
+	async head(key) {
+		const data = await (await this.client.fetch("/r2/head", {
+			binding: this.binding,
+			key
+		})).json();
+		if (!data) return null;
+		return makeR2Object(data);
+	}
+	async get(key) {
+		const res = await this.client.stream("/r2/get", {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify({
+				binding: this.binding,
+				key
+			})
+		});
+		if ((res.headers.get("content-type") ?? "").includes("application/json")) {
+			if (await res.clone().json() === null) return null;
+		}
+		return makeR2ObjectBody(key, res);
+	}
+	async put(key, value, options) {
+		let base64;
+		let textValue;
+		if (typeof value === "string") textValue = value;
+		else if (value === null) textValue = "";
+		else if (value instanceof ArrayBuffer) base64 = arrayBufferToBase64(value);
+		else if (ArrayBuffer.isView(value)) base64 = arrayBufferToBase64(value.buffer);
+		else if (value instanceof Blob) base64 = arrayBufferToBase64(await value.arrayBuffer());
+		else {
+			const reader = value.getReader();
+			const chunks = [];
+			while (true) {
+				const { done, value: chunk } = await reader.read();
+				if (done) break;
+				chunks.push(chunk);
+			}
+			const total = chunks.reduce((sum, c) => sum + c.length, 0);
+			const merged = new Uint8Array(total);
+			let offset = 0;
+			for (const chunk of chunks) {
+				merged.set(chunk, offset);
+				offset += chunk.length;
+			}
+			base64 = arrayBufferToBase64(merged.buffer);
+		}
+		const body = {
+			binding: this.binding,
+			key
+		};
+		if (base64) body.base64 = base64;
+		else body.value = textValue;
+		if (options?.httpMetadata) {
+			const meta = options.httpMetadata;
+			if (meta instanceof Headers) body.contentType = meta.get("content-type") ?? void 0;
+			else body.contentType = meta.contentType;
+		}
+		if (options?.customMetadata) body.customMetadata = options.customMetadata;
+		await this.client.fetch("/r2/put", body);
+		return makeR2Object({
+			key,
+			size: 0,
+			etag: "",
+			lastModified: (/* @__PURE__ */ new Date()).toISOString(),
+			contentType: "application/octet-stream"
+		});
+	}
+	async delete(keys) {
+		const body = { binding: this.binding };
+		if (Array.isArray(keys)) body.keys = keys;
+		else body.key = keys;
+		await this.client.fetch("/r2/delete", body);
+	}
+	async list(options) {
+		const data = await (await this.client.fetch("/r2/list", {
+			binding: this.binding,
+			prefix: options?.prefix,
+			limit: options?.limit,
+			cursor: options?.cursor,
+			delimiter: options?.delimiter
+		})).json();
+		return {
+			objects: data.objects.map((o) => makeR2Object({
+				key: o.key,
+				size: o.size,
+				etag: "",
+				lastModified: o.lastModified,
+				contentType: "application/octet-stream"
+			})),
+			truncated: data.truncated,
+			cursor: data.cursor ?? void 0,
+			delimitedPrefixes: []
+		};
+	}
+	createMultipartUpload() {
+		throw new Error("createMultipartUpload() is not supported with remote bindings");
+	}
+	resumeMultipartUpload() {
+		throw new Error("resumeMultipartUpload() is not supported with remote bindings");
+	}
+};
+function arrayBufferToBase64(buffer) {
+	const bytes = new Uint8Array(buffer);
+	let binary = "";
+	for (const byte of bytes) binary += String.fromCharCode(byte);
+	return btoa(binary);
+}
+function makeR2Object(data) {
+	return {
+		key: data.key,
+		version: "",
+		size: data.size,
+		etag: data.etag,
+		httpEtag: data.etag ? `"${data.etag}"` : "",
+		checksums: { toJSON: () => ({}) },
+		uploaded: new Date(data.lastModified || Date.now()),
+		httpMetadata: { contentType: data.contentType },
+		customMetadata: {},
+		storageClass: "Standard",
+		range: void 0,
+		writeHttpMetadata(_headers) {}
+	};
+}
+function makeR2ObjectBody(key, res) {
+	const size = parseInt(res.headers.get("content-length") ?? "0");
+	const etag = res.headers.get("etag") ?? "";
+	const contentType = res.headers.get("content-type") ?? "application/octet-stream";
+	return {
+		...makeR2Object({
+			key,
+			size,
+			etag,
+			lastModified: res.headers.get("last-modified") ?? (/* @__PURE__ */ new Date()).toISOString(),
+			contentType
+		}),
+		body: res.body,
+		get bodyUsed() {
+			return res.bodyUsed;
+		},
+		arrayBuffer: () => res.arrayBuffer(),
+		bytes: async () => new Uint8Array(await res.arrayBuffer()),
+		text: () => res.text(),
+		json: () => res.json(),
+		blob: () => res.blob()
+	};
+}
+//#endregion
+//#region src/runtime/remote/index.ts
+/**
+* Replace local D1/KV/R2 bindings with proxy-backed versions.
+* Called from the generated worker entry point when `__VOID_REMOTE` is set.
+*/
+function createRemoteEnv(env) {
+	const client = new ProxyClient(env.__VOID_PROXY_URL, env.__VOID_TOKEN, env.__VOID_PROJECT_ID, env);
+	return {
+		...env,
+		...env.DB != null && { DB: new ProxyD1Database(client, "DB") },
+		...env.KV != null && { KV: new ProxyKVNamespace(client, "KV") },
+		...env.STORAGE != null && { STORAGE: new ProxyR2Bucket(client, "STORAGE") }
+	};
+}
+//#endregion
+export { createRemoteEnv };

package/dist/runtime/response.d.mts

@@ -0,0 +1,14 @@
+//#region src/runtime/response.d.ts
+/** Returns true if the value is a Response that was created by convertReturnValue. */
+declare function isConvertedResponse(value: unknown): boolean;
+/**
+* Convert a handler's return value to a Web Response.
+*
+* - Response → passthrough
+* - null/undefined → 204 No Content
+* - string → text/html
+* - object/array → JSON
+*/
+declare function convertReturnValue(value: unknown): Response;
+//#endregion
+export { convertReturnValue, isConvertedResponse };