void 0.1.6 → 0.7.0

package/dist/runtime/response.mjs

@@ -0,0 +1,30 @@
+//#region src/runtime/response.ts
+/**
+* Tracks responses created by convertReturnValue (as opposed to responses
+* explicitly constructed by user code). Used by handlePageGet to decide
+* whether a Response should be passed through or unwrapped as page props.
+*/
+const convertedResponses = /* @__PURE__ */ new WeakSet();
+/** Returns true if the value is a Response that was created by convertReturnValue. */
+function isConvertedResponse(value) {
+	return value instanceof Response && convertedResponses.has(value);
+}
+/**
+* Convert a handler's return value to a Web Response.
+*
+* - Response → passthrough
+* - null/undefined → 204 No Content
+* - string → text/html
+* - object/array → JSON
+*/
+function convertReturnValue(value) {
+	if (value instanceof Response) return value;
+	let response;
+	if (value === null || value === void 0) response = new Response(null, { status: 204 });
+	else if (typeof value === "string") response = new Response(value, { headers: { "Content-Type": "text/html; charset=utf-8" } });
+	else response = Response.json(value);
+	convertedResponses.add(response);
+	return response;
+}
+//#endregion
+export { convertReturnValue, isConvertedResponse };

package/dist/runtime/sandbox.d.mts

@@ -0,0 +1,17 @@
+/// <reference types="@cloudflare/workers-types" />
+import { Sandbox, SandboxOptions } from "@cloudflare/sandbox";
+
+//#region src/runtime/sandbox.d.ts
+declare const DEFAULT_SANDBOX_ID = "default";
+declare const DEFAULT_SANDBOX_BINDING = "SANDBOX";
+type VoidSandbox = Sandbox;
+type VoidSandboxOptions = SandboxOptions & {
+  binding?: string;
+};
+declare function __setSandboxBindingName(bindingName: string): void;
+declare function getSandbox<T extends Sandbox = Sandbox>(id?: string, options?: VoidSandboxOptions): T;
+declare const sandbox: {
+  get: typeof getSandbox;
+};
+//#endregion
+export { DEFAULT_SANDBOX_BINDING, DEFAULT_SANDBOX_ID, Sandbox, type SandboxOptions, VoidSandbox, VoidSandboxOptions, __setSandboxBindingName, getSandbox, sandbox };

package/dist/runtime/sandbox.mjs

@@ -0,0 +1,19 @@
+import { requireRuntimeBinding } from "./env.mjs";
+import { Sandbox, getSandbox as getSandbox$1 } from "@cloudflare/sandbox";
+//#region src/runtime/sandbox.ts
+const DEFAULT_SANDBOX_ID = "default";
+const DEFAULT_SANDBOX_BINDING = "SANDBOX";
+let sandboxBindingName = DEFAULT_SANDBOX_BINDING;
+function __setSandboxBindingName(bindingName) {
+	sandboxBindingName = bindingName;
+}
+function getSandbox(id = DEFAULT_SANDBOX_ID, options) {
+	const { binding = sandboxBindingName, ...sandboxOptions } = options ?? {};
+	return getSandbox$1(requireRuntimeBinding(binding), id, {
+		normalizeId: true,
+		...sandboxOptions
+	});
+}
+const sandbox = { get: getSandbox };
+//#endregion
+export { DEFAULT_SANDBOX_BINDING, DEFAULT_SANDBOX_ID, Sandbox, __setSandboxBindingName, getSandbox, sandbox };

package/dist/runtime/schema-d1.d.mts

@@ -0,0 +1 @@
+export * from "drizzle-orm/sqlite-core";

package/dist/runtime/schema-d1.mjs

@@ -0,0 +1,2 @@
+export * from "drizzle-orm/sqlite-core";
+export {};

package/dist/runtime/schema-pg.d.mts

@@ -0,0 +1 @@
+export * from "drizzle-orm/pg-core";

package/dist/runtime/schema-pg.mjs

@@ -0,0 +1,2 @@
+export * from "drizzle-orm/pg-core";
+export {};

package/dist/runtime/seed.d.mts

@@ -0,0 +1,30 @@
+import { NodePgDatabase } from "drizzle-orm/node-postgres";
+import { BetterSQLite3Database } from "drizzle-orm/better-sqlite3";
+
+//#region src/runtime/seed.d.ts
+interface SqliteSeedContext<TSchema extends Record<string, unknown> = Record<string, never>> {
+  dialect: "sqlite";
+  db: BetterSQLite3Database<TSchema>;
+  schema: TSchema;
+}
+interface PostgresSeedContext<TSchema extends Record<string, unknown> = Record<string, never>> {
+  dialect: "postgresql";
+  db: NodePgDatabase<TSchema>;
+  schema: TSchema;
+}
+type DrizzleTableForDialect<TDialect extends string> = {
+  readonly _: {
+    readonly config: {
+      readonly dialect: TDialect;
+    };
+  };
+};
+type SchemaHasTableDialect<TSchema extends Record<string, unknown>, TDialect extends string> = [Extract<TSchema[keyof TSchema], DrizzleTableForDialect<TDialect>>] extends [never] ? false : true;
+type SchemaHasSqliteTables<TSchema extends Record<string, unknown>> = SchemaHasTableDialect<TSchema, "sqlite">;
+type SchemaHasPostgresTables<TSchema extends Record<string, unknown>> = SchemaHasTableDialect<TSchema, "pg">;
+type FallbackSeedContext<TSchema extends Record<string, unknown>> = SchemaHasSqliteTables<TSchema> extends false ? SchemaHasPostgresTables<TSchema> extends false ? SqliteSeedContext<TSchema> | PostgresSeedContext<TSchema> : never : never;
+type SeedContext<TSchema extends Record<string, unknown> = Record<string, never>> = (SchemaHasSqliteTables<TSchema> extends true ? SqliteSeedContext<TSchema> : never) | (SchemaHasPostgresTables<TSchema> extends true ? PostgresSeedContext<TSchema> : never) | FallbackSeedContext<TSchema>;
+type SeedFn<TSchema extends Record<string, unknown> = Record<string, never>> = (context: SeedContext<TSchema>) => void | Promise<void>;
+declare function defineSeed<TSchema extends Record<string, unknown> = Record<string, never>>(seed: SeedFn<TSchema>): SeedFn<TSchema>;
+//#endregion
+export { PostgresSeedContext, SeedContext, SeedFn, SqliteSeedContext, defineSeed };

package/dist/runtime/seed.mjs

@@ -0,0 +1,6 @@
+//#region src/runtime/seed.ts
+function defineSeed(seed) {
+	return seed;
+}
+//#endregion
+export { defineSeed };

package/dist/runtime/storage.d.mts

@@ -0,0 +1,7 @@
+//#region src/runtime/storage.d.ts
+/** Create a storage client for a specific R2Bucket instance. */
+declare function createStorage(bucket: R2Bucket): R2Bucket;
+/** Default storage client — resolves `STORAGE` from the active runtime environment. */
+declare const storage: R2Bucket;
+//#endregion
+export { createStorage, storage };

package/dist/runtime/storage.mjs

@@ -0,0 +1,14 @@
+import { requireRuntimeBinding } from "./env.mjs";
+//#region src/runtime/storage.ts
+/** Create a storage client for a specific R2Bucket instance. */
+function createStorage(bucket) {
+	return bucket;
+}
+/** Default storage client — resolves `STORAGE` from the active runtime environment. */
+const storage = new Proxy({}, { get(_target, prop) {
+	const bucket = requireRuntimeBinding("STORAGE");
+	const value = Reflect.get(bucket, prop, bucket);
+	return typeof value === "function" ? value.bind(bucket) : value;
+} });
+//#endregion
+export { createStorage, storage };

package/dist/runtime/validator.d.mts

@@ -0,0 +1,2 @@
+import { C as HandlerInput, T as runValidation, w as ValidatorSlots } from "../handler-B0ds0OHJ.mjs";
+export { HandlerInput, ValidatorSlots, runValidation };

package/dist/runtime/validator.mjs

@@ -0,0 +1,72 @@
+//#region src/runtime/validator.ts
+function flattenIssues(issues) {
+	return Array.from(issues, (issue) => ({
+		message: issue.message,
+		path: issue.path?.map((p) => typeof p === "object" ? p.key : p).join(".")
+	}));
+}
+async function validateSlot(schema, value) {
+	const result = await schema["~standard"].validate(value);
+	if (result.issues) return {
+		ok: false,
+		issues: result.issues
+	};
+	return {
+		ok: true,
+		value: result.value
+	};
+}
+async function runValidation(validators, c) {
+	const input = {};
+	const allIssues = [];
+	if (validators.params) {
+		const raw = c.req.param();
+		const result = await validateSlot(validators.params, raw);
+		if (result.ok) input.params = result.value;
+		else allIssues.push({
+			slot: "params",
+			issues: flattenIssues(result.issues)
+		});
+	}
+	if (validators.query) {
+		const url = new URL(c.req.url);
+		const raw = {};
+		for (const [key, value] of url.searchParams) raw[key] = value;
+		const result = await validateSlot(validators.query, raw);
+		if (result.ok) input.query = result.value;
+		else allIssues.push({
+			slot: "query",
+			issues: flattenIssues(result.issues)
+		});
+	}
+	if (validators.body) {
+		let raw;
+		try {
+			raw = await c.req.json();
+		} catch {
+			return {
+				ok: false,
+				response: Response.json({ error: "Invalid JSON body" }, { status: 400 })
+			};
+		}
+		const result = await validateSlot(validators.body, raw);
+		if (result.ok) input.body = result.value;
+		else allIssues.push({
+			slot: "body",
+			issues: flattenIssues(result.issues)
+		});
+	}
+	if (allIssues.length > 0) return {
+		ok: false,
+		response: Response.json({
+			error: "Validation failed",
+			issues: allIssues
+		}, { status: 400 })
+	};
+	return {
+		ok: true,
+		input
+	};
+}
+//#endregion
+export { runValidation };

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

@@ -0,0 +1,26 @@
+import { n as AuthState } from "../auth-BdsJ0Aff.mjs";
+import { i as VoidAuthRuntimeOptions, n as VoidAuthEnv } from "../better-auth-shared-C9_GHSkR.mjs";
+import { AnyWebSocketDefinition } from "./ws.mjs";
+
+//#region src/runtime/ws-server.d.ts
+interface WebSocketRouteMeta {
+  pattern: string;
+  params: Array<string>;
+  className: string;
+  bindingName: string;
+}
+interface WebSocketDurableObjectInstance {
+  fetch(request: Request): Promise<Response>;
+  webSocketMessage(webSocket: WebSocket, message: string | ArrayBuffer | ArrayBufferView): Promise<void>;
+  webSocketClose(webSocket: WebSocket, code: number, reason: string, wasClean: boolean): Promise<void>;
+}
+interface WebSocketDurableObjectClass {
+  new (state: DurableObjectState, env: Record<string, unknown>): WebSocketDurableObjectInstance;
+}
+type ResolveVoidAuthState = (request: Request, env: VoidAuthEnv, runtime: VoidAuthRuntimeOptions) => Promise<AuthState | null>;
+declare function buildWebSocketInstanceId(route: Pick<WebSocketRouteMeta, "params">, params: Record<string, string>): string;
+declare function createWebSocketDurableObject(definition: AnyWebSocketDefinition, route: WebSocketRouteMeta, authRuntime?: VoidAuthRuntimeOptions, resolveAuthState?: ResolveVoidAuthState): WebSocketDurableObjectClass;
+declare function handleWebSocketUpgrade(request: Request, env: Record<string, unknown>, routes: Array<WebSocketRouteMeta>): Promise<Response | null>;
+declare function forwardWebSocketRequest(request: Request, env: Record<string, unknown>, route: WebSocketRouteMeta): Promise<Response>;
+//#endregion
+export { WebSocketDurableObjectClass, WebSocketDurableObjectInstance, WebSocketRouteMeta, buildWebSocketInstanceId, createWebSocketDurableObject, forwardWebSocketRequest, handleWebSocketUpgrade };

package/dist/runtime/ws-server.mjs

@@ -0,0 +1,296 @@
+import { authContext } from "./auth.mjs";
+//#region src/runtime/ws-server.ts
+function matchRoute(pattern, pathname) {
+	const patternSegments = pattern.split("/").filter(Boolean);
+	const pathSegments = pathname.split("/").filter(Boolean);
+	const params = {};
+	let i = 0;
+	for (; i < patternSegments.length; i++) {
+		const patternSegment = patternSegments[i];
+		const pathSegment = pathSegments[i];
+		if (patternSegment === "*") return {
+			matched: true,
+			params
+		};
+		if (patternSegment.endsWith("{.+}") && patternSegment.startsWith(":")) {
+			params[patternSegment.slice(1, -4)] = decodeURIComponent(pathSegments.slice(i).join("/"));
+			return {
+				matched: true,
+				params
+			};
+		}
+		if (pathSegment == null) return {
+			matched: false,
+			params: {}
+		};
+		if (patternSegment.startsWith(":")) {
+			params[patternSegment.slice(1)] = decodeURIComponent(pathSegment);
+			continue;
+		}
+		if (patternSegment !== pathSegment) return {
+			matched: false,
+			params: {}
+		};
+	}
+	if (i !== pathSegments.length) return {
+		matched: false,
+		params: {}
+	};
+	return {
+		matched: true,
+		params
+	};
+}
+function getRouteMatch(request, route) {
+	const { pathname } = new URL(request.url);
+	const match = matchRoute(route.pattern, pathname);
+	return match.matched ? match.params : null;
+}
+function buildWebSocketInstanceId(route, params) {
+	if (route.params.length === 0) return "default";
+	return route.params.map((name) => `${name}=${params[name] ?? ""}`).join("&");
+}
+async function validateSchema(schema, value) {
+	const result = await schema["~standard"].validate(value);
+	if (result.issues) return {
+		ok: false,
+		issues: result.issues
+	};
+	return {
+		ok: true,
+		value: result.value
+	};
+}
+async function serializeServerEvent(schema, event) {
+	const result = await validateSchema(schema, event);
+	if (!result.ok) throw new Error(`ws: Message validation failed: ${result.issues.map((issue) => issue.message).join("; ")}.`);
+	return JSON.stringify(result.value);
+}
+function parseIncomingMessage(message) {
+	if (typeof message === "string") return message;
+	if (message instanceof ArrayBuffer) return new TextDecoder().decode(message);
+	return new TextDecoder().decode(message.buffer.slice(message.byteOffset, message.byteOffset + message.byteLength));
+}
+function withAuthState(state, fn) {
+	return Promise.resolve(authContext.run({
+		user: state?.user ?? null,
+		state
+	}, fn));
+}
+function getStoredConnection(webSocket) {
+	const stored = webSocket.deserializeAttachment?.();
+	if (stored) return {
+		...stored,
+		authState: stored.authState ?? null
+	};
+	return {
+		id: crypto.randomUUID(),
+		params: {},
+		roomId: "default",
+		user: null,
+		authState: null
+	};
+}
+function setStoredConnection(webSocket, data) {
+	webSocket.serializeAttachment?.(data);
+}
+function createConnection(webSocket, serverSchema) {
+	return {
+		get id() {
+			return getStoredConnection(webSocket).id;
+		},
+		get state() {
+			return getStoredConnection(webSocket).state;
+		},
+		async send(event) {
+			webSocket.send(await serializeServerEvent(serverSchema, event));
+		},
+		close(code, reason) {
+			webSocket.close(code, reason);
+		},
+		setState(data) {
+			setStoredConnection(webSocket, {
+				...getStoredConnection(webSocket),
+				state: data
+			});
+		}
+	};
+}
+function createRoomController(state, serverSchema) {
+	return {
+		async broadcast(event, excludeIds = []) {
+			const payload = await serializeServerEvent(serverSchema, event);
+			for (const socket of state.getWebSockets()) {
+				const stored = getStoredConnection(socket);
+				if (excludeIds.includes(stored.id)) continue;
+				socket.send(payload);
+			}
+		},
+		getConnections() {
+			return state.getWebSockets().map((socket) => createConnection(socket, serverSchema));
+		},
+		getConnection(id) {
+			const socket = state.getWebSockets().find((item) => getStoredConnection(item).id === id);
+			return socket ? createConnection(socket, serverSchema) : void 0;
+		}
+	};
+}
+function createRoomContext(state, env, request, webSocket, stored, serverSchema) {
+	return {
+		id: stored.roomId,
+		params: stored.params,
+		user: stored.user,
+		request,
+		env,
+		storage: state.storage,
+		room: createRoomController(state, serverSchema),
+		connection: createConnection(webSocket, serverSchema)
+	};
+}
+function createSocketContext(state, env, request, webSocket, stored, serverSchema) {
+	return {
+		id: stored.roomId,
+		params: stored.params,
+		user: stored.user,
+		request,
+		env,
+		storage: state.storage,
+		socket: createConnection(webSocket, serverSchema)
+	};
+}
+function assertDefinition(definition) {
+	if (!definition?.messages?.client || !definition?.messages?.server) throw new Error("ws: WebSocket routes must define both messages.client and messages.server.");
+}
+function createWebSocketDurableObject(definition, route, authRuntime, resolveAuthState) {
+	assertDefinition(definition);
+	class VoidWebSocketDurableObject {
+		constructor(state, env) {
+			this.state = state;
+			this.env = env;
+		}
+		async fetch(request) {
+			const params = getRouteMatch(request, route) ?? {};
+			const roomId = buildWebSocketInstanceId(route, params);
+			const authState = authRuntime && resolveAuthState ? await resolveAuthState(request, this.env, authRuntime) : null;
+			const user = authState?.user ?? null;
+			if (request.headers.get("upgrade")?.toLowerCase() === "websocket") {
+				const pair = new WebSocketPair();
+				const client = pair[0];
+				const server = pair[1];
+				const stored = {
+					id: crypto.randomUUID(),
+					params,
+					roomId,
+					user,
+					authState
+				};
+				setStoredConnection(server, stored);
+				if (definition.__kind === "room") {
+					const ctx = createRoomContext(this.state, this.env, request, server, stored, definition.messages.server);
+					const decision = await withAuthState(authState, () => definition.onBeforeConnect?.(ctx));
+					if (decision instanceof Response) return decision;
+				} else {
+					const ctx = createSocketContext(this.state, this.env, request, server, stored, definition.messages.server);
+					const decision = await withAuthState(authState, () => definition.onBeforeConnect?.(ctx));
+					if (decision instanceof Response) return decision;
+				}
+				this.state.acceptWebSocket(server);
+				if (definition.__kind === "room") {
+					const ctx = createRoomContext(this.state, this.env, request, server, stored, definition.messages.server);
+					await withAuthState(authState, () => definition.onConnect?.(ctx));
+				} else {
+					const ctx = createSocketContext(this.state, this.env, request, server, stored, definition.messages.server);
+					await withAuthState(authState, () => definition.onConnect?.(ctx));
+				}
+				return new Response(null, {
+					status: 101,
+					webSocket: client
+				});
+			}
+			if (!definition.onRequest) return new Response("Upgrade Required", { status: 426 });
+			const stored = {
+				id: crypto.randomUUID(),
+				params,
+				roomId,
+				user,
+				authState
+			};
+			if (definition.__kind === "room") {
+				const fakeSocket = new WebSocketPair()[1];
+				const ctx = createRoomContext(this.state, this.env, request, fakeSocket, stored, definition.messages.server);
+				return withAuthState(authState, () => definition.onRequest(ctx));
+			}
+			const fakeSocket = new WebSocketPair()[1];
+			const ctx = createSocketContext(this.state, this.env, request, fakeSocket, stored, definition.messages.server);
+			return withAuthState(authState, () => definition.onRequest(ctx));
+		}
+		async webSocketMessage(webSocket, message) {
+			const stored = getStoredConnection(webSocket);
+			const raw = parseIncomingMessage(message);
+			let parsed;
+			try {
+				parsed = JSON.parse(raw);
+			} catch {
+				webSocket.close(1007, "Invalid JSON");
+				return;
+			}
+			const result = await validateSchema(definition.messages.client, parsed);
+			if (!result.ok) {
+				webSocket.close(1007, "Invalid message");
+				return;
+			}
+			const request = new Request(`https://void.local${route.pattern}`);
+			if (definition.__kind === "room") {
+				const ctx = createRoomContext(this.state, this.env, request, webSocket, stored, definition.messages.server);
+				await withAuthState(stored.authState ?? null, () => definition.onMessage?.(ctx, result.value));
+			} else {
+				const ctx = createSocketContext(this.state, this.env, request, webSocket, stored, definition.messages.server);
+				await withAuthState(stored.authState ?? null, () => definition.onMessage?.(ctx, result.value));
+			}
+		}
+		async webSocketClose(webSocket, code, reason, wasClean) {
+			const stored = getStoredConnection(webSocket);
+			const request = new Request(`https://void.local${route.pattern}`);
+			if (definition.__kind === "room") {
+				const ctx = createRoomContext(this.state, this.env, request, webSocket, stored, definition.messages.server);
+				await withAuthState(stored.authState ?? null, () => definition.onClose?.(ctx, {
+					code,
+					reason,
+					wasClean
+				}));
+			} else {
+				const ctx = createSocketContext(this.state, this.env, request, webSocket, stored, definition.messages.server);
+				await withAuthState(stored.authState ?? null, () => definition.onClose?.(ctx, {
+					code,
+					reason,
+					wasClean
+				}));
+			}
+		}
+	}
+	return VoidWebSocketDurableObject;
+}
+function getStub(env, route, params) {
+	const binding = env[route.bindingName];
+	if (!binding) return null;
+	const id = binding.idFromName(buildWebSocketInstanceId(route, params));
+	return binding.get(id);
+}
+async function handleWebSocketUpgrade(request, env, routes) {
+	if (request.headers.get("upgrade")?.toLowerCase() !== "websocket") return null;
+	for (const route of routes) {
+		const params = getRouteMatch(request, route);
+		if (!params) continue;
+		const stub = getStub(env, route, params);
+		if (!stub) return new Response(`Missing Durable Object binding "${route.bindingName}"`, { status: 503 });
+		return stub.fetch(request);
+	}
+	return null;
+}
+async function forwardWebSocketRequest(request, env, route) {
+	const stub = getStub(env, route, getRouteMatch(request, route) ?? {});
+	if (!stub) return new Response(`Missing Durable Object binding "${route.bindingName}"`, { status: 503 });
+	return stub.fetch(request);
+}
+//#endregion
+export { buildWebSocketInstanceId, createWebSocketDurableObject, forwardWebSocketRequest, handleWebSocketUpgrade };

package/dist/runtime/ws.d.mts

@@ -0,0 +1,123 @@
+import { r as AuthUser } from "../auth-BdsJ0Aff.mjs";
+import { t as StandardSchemaV1 } from "../standard-schema-9CRjx-uR.mjs";
+import { i as CloudEnv } from "../handler-B0ds0OHJ.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;
+interface WebSocketConnection<ServerEvent = unknown> {
+  readonly id: string;
+  readonly state: unknown;
+  send(event: ServerEvent): Promise<void>;
+  close(code?: number, reason?: string): void;
+  setState(data: unknown): void;
+}
+interface RoomController<ServerEvent = unknown> {
+  broadcast(event: ServerEvent, excludeIds?: Array<string>): Promise<void>;
+  getConnections(): Iterable<WebSocketConnection<ServerEvent>>;
+  getConnection(id: string): WebSocketConnection<ServerEvent> | undefined;
+}
+interface WebSocketBaseContext {
+  readonly id: string;
+  readonly params: ParamsRecord;
+  readonly user: AuthUser | null;
+  readonly request: Request;
+  readonly env: CloudEnv["Bindings"];
+  readonly storage: DurableObjectStorage;
+}
+interface RoomContext<ServerEvent = unknown> extends WebSocketBaseContext {
+  readonly room: RoomController<ServerEvent>;
+  readonly connection: WebSocketConnection<ServerEvent>;
+}
+interface SocketContext<ServerEvent = unknown> extends WebSocketBaseContext {
+  readonly socket: WebSocketConnection<ServerEvent>;
+}
+interface 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>;
+}
+interface 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>;
+interface VoidSocketCloseEvent {
+  code?: number;
+  reason?: string;
+  wasClean?: boolean;
+}
+interface 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 { AnyWebSocketDefinition, ConnectCommonOptions, RoomContext, RoomController, RoomDefinition, SocketContext, SocketDefinition, VoidSocket, VoidSocketCloseEvent, WebSocketBaseContext, WebSocketConnection, connect, defineRoom, defineWebSocket };