void 0.20.2 → 0.21.0

package/dist/runtime/handler.mjs

@@ -1,151 +1,3 @@
-import { convertReturnValue } from "./response.mjs";
-import { runValidation } from "./validator.mjs";
 import { i as ValidationError, n as defer } from "../defer-YsYDUoii.mjs";
-//#region src/runtime/handler.ts
-/**
-* Thrown when `c.rewrite()` is called with a destination whose final path
-* segment ends in a known static-asset extension (e.g. `/hero.png`,
-* `/app.css`). Runtime rewrites only reach routes and SSR entries inside
-* the worker — static asset handlers run in front of the worker, so a
-* `c.rewrite()` into an asset path re-enters the Hono router, matches
-* nothing, and returns a 404. Fail at the call site so users reach for
-* static `routing.rewrites` instead of debugging a mystery 404.
-*/
-var VoidAssetRewriteError = class extends Error {
-	name = "VoidAssetRewriteError";
-	constructor(destination) {
-		super(`c.rewrite() cannot re-dispatch to a static asset path (${JSON.stringify(destination)}). Runtime rewrites only reach routes and SSR entries inside the worker — static asset handlers run in front of the worker. To rewrite into an asset, use a static \`routing.rewrites\` rule in void.json or a \`200!\` entry in _redirects. See https://void.dev/guide/edge/rewrites#runtime-rewrites-cannot-reach-static-assets`);
-	}
-};
-function defineHandler(...args) {
-	if (args.length === 1) return args[0];
-	const middlewares = args.slice(0, -1);
-	const handler = args[args.length - 1];
-	return (async (c) => {
-		let index = 0;
-		const dispatch = async () => {
-			if (index < middlewares.length) {
-				const middleware = middlewares[index++];
-				const middlewareResponse = await middleware(c, dispatch);
-				if (middlewareResponse instanceof Response) c.res = middlewareResponse;
-			} else c.res = convertReturnValue(await handler(c));
-		};
-		await dispatch();
-		return c.res;
-	});
-}
-(function(_defineHandler) {
-	function withValidator(validators) {
-		return (handler) => {
-			return (async (c) => {
-				const result = await runValidation(validators, c);
-				if (!result.ok) return result.response;
-				return convertReturnValue(await handler(c, result.input));
-			});
-		};
-	}
-	_defineHandler.withValidator = withValidator;
-})(defineHandler || (defineHandler = {}));
-/**
-* Identity function that provides type inference for middleware.
-* At runtime it simply returns the function passed to it.
-*/
-function defineMiddleware(handler) {
-	return handler;
-}
-const basicAuthEncoder = new TextEncoder();
-const basicAuthDecoder = new TextDecoder("utf-8", { fatal: true });
-function parseBasicAuthHeader(authorization) {
-	if (!authorization?.toLowerCase().startsWith("basic ")) return null;
-	try {
-		const encoded = authorization.slice(6).trim();
-		const binary = atob(encoded);
-		const bytes = Uint8Array.from(binary, (char) => char.charCodeAt(0));
-		const decoded = basicAuthDecoder.decode(bytes);
-		const separator = decoded.indexOf(":");
-		if (separator === -1) return null;
-		return {
-			username: decoded.slice(0, separator),
-			password: decoded.slice(separator + 1)
-		};
-	} catch {
-		return null;
-	}
-}
-function timingSafeStringEqual(actual, expected) {
-	const actualBytes = basicAuthEncoder.encode(actual);
-	const expectedBytes = basicAuthEncoder.encode(expected);
-	let difference = actualBytes.length ^ expectedBytes.length;
-	for (let i = 0; i < expectedBytes.length; i++) difference |= (actualBytes[i] ?? 0) ^ expectedBytes[i];
-	return difference === 0;
-}
-function isVoidInternalPath(pathname) {
-	return pathname === "/__void" || pathname.startsWith("/__void/");
-}
-function basicAuthChallenge(realm, message) {
-	const escapedRealm = realm.replace(/["\\]/g, "\\$&");
-	return new Response(message, {
-		status: 401,
-		headers: {
-			"Cache-Control": "no-store",
-			"WWW-Authenticate": `Basic realm="${escapedRealm}", charset="UTF-8"`
-		}
-	});
-}
-function resolveBasicAuthOption(value, fallback) {
-	if (value === void 0) return fallback;
-	return typeof value === "function" ? value() : value;
-}
-/**
-* Create Basic authentication middleware for temporary site gates and
-* pre-launch protection.
-*
-* Void internal endpoints under `/__void` are always excluded so deploy-time
-* migrations, prerendering, cron/queue dispatch, and remote binding helpers
-* continue to reach Void's own internal-token checks.
-*/
-function basicAuth(options) {
-	return defineMiddleware(async (c, next) => {
-		if (isVoidInternalPath(c.req.path)) {
-			await next();
-			return;
-		}
-		const username = resolveBasicAuthOption(options.username, "");
-		const password = resolveBasicAuthOption(options.password, "");
-		const credentials = parseBasicAuthHeader(c.req.raw.headers.get("Authorization"));
-		const usernameMatches = credentials && timingSafeStringEqual(credentials.username, username);
-		const passwordMatches = credentials && timingSafeStringEqual(credentials.password, password);
-		if (!usernameMatches || !passwordMatches) return basicAuthChallenge(resolveBasicAuthOption(options.realm, "Restricted"), resolveBasicAuthOption(options.message, "Authentication required"));
-		await next();
-	});
-}
-/**
-* Identity function that provides type inference for scheduled jobs.
-* At runtime it simply returns the function passed to it.
-*/
-function defineScheduled(handler) {
-	return handler;
-}
-/**
-* Identity function that provides type inference for SSR render entry.
-* The second argument includes asset tags for client scripts/styles.
-*/
-function defineRender(handler) {
-	return handler;
-}
-/**
-* Identity function that provides type inference for page `head()` exports.
-* At runtime it simply returns the function passed to it.
-*/
-function defineHead(handler) {
-	return handler;
-}
-/**
-* Identity function that provides type inference for queue consumers.
-* At runtime it simply returns the function passed to it.
-*/
-function defineQueue(handler) {
-	return handler;
-}
-//#endregion
+import { a as defineMiddleware, c as defineScheduled, i as defineHead, n as basicAuth, o as defineQueue, r as defineHandler, s as defineRender, t as VoidAssetRewriteError } from "../handler-DghKr6dU.mjs";
 export { ValidationError, VoidAssetRewriteError, basicAuth, defer, defineHandler, defineHead, defineMiddleware, defineQueue, defineRender, defineScheduled };

package/dist/runtime/kv.mjs

@@ -1,4 +1,4 @@
-import { requireRuntimeBinding } from "./env.mjs";
+import { a as requireRuntimeBinding } from "../env-Yz4HcvHs.mjs";
 //#region src/runtime/kv.ts
 function parseValue(raw) {
 	if (raw === null) return null;

package/dist/runtime/live-client.d.mts

@@ -1,4 +1,4 @@
-import { LiveClientEvent } from "./live.mjs";
+import { t as LiveClientEvent } from "../live-CKiJilLr.mjs";
 //#region src/runtime/live-client.d.ts
 export type LiveSubscribeOptions<Data = unknown> = {
   id: string;

package/dist/runtime/live-server.mjs

@@ -1,5 +1,5 @@
-import { eventStream } from "./sse.mjs";
-import { __getLiveBindingName } from "./live.mjs";
+import { n as eventStream } from "../sse-BaC1jXko.mjs";
+import { t as __getLiveBindingName } from "../live-CB1y5IuC.mjs";
 //#region src/runtime/live-server.ts
 const GENERATION_KEY = "connection:generation";
 const TOPIC_PRUNE_ALARM_DELAY_MS = 6e4;

package/dist/runtime/live.d.mts

@@ -1,105 +1,3 @@
 /// <reference types="@cloudflare/workers-types" />
-import { r as AuthUser } from "../auth-DkcFflXV.mjs";
-import { a as CloudEnv, r as CloudContext } from "../handler-D1hLsObx.mjs";
-//#region src/runtime/live.d.ts
-type MaybePromise<T> = T | Promise<T>;
-export type LiveControlRequest = {
-  connectionId: string;
-  operations: Array<LiveControlOperation>;
-};
-export type LiveControlOperation = {
-  kind: "subscribe";
-  id: string;
-  topic: string;
-  lastEventId?: string;
-} | {
-  kind: "unsubscribe";
-  id: string;
-};
-export type LiveControlErrorCode = "BAD_REQUEST" | "CONNECTION_CLOSED" | "CONNECTION_NOT_FOUND" | "FORBIDDEN" | "INVALID_SUBSCRIPTION_ID" | "INVALID_TOPIC" | "OWNER_MISMATCH" | "SUBSCRIPTION_LIMIT" | "TOPIC_FULL" | "PAYLOAD_TOO_LARGE" | "INTERNAL_ERROR";
-export type LiveControlError = {
-  code: LiveControlErrorCode;
-  message: string;
-};
-export type LiveControlOperationResult = {
-  ok: true;
-  kind: "subscribe" | "unsubscribe";
-  id: string;
-  topic?: string;
-} | {
-  ok: false;
-  kind: "subscribe" | "unsubscribe";
-  id: string;
-  error: LiveControlError;
-};
-export type LiveControlResponse = {
-  accepted: true;
-  connectionId: string;
-  results: Array<LiveControlOperationResult>;
-} | {
-  accepted: false;
-  error: LiveControlError;
-};
-export type LiveClientEvent<Data = unknown> = {
-  subscriptionId: string;
-  topic: string;
-  type?: string;
-  eventId?: string;
-  data: Data;
-};
-export type LivePublishOptions = {
-  type?: string;
-  eventId?: string;
-};
-export type LiveConnectOptions = {
-  owner?: string | null;
-  user?: unknown;
-};
-export type LiveControlOptions = LiveConnectOptions;
-export type LiveHookContext = {
-  request: Request;
-  env: CloudEnv["Bindings"];
-  user: AuthUser | unknown | null;
-  owner: string | null;
-};
-export type LiveConnectHookContext = LiveHookContext & {
-  connection: {
-    id: string;
-  };
-};
-export type LiveSubscribeHookContext = LiveHookContext & {
-  connection: {
-    id: string;
-  };
-  subscription: {
-    id: string;
-  };
-  topic: string;
-  lastEventId?: string;
-};
-export type LiveStreamOptions = {
-  id: string;
-  allowAnonymousControl?: boolean;
-  identifyConnection?: (ctx: LiveHookContext) => MaybePromise<string | null | undefined>;
-  onConnect?: (ctx: LiveConnectHookContext) => MaybePromise<Response | void>;
-  onSubscribe?: (ctx: LiveSubscribeHookContext) => MaybePromise<Response | void>;
-  limits?: Partial<LiveLimits>;
-};
-export type LiveLimits = {
-  maxSubscriptionsPerConnection: number;
-  maxSubscriptionsPerTopic: number;
-  maxOperationsPerControlRequest: number;
-  maxQueuedEventsPerConnection: number;
-  maxEncodedEventSize: number;
-  deliveryAttemptTimeoutMs: number;
-};
-export type LiveStream = {
-  connect(ctx: CloudContext, options?: LiveConnectOptions): Promise<Response>;
-  control(ctx: CloudContext, options?: LiveControlOptions): Promise<Response>;
-  publish(topic: string, data: unknown, options?: LivePublishOptions): Promise<void>;
-  withEnv(env: unknown): Pick<LiveStream, "publish">;
-};
-export declare function __setLiveBindingName(name: string): void;
-export declare function __getLiveBindingName(): string;
-export declare function defineLiveStream(options: LiveStreamOptions): LiveStream;
-//#endregion
+import { _ as __getLiveBindingName, a as LiveControlErrorCode, c as LiveControlOptions, d as LiveHookContext, f as LiveLimits, g as LiveSubscribeHookContext, h as LiveStreamOptions, i as LiveControlError, l as LiveControlRequest, m as LiveStream, n as LiveConnectHookContext, o as LiveControlOperation, p as LivePublishOptions, r as LiveConnectOptions, s as LiveControlOperationResult, t as LiveClientEvent, u as LiveControlResponse, v as __setLiveBindingName, y as defineLiveStream } from "../live-CKiJilLr.mjs";
+export { LiveClientEvent, LiveConnectHookContext, LiveConnectOptions, LiveControlError, LiveControlErrorCode, LiveControlOperation, LiveControlOperationResult, LiveControlOptions, LiveControlRequest, LiveControlResponse, LiveHookContext, LiveLimits, LivePublishOptions, LiveStream, LiveStreamOptions, LiveSubscribeHookContext, __getLiveBindingName, __setLiveBindingName, defineLiveStream };

package/dist/runtime/live.mjs

@@ -1,411 +1,2 @@
-import { a as getRawRuntimeEnv } from "../env-raw-Cx8ElDdj.mjs";
-import { getUser } from "./auth.mjs";
-//#region src/runtime/live.ts
-let liveBindingName = "VOID_LIVE";
-const registeredStreamIds = /* @__PURE__ */ new Set();
-const DEFAULT_LIMITS = {
-	maxSubscriptionsPerConnection: 256,
-	maxSubscriptionsPerTopic: 256,
-	maxOperationsPerControlRequest: 100,
-	maxQueuedEventsPerConnection: 100,
-	maxEncodedEventSize: 65536,
-	deliveryAttemptTimeoutMs: 1500
-};
-const MAX_SUBSCRIPTIONS_PER_TOPIC = 256;
-function __setLiveBindingName(name) {
-	liveBindingName = assertBindingName(name);
-}
-function __getLiveBindingName() {
-	return liveBindingName;
-}
-function defineLiveStream(options) {
-	const streamId = assertStreamId(options.id);
-	const limits = resolveLiveLimits(options.limits);
-	if (registeredStreamIds.has(streamId)) throw new Error(`live: duplicate stream id "${streamId}".`);
-	registeredStreamIds.add(streamId);
-	async function resolveOwner(ctx, request, connectOptions) {
-		const resolvedUser = connectOptions && "user" in connectOptions ? connectOptions.user : getContextUser(ctx) ?? getUser();
-		const hookContext = {
-			request,
-			env: ctx.env,
-			user: resolvedUser ?? null,
-			owner: connectOptions?.owner ?? null
-		};
-		const owner = (connectOptions && "owner" in connectOptions ? connectOptions.owner : await options.identifyConnection?.(hookContext)) ?? defaultOwner(resolvedUser);
-		if (owner == null && !options.allowAnonymousControl) throw liveResponseError("FORBIDDEN", "live: anonymous control is not enabled.", 403);
-		assertOwner(owner);
-		return {
-			owner,
-			user: resolvedUser ?? null
-		};
-	}
-	async function publishWithEnv(env, topic, data, publishOptions = {}) {
-		const binding = getLiveBinding(env);
-		assertTopic(topic);
-		assertOptionalString("type", publishOptions.type);
-		assertOptionalString("eventId", publishOptions.eventId);
-		assertJsonSerializable(data);
-		const topicKey = await topicDigest(streamId, topic);
-		const id = binding.idFromName(topicInstanceName(streamId, topicKey));
-		const response = await binding.get(id).fetch(internalUrl("/publish"), {
-			method: "POST",
-			body: JSON.stringify({
-				streamId,
-				topic,
-				topicKey,
-				data,
-				type: publishOptions.type,
-				eventId: publishOptions.eventId,
-				limits
-			})
-		});
-		if (!response.ok) {
-			const body = await response.text();
-			const parsed = parseLiveControlResponse(body);
-			if (parsed && !parsed.accepted) throw new Error(`${parsed.error.code}: ${parsed.error.message}`);
-			throw new Error(body || response.statusText);
-		}
-	}
-	return {
-		async connect(ctx, connectOptions) {
-			try {
-				const request = ctx.req.raw;
-				const connectionId = getConnectionId(request);
-				const { owner, user } = await resolveOwner(ctx, request, connectOptions);
-				const decision = await options.onConnect?.({
-					request,
-					env: ctx.env,
-					user,
-					owner,
-					connection: { id: connectionId }
-				});
-				if (decision instanceof Response) return decision;
-				const binding = getLiveBinding(ctx.env);
-				const id = binding.idFromName(connectionInstanceName(streamId, connectionId));
-				return binding.get(id).fetch(internalUrl("/connect"), {
-					method: "POST",
-					body: JSON.stringify({
-						streamId,
-						connectionId,
-						owner,
-						limits
-					})
-				});
-			} catch (error) {
-				return errorToResponse(error);
-			}
-		},
-		async control(ctx, controlOptions) {
-			try {
-				const request = ctx.req.raw;
-				const body = await readControlRequest(request, limits);
-				const { owner, user } = await resolveOwner(ctx, request, controlOptions);
-				const authorized = [];
-				const results = [];
-				for (const entry of body.operations) {
-					if (!entry.ok) {
-						results[entry.index] = entry.result;
-						continue;
-					}
-					const { operation, index } = entry;
-					if (operation.kind === "unsubscribe") {
-						authorized.push({
-							operation,
-							index
-						});
-						continue;
-					}
-					const decision = await options.onSubscribe?.({
-						request,
-						env: ctx.env,
-						user,
-						owner,
-						connection: { id: body.connectionId },
-						subscription: { id: operation.id },
-						topic: operation.topic,
-						lastEventId: operation.lastEventId
-					});
-					if (decision instanceof Response) {
-						results[index] = {
-							ok: false,
-							kind: "subscribe",
-							id: operation.id,
-							error: await responseToControlError(decision)
-						};
-						continue;
-					}
-					authorized.push({
-						operation,
-						index
-					});
-				}
-				if (authorized.length > 0) {
-					const binding = getLiveBinding(ctx.env);
-					const id = binding.idFromName(connectionInstanceName(streamId, body.connectionId));
-					const response = await binding.get(id).fetch(internalUrl("/control"), {
-						method: "POST",
-						body: JSON.stringify({
-							streamId,
-							connectionId: body.connectionId,
-							owner,
-							operations: authorized.map((entry) => entry.operation),
-							limits
-						})
-					});
-					const controlResponse = await response.json();
-					if (!controlResponse.accepted) return Response.json(controlResponse, { status: response.status });
-					for (const [resultIndex, result] of controlResponse.results.entries()) {
-						const operation = authorized[resultIndex];
-						if (operation) results[operation.index] = result;
-					}
-				}
-				for (const entry of body.operations) {
-					if (!entry.ok) continue;
-					const { operation, index } = entry;
-					results[index] ??= {
-						ok: false,
-						kind: operation.kind,
-						id: operation.id,
-						error: {
-							code: "INTERNAL_ERROR",
-							message: "live: missing control result."
-						}
-					};
-				}
-				return Response.json({
-					accepted: true,
-					connectionId: body.connectionId,
-					results
-				});
-			} catch (error) {
-				return errorToResponse(error);
-			}
-		},
-		publish(topic, data, publishOptions) {
-			let env;
-			try {
-				env = getRawRuntimeEnv();
-			} catch {
-				throw new Error("live: publish() was called outside a Void server runtime context. Pass an explicit env with stream.withEnv(env).publish(...).");
-			}
-			return publishWithEnv(env, topic, data, publishOptions);
-		},
-		withEnv(env) {
-			return { publish(topic, data, publishOptions) {
-				return publishWithEnv(env, topic, data, publishOptions);
-			} };
-		}
-	};
-}
-function defaultOwner(user) {
-	if (user && typeof user === "object" && "id" in user && typeof user.id === "string") return `user:${user.id}`;
-	return null;
-}
-function getContextUser(ctx) {
-	try {
-		return ctx.get("user");
-	} catch {
-		return null;
-	}
-}
-function parseLiveControlResponse(body) {
-	try {
-		const parsed = JSON.parse(body);
-		return typeof parsed === "object" && parsed !== null && "accepted" in parsed ? parsed : null;
-	} catch {
-		return null;
-	}
-}
-async function readControlRequest(request, limits) {
-	let body;
-	try {
-		body = await request.json();
-	} catch {
-		throw liveResponseError("BAD_REQUEST", "live: control request body must be JSON.", 400);
-	}
-	if (typeof body !== "object" || body === null || Array.isArray(body)) throw liveResponseError("BAD_REQUEST", "live: control request body must be an object.", 400);
-	const record = body;
-	const connectionId = assertConnectionId(record.connectionId);
-	if (!Array.isArray(record.operations)) throw liveResponseError("BAD_REQUEST", "live: operations must be an array.", 400);
-	if (record.operations.length > limits.maxOperationsPerControlRequest) throw liveResponseError("BAD_REQUEST", "live: too many operations in one control request.", 400);
-	return {
-		connectionId,
-		operations: record.operations.map(parseOperation)
-	};
-}
-function parseOperation(value, index) {
-	if (typeof value !== "object" || value === null || Array.isArray(value)) throw liveResponseError("BAD_REQUEST", "live: operation must be an object.", 400);
-	const record = value;
-	if (record.kind === "subscribe") {
-		const id = parseBoundedString(record.id, 1, 256);
-		if (id == null) return invalidOperation(index, "subscribe", record.id, "INVALID_SUBSCRIPTION_ID");
-		const topic = parseBoundedString(record.topic, 1, 512);
-		if (topic == null) return invalidOperation(index, "subscribe", id, "INVALID_TOPIC");
-		let lastEventId;
-		if (record.lastEventId !== void 0) {
-			lastEventId = parseBoundedString(record.lastEventId, 0, 512) ?? void 0;
-			if (lastEventId === void 0) return invalidOperation(index, "subscribe", id, "BAD_REQUEST");
-		}
-		return {
-			ok: true,
-			index,
-			operation: {
-				kind: "subscribe",
-				id,
-				topic,
-				...lastEventId !== void 0 && { lastEventId }
-			}
-		};
-	}
-	if (record.kind === "unsubscribe") {
-		const id = parseBoundedString(record.id, 1, 256);
-		if (id == null) return invalidOperation(index, "unsubscribe", record.id, "INVALID_SUBSCRIPTION_ID");
-		return {
-			ok: true,
-			index,
-			operation: {
-				kind: "unsubscribe",
-				id
-			}
-		};
-	}
-	throw liveResponseError("BAD_REQUEST", "live: operation kind is invalid.", 400);
-}
-function invalidOperation(index, kind, id, code) {
-	return {
-		ok: false,
-		index,
-		result: {
-			ok: false,
-			kind,
-			id: typeof id === "string" ? id : "",
-			error: {
-				code,
-				message: {
-					BAD_REQUEST: "live: invalid control operation.",
-					CONNECTION_CLOSED: "live: connection closed.",
-					CONNECTION_NOT_FOUND: "live: connection not found.",
-					FORBIDDEN: "Forbidden",
-					INVALID_SUBSCRIPTION_ID: "live: invalid subscription id.",
-					INVALID_TOPIC: "live: invalid topic.",
-					OWNER_MISMATCH: "live: owner mismatch.",
-					SUBSCRIPTION_LIMIT: "live: subscription limit reached.",
-					TOPIC_FULL: "live: topic subscription limit reached.",
-					PAYLOAD_TOO_LARGE: "live: payload too large.",
-					INTERNAL_ERROR: "live: internal error."
-				}[code]
-			}
-		}
-	};
-}
-function getLiveBinding(env) {
-	if (typeof env !== "object" || env === null) throw new Error("live: Cloudflare env is unavailable.");
-	const binding = env[liveBindingName];
-	if (!binding) throw new Error(`live: Missing Durable Object binding "${liveBindingName}".`);
-	return binding;
-}
-function getConnectionId(request) {
-	return assertConnectionId(new URL(request.url).searchParams.get("connectionId"));
-}
-function assertStreamId(value) {
-	return assertBoundedString("stream id", value, 1, 128);
-}
-function assertBindingName(value) {
-	if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(value)) throw new Error(`live: invalid Durable Object binding name "${value}".`);
-	return value;
-}
-function assertConnectionId(value) {
-	return assertBoundedString("connectionId", value, 16, 256);
-}
-function assertTopic(value) {
-	return assertBoundedString("topic", value, 1, 512);
-}
-function assertOwner(value) {
-	if (value !== null) assertBoundedString("owner", value, 1, 512);
-}
-function assertOptionalString(name, value) {
-	if (value !== void 0) assertBoundedString(name, value, 1, 512);
-}
-function resolveLiveLimits(input) {
-	const limits = { ...DEFAULT_LIMITS };
-	for (const key of Object.keys(limits)) {
-		const value = input?.[key];
-		if (value === void 0) continue;
-		if (!Number.isFinite(value) || !Number.isInteger(value) || value <= 0) throw new Error(`live: limits.${key} must be a positive finite integer.`);
-		limits[key] = value;
-	}
-	if (limits.maxSubscriptionsPerTopic > MAX_SUBSCRIPTIONS_PER_TOPIC) throw new Error(`live: limits.maxSubscriptionsPerTopic must be at most ${MAX_SUBSCRIPTIONS_PER_TOPIC}.`);
-	return limits;
-}
-function assertBoundedString(name, value, min, max) {
-	const parsed = parseBoundedString(value, min, max);
-	if (parsed == null) throw liveResponseError("BAD_REQUEST", `live: invalid ${name}.`, 400);
-	return parsed;
-}
-function parseBoundedString(value, min, max) {
-	if (typeof value !== "string" || value.length < min || value.length > max || /[\r\n]/.test(value) || value.includes("\0")) return null;
-	return value;
-}
-function assertJsonSerializable(value) {
-	try {
-		if (typeof JSON.stringify(value) !== "string") throw new Error("unsupported value");
-	} catch (error) {
-		throw new Error(`live: payload must be JSON-serializable. ${error instanceof Error ? error.message : String(error)}`);
-	}
-}
-async function topicDigest(streamId, topic) {
-	const bytes = new TextEncoder().encode(`${streamId}\u0000${topic}`);
-	const digest = await crypto.subtle.digest("SHA-256", bytes);
-	const binary = String.fromCharCode(...new Uint8Array(digest));
-	return btoa(binary).replaceAll("+", "-").replaceAll("/", "_").replace(/=+$/, "");
-}
-function connectionInstanceName(streamId, connectionId) {
-	return `live:${streamId}:connection:${connectionId}`;
-}
-function topicInstanceName(streamId, topicKey) {
-	return `live:${streamId}:topic:${topicKey}`;
-}
-function internalUrl(path) {
-	return `https://void.live${path}`;
-}
-var LiveResponseError = class extends Error {
-	code;
-	status;
-	constructor(code, message, status) {
-		super(message);
-		this.code = code;
-		this.status = status;
-	}
-};
-function liveResponseError(code, message, status) {
-	throw new LiveResponseError(code, message, status);
-}
-function errorToResponse(error) {
-	if (error instanceof LiveResponseError) return Response.json({
-		accepted: false,
-		error: {
-			code: error.code,
-			message: error.message
-		}
-	}, { status: error.status });
-	return Response.json({
-		accepted: false,
-		error: {
-			code: "INTERNAL_ERROR",
-			message: error instanceof Error ? error.message : String(error)
-		}
-	}, { status: 500 });
-}
-async function responseToControlError(response) {
-	const message = await response.text().catch(() => "") || response.statusText;
-	if (response.status === 403 || response.status === 401) return {
-		code: "FORBIDDEN",
-		message: message || "Forbidden"
-	};
-	return {
-		code: "BAD_REQUEST",
-		message: message || "Subscription rejected"
-	};
-}
-//#endregion
+import { n as __setLiveBindingName, r as defineLiveStream, t as __getLiveBindingName } from "../live-CB1y5IuC.mjs";
 export { __getLiveBindingName, __setLiveBindingName, defineLiveStream };