void 0.27.0 → 1.0.3

package/dist/wrapper-CwhpNWtH.mjs

@@ -0,0 +1,663 @@
+import { a as join, l as toSlash, n as dirname, r as extname } from "./dist-ipQi0Q8y.mjs";
+import { n as readProjectPaths } from "./project-paths-DMvEeSau.mjs";
+import { d as readConfig, s as getDatabaseDialect } from "./config-Bx_1SpnO.mjs";
+import { n as isIdentifier, r as isLiteral } from "./ast-CPGPjb0V.mjs";
+import { t as MagicString } from "./dist-Cegxq8gs.mjs";
+import { r as voidDbBundlerPlugin, t as generateQueueResolverSource } from "./dispatch-DrTTk8Xg.mjs";
+import { createRequire } from "node:module";
+import { copyFileSync, existsSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { build, parseSync } from "vite";
+import { createHash } from "node:crypto";
+//#region src/cli/worker-require-transform.ts
+function nodes(root) {
+	const found = [];
+	const pending = [root];
+	while (pending.length > 0) {
+		const node = pending.pop();
+		found.push(node);
+		for (const value of Object.values(node)) if (Array.isArray(value)) {
+			for (const child of value) if (child && typeof child === "object" && typeof child.type === "string") pending.push(child);
+		} else if (value && typeof value === "object" && typeof value.type === "string") pending.push(value);
+	}
+	return found;
+}
+/**
+* Replace the `createRequire(import.meta.url)` binding that the bundler emits for CommonJS
+* database drivers with `requireShim`, which serves Node built-ins from static imports.
+* workerd gives modules no `import.meta.url`, so the original binding fails at startup.
+* PostgreSQL bundles also replace `pgpass`, which reads the filesystem.
+*/
+function transformWorkerRequireBundle(code, filename, requireShim, database) {
+	if (!code.includes("createRequire") && !code.includes("pgpass")) return code;
+	const program = parseSync(filename, code).program;
+	const edits = [];
+	let hasRequireBinding = false;
+	let pgpassCalls = 0;
+	for (const statement of program.body ?? []) {
+		if (statement.type === "ImportDeclaration" && statement.source?.value === "node:module") {
+			const specifiers = statement.specifiers;
+			if (specifiers?.length !== 1 || !isIdentifier(specifiers[0]?.imported) || specifiers[0].imported.name !== "createRequire") throw new Error(`deploy: Unsupported node:module import in ${database} bundle ${filename}.`);
+			edits.push({
+				start: statement.start,
+				end: statement.end,
+				replacement: ""
+			});
+		}
+		if (statement.type === "VariableDeclaration") {
+			const declarations = statement.declarations;
+			if (declarations?.some((declaration) => isIdentifier(declaration.id) && declaration.id.name === "__require")) {
+				if (declarations.length !== 1 || hasRequireBinding) throw new Error(`deploy: Unsupported require binding in ${database} bundle ${filename}.`);
+				hasRequireBinding = true;
+				edits.push({
+					start: statement.start,
+					end: statement.end,
+					replacement: requireShim
+				});
+			}
+		}
+	}
+	for (const node of nodes(program)) {
+		if (node.type !== "CallExpression" || !isIdentifier(node.callee) || node.callee.name !== "__require") continue;
+		const args = node.arguments;
+		if (args?.length !== 1 || !isLiteral(args[0]) || args[0].value !== "pgpass") continue;
+		pgpassCalls++;
+		edits.push({
+			start: node.start,
+			end: node.end,
+			replacement: "__voidPgpassNoop"
+		});
+	}
+	if (code.includes("createRequire") && !hasRequireBinding) throw new Error(`deploy: Could not locate the generated require binding in ${database} bundle ${filename}.`);
+	if (code.includes("pgpass") && pgpassCalls === 0 && code.includes("__require")) throw new Error(`deploy: Could not locate the pgpass require in ${database} bundle ${filename}.`);
+	const ms = new MagicString(code);
+	for (const edit of edits.sort((a, b) => b.start - a.start)) ms.overwrite(edit.start, edit.end, edit.replacement);
+	const transformed = ms.toString();
+	if (transformed.includes("createRequire") || transformed.includes("__require(\"pgpass\")")) throw new Error(`deploy: ${database} bundle ${filename} still contains an unsupported require.`);
+	return pgpassCalls > 0 ? `const __voidPgpassNoop = Object.assign(function pgpass(_connectionInfo, callback) { callback(undefined); }, { warnTo() {} });\n${transformed}` : transformed;
+}
+//#endregion
+//#region src/cli/wrapper.ts
+const BUNDLED_ENTRY_RE = /^index\.(?:m?js|cjs)$/;
+const envModuleFile = fileURLToPath(import.meta.resolve("#self/_env"));
+const WRAPPER_MARKER = "// Generated by Void: deployment wrapper.";
+function isGeneratedWrapper(source, originalName) {
+	return source.startsWith(WRAPPER_MARKER) || source.startsWith(`import original from "./${originalName}";\n`);
+}
+function selectBundledEntryFilename(outFiles) {
+	const entryFilename = outFiles.find((file) => BUNDLED_ENTRY_RE.test(file));
+	if (!entryFilename) throw new Error(`deploy: Bundled worker entry not found. Expected index.js, index.mjs, or index.cjs in bundle output. Found: ${outFiles.join(", ") || "(none)"}`);
+	return entryFilename;
+}
+/**
+* Determine whether a wrapper is needed based on the features.
+*/
+function needsWrapper(features) {
+	return features.crons.length > 0 || features.queues.length > 0 || !!features.hasMigrations || !!features.readiness || !!features.isr;
+}
+/**
+* Generate a wrapper entry in-place in the worker directory.
+*
+* - Preserves the original entry (e.g. `index.js` → `__original.js`)
+* - Compiles cron/queue handlers via a small Vite build
+* - Writes a wrapper module as the original entry name that imports
+*   the renamed original + compiled handlers
+*
+* The original worker code is never re-bundled.
+*/
+async function generateWrapper(workerDir, workerMain, root, features) {
+	const renamedName = `__original${extname(workerMain) || ".js"}`;
+	const mainPath = join(workerDir, workerMain);
+	const originalPath = join(workerDir, renamedName);
+	const alreadyWrapped = isGeneratedWrapper(readFileSync(mainPath, "utf8"), renamedName);
+	if (alreadyWrapped && (!existsSync(originalPath) || isGeneratedWrapper(readFileSync(originalPath, "utf8"), renamedName))) throw new Error("deploy: Original framework entry is missing or already wrapped. Rebuild the application before deploying.");
+	let handlerFilename = "__void_handlers.mjs";
+	if (features.crons.length > 0 || features.queues.length > 0) {
+		const tmpDir = join(root, ".void", "handlers");
+		mkdirSync(tmpDir, { recursive: true });
+		const config = readConfig(root);
+		const handlersSource = generateHandlersSource(root, features, getDatabaseDialect(config));
+		const handlersEntry = join(tmpDir, "handlers.ts");
+		writeFileSync(handlersEntry, handlersSource);
+		const outDir = join(tmpDir, "out");
+		await build({
+			root: tmpDir,
+			logLevel: "silent",
+			plugins: [voidDbBundlerPlugin(root, {
+				config,
+				sqlDriver: (dialect, entry) => bundleWorkerSqlDriver(dialect, entry, join(tmpDir, "sql-driver"))
+			})],
+			resolve: { alias: [{
+				find: /^void$/,
+				replacement: fileURLToPath(import.meta.resolve("void/handler"))
+			}] },
+			build: {
+				outDir,
+				emptyOutDir: true,
+				lib: {
+					entry: handlersEntry,
+					formats: ["es"],
+					fileName: "__void_handlers"
+				},
+				rollupOptions: { external: [/^cloudflare:/, /^node:/] },
+				minify: false,
+				target: "esnext"
+			}
+		});
+		handlerFilename = readdirSync(outDir).filter((f) => f.startsWith("__void_handlers"))[0] ?? "__void_handlers.mjs";
+		copyFileSync(join(outDir, handlerFilename), join(workerDir, handlerFilename));
+	}
+	let migrations;
+	let migrationPlanBundle;
+	if (features.hasMigrations) {
+		const { collectMigrations } = await import("./collect-Cae8A7Zr.mjs");
+		const { buildMigrationPlanBundle } = await import("./plan-CKX_jWnD.mjs");
+		const migrationsDir = readProjectPaths(root).migrationsDir;
+		migrations = collectMigrations(migrationsDir);
+		migrationPlanBundle = features.migrationDialect === "sqlite" ? buildMigrationPlanBundle(migrations) : void 0;
+		const handlerName = features.migrationDialect === "postgresql" ? "migration-handler-pg" : features.migrationDialect === "mysql" ? "migration-handler-mysql" : "migration-handler";
+		const handlerFilename_ = `${handlerName}.mjs`;
+		let handlerPath = join(import.meta.dirname, "..", "runtime", `${handlerName}.ts`);
+		if (!existsSync(handlerPath)) handlerPath = join(import.meta.dirname, "runtime", handlerFilename_);
+		if (!existsSync(handlerPath)) handlerPath = join(import.meta.dirname, "..", "runtime", handlerFilename_);
+		if (!existsSync(handlerPath)) throw new Error(`Migration handler not found: ${handlerFilename_}. Run "pnpm -C packages/void build" first.`);
+		await bundleMigrationHandler(root, workerDir, handlerPath, features.migrationDialect ?? "sqlite");
+	}
+	if (features.isr) await bundleFrameworkIsr(root, workerDir);
+	const wrapperSource = generateWrapperSource(renamedName, handlerFilename, features, migrations, migrationPlanBundle);
+	const stagedPath = `${mainPath}.${crypto.randomUUID()}.tmp`;
+	try {
+		writeFileSync(stagedPath, wrapperSource);
+		if (!alreadyWrapped) copyFileSync(mainPath, originalPath);
+		renameSync(stagedPath, mainPath);
+	} finally {
+		rmSync(stagedPath, { force: true });
+	}
+}
+async function bundleFrameworkIsr(root, workerDir) {
+	const entry = fileURLToPath(import.meta.resolve("@void/isr/runtime"));
+	const tmpDir = join(root, ".void", "isr");
+	const outDir = join(tmpDir, "out");
+	mkdirSync(tmpDir, { recursive: true });
+	await build({
+		root: tmpDir,
+		logLevel: "silent",
+		ssr: { noExternal: true },
+		build: {
+			outDir,
+			emptyOutDir: true,
+			minify: false,
+			ssr: entry,
+			target: "esnext",
+			rollupOptions: {
+				input: entry,
+				external: [/^cloudflare:/, /^node:/],
+				output: {
+					entryFileNames: "__void_isr.mjs",
+					chunkFileNames: "__void_isr-[hash].mjs"
+				}
+			}
+		}
+	});
+	for (const file of readdirSync(outDir)) copyFileSync(join(outDir, file), join(workerDir, file));
+}
+async function bundleMigrationHandler(root, workerDir, handlerPath, dialect) {
+	const tmpDir = join(root, ".void", "migration-handler");
+	mkdirSync(tmpDir, { recursive: true });
+	const outDir = join(tmpDir, "out");
+	const isPostgresql = dialect === "postgresql";
+	const isMysql = dialect === "mysql";
+	await build({
+		root: tmpDir,
+		logLevel: "silent",
+		resolve: isPostgresql ? {
+			alias: pgWorkerAliases(handlerPath),
+			conditions: WORKER_CONDITIONS
+		} : void 0,
+		ssr: {
+			noExternal: true,
+			...isPostgresql && { resolve: { conditions: WORKER_CONDITIONS } }
+		},
+		build: {
+			outDir,
+			emptyOutDir: true,
+			minify: false,
+			ssr: handlerPath,
+			target: "esnext",
+			rollupOptions: {
+				input: handlerPath,
+				external: SQL_WORKER_EXTERNAL,
+				output: {
+					entryFileNames: "__void_migration_handler.mjs",
+					chunkFileNames: "__void_migration_handler-[hash].mjs"
+				}
+			}
+		}
+	});
+	if (isPostgresql || isMysql) patchWorkerRequireBundle(outDir, isPostgresql ? "PostgreSQL" : "MySQL", "migration bundle");
+	for (const file of readdirSync(outDir)) copyFileSync(join(outDir, file), join(workerDir, file));
+}
+const WORKER_CONDITIONS = [
+	"workerd",
+	"worker",
+	"browser",
+	"module",
+	"import",
+	"default"
+];
+const SQL_WORKER_EXTERNAL = [
+	/^cloudflare:/,
+	/^node:/,
+	/^pgpass$/
+];
+/** pg's workerd socket and its CommonJS pool, resolved from the pg that `fromPath` loads. */
+function pgWorkerAliases(fromPath) {
+	return {
+		"pg-cloudflare": resolvePgCloudflareWorkerdEntry(fromPath),
+		"pg-pool": resolvePgCjsDependency(fromPath, "pg-pool")
+	};
+}
+/**
+* Build the PostgreSQL or MySQL driver whose entry file is `main` as an ES module for workerd,
+* the way the migration handler bundles Void's own, and return its path. Bundlers that do not run
+* voidPlugin() import this module for `pg` or `mysql2`: their CommonJS handling breaks the
+* drivers in workerd. Each driver copy gets its own folder in `baseDir`. The same build gives
+* mysql2's `mysql2/promise` API as `promise.mjs` next to it, so both share one copy of the driver.
+*/
+async function bundleWorkerSqlDriver(dialect, main, baseDir) {
+	const packageName = dialect === "postgresql" ? "pg" : "mysql2";
+	const outDir = join(baseDir, createHash("sha256").update(main).digest("hex").slice(0, 12));
+	mkdirSync(outDir, { recursive: true });
+	const input = { [packageName]: writeDriverEntry(join(outDir, "entry.mjs"), main) };
+	const promise = dialect === "mysql" ? resolveMysqlPromise(main) : void 0;
+	if (promise !== void 0) input.promise = writeDriverEntry(join(outDir, "promise-entry.mjs"), promise);
+	const bundleDir = join(outDir, "out");
+	await build({
+		root: outDir,
+		logLevel: "silent",
+		resolve: {
+			alias: dialect === "postgresql" ? pgWorkerAliases(main) : {},
+			conditions: WORKER_CONDITIONS
+		},
+		ssr: {
+			noExternal: true,
+			resolve: { conditions: WORKER_CONDITIONS }
+		},
+		build: {
+			outDir: bundleDir,
+			emptyOutDir: true,
+			minify: false,
+			ssr: true,
+			target: "esnext",
+			rollupOptions: {
+				input,
+				external: SQL_WORKER_EXTERNAL,
+				output: {
+					entryFileNames: "[name].mjs",
+					chunkFileNames: `${packageName}-[hash].mjs`
+				}
+			}
+		}
+	});
+	patchWorkerRequireBundle(bundleDir, dialect === "postgresql" ? "PostgreSQL" : "MySQL", "driver bundle");
+	return join(bundleDir, `${packageName}.mjs`);
+}
+/** Write an ES module at `entry` that exports the CommonJS module `file`, and return `entry`. */
+function writeDriverEntry(entry, file) {
+	const names = Object.keys(createRequire(file)(file)).filter((name) => name !== "default" && /^[A-Za-z_$][\w$]*$/.test(name));
+	writeFileSync(entry, `import driver from ${JSON.stringify(toSlash(file))};\nexport default driver;\nexport const { ${names.join(", ")} } = driver;\n`);
+	return entry;
+}
+/** The `mysql2/promise` file of the mysql2 copy whose entry file is `main`, if it has one. */
+function resolveMysqlPromise(main) {
+	try {
+		return createRequire(main).resolve("mysql2/promise");
+	} catch {
+		return;
+	}
+}
+/** `bundle` names the bundle in the error a failed require throws. */
+function patchWorkerRequireBundle(outDir, database, bundle) {
+	for (const file of readdirSync(outDir)) {
+		if (!file.endsWith(".mjs") && !file.endsWith(".js")) continue;
+		const path = join(outDir, file);
+		const code = readFileSync(path, "utf-8");
+		const transformed = transformWorkerRequireBundle(code, file, database === "PostgreSQL" ? pgWorkerRequireShim(bundle) : mysqlWorkerRequireShim(bundle), database);
+		if (transformed !== code) writeFileSync(path, transformed);
+	}
+}
+function createPgPackageRequire(fromPath) {
+	const fromRequire = createRequire(fromPath);
+	return createRequire(fromRequire.resolve("pg/package.json"));
+}
+function resolvePgCjsDependency(fromPath, specifier) {
+	return createPgPackageRequire(fromPath).resolve(specifier);
+}
+function resolvePgCloudflareWorkerdEntry(fromPath) {
+	const packageJsonPath = createPgPackageRequire(fromPath).resolve("pg-cloudflare/package.json");
+	return join(dirname(packageJsonPath), "dist", "index.js");
+}
+function pgWorkerRequireShim(bundle) {
+	return [
+		"import * as __voidNodeCrypto from \"node:crypto\";",
+		"import * as __voidNodeDns from \"node:dns\";",
+		"import * as __voidNodeEvents from \"node:events\";",
+		"import * as __voidNodeNet from \"node:net\";",
+		"import * as __voidNodeTls from \"node:tls\";",
+		"import * as __voidNodeUtil from \"node:util\";",
+		"import * as __voidNodeUtilTypes from \"node:util/types\";",
+		"var __voidNodeRequireModules = {",
+		"  crypto: __voidNodeCrypto,",
+		"  dns: __voidNodeDns,",
+		"  events: __voidNodeEvents,",
+		"  net: __voidNodeNet,",
+		"  tls: __voidNodeTls,",
+		"  util: __voidNodeUtil,",
+		"  \"util/types\": __voidNodeUtilTypes,",
+		"};",
+		"var __require = (id) => {",
+		"  if (id.startsWith(\"node:\")) id = id.slice(5);",
+		"  const mod = __voidNodeRequireModules[id];",
+		"  if (mod) return mod;",
+		`  throw new Error(\`Unsupported require("\${id}") in Void PG ${bundle}\`);`,
+		"};"
+	].join("\n");
+}
+function mysqlWorkerRequireShim(bundle) {
+	return [
+		"import __voidNodeBuffer from \"node:buffer\";",
+		"import __voidNodeCrypto from \"node:crypto\";",
+		"import __voidNodeDiagnosticsChannel from \"node:diagnostics_channel\";",
+		"import __voidNodeEvents from \"node:events\";",
+		"import __voidNodeNet from \"node:net\";",
+		"import __voidNodeProcess from \"node:process\";",
+		"import __voidNodeStream from \"node:stream\";",
+		"import __voidNodeStringDecoder from \"node:string_decoder\";",
+		"import __voidNodeTimers from \"node:timers\";",
+		"import __voidNodeTls from \"node:tls\";",
+		"import __voidNodeUrl from \"node:url\";",
+		"import __voidNodeUtil from \"node:util\";",
+		"import __voidNodeZlib from \"node:zlib\";",
+		"var __voidNodeRequireModules = {",
+		"  buffer: __voidNodeBuffer,",
+		"  crypto: __voidNodeCrypto,",
+		"  diagnostics_channel: __voidNodeDiagnosticsChannel,",
+		"  events: __voidNodeEvents,",
+		"  net: __voidNodeNet,",
+		"  process: __voidNodeProcess,",
+		"  stream: __voidNodeStream,",
+		"  string_decoder: __voidNodeStringDecoder,",
+		"  timers: __voidNodeTimers,",
+		"  tls: __voidNodeTls,",
+		"  url: __voidNodeUrl,",
+		"  util: __voidNodeUtil,",
+		"  zlib: __voidNodeZlib,",
+		"};",
+		"var __require = (id) => {",
+		"  if (id.startsWith(\"node:\")) id = id.slice(5);",
+		"  const mod = __voidNodeRequireModules[id];",
+		"  if (mod) return mod;",
+		`  throw new Error(\`Unsupported require("\${id}") in Void MySQL ${bundle}\`);`,
+		"};"
+	].join("\n");
+}
+/**
+* Bundle a worker entry into a self-contained module.
+*
+* Used for frameworks whose build output has unbundled bare imports
+* (e.g. SvelteKit's `_worker.js` imports from `@sveltejs/kit`).
+*/
+async function bundleEntry(root, entry) {
+	const tmpDir = join(root, ".void", "bundle");
+	mkdirSync(tmpDir, { recursive: true });
+	const outDir = join(tmpDir, "out");
+	await build({
+		root: tmpDir,
+		logLevel: "silent",
+		build: {
+			outDir,
+			emptyOutDir: true,
+			lib: {
+				entry,
+				formats: ["es"],
+				fileName: "index"
+			},
+			rollupOptions: {
+				external: [/^cloudflare:/, /^node:/],
+				output: { banner: [
+					"const __noopCache = {",
+					"  match() { return Promise.resolve(undefined); },",
+					"  put() { return Promise.resolve(); },",
+					"  delete() { return Promise.resolve(false); },",
+					"};",
+					"globalThis.caches = { default: __noopCache, open() { return Promise.resolve(__noopCache); } };"
+				].join("\n") }
+			},
+			minify: false,
+			target: "esnext"
+		}
+	});
+	return {
+		entryFilename: selectBundledEntryFilename(readdirSync(outDir)),
+		outputDir: outDir
+	};
+}
+/** Clean up the temporary directories created while generating a deploy wrapper. */
+function cleanupWrapper(root) {
+	const voidDir = join(root, ".void");
+	for (const directory of [
+		"handlers",
+		"migration-handler",
+		"isr",
+		"bundle"
+	]) rmSync(join(voidDir, directory), {
+		recursive: true,
+		force: true
+	});
+}
+function generateWrapperSource(renamedEntry, handlersModule, features, migrations, migrationPlanBundle) {
+	const lines = [];
+	lines.push(WRAPPER_MARKER);
+	lines.push(`import original from "./${renamedEntry}";`);
+	if (features.isr) {
+		lines.push("import { handleFrameworkIsr } from \"./__void_isr.mjs\";");
+		lines.push(`const __voidIsrDeploymentId = ${JSON.stringify(crypto.randomUUID())};`);
+		lines.push(`const __voidIsrPolicy = ${JSON.stringify({
+			revalidate: features.isr.revalidate,
+			queryAllowlist: features.isr.queryAllowlist
+		})};`);
+	}
+	if (features.crons.length > 0) lines.push(`import { handleScheduled } from "./${handlersModule}";`);
+	if (features.queues.length > 0) lines.push(`import { handleQueue, handleQueueRelay } from "./${handlersModule}";`);
+	if (migrations && migrations.length > 0) {
+		lines.push(`import { createMigrationHandler } from "./__void_migration_handler.mjs";`);
+		lines.push(`const __migrations = ${JSON.stringify(migrations)};`);
+		lines.push(`const __migrationPlanBundle = ${JSON.stringify(migrationPlanBundle)};`);
+	}
+	lines.push("");
+	const needsFetchWrap = features.readiness || features.crons.length > 0 || features.queues.length > 0 || migrations && migrations.length > 0 || !!features.isr;
+	if (needsFetchWrap) {
+		lines.push("async function wrappedFetch(request, env, ctx) {");
+		lines.push("  const url = new URL(request.url);");
+		if (features.isr) {
+			lines.push("  env.__VOID_ISR_DEPLOYMENT_ID ??= __voidIsrDeploymentId;");
+			lines.push("  env.__VOID_ISR_HOST = url.hostname;");
+		}
+		if (features.readiness || features.crons.length > 0 || features.queues.length > 0 || features.hasMigrations) {
+			lines.push("  if (request.method === \"GET\" && url.pathname === \"/__void/ready\") {");
+			lines.push("    if (typeof original?.fetch !== \"function\") {");
+			lines.push("      return Response.json({ ready: false, error: \"worker entry has no fetch handler\" }, { status: 503, headers: { \"cache-control\": \"no-store\" } });");
+			lines.push("    }");
+			lines.push(`    return Response.json({ ready: true${features.versionMetadataBinding ? `, versionId: env[${JSON.stringify(features.versionMetadataBinding)}]?.id` : ""} }${features.versionMetadataBinding ? ", { headers: { \"cache-control\": \"no-store\" } }" : ""});`);
+			lines.push("  }");
+		}
+		if (features.queues.length > 0) {
+			lines.push("  if (request.method === \"POST\" && url.pathname === \"/__void/queue\") {");
+			lines.push("    const expected = env?.__VOID_PROXY_TOKEN;");
+			lines.push("    if (!expected || request.headers.get(\"x-void-internal\") !== expected) {");
+			lines.push("      return Response.json({ error: \"unauthorized\" }, { status: 401 });");
+			lines.push("    }");
+			lines.push("    try {");
+			lines.push("      return Response.json(await handleQueueRelay(await request.json(), env, ctx));");
+			lines.push("    } catch {");
+			lines.push("      return Response.json({ error: \"Invalid queue payload\" }, { status: 400 });");
+			lines.push("    }");
+			lines.push("  }");
+		}
+		if (migrations && migrations.length > 0) {
+			lines.push("  if (request.method === \"POST\" && url.pathname === \"/__void/migrate\") {");
+			lines.push("    const handler = createMigrationHandler(env, __migrations);");
+			lines.push("    return handler(request);");
+			lines.push("  }");
+			lines.push("  if (request.method === \"GET\" && url.pathname === \"/__void/migrate/capabilities\") {");
+			lines.push("    const handler = createMigrationHandler(env, __migrations, undefined, __migrationPlanBundle);");
+			lines.push("    return handler(request);");
+			lines.push("  }");
+			lines.push("  if (request.method === \"POST\" && url.pathname === \"/__void/migrate/app\") {");
+			lines.push("    const handler = createMigrationHandler(env, __migrations, undefined, __migrationPlanBundle);");
+			lines.push("    return handler(request);");
+			lines.push("  }");
+			lines.push("  if (request.method === \"GET\" && url.pathname.startsWith(\"/__void/migrate/app/attempt/\")) {");
+			lines.push("    const handler = createMigrationHandler(env, __migrations, undefined, __migrationPlanBundle);");
+			lines.push("    return handler(request);");
+			lines.push("  }");
+		}
+		if (features.crons.length > 0) {
+			lines.push("  if (request.method === \"POST\" && url.pathname === \"/__void/scheduled\") {");
+			lines.push("    const __token = request.headers.get(\"x-void-internal\");");
+			lines.push("    const __expected = env?.__VOID_PROXY_TOKEN || env?.CRON_SECRET;");
+			lines.push("    if (!__expected || __token !== __expected) {");
+			lines.push("      return new Response(JSON.stringify({ error: 'unauthorized' }), {");
+			lines.push("        status: 401,");
+			lines.push("        headers: { \"Content-Type\": \"application/json\" },");
+			lines.push("      });");
+			lines.push("    }");
+			lines.push("    try {");
+			lines.push("      const { cron, scheduledTime } = await request.json();");
+			lines.push("      const controller = { cron, scheduledTime, noRetry() {} };");
+			lines.push("      await handleScheduled(controller, env, ctx);");
+			lines.push("      return new Response(JSON.stringify({ ok: true }), {");
+			lines.push("        headers: { \"Content-Type\": \"application/json\" },");
+			lines.push("      });");
+			lines.push("    } catch (err) {");
+			lines.push("      return new Response(JSON.stringify({ error: String(err) }), {");
+			lines.push("        status: 500,");
+			lines.push("        headers: { \"Content-Type\": \"application/json\" },");
+			lines.push("      });");
+			lines.push("    }");
+			lines.push("  }");
+		}
+		if (features.isr) {
+			lines.push("  if (env.ISR_CACHE && request.headers.get(\"upgrade\")?.toLowerCase() !== \"websocket\") {");
+			lines.push("    const cached = await handleFrameworkIsr(request, env, ctx, { ...__voidIsrPolicy, deploymentId: __voidIsrDeploymentId }, (req) => original.fetch(req, env, ctx));");
+			lines.push("    if (cached) return cached;");
+			lines.push("  }");
+		}
+		lines.push("  return original.fetch(request, env, ctx);");
+		lines.push("}");
+		lines.push("");
+	}
+	lines.push("export default {");
+	if (needsFetchWrap) lines.push("  fetch: wrappedFetch,");
+	else lines.push("  fetch: original.fetch,");
+	if (features.crons.length > 0) lines.push(features.isr ? "  scheduled(controller, env, ctx) { env.__VOID_ISR_DEPLOYMENT_ID ??= __voidIsrDeploymentId; return handleScheduled(controller, env, ctx); }," : "  scheduled: handleScheduled,");
+	if (features.queues.length > 0) lines.push(features.isr ? "  queue(batch, env, ctx) { env.__VOID_ISR_DEPLOYMENT_ID ??= __voidIsrDeploymentId; return handleQueue(batch, env, ctx); }," : "  queue: handleQueue,");
+	lines.push("};");
+	return lines.join("\n");
+}
+function generateHandlersSource(root, features, dialect) {
+	const lines = [];
+	const paths = readProjectPaths(root);
+	const scoped = dialect !== "sqlite";
+	if (scoped) lines.push(`import { withRuntimeEnv } from ${JSON.stringify(envModuleFile)};`);
+	if (features.crons.length > 0) {
+		for (let i = 0; i < features.crons.length; i++) {
+			const absPath = join(paths.cronsDir, features.crons[i].filePath);
+			lines.push(`import cronHandler${i} from "${absPath}";`);
+		}
+		lines.push("");
+		lines.push(scoped ? "async function __runScheduled(controller, env, ctx) {" : "export async function handleScheduled(controller, env, ctx) {");
+		lines.push("  const tasks = [];");
+		for (let i = 0; i < features.crons.length; i++) {
+			lines.push(`  if (${JSON.stringify(features.crons[i].crons)}.includes(controller.cron)) {`);
+			lines.push("    tasks.push((async () => {");
+			lines.push(`      if (typeof cronHandler${i} === "function") {`);
+			lines.push(`        await cronHandler${i}(controller, env, ctx);`);
+			lines.push(`      } else if (cronHandler${i} && typeof cronHandler${i}.default === "function") {`);
+			lines.push(`        await cronHandler${i}.default(controller, env, ctx);`);
+			lines.push("      }");
+			lines.push("    })());");
+			lines.push("  }");
+		}
+		lines.push("  const results = await Promise.allSettled(tasks);");
+		lines.push("  const errors = results.filter(result => result.status === \"rejected\").map(result => result.reason);");
+		lines.push("  if (errors.length) throw new AggregateError(errors, \"Scheduled jobs failed\");");
+		lines.push("}");
+		if (scoped) {
+			lines.push("export function handleScheduled(controller, env, ctx) {");
+			lines.push("  return withRuntimeEnv(env, () => __runScheduled(controller, env, ctx));");
+			lines.push("}");
+		}
+	}
+	if (features.queues.length > 0) {
+		lines.push("");
+		for (let i = 0; i < features.queues.length; i++) {
+			const absPath = join(paths.queuesDir, features.queues[i].filePath);
+			lines.push(`import queueHandler${i} from "${absPath}";`);
+		}
+		lines.push("");
+		lines.push(generateQueueResolverSource(features.queues.map((queue) => queue.name)));
+		lines.push("");
+		lines.push(scoped ? "async function __runQueue(batch, env, ctx) {" : "export async function handleQueue(batch, env, ctx) {");
+		lines.push("  const queueSuffix = batch.queue;");
+		lines.push("  const __queueIndex = __resolveQueueIndex(queueSuffix);");
+		lines.push("  if (__queueIndex === -1) {");
+		lines.push("    batch.retryAll();");
+		lines.push("    throw new Error(`No unambiguous queue handler matches \"${String(queueSuffix)}\"`);");
+		lines.push("  }");
+		lines.push("  switch (__queueIndex) {");
+		for (let i = 0; i < features.queues.length; i++) {
+			lines.push(`    case ${i}:`);
+			lines.push(`      if (typeof queueHandler${i} === "function") {`);
+			lines.push(`        await queueHandler${i}(batch, env);`);
+			lines.push(`      } else if (queueHandler${i} && typeof queueHandler${i}.default === "function") {`);
+			lines.push(`        await queueHandler${i}.default(batch, env);`);
+			lines.push(`      }`);
+			lines.push(`      return;`);
+		}
+		lines.push("  }");
+		lines.push("}");
+		if (scoped) {
+			lines.push("export function handleQueue(batch, env, ctx) {");
+			lines.push("  return withRuntimeEnv(env, () => __runQueue(batch, env, ctx));");
+			lines.push("}");
+		}
+		lines.push(`
+export async function handleQueueRelay(payload, env, ctx) {
+  if (!payload || typeof payload.queue !== "string" || !Array.isArray(payload.messages) ||
+    payload.messages.some(m => !m || typeof m.id !== "string" || typeof m.timestamp !== "string" || !Number.isFinite(Date.parse(m.timestamp)))) {
+    throw new Error("Invalid queue payload");
+  }
+  const decisions = new Map();
+  const messages = payload.messages.map(m => {
+    const decide = (decision) => { if (!decisions.has(m.id)) decisions.set(m.id, decision); };
+    return {
+      id: m.id, timestamp: new Date(m.timestamp), body: m.body, attempts: m.attempts,
+      ack() { decide({ action: "ack" }); },
+      retry(options) { decide({ action: "retry", ...(options?.delaySeconds != null ? { delaySeconds: options.delaySeconds } : {}) }); },
+    };
+  });
+  const batch = {
+    queue: payload.queue, messages,
+    ackAll() { for (const message of messages) message.ack(); },
+    retryAll(options) { for (const message of messages) message.retry(options); },
+  };
+  let ok = true;
+  try { await handleQueue(batch, env, ctx); } catch { ok = false; }
+  return { ok, ...(decisions.size ? { decisions: Object.fromEntries(decisions) } : {}) };
+}`);
+	}
+	return lines.join("\n");
+}
+//#endregion
+export { needsWrapper as a, generateWrapper as i, bundleWorkerSqlDriver as n, cleanupWrapper as r, bundleEntry as t };

package/dist/{ws-CChrrAU-.d.mts → ws-aKVYB-fA.d.mts}

@@ -1,6 +1,6 @@
 import { t as StandardSchemaV1 } from "./standard-schema-Fo_vCAZh.mjs";
 import { r as AuthUser } from "./auth-DkcFflXV.mjs";
-import { a as CloudEnv } from "./handler-CNAwjRcW.mjs";
+import { a as CloudEnv } from "./handler-_PqY82xe.mjs";
 import { WebSocketRouteMap } from "void/routes";
 //#region src/runtime/ws.d.ts
 type MaybePromise<T> = T | Promise<T>;