void 0.20.3 → 0.21.1

package/dist/{wrangler--imS8n0d.mjs → wrangler-D01qs6VB.mjs}

@@ -1,9 +1,185 @@
-import { a as isAbsolute, n as dirname, o as join, s as normalize } from "./dist-BrsS7cai.mjs";
+import { a as join, i as isAbsolute, n as dirname, o as normalize, t as basename } from "./dist-4WkAWhWx.mjs";
+import "./project-paths-CKQ-Q5JS.mjs";
+import { m as readConfig } from "./config-Dxr6cTXn.mjs";
 import { createRequire } from "node:module";
-import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
 import { appendSqliteClassMigration } from "@void/deploy-core";
-import { createHash } from "node:crypto";
+import { createHash, randomUUID } from "node:crypto";
 import { SyntaxKind, applyEdits, createScanner, findNodeAtLocation, modify, parse, parseTree } from "jsonc-parser";
+import { isDeepStrictEqual } from "node:util";
+//#region src/cloudflare-config.ts
+const MATERIALIZED_CLOUDFLARE_FILE = ".void-wrangler.jsonc";
+const VOID_LOCK_FILE = "void.lock.json";
+const PREVIEW_POINTER_FILE = "preview-deploy-config.json";
+function isObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function arrayIdentity(value) {
+	if (isObject(value)) {
+		for (const key of [
+			"binding",
+			"name",
+			"tag",
+			"class_name",
+			"pattern",
+			"route"
+		]) if (typeof value[key] === "string") return `${key}:${value[key]}`;
+	}
+	return JSON.stringify(value) ?? String(value);
+}
+/** Keep authored values authoritative while retaining fields produced by Void. */
+function mergeConfig(previous, resolved, authored) {
+	if (isDeepStrictEqual(previous, authored)) return resolved;
+	if (Array.isArray(previous) && Array.isArray(resolved) && Array.isArray(authored)) {
+		const previousByIdentity = new Map(previous.map((item) => [arrayIdentity(item), item]));
+		const resolvedByIdentity = new Map(resolved.map((item) => [arrayIdentity(item), item]));
+		const authoredIdentities = new Set(authored.map(arrayIdentity));
+		return [...authored.map((item) => {
+			const identity = arrayIdentity(item);
+			return previousByIdentity.has(identity) && resolvedByIdentity.has(identity) ? mergeConfig(previousByIdentity.get(identity), resolvedByIdentity.get(identity), item) : item;
+		}), ...resolved.filter((item) => {
+			const identity = arrayIdentity(item);
+			return !previousByIdentity.has(identity) && !authoredIdentities.has(identity);
+		})];
+	}
+	if (isObject(previous) && isObject(resolved) && isObject(authored)) {
+		const result = {};
+		for (const key of /* @__PURE__ */ new Set([
+			...Object.keys(previous),
+			...Object.keys(resolved),
+			...Object.keys(authored)
+		])) {
+			if (!(key in authored)) {
+				if (!(key in previous) && key in resolved) Object.defineProperty(result, key, {
+					value: resolved[key],
+					enumerable: true,
+					writable: true,
+					configurable: true
+				});
+				continue;
+			}
+			const value = mergeConfig(previous[key], resolved[key], authored[key]);
+			Object.defineProperty(result, key, {
+				value,
+				enumerable: true,
+				writable: true,
+				configurable: true
+			});
+		}
+		return result;
+	}
+	return authored;
+}
+function parseCloudflareText(text, path) {
+	const errors = [];
+	const value = parse(text.replace(/^\uFEFF/, ""), errors, { allowTrailingComma: true });
+	if (errors.length > 0 || !isObject(value)) throw new Error(`config: ${path} must contain a valid JSON/JSONC object.`);
+	return value;
+}
+function readState(root) {
+	const path = join(root, VOID_LOCK_FILE);
+	if (!existsSync(path)) return;
+	let value;
+	try {
+		value = JSON.parse(readFileSync(path, "utf8"));
+	} catch {
+		throw new Error(`config: Invalid ${VOID_LOCK_FILE}. Fix or restore it before continuing.`);
+	}
+	if (!isObject(value) || value.version !== 1 || !isObject(value.source) || !isObject(value.resolved) || typeof value.text !== "string") throw new Error(`config: Invalid ${VOID_LOCK_FILE}. Fix or restore it before continuing.`);
+	const state = value;
+	if (!isDeepStrictEqual(parseCloudflareText(state.text, "void.lock.json"), state.resolved)) state.text = `${provenance(state.text)}${JSON.stringify(state.resolved, null, 2)}\n`;
+	return state;
+}
+function writeAtomic(path, content) {
+	const temporary = `${path}.${randomUUID()}.tmp`;
+	writeFileSync(temporary, content, { flag: "wx" });
+	try {
+		renameSync(temporary, path);
+	} finally {
+		rmSync(temporary, { force: true });
+	}
+}
+function writeState(root, state) {
+	const path = join(root, VOID_LOCK_FILE);
+	const content = `${JSON.stringify(state, null, 2)}\n`;
+	if (existsSync(path)) try {
+		if (isDeepStrictEqual(JSON.parse(readFileSync(path, "utf8")), state)) return;
+	} catch {}
+	writeAtomic(path, content);
+}
+/** Keep Vite preview usable without leaving Wrangler's implicit deploy pointer after a build. */
+function stashCloudflareDeployPointer(root) {
+	const pointer = join(root, ".wrangler", "deploy", "config.json");
+	if (!existsSync(pointer)) return;
+	const directory = join(root, ".void");
+	mkdirSync(directory, { recursive: true });
+	writeAtomic(join(directory, PREVIEW_POINTER_FILE), readFileSync(pointer, "utf8"));
+	rmSync(pointer, { force: true });
+}
+function restoreCloudflarePreviewPointer(root) {
+	const saved = join(root, ".void", PREVIEW_POINTER_FILE);
+	if (!existsSync(saved)) return false;
+	const directory = join(root, ".wrangler", "deploy");
+	mkdirSync(directory, { recursive: true });
+	writeAtomic(join(directory, "config.json"), readFileSync(saved, "utf8"));
+	return true;
+}
+/** Preserve Void's JSONC provenance comments when authored settings change. */
+function provenance(text) {
+	const lines = text.match(/^\s*\/\/ void:(?:managed-queues|published-traffic):v1:[A-Za-z0-9_-]+\s*$/gm);
+	return lines ? `${lines.join("\n")}\n` : "";
+}
+/** Resolve the config file passed to Cloudflare tooling. Typed projects use a generated file. */
+function materializeCloudflareConfig(root) {
+	if (!existsSync(join(root, "void.config.ts"))) {
+		for (const name of ["wrangler.jsonc", "wrangler.json"]) if (existsSync(join(root, name))) return join(root, name);
+		return join(root, "wrangler.jsonc");
+	}
+	if (["wrangler.jsonc", "wrangler.json"].some((name) => existsSync(join(root, name)))) throw new Error("config: Run `void migrate` to move the root Wrangler config into void.config.ts.");
+	const authored = readConfig(root).cloudflare ?? {};
+	const state = readState(root);
+	const resolved = state ? mergeConfig(state.source, state.resolved, authored) : authored;
+	const text = state && isDeepStrictEqual(resolved, state.resolved) && isDeepStrictEqual(authored, state.source) ? state.text : `${provenance(state?.text ?? "")}${JSON.stringify(resolved, null, 2)}\n`;
+	const path = join(root, MATERIALIZED_CLOUDFLARE_FILE);
+	if (!existsSync(path) || readFileSync(path, "utf8") !== text) writeAtomic(path, text);
+	if (state) writeState(root, {
+		version: 1,
+		source: authored,
+		resolved,
+		text
+	});
+	return path;
+}
+/** Record Cloudflare settings written by Void so later builds reproduce them. */
+function persistCloudflareConfig(root) {
+	if (!existsSync(join(root, "void.config.ts"))) return;
+	const path = join(root, MATERIALIZED_CLOUDFLARE_FILE);
+	if (!existsSync(path)) throw new Error(`config: Missing generated ${MATERIALIZED_CLOUDFLARE_FILE}.`);
+	const text = readFileSync(path, "utf8");
+	const resolved = parseCloudflareText(text, path);
+	const authored = readConfig(root).cloudflare ?? {};
+	if (readState(root) || !isDeepStrictEqual(resolved, authored) || text !== `${JSON.stringify(authored, null, 2)}\n`) writeState(root, {
+		version: 1,
+		source: authored,
+		resolved,
+		text
+	});
+}
+/** Seed the checked-in lock from a root Wrangler file during migration. */
+function seedCloudflareConfig(root, source, text) {
+	const existing = readState(root);
+	if (existing) {
+		if (isDeepStrictEqual(existing.source, source) && isDeepStrictEqual(existing.resolved, source)) return;
+		throw new Error(`migrate: ${VOID_LOCK_FILE} already exists with different settings. Resolve it before migrating.`);
+	}
+	if (!isDeepStrictEqual(parseCloudflareText(text, ".void-wrangler.jsonc"), source)) throw new Error("migrate: The Cloudflare config changed during migration. Retry.");
+	writeState(root, {
+		version: 1,
+		source,
+		resolved: source,
+		text
+	});
+}
 const SANDBOX_MIGRATION_TAG = "void-sandbox-v1";
 const require = createRequire(import.meta.url);
 function isSandboxEnabled(config) {
@@ -54,6 +230,14 @@ const UTF8_BOM = "";
 const NODEJS_ALS_FLAG = "nodejs_als";
 const NODEJS_COMPAT_FLAG = "nodejs_compat";
 const VOID_CONFIG_FILE = "void.json";
+function projectWranglerPaths(root) {
+	if (existsSync(join(root, "void.config.ts"))) return [materializeCloudflareConfig(root)];
+	return ["wrangler.jsonc", "wrangler.json"].map((name) => join(root, name));
+}
+function writeProjectWranglerFile(configPath, text) {
+	writeFileSync(configPath, text);
+	if (basename(configPath) === ".void-wrangler.jsonc") persistCloudflareConfig(dirname(configPath));
+}
 const MANAGED_QUEUES_MARKER = /^\s*\/\/ void:managed-queues:v1:([A-Za-z0-9_-]+)\s*$/m;
 const PUBLISHED_TRAFFIC_MARKER = /^\s*\/\/ void:published-traffic:v1:([A-Za-z0-9_-]+)\s*$/m;
 const DEFAULT_LIVE_BINDING = "VOID_LIVE";
@@ -61,8 +245,7 @@ const DEFAULT_LIVE_CLASS = "VoidLiveStreamDurableObject";
 const LIVE_MIGRATION_TAG = "live-v1";
 /** Read the root Wrangler config with the same JSONC parser used by binding sync. */
 function readRootWranglerConfig(root) {
-	for (const name of ["wrangler.jsonc", "wrangler.json"]) {
-		const configPath = join(root, name);
+	for (const configPath of projectWranglerPaths(root)) {
 		if (!existsSync(configPath)) continue;
 		const parsed = parseJsonc(readFileSync(configPath, "utf-8"));
 		if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) throw new SyntaxError(`Failed to parse ${configPath}: expected a JSON object.`);
@@ -97,7 +280,7 @@ function writeWranglerPublishedTrafficSnapshot(configPath, snapshot, options) {
 	const existing = PUBLISHED_TRAFFIC_MARKER.exec(raw);
 	if (!existing && options?.create === false) return;
 	const next = existing ? raw.slice(0, existing.index) + marker + raw.slice(existing.index + existing[0].length) : `${marker}${raw.includes("\r\n") ? "\r\n" : "\n"}${raw}`;
-	if (next !== raw) writeFileSync(configPath, next);
+	if (next !== raw) writeProjectWranglerFile(configPath, next);
 }
 /** Latest compatibility date the Void test suite is pinned against. */
 const LATEST_KNOWN_COMPAT_DATE = "2026-02-24";
@@ -139,8 +322,8 @@ function readExistingLiveBindingConfig(root) {
 	} : void 0;
 }
 function readWranglerDurableObjectBindings(root) {
-	for (const name of ["wrangler.jsonc", "wrangler.json"]) try {
-		const bindings = parseJsonc(readFileSync(join(root, name), "utf-8")).durable_objects?.bindings;
+	for (const path of projectWranglerPaths(root)) try {
+		const bindings = parseJsonc(readFileSync(path, "utf-8")).durable_objects?.bindings;
 		if (!Array.isArray(bindings)) return [];
 		return bindings.filter((binding) => typeof binding.name === "string" && typeof binding.class_name === "string");
 	} catch {}
@@ -195,8 +378,8 @@ function ensureWranglerCompat(root, config, buildOutputDir) {
 function readWranglerCompatFields(root, config, buildOutputDir) {
 	const voidConfig = config ?? readVoidConfigIfExists(root);
 	let raw;
-	for (const name of ["wrangler.jsonc", "wrangler.json"]) try {
-		raw = readFileSync(join(root, name), "utf-8");
+	for (const path of projectWranglerPaths(root)) try {
+		raw = readFileSync(path, "utf-8");
 		break;
 	} catch {}
 	let wranglerDate;
@@ -243,18 +426,13 @@ function validateCompatDate(value, source) {
 	if (!COMPAT_DATE_RE.test(value)) throw new Error(`config: "compatibility_date" in ${source} must use YYYY-MM-DD format, got '${value}'.`);
 }
 function readVoidConfigIfExists(root) {
-	const filePath = join(root, VOID_CONFIG_FILE);
-	if (!existsSync(filePath)) return;
-	try {
-		const parsed = JSON.parse(readFileSync(filePath, "utf-8"));
-		if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) throw new Error(`config: ${VOID_CONFIG_FILE} must be a JSON object.`);
-		return parsed;
-	} catch (error) {
-		if (error instanceof SyntaxError) throw new Error(`config: Invalid JSON in ${VOID_CONFIG_FILE}.`);
-		throw error;
-	}
+	return existsSync(join(root, VOID_CONFIG_FILE)) || existsSync(join(root, "void.config.ts")) ? readConfig(root) : void 0;
 }
 function ensureVoidCompatibilityDate(root, config) {
+	if (existsSync(join(root, "void.config.ts"))) {
+		writeProvisionedWranglerConfig(root, { compatibilityDate: LATEST_KNOWN_COMPAT_DATE });
+		return LATEST_KNOWN_COMPAT_DATE;
+	}
 	const filePath = join(root, VOID_CONFIG_FILE);
 	let nextConfig = {};
 	if (existsSync(filePath)) try {
@@ -282,18 +460,15 @@ function syncWranglerBindings(root, bindings, options) {
 	let configPath;
 	let parsed;
 	let created = false;
-	for (const name of ["wrangler.jsonc", "wrangler.json"]) {
-		const p = join(root, name);
-		if (existsSync(p)) {
-			configPath = p;
-			try {
-				parsed = parseJsonc(readFileSync(p, "utf-8"));
-			} catch {}
-			break;
-		}
+	for (const p of projectWranglerPaths(root)) if (existsSync(p)) {
+		configPath = p;
+		try {
+			parsed = parseJsonc(readFileSync(p, "utf-8"));
+		} catch {}
+		break;
 	}
 	if (!configPath || !parsed) {
-		configPath = join(root, "wrangler.jsonc");
+		configPath = materializeCloudflareConfig(root);
 		parsed = {};
 		created = true;
 	}
@@ -332,6 +507,31 @@ function syncWranglerBindings(root, bindings, options) {
 			modified = true;
 		}
 	}
+	if (bindings.needsAI && options?.directCloudflareAi) {
+		const existing = parsed.ai;
+		const binding = typeof existing?.binding === "string" ? existing.binding : options.bindingNames?.ai ?? "AI";
+		const nextAi = {
+			...existing ?? {},
+			binding,
+			remote: true
+		};
+		if (JSON.stringify(existing) !== JSON.stringify(nextAi)) {
+			parsed.ai = nextAi;
+			modified = true;
+		}
+		if (binding !== "AI" || options.directCloudflareAi.gateway) {
+			const vars = parsed.vars ?? {};
+			const nextVars = {
+				...vars,
+				...binding !== "AI" ? { __VOID_AI_BINDING: binding } : {},
+				...options.directCloudflareAi.gateway ? { __VOID_AI_GATEWAY: options.directCloudflareAi.gateway } : {}
+			};
+			if (JSON.stringify(vars) !== JSON.stringify(nextVars)) {
+				parsed.vars = nextVars;
+				modified = true;
+			}
+		}
+	}
 	if (options?.websockets) {
 		const existing = parsed.durable_objects?.bindings ?? [];
 		const migrations = Array.isArray(parsed.migrations) ? parsed.migrations : [];
@@ -441,7 +641,7 @@ function syncWranglerBindings(root, bindings, options) {
 			modified = true;
 		}
 	}
-	if (created || modified) writeFileSync(configPath, JSON.stringify(parsed, null, 2) + "\n");
+	if (created || modified) writeProjectWranglerFile(configPath, JSON.stringify(parsed, null, 2) + "\n");
 	return created || modified;
 }
 const NO_INFERRED_BINDINGS = {
@@ -461,7 +661,7 @@ function syncWranglerDurableObjects(root, durableObjects) {
 }
 /** Persist WebSocket Durable Object bindings and SQLite migration history. */
 function syncWranglerWebSockets(root, websockets) {
-	if (websockets.length === 0 && !["wrangler.jsonc", "wrangler.json"].some((name) => existsSync(join(root, name)))) return false;
+	if (websockets.length === 0 && !projectWranglerPaths(root).some((path) => existsSync(path))) return false;
 	return writeProvisionedWranglerConfig(root, { webSockets: websockets }).modified;
 }
 /**
@@ -471,7 +671,7 @@ function syncWranglerWebSockets(root, websockets) {
 * requiring provenance from Void's WebSocket migration tag.
 */
 function readWranglerWebSocketTombstones(root, websockets) {
-	const configPath = ["wrangler.jsonc", "wrangler.json"].map((name) => join(root, name)).find((path) => existsSync(path));
+	const configPath = projectWranglerPaths(root).find((path) => existsSync(path));
 	if (!configPath) return [];
 	const parsed = parseJsonc(readFileSync(configPath, "utf-8"));
 	const migrations = Array.isArray(parsed.migrations) ? parsed.migrations : [];
@@ -489,23 +689,20 @@ function ensureWranglerCompatibilityDate(root, compatibilityDate) {
 	validateCompatDate(compatibilityDate, "void.json worker config");
 	let configPath;
 	let parsed;
-	for (const name of ["wrangler.jsonc", "wrangler.json"]) {
-		const p = join(root, name);
-		if (existsSync(p)) {
-			configPath = p;
-			try {
-				parsed = parseJsonc(readFileSync(p, "utf-8"));
-			} catch {}
-			break;
-		}
+	for (const p of projectWranglerPaths(root)) if (existsSync(p)) {
+		configPath = p;
+		try {
+			parsed = parseJsonc(readFileSync(p, "utf-8"));
+		} catch {}
+		break;
 	}
 	if (!configPath || !parsed) {
-		configPath = join(root, "wrangler.jsonc");
+		configPath = materializeCloudflareConfig(root);
 		parsed = {};
 	}
 	if (parsed.compatibility_date === compatibilityDate) return false;
 	parsed.compatibility_date = compatibilityDate;
-	writeFileSync(configPath, JSON.stringify(parsed, null, 2) + "\n");
+	writeProjectWranglerFile(configPath, JSON.stringify(parsed, null, 2) + "\n");
 	return true;
 }
 /**
@@ -515,24 +712,21 @@ function ensureWranglerCompatibilityDate(root, compatibilityDate) {
 function ensureWranglerNodejsAlsFlag(root) {
 	let configPath;
 	let parsed;
-	for (const name of ["wrangler.jsonc", "wrangler.json"]) {
-		const p = join(root, name);
-		if (existsSync(p)) {
-			configPath = p;
-			try {
-				parsed = parseJsonc(readFileSync(p, "utf-8"));
-			} catch {}
-			break;
-		}
+	for (const p of projectWranglerPaths(root)) if (existsSync(p)) {
+		configPath = p;
+		try {
+			parsed = parseJsonc(readFileSync(p, "utf-8"));
+		} catch {}
+		break;
 	}
 	if (!configPath || !parsed) {
-		configPath = join(root, "wrangler.jsonc");
+		configPath = materializeCloudflareConfig(root);
 		parsed = {};
 	}
 	const compatibilityFlags = Array.isArray(parsed.compatibility_flags) ? parsed.compatibility_flags : [];
 	if (compatibilityFlags.includes(NODEJS_ALS_FLAG)) return false;
 	parsed.compatibility_flags = [...compatibilityFlags, NODEJS_ALS_FLAG];
-	writeFileSync(configPath, JSON.stringify(parsed, null, 2) + "\n");
+	writeProjectWranglerFile(configPath, JSON.stringify(parsed, null, 2) + "\n");
 	return true;
 }
 function readManagedQueueProvenance(text) {
@@ -606,7 +800,7 @@ function acknowledgeWranglerManagedQueueRemovals(configPath, removedQueues) {
 		pendingConsumerRemovals: provenance.pendingConsumerRemovals.filter((queue) => !removed.has(queue))
 	});
 	const finalText = hasBom ? `${UTF8_BOM}${updated}` : updated;
-	if (finalText !== raw) writeFileSync(configPath, finalText);
+	if (finalText !== raw) writeProjectWranglerFile(configPath, finalText);
 }
 /**
 * Fill root Wrangler config fields required by generated/provisioned resources, including
@@ -621,14 +815,11 @@ function acknowledgeWranglerManagedQueueRemovals(configPath, removedQueues) {
 function writeProvisionedWranglerConfig(root, patch, options) {
 	let configPath = options?.configPath;
 	if (configPath === void 0) {
-		for (const name of ["wrangler.jsonc", "wrangler.json"]) {
-			const p = join(root, name);
-			if (existsSync(p)) {
-				configPath = p;
-				break;
-			}
+		for (const p of projectWranglerPaths(root)) if (existsSync(p)) {
+			configPath = p;
+			break;
 		}
-		configPath ??= join(root, "wrangler.jsonc");
+		configPath ??= materializeCloudflareConfig(root);
 	}
 	const rawContent = existsSync(configPath) ? readFileSync(configPath, "utf-8") : "{}";
 	const hasBom = rawContent.startsWith(UTF8_BOM);
@@ -916,7 +1107,7 @@ function writeProvisionedWranglerConfig(root, patch, options) {
 	}
 	const finalText = hasBom ? `${UTF8_BOM}${text}` : text;
 	const modified = finalText !== rawContent;
-	if (modified) writeFileSync(configPath, finalText);
+	if (modified) writeProjectWranglerFile(configPath, finalText);
 	return {
 		configPath,
 		modified,
@@ -982,7 +1173,7 @@ function updateWranglerCustomDomain(root, hostname, action) {
 	} else if (action === "delete" && matches.length === 1) text = applyEdits(text, modify(text, ["routes", matches[0]], void 0, { formattingOptions }));
 	const finalText = hasBom ? `${UTF8_BOM}${text}` : text;
 	const modified = finalText !== raw;
-	if (modified) writeFileSync(configPath, finalText);
+	if (modified) writeProjectWranglerFile(configPath, finalText);
 	return {
 		configPath,
 		domains: parseCustomDomains(parseJsonc(text).routes, configPath),
@@ -990,11 +1181,8 @@ function updateWranglerCustomDomain(root, hostname, action) {
 	};
 }
 function discoverWranglerConfigPath(root) {
-	for (const name of ["wrangler.jsonc", "wrangler.json"]) {
-		const path = join(root, name);
-		if (existsSync(path)) return path;
-	}
-	return join(root, "wrangler.jsonc");
+	for (const path of projectWranglerPaths(root)) if (existsSync(path)) return path;
+	return materializeCloudflareConfig(root);
 }
 function parseCustomDomains(value, configPath) {
 	if (value === void 0) return [];
@@ -1793,4 +1981,4 @@ function canonicalize(value) {
 	return value;
 }
 //#endregion
-export { writeWranglerPublishedTrafficSnapshot as A, readWranglerWebSocketTombstones as C, syncWranglerWebSockets as D, syncWranglerDurableObjects as E, isSandboxEnabled as M, requiresSandboxPlatformImage as N, updateWranglerCustomDomain as O, resolveSandboxConfig as P, readWranglerPublishedTrafficSnapshot as S, syncWranglerBindings as T, readProvisionedBindingEntry as _, LIVE_MIGRATION_TAG as a, readWranglerCustomDomains as b, bindingEntriesForField as c, ensureWranglerNodejsAlsFlag as d, findBindingNameOwner as f, readExistingLiveBindingConfig as g, normalizeWranglerCompatibilityFlags as h, LATEST_KNOWN_COMPAT_DATE as i, SANDBOX_MIGRATION_TAG as j, writeProvisionedWranglerConfig as k, ensureWranglerCompat as l, nextDurableObjectMigrationTag as m, DEFAULT_LIVE_CLASS as n, acknowledgeWranglerManagedQueueRemovals as o, hasDurableObjectSqliteMigration as p, FRIENDLY_BINDING_NAMES as r, assertNoDuplicateMembers as s, DEFAULT_LIVE_BINDING as t, ensureWranglerCompatibilityDate as u, readRootWranglerConfig as v, resolveLiveBindingConfig as w, readWranglerManagedQueueCleanupCandidates as x, readWranglerCompat as y };
+export { writeWranglerPublishedTrafficSnapshot as A, seedCloudflareConfig as B, readWranglerWebSocketTombstones as C, syncWranglerWebSockets as D, syncWranglerDurableObjects as E, MATERIALIZED_CLOUDFLARE_FILE as F, VOID_LOCK_FILE as I, materializeCloudflareConfig as L, isSandboxEnabled as M, requiresSandboxPlatformImage as N, updateWranglerCustomDomain as O, resolveSandboxConfig as P, persistCloudflareConfig as R, readWranglerPublishedTrafficSnapshot as S, syncWranglerBindings as T, stashCloudflareDeployPointer as V, readProvisionedBindingEntry as _, LIVE_MIGRATION_TAG as a, readWranglerCustomDomains as b, bindingEntriesForField as c, ensureWranglerNodejsAlsFlag as d, findBindingNameOwner as f, readExistingLiveBindingConfig as g, normalizeWranglerCompatibilityFlags as h, LATEST_KNOWN_COMPAT_DATE as i, SANDBOX_MIGRATION_TAG as j, writeProvisionedWranglerConfig as k, ensureWranglerCompat as l, nextDurableObjectMigrationTag as m, DEFAULT_LIVE_CLASS as n, acknowledgeWranglerManagedQueueRemovals as o, hasDurableObjectSqliteMigration as p, FRIENDLY_BINDING_NAMES as r, assertNoDuplicateMembers as s, DEFAULT_LIVE_BINDING as t, ensureWranglerCompatibilityDate as u, readRootWranglerConfig as v, resolveLiveBindingConfig as w, readWranglerManagedQueueCleanupCandidates as x, readWranglerCompat as y, restoreCloudflarePreviewPointer as z };

package/dist/ws-BwcqizuH.d.mts

@@ -0,0 +1,122 @@
+import { t as StandardSchemaV1 } from "./standard-schema-Fo_vCAZh.mjs";
+import { r as AuthUser } from "./auth-DkcFflXV.mjs";
+import { a as CloudEnv } from "./handler-BXJTXd02.mjs";
+import { WebSocketRouteMap } from "void/routes";
+//#region src/runtime/ws.d.ts
+type MaybePromise<T> = T | Promise<T>;
+type ParamsRecord = Record<string, string>;
+type WsEntry<P extends keyof WebSocketRouteMap> = WebSocketRouteMap[P];
+type ParamsOf<P extends keyof WebSocketRouteMap> = WsEntry<P> extends {
+  params: infer T;
+} ? T : Record<string, never>;
+type ClientEventOf<P extends keyof WebSocketRouteMap> = WsEntry<P> extends {
+  client: infer T;
+} ? T : never;
+type ServerEventOf<P extends keyof WebSocketRouteMap> = WsEntry<P> extends {
+  server: infer T;
+} ? T : never;
+type HasParams<P extends keyof WebSocketRouteMap> = ParamsOf<P> extends Record<string, never> ? false : [keyof ParamsOf<P>] extends [never] ? false : true;
+type WebSocketConnection<ServerEvent = unknown> = {
+  readonly id: string;
+  readonly state: unknown;
+  send(event: ServerEvent): Promise<void>;
+  close(code?: number, reason?: string): void;
+  setState(data: unknown): void;
+};
+type RoomController<ServerEvent = unknown> = {
+  broadcast(event: ServerEvent, excludeIds?: Array<string>): Promise<void>;
+  getConnections(): Iterable<WebSocketConnection<ServerEvent>>;
+  getConnection(id: string): WebSocketConnection<ServerEvent> | undefined;
+};
+type WebSocketBaseContext = {
+  readonly id: string;
+  readonly params: ParamsRecord;
+  readonly user: AuthUser | null;
+  readonly request: Request;
+  readonly env: CloudEnv["Bindings"];
+  readonly storage: DurableObjectStorage;
+};
+type RoomContext<ServerEvent = unknown> = WebSocketBaseContext & {
+  readonly room: RoomController<ServerEvent>;
+  readonly connection: WebSocketConnection<ServerEvent>;
+};
+type SocketContext<ServerEvent = unknown> = WebSocketBaseContext & {
+  readonly socket: WebSocketConnection<ServerEvent>;
+};
+type RoomDefinition<ClientSchema extends StandardSchemaV1 = StandardSchemaV1, ServerSchema extends StandardSchemaV1 = StandardSchemaV1> = {
+  readonly __kind: "room";
+  readonly messages: {
+    client: ClientSchema;
+    server: ServerSchema;
+  };
+  onBeforeConnect?: (ctx: RoomContext<StandardSchemaV1.InferInput<ServerSchema>>) => MaybePromise<Response | void>;
+  onConnect?: (ctx: RoomContext<StandardSchemaV1.InferInput<ServerSchema>>) => MaybePromise<void>;
+  onMessage?: (ctx: RoomContext<StandardSchemaV1.InferInput<ServerSchema>>, event: StandardSchemaV1.InferOutput<ClientSchema>) => MaybePromise<void>;
+  onClose?: (ctx: RoomContext<StandardSchemaV1.InferInput<ServerSchema>>, details?: {
+    code: number;
+    reason: string;
+    wasClean: boolean;
+  }) => MaybePromise<void>;
+  onRequest?: (ctx: RoomContext<StandardSchemaV1.InferInput<ServerSchema>>) => MaybePromise<Response>;
+};
+type SocketDefinition<ClientSchema extends StandardSchemaV1 = StandardSchemaV1, ServerSchema extends StandardSchemaV1 = StandardSchemaV1> = {
+  readonly __kind: "socket";
+  readonly messages: {
+    client: ClientSchema;
+    server: ServerSchema;
+  };
+  onBeforeConnect?: (ctx: SocketContext<StandardSchemaV1.InferInput<ServerSchema>>) => MaybePromise<Response | void>;
+  onConnect?: (ctx: SocketContext<StandardSchemaV1.InferInput<ServerSchema>>) => MaybePromise<void>;
+  onMessage?: (ctx: SocketContext<StandardSchemaV1.InferInput<ServerSchema>>, event: StandardSchemaV1.InferOutput<ClientSchema>) => MaybePromise<void>;
+  onClose?: (ctx: SocketContext<StandardSchemaV1.InferInput<ServerSchema>>, details?: {
+    code: number;
+    reason: string;
+    wasClean: boolean;
+  }) => MaybePromise<void>;
+  onRequest?: (ctx: SocketContext<StandardSchemaV1.InferInput<ServerSchema>>) => MaybePromise<Response>;
+};
+type AnyWebSocketDefinition = RoomDefinition | SocketDefinition;
+declare function defineRoom<ClientSchema extends StandardSchemaV1, ServerSchema extends StandardSchemaV1>(definition: Omit<RoomDefinition<ClientSchema, ServerSchema>, "__kind">): RoomDefinition<ClientSchema, ServerSchema>;
+declare function defineWebSocket<ClientSchema extends StandardSchemaV1, ServerSchema extends StandardSchemaV1>(definition: Omit<SocketDefinition<ClientSchema, ServerSchema>, "__kind">): SocketDefinition<ClientSchema, ServerSchema>;
+type VoidSocketCloseEvent = {
+  code?: number;
+  reason?: string;
+  wasClean?: boolean;
+};
+type ConnectCommonOptions = {
+  baseURL?: string;
+  reconnect?: boolean;
+  reconnectDelayMs?: number;
+  maxReconnectAttempts?: number;
+  protocols?: string | Array<string>;
+};
+type ConnectOptions<P extends keyof WebSocketRouteMap> = ConnectCommonOptions & (HasParams<P> extends true ? {
+  params: ParamsOf<P>;
+} : {
+  params?: never;
+});
+type ListenerMap<ServerEvent> = {
+  message: (event: ServerEvent) => void;
+  open: () => void;
+  close: (event: VoidSocketCloseEvent) => void;
+  error: (error: unknown) => void;
+};
+declare class VoidSocket<P extends keyof WebSocketRouteMap & string> {
+  private readonly url;
+  private readonly options;
+  private socket;
+  private readonly listeners;
+  private readonly buffer;
+  private reconnectAttempts;
+  private closedByUser;
+  constructor(url: string, options: ConnectCommonOptions);
+  private emit;
+  private connect;
+  send(event: ClientEventOf<P>): void;
+  close(code?: number, reason?: string): void;
+  on<K extends keyof ListenerMap<ServerEventOf<P>>>(type: K, handler: ListenerMap<ServerEventOf<P>>[K]): () => void;
+}
+declare function connect<P extends keyof WebSocketRouteMap & string>(path: HasParams<P> extends false ? P : never): VoidSocket<P>;
+declare function connect<P extends keyof WebSocketRouteMap & string>(path: P, options: ConnectOptions<P>): VoidSocket<P>;
+//#endregion
+export { RoomDefinition as a, VoidSocket as c, WebSocketConnection as d, connect as f, RoomController as i, VoidSocketCloseEvent as l, defineWebSocket as m, ConnectCommonOptions as n, SocketContext as o, defineRoom as p, RoomContext as r, SocketDefinition as s, AnyWebSocketDefinition as t, WebSocketBaseContext as u };

package/dist/{yarn-pnp-DxSInkzL.mjs → yarn-pnp-CVEc3gE7.mjs}

@@ -1,4 +1,4 @@
-import { n as dirname, o as join } from "./dist-BrsS7cai.mjs";
+import { a as join, n as dirname } from "./dist-4WkAWhWx.mjs";
 import { existsSync, readdirSync } from "node:fs";
 import { pathToFileURL } from "node:url";
 //#region src/cli/yarn-pnp.ts