void 0.22.0 → 0.23.0

package/dist/runtime/sandbox-container.d.mts

@@ -1,3 +1,3 @@
 /// <reference types="@cloudflare/workers-types" />
-import { a as SandboxInstance, c as SandboxProcessWire, i as SandboxExecOptions, l as validateSandboxOptions, n as SandboxCapability, o as SandboxNativeContainer, r as SandboxContainer, s as SandboxOptions, t as DEFAULT_SANDBOX_INACTIVITY_TIMEOUT_MS } from "../sandbox-container-DdNEBfCc.mjs";
+import { a as SandboxInstance, c as SandboxProcessWire, i as SandboxExecOptions, l as validateSandboxOptions, n as SandboxCapability, o as SandboxNativeContainer, r as SandboxContainer, s as SandboxOptions, t as DEFAULT_SANDBOX_INACTIVITY_TIMEOUT_MS } from "../sandbox-container-Bo0eiFKz.mjs";
 export { DEFAULT_SANDBOX_INACTIVITY_TIMEOUT_MS, SandboxCapability, SandboxContainer, SandboxExecOptions, SandboxInstance, SandboxNativeContainer, SandboxOptions, SandboxProcessWire, validateSandboxOptions };

package/dist/runtime/sandbox-container.mjs

@@ -1,2 +1,2 @@
-import { n as SandboxContainer, r as validateSandboxOptions, t as DEFAULT_SANDBOX_INACTIVITY_TIMEOUT_MS } from "../sandbox-container-4fdqLnyb.mjs";
+import { n as SandboxContainer, r as validateSandboxOptions, t as DEFAULT_SANDBOX_INACTIVITY_TIMEOUT_MS } from "../sandbox-container-C6ItmVuN.mjs";
 export { DEFAULT_SANDBOX_INACTIVITY_TIMEOUT_MS, SandboxContainer, validateSandboxOptions };

package/dist/runtime/sandbox.d.mts

@@ -1,5 +1,5 @@
 /// <reference types="@cloudflare/workers-types" />
-import { i as SandboxExecOptions, s as SandboxOptions } from "../sandbox-container-DdNEBfCc.mjs";
-import { a as SandboxLimitError, c as VoidPlatformSandbox, d as getSandbox, f as sandbox, i as SandboxClient, l as VoidSandboxOptions, n as DEFAULT_SANDBOX_ID, o as SandboxProcess, r as SANDBOX_SERVICE_BINDING, s as SandboxUnavailableError, t as DEFAULT_SANDBOX_BINDING, u as __setSandboxBindingName } from "../sandbox-qpNBT8a3.mjs";
+import { i as SandboxExecOptions, s as SandboxOptions } from "../sandbox-container-Bo0eiFKz.mjs";
+import { a as SandboxFiles, c as SandboxUnavailableError, d as __setSandboxBindingName, f as getSandbox, i as SandboxClient, l as VoidPlatformSandbox, n as DEFAULT_SANDBOX_ID, o as SandboxLimitError, p as sandbox, r as SANDBOX_SERVICE_BINDING, s as SandboxProcess, t as DEFAULT_SANDBOX_BINDING, u as VoidSandboxOptions } from "../sandbox-XZAqzFlG.mjs";
 export * from "@cloudflare/sandbox";
-export { DEFAULT_SANDBOX_BINDING, DEFAULT_SANDBOX_ID, SANDBOX_SERVICE_BINDING, SandboxClient, type SandboxExecOptions, SandboxLimitError, type SandboxOptions, SandboxProcess, SandboxUnavailableError, VoidPlatformSandbox, VoidSandboxOptions, __setSandboxBindingName, getSandbox, sandbox };
+export { DEFAULT_SANDBOX_BINDING, DEFAULT_SANDBOX_ID, SANDBOX_SERVICE_BINDING, SandboxClient, type SandboxExecOptions, SandboxFiles, SandboxLimitError, type SandboxOptions, SandboxProcess, SandboxUnavailableError, VoidPlatformSandbox, VoidSandboxOptions, __setSandboxBindingName, getSandbox, sandbox };

package/dist/runtime/sandbox.mjs

@@ -1,17 +1,20 @@
 import { a as getRawRuntimeEnv } from "../env-raw-Cx8ElDdj.mjs";
 import { a as requireRuntimeBinding } from "../env-D5liuQYR.mjs";
-import { n as SandboxContainer, r as validateSandboxOptions } from "../sandbox-container-4fdqLnyb.mjs";
+import { i as limitOperation, t as UsageLimit } from "../limits-Cjuk2VPm.mjs";
+import { n as SandboxContainer, r as validateSandboxOptions } from "../sandbox-container-C6ItmVuN.mjs";
 export * from "@cloudflare/sandbox";
 //#region src/runtime/sandbox.ts
 const DEFAULT_SANDBOX_ID = "default";
 const DEFAULT_SANDBOX_BINDING = "SANDBOX";
 const SANDBOX_SERVICE_BINDING = "__VOID_SANDBOX";
-var SandboxLimitError = class extends Error {
+var SandboxLimitError = class extends UsageLimit {
 	name = "SandboxLimitError";
-	reason;
 	constructor(reason, message) {
-		super(message ?? `Sandbox limit reached: ${reason}`);
-		this.reason = reason;
+		super({
+			resource: "sandbox",
+			reason,
+			message: message ?? `Sandbox limit reached: ${reason}`
+		});
 	}
 };
 var SandboxUnavailableError = class extends Error {
@@ -88,48 +91,75 @@ function client(capability) {
 			throw error;
 		}
 	};
+	const files = new Proxy(Object.create(null), { get(_target, method) {
+		if (typeof method !== "string" || method === "then") return;
+		return (...args) => {
+			const index = method === "writeFile" || method === "rename" ? 3 : 2;
+			return limitOperation(() => callWithOptions("files", [method, ...args], index));
+		};
+	} });
+	const execute = async (argv, options) => {
+		const wire = await callWithOptions("exec", [argv, options], 1);
+		let exitCode;
+		let output;
+		const process = {
+			pid: wire.pid,
+			isPty: wire.isPty,
+			stdin: wire.stdin,
+			stdout: wire.stdout,
+			stderr: wire.stderr,
+			get exitCode() {
+				return exitCode ??= limitOperation(async () => {
+					try {
+						return await wire.capability.invoke("exitCode", []);
+					} catch (error) {
+						rethrowSandboxError(error);
+					}
+				});
+			},
+			output() {
+				return output ??= limitOperation(async () => {
+					try {
+						return await Promise.all([
+							wire.stdout ? new Response(wire.stdout).arrayBuffer() : /* @__PURE__ */ new ArrayBuffer(0),
+							wire.stderr ? new Response(wire.stderr).arrayBuffer() : /* @__PURE__ */ new ArrayBuffer(0),
+							process.exitCode.match({
+								ok: (code) => code,
+								limited: (limit) => {
+									throw limit;
+								}
+							})
+						]).then(([stdout, stderr, exitCode]) => ({
+							stdout,
+							stderr,
+							exitCode
+						}));
+					} catch (error) {
+						rethrowSandboxError(error);
+					}
+				});
+			},
+			kill: async (signal) => {
+				await wire.capability.invoke("kill", [signal]);
+			},
+			resize: async (cols, rows) => {
+				await wire.capability.invoke("resize", [cols, rows]);
+			}
+		};
+		return process;
+	};
 	return {
-		files: new Proxy(Object.create(null), { get(_target, method) {
-			if (typeof method !== "string" || method === "then") return;
-			return (...args) => {
-				const index = method === "writeFile" || method === "rename" ? 3 : 2;
-				return callWithOptions("files", [method, ...args], index);
-			};
-		} }),
-		async exec(argv, options) {
-			const wire = await callWithOptions("exec", [argv, options], 1);
-			let exitCode;
-			let output;
-			const process = {
-				pid: wire.pid,
-				isPty: wire.isPty,
-				stdin: wire.stdin,
-				stdout: wire.stdout,
-				stderr: wire.stderr,
-				get exitCode() {
-					return exitCode ??= wire.capability.invoke("exitCode", []);
-				},
-				output() {
-					return output ??= Promise.all([
-						wire.stdout ? new Response(wire.stdout).arrayBuffer() : /* @__PURE__ */ new ArrayBuffer(0),
-						wire.stderr ? new Response(wire.stderr).arrayBuffer() : /* @__PURE__ */ new ArrayBuffer(0),
-						process.exitCode
-					]).then(([stdout, stderr, exitCode]) => ({
-						stdout,
-						stderr,
-						exitCode
-					}));
-				},
-				kill: async (signal) => {
-					await wire.capability.invoke("kill", [signal]);
-				},
-				resize: async (cols, rows) => {
-					await wire.capability.invoke("resize", [cols, rows]);
+		files,
+		exec: (argv, options) => limitOperation(() => execute(argv, options)),
+		run: (argv, options) => limitOperation(async () => {
+			return (await execute(argv, options)).output().match({
+				ok: (result) => result,
+				limited: (limit) => {
+					throw limit;
 				}
-			};
-			return process;
-		},
-		fetch: async (port, request) => await call("fetch", [port, request]),
+			});
+		}),
+		fetch: (port, request) => limitOperation(async () => await call("fetch", [port, request])),
 		running: async () => await call("running", []),
 		destroy: async () => {
 			await call("destroy", []);

package/dist/runtime/sse.mjs

@@ -1,2 +1,2 @@
-import { a as getLastEventId, i as formatSseText, n as eventStream, r as formatSse, t as SseStreamClosedError } from "../sse-BaC1jXko.mjs";
+import { a as getLastEventId, i as formatSseText, n as eventStream, r as formatSse, t as SseStreamClosedError } from "../sse-CQNaDFFV.mjs";
 export { SseStreamClosedError, eventStream, formatSse, formatSseText, getLastEventId };

package/dist/runtime/validator.d.mts

@@ -1,2 +1,2 @@
-import { D as runValidation, E as ValidatorSlots, T as HandlerInput } from "../handler-HEcZsaij.mjs";
+import { D as runValidation, E as ValidatorSlots, T as HandlerInput } from "../handler-CZ4nAylQ.mjs";
 export { HandlerInput, ValidatorSlots, runValidation };

package/dist/runtime/ws-server.d.mts

@@ -1,8 +1,10 @@
 import { n as AuthState } from "../auth-DkcFflXV.mjs";
 import { i as VoidAuthRuntimeOptions, n as VoidAuthEnv } from "../better-auth-shared-BVkjZ3vM.mjs";
-import { t as AnyWebSocketDefinition } from "../ws-BoY7vQML.mjs";
+import { f as WebSocketInstanceKey, t as AnyWebSocketDefinition } from "../ws-CL1w7GXU.mjs";
 //#region src/runtime/ws-server.d.ts
 export type WebSocketRouteMeta = {
+  name?: string;
+  key?: WebSocketInstanceKey;
   pattern: string;
   params: Array<string>;
   className: string;
@@ -17,7 +19,7 @@ export type WebSocketDurableObjectClass = {
   new (state: DurableObjectState, env: Record<string, unknown>): WebSocketDurableObjectInstance;
 };
 type ResolveVoidAuthState = (request: Request, env: VoidAuthEnv, runtime: VoidAuthRuntimeOptions) => Promise<AuthState | null>;
-export declare function buildWebSocketInstanceId(route: Pick<WebSocketRouteMeta, "params">, params: Record<string, string>): string;
+export declare function buildWebSocketInstanceId(route: Pick<WebSocketRouteMeta, "params" | "key">, params: Record<string, string>): string;
 export declare function createWebSocketDurableObject(definition: AnyWebSocketDefinition, route: WebSocketRouteMeta, authRuntime?: VoidAuthRuntimeOptions, resolveAuthState?: ResolveVoidAuthState): WebSocketDurableObjectClass;
 /** Keep a removed WebSocket Durable Object class deployable without deleting its storage. */
 export declare function createWebSocketTombstoneDurableObject(className: string): WebSocketDurableObjectClass;

package/dist/runtime/ws-server.mjs

@@ -48,7 +48,14 @@ function getRouteMatch(request, route) {
 	return match.matched ? match.params : null;
 }
 function buildWebSocketInstanceId(route, params) {
+	if (route.key) {
+		const key = route.key({ params });
+		if (typeof key !== "string") throw new Error("ws: key must return a string synchronously.");
+		return key;
+	}
 	if (route.params.length === 0) return "default";
+	const entries = route.params.map((name) => [name, params[name] ?? ""]);
+	if (entries.length > 1 && entries.some(([, value]) => value.includes("&"))) return `v2:${JSON.stringify(entries)}`;
 	return route.params.map((name) => `${name}=${params[name] ?? ""}`).join("&");
 }
 async function validateSchema(schema, value) {
@@ -92,6 +99,16 @@ function getStoredConnection(webSocket) {
 		authState: null
 	};
 }
+function completeWebSocketClose(webSocket, code, reason) {
+	if (webSocket.readyState === 3) return;
+	if ([
+		1004,
+		1005,
+		1006,
+		1015
+	].includes(code)) webSocket.close();
+	else webSocket.close(code, reason);
+}
 function setStoredConnection(webSocket, data) {
 	webSocket.serializeAttachment?.(data);
 }
@@ -164,6 +181,11 @@ function assertDefinition(definition) {
 }
 function createWebSocketDurableObject(definition, route, authRuntime, resolveAuthState) {
 	assertDefinition(definition);
+	if (definition.name !== route.name) throw new Error("ws: name must be statically discoverable in the route definition. Run void info to inspect this route.");
+	const instanceRoute = {
+		...route,
+		key: definition.key
+	};
 	class VoidWebSocketDurableObject {
 		state;
 		env;
@@ -176,7 +198,7 @@ function createWebSocketDurableObject(definition, route, authRuntime, resolveAut
 		}
 		async handleFetch(request) {
 			const params = getRouteMatch(request, route) ?? {};
-			const roomId = buildWebSocketInstanceId(route, params);
+			const roomId = buildWebSocketInstanceId(instanceRoute, params);
 			const authState = authRuntime && resolveAuthState ? await resolveAuthState(request, this.env, authRuntime) : null;
 			const user = authState?.user ?? null;
 			if (request.headers.get("upgrade")?.toLowerCase() === "websocket") {
@@ -261,6 +283,7 @@ function createWebSocketDurableObject(definition, route, authRuntime, resolveAut
 			return withRuntimeEnv(this.env, () => this.handleWebSocketClose(webSocket, code, reason, wasClean));
 		}
 		async handleWebSocketClose(webSocket, code, reason, wasClean) {
+			completeWebSocketClose(webSocket, code, reason);
 			const stored = getStoredConnection(webSocket);
 			const request = new Request(`https://void.local${route.pattern}`);
 			if (definition.__kind === "room") {
@@ -297,7 +320,9 @@ function createWebSocketTombstoneDurableObject(className) {
 		async webSocketMessage(webSocket) {
 			webSocket.close(1012, "WebSocket route removed");
 		}
-		async webSocketClose() {}
+		async webSocketClose(webSocket, code, reason) {
+			completeWebSocketClose(webSocket, code, reason);
+		}
 	};
 }
 function getStub(env, route, params) {

package/dist/runtime/ws.d.mts

@@ -1,2 +1,2 @@
-import { a as RoomDefinition, c as VoidSocket, d as WebSocketConnection, f as connect, i as RoomController, l as VoidSocketCloseEvent, m as defineWebSocket, n as ConnectCommonOptions, o as SocketContext, p as defineRoom, r as RoomContext, s as SocketDefinition, t as AnyWebSocketDefinition, u as WebSocketBaseContext } from "../ws-BoY7vQML.mjs";
-export { AnyWebSocketDefinition, ConnectCommonOptions, RoomContext, RoomController, RoomDefinition, SocketContext, SocketDefinition, VoidSocket, VoidSocketCloseEvent, WebSocketBaseContext, WebSocketConnection, connect, defineRoom, defineWebSocket };
+import { a as RoomDefinition, c as VoidSocket, d as WebSocketConnection, f as WebSocketInstanceKey, h as defineWebSocket, i as RoomController, l as VoidSocketCloseEvent, m as defineRoom, n as ConnectCommonOptions, o as SocketContext, p as connect, r as RoomContext, s as SocketDefinition, t as AnyWebSocketDefinition, u as WebSocketBaseContext } from "../ws-CL1w7GXU.mjs";
+export { AnyWebSocketDefinition, ConnectCommonOptions, RoomContext, RoomController, RoomDefinition, SocketContext, SocketDefinition, VoidSocket, VoidSocketCloseEvent, WebSocketBaseContext, WebSocketConnection, WebSocketInstanceKey, connect, defineRoom, defineWebSocket };

package/dist/runtime/ws.mjs

@@ -1,16 +1,23 @@
+import { t as isResourceName } from "../resource-name-C7LVpcRm.mjs";
+import { t as interpolateRouteParams } from "../route-url-CG7U-cRN.mjs";
 //#region src/runtime/ws.ts
 function defineRoom(definition) {
+	assertResourceName(definition.name);
 	return {
 		...definition,
 		__kind: "room"
 	};
 }
 function defineWebSocket(definition) {
+	assertResourceName(definition.name);
 	return {
 		...definition,
 		__kind: "socket"
 	};
 }
+function assertResourceName(name) {
+	if (name !== void 0 && !isResourceName(name)) throw new Error("ws: name must contain a word starting with a letter.");
+}
 var VoidSocket = class {
 	url;
 	options;
@@ -89,14 +96,9 @@ function resolveBaseUrl(baseURL) {
 	if (!location) throw new Error("ws: connect() requires a browser-like runtime or an explicit \"baseURL\".");
 	return new URL(location.href);
 }
-function interpolateParams(path, params) {
-	let resolved = path;
-	if (params) for (const [key, value] of Object.entries(params)) resolved = resolved.replace(`:${key}`, encodeURIComponent(value));
-	return resolved;
-}
 function connect(path, options = {}) {
 	const base = resolveBaseUrl(options.baseURL);
-	const resolvedPath = interpolateParams(path, options.params);
+	const resolvedPath = interpolateRouteParams(path, options.params);
 	const url = new URL(resolvedPath, base);
 	url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
 	return new VoidSocket(url.toString(), options);

package/dist/{sandbox-qpNBT8a3.d.mts → sandbox-XZAqzFlG.d.mts}

@@ -1,4 +1,5 @@
-import { i as SandboxExecOptions, r as SandboxContainer, s as SandboxOptions } from "./sandbox-container-DdNEBfCc.mjs";
+import { n as LimitOperation, r as UsageLimit } from "./limits-Bq5LG8Id.mjs";
+import { i as SandboxExecOptions, r as SandboxContainer, s as SandboxOptions } from "./sandbox-container-Bo0eiFKz.mjs";
 import { Files } from "@cloudflare/sandbox";
 //#region src/runtime/sandbox.d.ts
 declare const DEFAULT_SANDBOX_ID = "default";
@@ -14,19 +15,21 @@ type SandboxProcess = {
   stdin: WritableStream | null;
   stdout: ReadableStream | null;
   stderr: ReadableStream | null;
-  readonly exitCode: Promise<number>;
-  output(): Promise<ExecOutput>;
+  readonly exitCode: LimitOperation<number>;
+  output(): LimitOperation<ExecOutput>;
   kill(signal?: number): Promise<void>;
   resize(cols: number, rows: number): Promise<void>;
 };
+type SandboxFiles = { [K in keyof Files]: Files[K] extends ((...args: infer A) => Promise<infer R>) ? (...args: A) => LimitOperation<R> : never; };
 type SandboxClient = {
-  exec(argv: Array<string>, options?: SandboxExecOptions): Promise<SandboxProcess>;
-  files: Files;
-  fetch(port: number, request: Request): Promise<Response>;
+  exec(argv: Array<string>, options?: SandboxExecOptions): LimitOperation<SandboxProcess>;
+  run(argv: Array<string>, options?: SandboxExecOptions): LimitOperation<ExecOutput>;
+  files: SandboxFiles;
+  fetch(port: number, request: Request): LimitOperation<Response>;
   running(): Promise<boolean>;
   destroy(): Promise<void>;
 };
-declare class SandboxLimitError extends Error {
+declare class SandboxLimitError extends UsageLimit {
   override readonly name = "SandboxLimitError";
   readonly reason: "concurrency" | "runtime_budget";
   constructor(reason: "concurrency" | "runtime_budget", message?: string);
@@ -46,4 +49,4 @@ declare const sandbox: {
   get: typeof getSandbox;
 };
 //#endregion
-export { SandboxLimitError as a, VoidPlatformSandbox as c, getSandbox as d, sandbox as f, SandboxClient as i, VoidSandboxOptions as l, DEFAULT_SANDBOX_ID as n, SandboxProcess as o, SANDBOX_SERVICE_BINDING as r, SandboxUnavailableError as s, DEFAULT_SANDBOX_BINDING as t, __setSandboxBindingName as u };
+export { SandboxFiles as a, SandboxUnavailableError as c, __setSandboxBindingName as d, getSandbox as f, SandboxClient as i, VoidPlatformSandbox as l, DEFAULT_SANDBOX_ID as n, SandboxLimitError as o, sandbox as p, SANDBOX_SERVICE_BINDING as r, SandboxProcess as s, DEFAULT_SANDBOX_BINDING as t, VoidSandboxOptions as u };

package/dist/{sandbox-container-DdNEBfCc.d.mts → sandbox-container-Bo0eiFKz.d.mts}

@@ -53,7 +53,8 @@ declare class SandboxContainer<Env = unknown> extends DurableObject<Env> {
   protected afterStart(): Promise<void>;
   protected beforeUse(): Promise<void>;
   protected stopped(): Promise<void>;
-  protected waitForProcessExit(exitCode: Promise<number>): Promise<number>;
+  protected processContext(_exitCode: Promise<number>): unknown;
+  protected waitForProcessExit(exitCode: Promise<number>, _context?: unknown): Promise<number>;
   /** Native abort listeners must be detached as soon as a process exits. */
   protected execProcess(argv: Array<string>, options?: SandboxExecOptions): Promise<ExecProcess & {
     isPty?: boolean;

package/dist/{sandbox-container-4fdqLnyb.mjs → sandbox-container-C6ItmVuN.mjs}

@@ -109,7 +109,8 @@ var SandboxContainer = class extends DurableObject {
 	async afterStart() {}
 	async beforeUse() {}
 	async stopped() {}
-	async waitForProcessExit(exitCode) {
+	processContext(_exitCode) {}
+	async waitForProcessExit(exitCode, _context) {
 		return exitCode;
 	}
 	/** Native abort listeners must be detached as soon as a process exits. */
@@ -253,8 +254,9 @@ var SandboxContainer = class extends DurableObject {
 					...options
 				});
 				process.exitCode.then(finish, finish);
+				const processContext = this.processContext(process.exitCode);
 				return {
-					capability: new ProcessCapability(process, () => this.waitForProcessExit(process.exitCode)),
+					capability: new ProcessCapability(process, () => this.waitForProcessExit(process.exitCode, processContext)),
 					pid: process.pid,
 					isPty: process.isPty ?? false,
 					stdin: process.stdin ?? null,

package/dist/{scan-4tfN-PSn.mjs → scan-C7okrLyM.mjs}

@@ -2,41 +2,9 @@ import { a as join, n as dirname, r as extname, t as basename } from "./dist-BVq
 import { n as readProjectPaths } from "./project-paths-GgcMozYz.mjs";
 import { t as glob } from "./dist-Bn8Kodjp.mjs";
 import { n as isIdentifier, r as isLiteral } from "./ast-CPGPjb0V.mjs";
-import { n as parseRouteFilename } from "./parse-filename-DioPHiR9.mjs";
+import { a as staticLiteral, i as staticExportInitializers, n as parseRouteFilename } from "./parse-filename-CUbj-1MP.mjs";
 import { existsSync, readFileSync } from "node:fs";
 import { parseSync } from "vite";
-//#region src/shared/static-exports.ts
-/** Read the initializer of directly exported constants without evaluating user code. */
-function staticExportInitializers(filename, source, names) {
-	const result = /* @__PURE__ */ new Map();
-	const program = parseSync(filename, source).program;
-	for (const statement of program.body ?? []) {
-		if (statement.type !== "ExportNamedDeclaration") continue;
-		const declaration = statement.declaration;
-		if (declaration?.type !== "VariableDeclaration" || declaration.kind !== "const") continue;
-		for (const variable of declaration.declarations ?? []) if (isIdentifier(variable.id) && names.has(variable.id.name) && variable.init) result.set(variable.id.name, variable.init);
-	}
-	return result;
-}
-function unwrapStaticExpression(node) {
-	while (node && [
-		"ParenthesizedExpression",
-		"TSAsExpression",
-		"TSSatisfiesExpression",
-		"TSTypeAssertion"
-	].includes(node.type)) node = node.expression;
-	return node;
-}
-function staticLiteral(node) {
-	node = unwrapStaticExpression(node);
-	if (node?.type === "Literal") return node.value;
-	if (node?.type === "TemplateLiteral") {
-		const expressions = node.expressions;
-		const quasis = node.quasis;
-		if (expressions?.length === 0 && quasis?.length === 1) return quasis[0]?.value?.cooked;
-	}
-}
-//#endregion
 //#region src/pages/layout-resolution.ts
 function isNamedLayout(layout) {
 	return "name" in layout;
@@ -131,7 +99,8 @@ function componentLayout(source, filename) {
 	const scripts = filename.endsWith(".vue") || filename.endsWith(".svelte") ? [...source.matchAll(/<script\b[^>]*>([\s\S]*?)<\/script\s*>/gi)].map((match) => match[1]) : [source];
 	for (const script of scripts) {
 		if (!script.includes("layout")) continue;
-		const value = staticLiteral(staticExportInitializers(filename.replace(/\.(vue|svelte)$/, ".ts"), script, /* @__PURE__ */ new Set(["layout"])).get("layout"));
+		const initializer = staticExportInitializers(filename.replace(/\.(vue|svelte)$/, ".ts"), script, /* @__PURE__ */ new Set(["layout"])).get("layout");
+		const value = staticLiteral(initializer);
 		if (typeof value === "string" || value === false) return value;
 	}
 }
@@ -366,4 +335,4 @@ function extractFrontmatterLayout(source) {
 	return value;
 }
 //#endregion
-export { resolveNamedLayout as a, unwrapStaticExpression as c, resolveLayoutIds as i, resolveEffectiveLayoutChain as n, staticExportInitializers as o, resolveLayoutChain as r, staticLiteral as s, scanPages as t };
+export { resolveNamedLayout as a, resolveLayoutIds as i, resolveEffectiveLayoutChain as n, resolveLayoutChain as r, scanPages as t };

package/dist/{secret-BOtOl_cb.mjs → secret-Dli5fP0B.mjs}

@@ -1,8 +1,8 @@
-import { c as getToken } from "./auth-DLNN0D3Z.mjs";
+import { c as getToken } from "./auth-CSkdO2Bb.mjs";
 import { i as readDeploymentPlatform, o as readProjectConfig } from "./project-C0Fqu05O.mjs";
-import { _ as validateSecretValues } from "./env-validation-BB4GkLxn.mjs";
+import { _ as validateSecretValues } from "./env-validation-BPn7vk-V.mjs";
 import { E as confirm, F as password, N as note, O as intro, P as outro, T as cancel, W as isCancel, j as log } from "./dist-CTBk70IR.mjs";
-import { n as PlatformClient } from "./client-BTZ3XkrB.mjs";
+import { n as PlatformClient } from "./client-RV8NVeB8.mjs";
 import { r as cliTitle } from "./output-Dm_A4Tbv.mjs";
 import { r as resolveProjectBySlug, t as getRequestedProjectSlug } from "./resolve-project-BG5ORGID.mjs";
 import { readFileSync } from "node:fs";
@@ -78,7 +78,7 @@ async function runSecretCommand(root, args) {
 }
 async function runCloudflareSecretCommand(root, args) {
 	if (args.projectName) throw new Error("secret: --project selects a Void platform project and is not used for direct Cloudflare apps.");
-	const { deleteCloudflareSecret, listCloudflareSecrets, putCloudflareSecret, resolveCloudflareOperationContext, syncCloudflareSecrets } = await import("./cloudflare-operations-BT6OWFBk.mjs");
+	const { deleteCloudflareSecret, listCloudflareSecrets, putCloudflareSecret, resolveCloudflareOperationContext, syncCloudflareSecrets } = await import("./cloudflare-operations-AiWashgg.mjs");
 	const context = resolveCloudflareOperationContext(root);
 	if (args.action === "list") {
 		const secrets = await listCloudflareSecrets(context);

package/dist/{sse-BaC1jXko.mjs → sse-CQNaDFFV.mjs}

@@ -55,6 +55,7 @@ function eventStream(start, options = {}) {
 	const markClosed = () => {
 		if (closedOnce) return;
 		closedOnce = true;
+		options.signal?.removeEventListener("abort", abort);
 		if (!signalController.signal.aborted) signalController.abort();
 		if (keepAliveTimer != null) {
 			clearInterval(keepAliveTimer);
@@ -68,10 +69,12 @@ function eventStream(start, options = {}) {
 		await writer.close().catch(() => {});
 	}
 	async function fail(error) {
-		if (closedOnce) return;
 		markClosed();
 		await writer.abort(error).catch(() => {});
 	}
+	function abort() {
+		fail(options.signal?.reason ?? new SseStreamClosedError());
+	}
 	async function write(text) {
 		if (closedOnce) throw new SseStreamClosedError();
 		try {
@@ -95,11 +98,11 @@ function eventStream(start, options = {}) {
 	writer.closed.catch(() => {
 		close();
 	});
-	if (options.signal?.aborted) close();
-	else options.signal?.addEventListener("abort", () => void close(), { once: true });
 	if (keepAlive) keepAliveTimer = setInterval(() => {
 		stream.comment(keepAlive.comment).catch(() => close());
 	}, keepAlive.intervalMs);
+	if (options.signal?.aborted) abort();
+	else options.signal?.addEventListener("abort", abort, { once: true });
 	queueMicrotask(() => {
 		(async () => {
 			try {

package/dist/validate-Dq_L3s0S.mjs

@@ -0,0 +1,2 @@
+import { i as validateMigrations } from "./validate-ctOrgiS3.mjs";
+export { validateMigrations };

package/dist/{validate-CIUwFpjB.mjs → validate-ctOrgiS3.mjs}

@@ -1,7 +1,8 @@
 import { a as join } from "./dist-BVqXeR_h.mjs";
 import { n as readJournal, r as stripSqlExt } from "./collect-DiTn9yr6.mjs";
-import { t as DESTRUCTIVE_PRAGMA, u as tokenizeSql } from "./plan-BEZ8VJW0.mjs";
+import { t as DESTRUCTIVE_PRAGMA } from "./plan-NPpwZ_kc.mjs";
 import { existsSync, readdirSync } from "node:fs";
+import { tokenizeSql } from "@void/deploy-core";
 //#region src/migrations/validate.ts
 /**
 * Destructive SQL patterns that are rejected unless the migration