effect-cf 0.39.1 → 0.40.1

package/dist/index.mjs

@@ -1,3124 +1,41 @@
-import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
-import { a as WorkerEnvironment, i as WorkerConfig, n as violationsMessage, r as Environment_exports, t as causeMessage } from "./ErrorMessage-Byx2OgNd.mjs";
-import { n as Service$1, r as layer$18, t as Binding_exports } from "./Binding-C82jRhdr.mjs";
-import { n as Artifacts_exports } from "./Artifacts-CBxWGeZB.mjs";
-import { t as fromExecutionContext } from "./WorkerContext-Yobnfw-K.mjs";
-import { a as DurableWebSocketAttachmentError, c as StorageOperationError, i as DurableObjectWebSocket_exports, n as DurableObjectState_exports, o as fromWebSocket, r as fromDurableObjectState, s as DurableObjectStorage_exports, t as DurableObjectState } from "./DurableObjectState-DLL0YgBd.mjs";
-import { A as QueueDefinition_exports, C as decodeSuccess, D as method$1, E as make$15, O as reservedMethodNames$2, S as decodeArgs, T as encodeSuccess, _ as RpcTracing_exports, a as WorkerDefinition_exports, b as RpcDefinition_exports, c as resolve, d as makeEntrypointRuntime, f as runEventPromise, g as recordDecodedArgs, h as invokeRpcMethod, i as Worker_exports, j as QueueBinding_exports, k as Queue_exports, l as scoped, m as defineEntrypointRpcMethods, n as NativeRequest, o as ServiceBinding_exports, p as assumeEntrypointClass, r as WorkerContext, s as Rpc_exports, t as ExecutionContext, u as scheduleTelemetryFlush$1, v as withRpcClientSpan, w as encodeArgs, x as assertNoReservedMethods, y as withRpcTraceContext } from "./Worker-XsGJsCJX.mjs";
-import { Cause, Clock, Config, ConfigProvider, Context, Data, DateTime, Duration, Effect, Exit, FiberSet, Function as Function$1, Layer, Option, Predicate, Queue, Result, Schema, Tracer } from "effect";
-import { FetchHttpClient, HttpClient, HttpClientRequest } from "effect/unstable/http";
-import { OtlpExporter, OtlpLogger, OtlpMetrics, OtlpSerialization, OtlpTracer } from "effect/unstable/observability";
-import { AsyncLocalStorage } from "node:async_hooks";
-import { DurableObject, WorkflowEntrypoint, tracing } from "cloudflare:workers";
-import { D1Client } from "@effect/sql-d1";
-import * as RpcMessage from "effect/unstable/rpc/RpcMessage";
-import * as RpcSerialization from "effect/unstable/rpc/RpcSerialization";
-import * as RpcServer from "effect/unstable/rpc/RpcServer";
-import { SqliteClient } from "@effect/sql-sqlite-do";
-import { NonRetryableError } from "cloudflare:workflows";
-//#region src/WorkersAi.ts
-var WorkersAi_exports = /* @__PURE__ */ __exportAll({
-	Tag: () => Tag$13,
-	WorkersAiOperationError: () => WorkersAiOperationError,
-	embeddingResponse: () => embeddingResponse,
-	isWorkersAiBinding: () => isWorkersAiBinding,
-	layer: () => layer$17,
-	make: () => make$14,
-	makeClient: () => makeClient$13
-});
-const expectedWorkersAiBinding = "Workers AI binding with run(), gateway(), and models()";
-var WorkersAiOperationError = class extends Data.TaggedError("WorkersAiOperationError") {
-	get message() {
-		return `Workers AI ${this.operation} failed for binding "${this.binding}": ${causeMessage(this.cause)}`;
-	}
-};
-const embeddingDimensionsKey = "shape";
-const workersAiError = (binding, operation, cause) => new WorkersAiOperationError({
-	binding,
-	operation,
-	cause
-});
-const tryWorkersAiPromise = (binding, operation, evaluate) => Effect.tryPromise({
-	try: evaluate,
-	catch: (cause) => workersAiError(binding, operation, cause)
-});
-const tryWorkersAiSync = (binding, operation, evaluate) => Effect.try({
-	try: evaluate,
-	catch: (cause) => workersAiError(binding, operation, cause)
-});
-const WorkersAiBindingSchema = Schema.declare((value) => Predicate.hasProperty(value, "run") && Predicate.isFunction(value.run) && Predicate.hasProperty(value, "gateway") && Predicate.isFunction(value.gateway) && Predicate.hasProperty(value, "models") && Predicate.isFunction(value.models));
-const decodeWorkersAiBinding = Schema.decodeUnknownOption(WorkersAiBindingSchema);
-const isWorkersAiBinding = (value) => Option.isSome(decodeWorkersAiBinding(value));
-const embeddingResponse = (value) => ({
-	data: value.data ?? [],
-	[embeddingDimensionsKey]: value[embeddingDimensionsKey] ?? []
-});
-const decodeEmbeddingResponse = Schema.decodeUnknownEffect(Schema.Struct({
-	data: Schema.optional(Schema.Array(Schema.Array(Schema.Number))),
-	[embeddingDimensionsKey]: Schema.optional(Schema.Array(Schema.Number))
-}));
-const makeClient$13 = (definition) => (ai) => {
-	const run = Effect.fn("WorkersAi.run")((model, input, options) => tryWorkersAiPromise(definition.binding, "run", () => {
-		return ai.run(model, input, options);
-	}));
-	return {
-		definition,
-		aiGatewayLogId: tryWorkersAiSync(definition.binding, "aiGatewayLogId", () => ai.aiGatewayLogId),
-		run,
-		runEmbedding: Effect.fn("WorkersAi.runEmbedding")(function* (model, input, options) {
-			const response = yield* run(model, input, options);
-			const decoded = yield* decodeEmbeddingResponse(response).pipe(Effect.mapError((cause) => new WorkersAiOperationError({
-				binding: definition.binding,
-				operation: "runEmbedding",
-				cause
-			})));
-			return embeddingResponse(decoded);
-		}),
-		models: Effect.fn("WorkersAi.models")((params) => tryWorkersAiPromise(definition.binding, "models", () => ai.models(params))),
-		gateway: (gatewayId) => tryWorkersAiSync(definition.binding, "gateway", () => ai.gateway(gatewayId)),
-		rawUnsafe: Effect.succeed(ai)
-	};
-};
-const layer$17 = (tag, definition) => layer$18(tag, definition.binding, (value) => isWorkersAiBinding(value), makeClient$13(definition), { expected: expectedWorkersAiBinding });
-const make$14 = (id) => Tag$13()(id);
-const Tag$13 = () => (id) => {
-	const tag = Context.Service()(id);
-	const makeLayer = (definition) => layer$17(tag, definition);
-	return Object.assign(tag, {
-		id,
-		layer: makeLayer
-	});
-};
-//#endregion
-//#region src/AiGateway.ts
-var AiGateway_exports = /* @__PURE__ */ __exportAll({
-	AiGatewayOperationError: () => AiGatewayOperationError,
-	Tag: () => Tag$12,
-	isAiGatewayBinding: () => isAiGatewayBinding,
-	layer: () => layer$16,
-	make: () => make$13,
-	makeClient: () => makeClient$12,
-	makeClientFromAi: () => makeClientFromAi,
-	makeHttpClient: () => makeHttpClient
-});
-const expectedAiGatewayBinding = "Workers AI binding with gateway()";
-var AiGatewayOperationError = class extends Data.TaggedError("AiGatewayOperationError") {
-	get message() {
-		return `AI Gateway ${this.operation} failed for binding "${this.binding}": ${causeMessage(this.cause)}`;
-	}
-};
-const AiGatewayMetadata = Schema.Record(Schema.String, Schema.Union([
-	Schema.String,
-	Schema.Number,
-	Schema.Boolean,
-	Schema.Null
-]));
-const AiGatewayHttpMetadata = Schema.Union([AiGatewayMetadata, Schema.fromJsonString(AiGatewayMetadata)]);
-const AiGatewayLogResponse = Schema.Struct({
-	success: Schema.Literal(true),
-	result: Schema.Struct({
-		id: Schema.String,
-		provider: Schema.String,
-		model: Schema.String,
-		model_type: Schema.optional(Schema.String),
-		path: Schema.String,
-		duration: Schema.Number,
-		request_type: Schema.optional(Schema.String),
-		request_content_type: Schema.optional(Schema.String),
-		status_code: Schema.Number,
-		response_content_type: Schema.optional(Schema.String),
-		success: Schema.Boolean,
-		cached: Schema.Boolean,
-		tokens_in: Schema.optional(Schema.Number),
-		tokens_out: Schema.optional(Schema.Number),
-		metadata: Schema.optional(AiGatewayHttpMetadata),
-		step: Schema.optional(Schema.Number),
-		cost: Schema.optional(Schema.Number),
-		custom_cost: Schema.optional(Schema.Boolean),
-		request_size: Schema.Number,
-		request_head: Schema.optional(Schema.String),
-		request_head_complete: Schema.Boolean,
-		response_size: Schema.Number,
-		response_head: Schema.optional(Schema.String),
-		response_head_complete: Schema.Boolean,
-		created_at: Schema.DateFromString
-	})
-});
-const AiGatewayPatchLogResponse = Schema.Struct({
-	success: Schema.Literal(true),
-	result: Schema.Unknown
-});
-const decodeAiGatewayLogResponse = Schema.decodeUnknownPromise(AiGatewayLogResponse);
-const decodeAiGatewayPatchLogResponse = Schema.decodeUnknownPromise(AiGatewayPatchLogResponse);
-const aiGatewayError = (binding, operation, cause) => new AiGatewayOperationError({
-	binding,
-	operation,
-	cause
-});
-const tryAiGatewayPromise = (binding, operation, evaluate) => Effect.tryPromise({
-	try: evaluate,
-	catch: (cause) => aiGatewayError(binding, operation, cause)
-});
-const mergeAbortSignals = (userSignal, signal) => userSignal === null || userSignal === void 0 ? signal : AbortSignal.any([userSignal, signal]);
-const tryAiGatewaySync = (binding, operation, evaluate) => Effect.try({
-	try: evaluate,
-	catch: (cause) => aiGatewayError(binding, operation, cause)
-});
-const providerUrl = (baseUrl, path = "") => {
-	const url = new URL(baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`);
-	const normalizedPath = path.replace(/^\/+/, "");
-	return normalizedPath === "" ? url : new URL(normalizedPath, url);
-};
-const gatewayUrl = (definition) => `https://gateway.ai.cloudflare.com/v1/${definition.accountId}/${definition.gatewayId}/`;
-const ensureSuccessfulResponse = (response) => {
-	if (!response.ok) throw new Error(`AI Gateway HTTP request failed with status ${response.status}`);
-};
-const isAiGatewayBinding = (value) => isWorkersAiBinding(value);
-const makeClient$12 = (definition, gateway) => ({
-	definition,
-	run: Effect.fn("AiGateway.run")((data, options) => tryAiGatewayPromise(definition.binding, "run", () => gateway.run(Array.isArray(data) ? [...data] : data, options))),
-	getUrl: Effect.fn("AiGateway.getUrl")((provider) => tryAiGatewayPromise(definition.binding, "getUrl", () => gateway.getUrl(provider))),
-	fetch: Effect.fn("AiGateway.fetch")(function* (options) {
-		const baseUrl = yield* tryAiGatewayPromise(definition.binding, "getUrl", () => gateway.getUrl(options.provider));
-		return yield* tryAiGatewayPromise(definition.binding, "fetch", (signal) => fetch(providerUrl(baseUrl, options.path).href, {
-			...options.init,
-			signal: mergeAbortSignals(options.init?.signal, signal)
-		}));
-	}),
-	patchLog: Effect.fn("AiGateway.patchLog")((logId, data) => tryAiGatewayPromise(definition.binding, "patchLog", () => gateway.patchLog(logId, data))),
-	getLog: Effect.fn("AiGateway.getLog")((logId) => tryAiGatewayPromise(definition.binding, "getLog", () => gateway.getLog(logId))),
-	rawUnsafe: Effect.succeed(gateway)
-});
-const makeClientFromAi = (definition, ai) => {
-	const gateway = tryAiGatewaySync(definition.binding, "gateway", () => ai.gateway(definition.gatewayId));
-	const withGateway = (operation) => gateway.pipe(Effect.flatMap(operation));
-	return {
-		definition,
-		run: (data, options) => withGateway((raw) => makeClient$12(definition, raw).run(data, options)),
-		getUrl: (provider) => withGateway((raw) => makeClient$12(definition, raw).getUrl(provider)),
-		fetch: (options) => withGateway((raw) => makeClient$12(definition, raw).fetch(options)),
-		patchLog: (logId, data) => withGateway((raw) => makeClient$12(definition, raw).patchLog(logId, data)),
-		getLog: (logId) => withGateway((raw) => makeClient$12(definition, raw).getLog(logId)),
-		rawUnsafe: gateway
-	};
-};
-const makeHttpClient = (definition, request = fetch) => {
-	const binding = definition.binding ?? "AI_GATEWAY";
-	const clientDefinition = {
-		binding,
-		gatewayId: definition.gatewayId,
-		accountId: definition.accountId
-	};
-	const getUrl = (provider) => Effect.succeed(provider === void 0 ? gatewayUrl(definition) : providerUrl(gatewayUrl(definition), provider).href.replace(/\/$/, ""));
-	const extraHeaders = (options) => {
-		if (options?.extraHeaders === void 0 || Array.isArray(options.extraHeaders) || options.extraHeaders instanceof Headers) return options?.extraHeaders;
-		return Object.fromEntries(Object.entries(options.extraHeaders).map(([key, value]) => [key, String(value)]));
-	};
-	return {
-		definition: clientDefinition,
-		run: Effect.fn("AiGateway.run")((data, options) => tryAiGatewayPromise(binding, "run", (signal) => request(gatewayUrl(definition), {
-			method: "POST",
-			body: JSON.stringify(data),
-			headers: new Headers({
-				"content-type": "application/json",
-				...Object.fromEntries(new Headers(extraHeaders(options)).entries())
-			}),
-			signal: mergeAbortSignals(options?.signal, signal)
-		}))),
-		getUrl,
-		fetch: Effect.fn("AiGateway.fetch")((options) => getUrl(options.provider).pipe(Effect.flatMap((baseUrl) => tryAiGatewayPromise(binding, "fetch", (signal) => request(providerUrl(baseUrl, options.path).href, {
-			...options.init,
-			signal: mergeAbortSignals(options.init?.signal, signal)
-		}))))),
-		patchLog: Effect.fn("AiGateway.patchLog")((logId, data) => tryAiGatewayPromise(binding, "patchLog", async (signal) => {
-			const response = await request(providerUrl(gatewayUrl(definition), `logs/${logId}`).href, {
-				method: "PATCH",
-				body: JSON.stringify(data),
-				headers: { "content-type": "application/json" },
-				signal
-			});
-			ensureSuccessfulResponse(response);
-			await decodeAiGatewayPatchLogResponse(await response.json());
-		})),
-		getLog: Effect.fn("AiGateway.getLog")((logId) => tryAiGatewayPromise(binding, "getLog", async (signal) => {
-			const response = await request(providerUrl(gatewayUrl(definition), `logs/${logId}`).href, { signal });
-			ensureSuccessfulResponse(response);
-			return (await decodeAiGatewayLogResponse(await response.json())).result;
-		})),
-		rawUnsafe: Effect.fail(aiGatewayError(binding, "rawUnsafe", /* @__PURE__ */ new TypeError("HTTP AI Gateway clients have no raw binding")))
-	};
-};
-const layer$16 = (tag, definition) => layer$18(tag, definition.binding, isAiGatewayBinding, (ai) => makeClientFromAi(definition, ai), { expected: expectedAiGatewayBinding });
-const make$13 = (id) => Tag$12()(id);
-const Tag$12 = () => (id) => {
-	const tag = Context.Service()(id);
-	const makeLayer = (definition) => layer$16(tag, definition);
-	return Object.assign(tag, {
-		id,
-		layer: makeLayer
-	});
-};
-//#endregion
-//#region src/AnalyticsEngine.ts
-var AnalyticsEngine_exports = /* @__PURE__ */ __exportAll({
-	AnalyticsEngineDataPointSchema: () => AnalyticsEngineDataPointSchema,
-	AnalyticsEngineFieldValueSchema: () => AnalyticsEngineFieldValueSchema,
-	AnalyticsEngineOperationError: () => AnalyticsEngineOperationError,
-	AnalyticsEngineQueryError: () => AnalyticsEngineQueryError,
-	AnalyticsEngineWriteValidationError: () => AnalyticsEngineWriteValidationError,
-	QueryTag: () => QueryTag,
-	Tag: () => Tag$11,
-	isAnalyticsEngineDataset: () => isAnalyticsEngineDataset,
-	layer: () => layer$15,
-	layerFetch: () => layerFetch,
-	layerFetchConfig: () => layerFetchConfig,
-	make: () => make$12,
-	makeClient: () => makeClient$11,
-	makeQuery: () => makeQuery,
-	makeQueryClient: () => makeQueryClient,
-	queryConfig: () => queryConfig,
-	queryLayer: () => queryLayer,
-	queryLayerConfig: () => queryLayerConfig,
-	writeLimits: () => writeLimits
-});
-const expectedAnalyticsEngineDataset = "Analytics Engine dataset binding with writeDataPoint()";
-const defaultQueryApiBaseUrl = "https://api.cloudflare.com/client/v4";
-const textEncoder$1 = new TextEncoder();
-const writeLimits = {
-	maxBlobs: 20,
-	maxDoubles: 20,
-	maxIndexes: 1,
-	maxBlobBytes: 16384,
-	maxIndexBytes: 96,
-	maxDataPointsPerInvocation: 250
-};
-const queryColumnSchema = Schema.Struct({
-	name: Schema.String,
-	type: Schema.String
-});
-const queryRowSchema = Schema.Record(Schema.String, Schema.Unknown);
-const queryResponseSchema = Schema.Struct({
-	meta: Schema.Array(queryColumnSchema),
-	data: Schema.Array(queryRowSchema),
-	rows: Schema.Number
-});
-const AnalyticsEngineFieldValueSchema = Schema.NullOr(Schema.Union([Schema.String, Schema.instanceOf(ArrayBuffer)]));
-const AnalyticsEngineDataPointSchema = Schema.Struct({
-	indexes: Schema.optional(Schema.Array(AnalyticsEngineFieldValueSchema)),
-	doubles: Schema.optional(Schema.Array(Schema.Finite)),
-	blobs: Schema.optional(Schema.Array(AnalyticsEngineFieldValueSchema))
-});
-const decodeQueryResponse = Schema.decodeUnknownEffect(queryResponseSchema);
-const decodeDataPoint = Schema.decodeUnknownEffect(AnalyticsEngineDataPointSchema);
-var AnalyticsEngineOperationError = class extends Data.TaggedError("AnalyticsEngineOperationError") {
-	get message() {
-		return `Analytics Engine ${this.operation} failed for binding "${this.binding}": ${causeMessage(this.cause)}`;
-	}
-};
-var AnalyticsEngineWriteValidationError = class extends Data.TaggedError("AnalyticsEngineWriteValidationError") {
-	get message() {
-		return `Analytics Engine ${this.operation} for binding "${this.binding}" failed validation: ${violationsMessage(this.violations)}`;
-	}
-};
-var AnalyticsEngineQueryError = class extends Data.TaggedError("AnalyticsEngineQueryError") {};
-const analyticsEngineError = (binding, operation, cause) => new AnalyticsEngineOperationError({
-	binding,
-	operation,
-	cause
-});
-const analyticsEngineWriteValidationError = (binding, operation, violations, cause) => new AnalyticsEngineWriteValidationError({
-	binding,
-	operation,
-	violations,
-	cause
-});
-const analyticsEngineQueryError = (definition, operation, message, options) => new AnalyticsEngineQueryError({
-	operation,
-	accountId: definition.accountId,
-	message,
-	status: options?.status,
-	body: options?.body,
-	cause: options?.cause
-});
-const tryAnalyticsEngineSync = (binding, operation, evaluate) => Effect.try({
-	try: evaluate,
-	catch: (cause) => analyticsEngineError(binding, operation, cause)
-});
-const resolveWritePolicy = (defaults, options) => ({ onInvalid: options?.onInvalid ?? defaults?.onInvalid ?? "error" });
-const fieldPath = (prefix, field) => prefix === "" ? field : `${prefix}.${field}`;
-const indexedPath = (prefix, field, index) => `${fieldPath(prefix, field)}[${index}]`;
-const byteLength$1 = (value) => {
-	if (value === null) return 0;
-	return Predicate.isString(value) ? textEncoder$1.encode(value).byteLength : value.byteLength;
-};
-const lengthViolation = (path, label, actual, limit) => ({
-	path,
-	message: `${label} exceeds Cloudflare Analytics Engine limit`,
-	actual,
-	limit
-});
-const validateDataPointLimits = (dataPoint, pathPrefix = "") => {
-	const violations = [];
-	if (dataPoint.blobs !== void 0 && dataPoint.blobs.length > writeLimits.maxBlobs) violations.push(lengthViolation(fieldPath(pathPrefix, "blobs"), "blobs", dataPoint.blobs.length, writeLimits.maxBlobs));
-	if (dataPoint.doubles !== void 0 && dataPoint.doubles.length > writeLimits.maxDoubles) violations.push(lengthViolation(fieldPath(pathPrefix, "doubles"), "doubles", dataPoint.doubles.length, writeLimits.maxDoubles));
-	if (dataPoint.indexes !== void 0 && dataPoint.indexes.length > writeLimits.maxIndexes) violations.push(lengthViolation(fieldPath(pathPrefix, "indexes"), "indexes", dataPoint.indexes.length, writeLimits.maxIndexes));
-	if (dataPoint.blobs !== void 0) {
-		const blobBytes = dataPoint.blobs.reduce((total, value) => total + byteLength$1(value), 0);
-		if (blobBytes > writeLimits.maxBlobBytes) violations.push(lengthViolation(fieldPath(pathPrefix, "blobs"), "blob bytes", blobBytes, writeLimits.maxBlobBytes));
-	}
-	if (dataPoint.indexes !== void 0) for (let index = 0; index < dataPoint.indexes.length; index++) {
-		const indexBytes = byteLength$1(dataPoint.indexes[index] ?? null);
-		if (indexBytes > writeLimits.maxIndexBytes) violations.push(lengthViolation(indexedPath(pathPrefix, "indexes", index), "index bytes", indexBytes, writeLimits.maxIndexBytes));
-	}
-	return violations;
-};
-const schemaViolation = (pathPrefix, cause) => ({
-	path: pathPrefix === "" ? "$" : pathPrefix,
-	message: cause.message
-});
-const toAnalyticsEngineDataPoint = (dataPoint) => {
-	const result = {};
-	if (dataPoint.indexes !== void 0) result.indexes = [...dataPoint.indexes];
-	if (dataPoint.doubles !== void 0) result.doubles = [...dataPoint.doubles];
-	if (dataPoint.blobs !== void 0) result.blobs = [...dataPoint.blobs];
-	return result;
-};
-const validateDataPoint = (binding, operation, dataPoint, pathPrefix = "") => Effect.gen(function* () {
-	const decoded = yield* decodeDataPoint(dataPoint).pipe(Effect.mapError((cause) => analyticsEngineWriteValidationError(binding, operation, [schemaViolation(pathPrefix, cause)], cause)));
-	const validated = toAnalyticsEngineDataPoint(decoded);
-	const violations = validateDataPointLimits(validated, pathPrefix);
-	if (violations.length > 0) return yield* Effect.fail(analyticsEngineWriteValidationError(binding, operation, violations));
-	return validated;
-});
-const validateOptionalDataPoint = (binding, operation, dataPoint) => dataPoint === void 0 ? Effect.succeed(void 0) : validateDataPoint(binding, operation, dataPoint);
-const validateDataPoints = (binding, operation, dataPoints, policy) => Effect.gen(function* () {
-	const points = dataPoints.length > writeLimits.maxDataPointsPerInvocation && policy.onInvalid === "drop" ? dataPoints.slice(0, writeLimits.maxDataPointsPerInvocation) : dataPoints;
-	const violations = [];
-	if (dataPoints.length > writeLimits.maxDataPointsPerInvocation && policy.onInvalid === "error") violations.push(lengthViolation("dataPoints", "data points per Worker invocation", dataPoints.length, writeLimits.maxDataPointsPerInvocation));
-	const validPoints = [];
-	for (let index = 0; index < points.length; index++) {
-		const result = yield* Effect.result(validateDataPoint(binding, operation, points[index], `dataPoints[${index}]`));
-		if (Result.isSuccess(result)) validPoints.push(result.success);
-		else if (policy.onInvalid === "error") violations.push(...result.failure.violations);
-	}
-	if (violations.length > 0) return yield* Effect.fail(analyticsEngineWriteValidationError(binding, operation, violations));
-	return validPoints;
-});
-const writeChunks = (binding, operation, dataset, dataPoints) => Effect.gen(function* () {
-	for (const point of dataPoints) yield* tryAnalyticsEngineSync(binding, operation, () => dataset.writeDataPoint(point));
-});
-const queryApiUrl = (definition) => {
-	const baseUrl = new URL(definition.apiBaseUrl ?? defaultQueryApiBaseUrl);
-	baseUrl.pathname = `${baseUrl.pathname.replace(/\/+$/, "")}/accounts/${definition.accountId}/analytics_engine/sql`;
-	return baseUrl.href;
-};
-const queryRequest = (definition, sql, options) => {
-	let request = HttpClientRequest.post(queryApiUrl(definition)).pipe(HttpClientRequest.bodyText(sql, "text/plain;charset=UTF-8"));
-	if (options?.headers !== void 0) request = HttpClientRequest.setHeaders(request, options.headers);
-	return HttpClientRequest.bearerToken(request, definition.apiToken);
-};
-const responseText = (definition, response, operation) => response.text.pipe(Effect.catch((cause) => Effect.fail(analyticsEngineQueryError(definition, operation, "Failed to read Analytics Engine SQL API response body", { cause }))));
-const executeQueryRequest = (definition, httpClient, sql, options) => Effect.gen(function* () {
-	const request = yield* Effect.try({
-		try: () => queryRequest(definition, sql, options),
-		catch: (cause) => analyticsEngineQueryError(definition, "query", "Invalid Analytics Engine SQL API URL", { cause })
-	});
-	const response = yield* httpClient.execute(request).pipe(Effect.mapError((cause) => analyticsEngineQueryError(definition, "query", "Analytics Engine SQL API request failed", { cause })));
-	if (response.status < 200 || response.status >= 300) {
-		const body = yield* responseText(definition, response, "queryErrorBody");
-		return yield* Effect.fail(analyticsEngineQueryError(definition, "query", `Analytics Engine SQL API returned HTTP ${response.status}`, {
-			status: response.status,
-			body
-		}));
-	}
-	return response;
-});
-const makeQueryClientWith = (definition, httpClient) => {
-	const raw = Effect.fn("AnalyticsEngine.raw")((sql, options) => executeQueryRequest(definition, httpClient, sql, options));
-	const query = Effect.fn("AnalyticsEngine.query")(function* (sql, options) {
-		const json = yield* (yield* raw(sql, options)).json.pipe(Effect.catch((cause) => Effect.fail(analyticsEngineQueryError(definition, "json", "Failed to read Analytics Engine SQL API JSON response body", { cause }))));
-		return yield* decodeQueryResponse(json);
-	});
-	const queryResult = (row, sql, options) => Effect.gen(function* () {
-		const result = yield* query(sql, options);
-		const decodeRow = Schema.decodeUnknownEffect(row);
-		const data = [];
-		for (const value of result.data) data.push(yield* decodeRow(value));
-		return {
-			...result,
-			data,
-			rows: result.rows
-		};
-	}).pipe(Effect.withSpan("AnalyticsEngine.queryResult"));
-	return {
-		definition,
-		raw,
-		query,
-		queryResult,
-		queryRows: (row, sql, options) => queryResult(row, sql, options).pipe(Effect.map((result) => result.data), Effect.withSpan("AnalyticsEngine.queryRows")),
-		queryOne: (row, sql, options) => queryResult(row, sql, options).pipe(Effect.map((result) => result.data[0] === void 0 ? Option.none() : Option.some(result.data[0])), Effect.withSpan("AnalyticsEngine.queryOne")),
-		queryText: Effect.fn("AnalyticsEngine.queryText")((sql, options) => raw(sql, options).pipe(Effect.flatMap((response) => responseText(definition, response, "text"))))
-	};
-};
-const makeQueryClient = (definition) => Effect.map(HttpClient.HttpClient, (httpClient) => makeQueryClientWith(definition, httpClient));
-const isAnalyticsEngineDataset = (value) => Predicate.hasProperty(value, "writeDataPoint") && Predicate.isFunction(value.writeDataPoint);
-const makeClient$11 = (definition, defaults) => (dataset) => {
-	return {
-		definition,
-		writeDataPoint: Effect.fn("AnalyticsEngine.writeDataPoint")((dataPoint, options) => {
-			const policy = resolveWritePolicy(defaults, options);
-			return validateOptionalDataPoint(definition.binding, "writeDataPoint", dataPoint).pipe(Effect.matchEffect({
-				onFailure: (error) => policy.onInvalid === "drop" ? Effect.succeed(void 0) : Effect.fail(error),
-				onSuccess: (point) => tryAnalyticsEngineSync(definition.binding, "writeDataPoint", () => dataset.writeDataPoint(point))
-			}));
-		}),
-		writeDataPoints: Effect.fn("AnalyticsEngine.writeDataPoints")(function* (dataPoints, options) {
-			const policy = resolveWritePolicy(defaults, options);
-			const validPoints = yield* validateDataPoints(definition.binding, "writeDataPoints", dataPoints, policy);
-			yield* writeChunks(definition.binding, "writeDataPoints", dataset, validPoints);
-		}),
-		rawUnsafe: Effect.succeed(dataset)
-	};
-};
-const queryConfig = (options) => Config.all({
-	accountId: options?.accountId ?? Config.string("CLOUDFLARE_ACCOUNT_ID"),
-	apiToken: options?.apiToken ?? Config.redacted("CLOUDFLARE_API_TOKEN"),
-	apiBaseUrl: options?.apiBaseUrl ?? Config.string("CLOUDFLARE_API_BASE_URL").pipe(Config.withDefault(defaultQueryApiBaseUrl))
-});
-const queryLayer = (tag, definition) => Layer.effect(tag, makeQueryClient(definition));
-const layerFetch = (tag, definition) => queryLayer(tag, definition).pipe(Layer.provide(FetchHttpClient.layer));
-const queryLayerConfig = (tag, config = queryConfig()) => Layer.effect(tag, Effect.gen(function* () {
-	const definition = yield* config;
-	return yield* makeQueryClient(definition);
-}));
-const layerFetchConfig = (tag, config = queryConfig()) => queryLayerConfig(tag, config).pipe(Layer.provide(FetchHttpClient.layer));
-const layer$15 = (tag, definition) => layer$18(tag, definition.binding, isAnalyticsEngineDataset, makeClient$11(definition, definition.write), { expected: expectedAnalyticsEngineDataset });
-const make$12 = (id) => Tag$11()(id);
-const makeQuery = (id) => QueryTag()(id);
-const Tag$11 = () => (id) => {
-	const tag = Context.Service()(id);
-	const makeLayer = (definition) => layer$15(tag, definition);
-	return Object.assign(tag, {
-		id,
-		layer: makeLayer
-	});
-};
-const QueryTag = () => (id) => {
-	const tag = Context.Service()(id);
-	const makeLayer = (definition) => queryLayer(tag, definition);
-	const makeLayerFetch = (definition) => layerFetch(tag, definition);
-	const makeLayerConfig = (config) => queryLayerConfig(tag, config);
-	const makeLayerFetchConfig = (config) => layerFetchConfig(tag, config);
-	return Object.assign(tag, {
-		id,
-		layer: makeLayer,
-		layerFetch: makeLayerFetch,
-		layerConfig: makeLayerConfig,
-		layerFetchConfig: makeLayerFetchConfig
-	});
-};
-//#endregion
-//#region src/BrowserRendering.ts
-var BrowserRendering_exports = /* @__PURE__ */ __exportAll({
-	BrowserRenderingOperationError: () => BrowserRenderingOperationError,
-	Tag: () => Tag$10,
-	isBrowserRenderingBinding: () => isBrowserRenderingBinding,
-	layer: () => layer$14,
-	make: () => make$11,
-	makeClient: () => makeClient$10
-});
-const expectedBrowserRenderingBinding = "Browser Rendering binding resource";
-var BrowserRenderingOperationError = class extends Data.TaggedError("BrowserRenderingOperationError") {
-	get message() {
-		return `Browser Rendering ${this.operation} failed for binding "${this.binding}": ${causeMessage(this.cause)}`;
-	}
-};
-const browserRenderingError = (binding, operation, cause) => new BrowserRenderingOperationError({
-	binding,
-	operation,
-	cause
-});
-const tryBrowserRenderingPromise = (binding, operation, evaluate) => Effect.tryPromise({
-	try: evaluate,
-	catch: (cause) => browserRenderingError(binding, operation, cause)
-});
-const tryBrowserRenderingSync = (binding, operation, evaluate) => Effect.try({
-	try: evaluate,
-	catch: (cause) => browserRenderingError(binding, operation, cause)
-});
-const missingMethod = (binding, operation) => Effect.fail(browserRenderingError(binding, operation, /* @__PURE__ */ new TypeError(`Browser Rendering object does not expose ${operation}()`)));
-const wrapPage = (binding, page) => ({
-	raw: page,
-	goto: (url, options) => page.goto === void 0 ? missingMethod(binding, "goto") : tryBrowserRenderingPromise(binding, "goto", () => page.goto(url, options)),
-	setContent: (html, options) => page.setContent === void 0 ? missingMethod(binding, "setContent") : tryBrowserRenderingPromise(binding, "setContent", () => page.setContent(html, options)),
-	content: page.content === void 0 ? missingMethod(binding, "content") : tryBrowserRenderingPromise(binding, "content", () => page.content()),
-	screenshot: (options) => {
-		const screenshot = page.screenshot?.bind(page);
-		return screenshot === void 0 ? missingMethod(binding, "screenshot") : tryBrowserRenderingPromise(binding, "screenshot", () => screenshot(options));
-	},
-	pdf: (options) => {
-		const pdf = page.pdf?.bind(page);
-		return pdf === void 0 ? missingMethod(binding, "pdf") : tryBrowserRenderingPromise(binding, "pdf", () => pdf(options));
-	},
-	evaluate: (pageFunction, ...args) => {
-		const evaluate = page.evaluate?.bind(page);
-		return evaluate === void 0 ? missingMethod(binding, "evaluate") : tryBrowserRenderingPromise(binding, "evaluate", () => evaluate(pageFunction, ...args));
-	},
-	close: (options) => page.close === void 0 ? Effect.void : tryBrowserRenderingPromise(binding, "closePage", () => page.close(options))
-});
-const wrapBrowser = (binding, browser) => ({
-	raw: browser,
-	newPage: tryBrowserRenderingPromise(binding, "newPage", () => browser.newPage()).pipe(Effect.map((page) => wrapPage(binding, page))),
-	version: browser.version === void 0 ? missingMethod(binding, "version") : tryBrowserRenderingPromise(binding, "version", () => browser.version()),
-	close: browser.close === void 0 ? Effect.void : tryBrowserRenderingPromise(binding, "closeBrowser", () => browser.close()),
-	disconnect: browser.disconnect === void 0 ? Effect.void : tryBrowserRenderingSync(binding, "disconnect", () => browser.disconnect())
-});
-const isBrowserRenderingBinding = (value) => Predicate.isObjectOrArray(value) || Predicate.isFunction(value);
-const makeClient$10 = (definition) => (binding) => ({
-	definition,
-	launchWith: (launch, options) => tryBrowserRenderingPromise(definition.binding, "launch", () => launch(binding, options)).pipe(Effect.map((browser) => wrapBrowser(definition.binding, browser)), Effect.withSpan("BrowserRendering.launchWith")),
-	connectWith: (connect, options) => tryBrowserRenderingPromise(definition.binding, "connect", () => connect(binding, options)).pipe(Effect.map((browser) => wrapBrowser(definition.binding, browser)), Effect.withSpan("BrowserRendering.connectWith")),
-	rawUnsafe: Effect.succeed(binding)
-});
-const layer$14 = (tag, definition) => layer$18(tag, definition.binding, isBrowserRenderingBinding, makeClient$10(definition), { expected: expectedBrowserRenderingBinding });
-const make$11 = (id) => Tag$10()(id);
-const Tag$10 = () => (id) => {
-	const tag = Context.Service()(id);
-	const makeLayer = (definition) => layer$14(tag, definition);
-	return Object.assign(tag, {
-		id,
-		layer: makeLayer
-	});
-};
-//#endregion
-//#region src/Cache.ts
-var Cache_exports = /* @__PURE__ */ __exportAll({
-	CacheOperationError: () => CacheOperationError,
-	CacheStorage: () => CacheStorage,
-	layer: () => layer$13,
-	layerFrom: () => layerFrom,
-	makeCacheClient: () => makeCacheClient,
-	makeClient: () => makeClient$9
-});
-var CacheOperationError = class extends Data.TaggedError("CacheOperationError") {
-	get message() {
-		return `Cache ${this.operation} failed for cache "${this.cache}": ${causeMessage(this.cause)}`;
-	}
-};
-var CacheStorage = class extends Context.Service()("effect-cf/CacheStorage") {};
-const cacheError = (cache, operation, cause) => new CacheOperationError({
-	cache,
-	operation,
-	cause
-});
-const tryCachePromise = (cache, operation, evaluate) => Effect.tryPromise({
-	try: evaluate,
-	catch: (cause) => cacheError(cache, operation, cause)
-});
-const spanOptions$2 = (cache, operation) => ({ attributes: {
-	cache,
-	operation
-} });
-const makeCacheClient = (cache, name = "default") => ({
-	name,
-	match: Effect.fn("Cache.match", spanOptions$2(name, "match"))((request, options) => tryCachePromise(name, "match", () => cache.match(request, options)).pipe(Effect.map(Option.fromUndefinedOr))),
-	put: Effect.fn("Cache.put", spanOptions$2(name, "put"))((request, response) => tryCachePromise(name, "put", () => cache.put(request, response))),
-	delete: Effect.fn("Cache.delete", spanOptions$2(name, "delete"))((request, options) => tryCachePromise(name, "delete", () => cache.delete(request, options))),
-	rawUnsafe: Effect.succeed(cache)
-});
-const makeClient$9 = (storage) => ({
-	default: makeCacheClient(storage.default),
-	open: (name) => tryCachePromise(name, "open", () => storage.open(name)).pipe(Effect.map((cache) => makeCacheClient(cache, name)), Effect.withSpan("Cache.open", spanOptions$2(name, "open"))),
-	rawUnsafe: Effect.succeed(storage)
-});
-const layerFrom = (storage) => Layer.succeed(CacheStorage, makeClient$9(storage));
-const layer$13 = Layer.sync(CacheStorage, () => makeClient$9(caches));
-//#endregion
-//#region src/CloudflareOtlp.ts
-/**
-* Worker fetch/queue/RPC and Durable Object alarm/RPC handlers schedule a
-* best-effort flusher. It settles within two seconds; other lifecycles must
-* flush explicitly. Scheduled flush failures cannot fail user events. Exporter
-* layer finalizers run separately and follow their configured shutdown timeout.
-*/
-var CloudflareOtlp_exports = /* @__PURE__ */ __exportAll({
-	layer: () => layer$12,
-	layerDurableObject: () => layerDurableObject,
-	layerJson: () => layerJson,
-	layerProtobuf: () => layerProtobuf,
-	layerWorker: () => layerWorker
-});
-const allSignals = [
-	"logs",
-	"traces",
-	"metrics"
-];
-const emptyConfigProvider = ConfigProvider.fromUnknown({});
-const cloudflareConfigProviderLayer = ConfigProvider.layerAdd(Effect.map(Effect.serviceOption(WorkerEnvironment), (env) => Option.isSome(env) ? WorkerConfig.providerFromEnv(env.value) : emptyConfigProvider), { asPrimary: true });
-const selectedSignals = (signals) => new Set(signals ?? allSignals);
-const withDefinedAttributes = (attributes) => {
-	const out = {};
-	for (const [key, value] of Object.entries(attributes)) if (value !== void 0) out[key] = value;
-	return out;
-};
-const makeResource = (options, runtimeAttributes) => ({
-	serviceName: options.resource?.serviceName,
-	serviceVersion: options.resource?.serviceVersion,
-	attributes: {
-		...withDefinedAttributes(runtimeAttributes),
-		...options.resource?.attributes
-	}
-});
-const serializationLayer = (serialization) => serialization === "json" ? OtlpSerialization.layerJson : OtlpSerialization.layerProtobuf;
-const mergeSignalLayers = (layers) => {
-	let merged = layers[0];
-	for (let index = 1; index < layers.length; index++) merged = Layer.mergeAll(merged, layers[index]);
-	return merged;
-};
-const makeLayer = (options = {}, runtimeAttributes = {}) => {
-	const signals = selectedSignals(options.signals);
-	const resource = makeResource(options, runtimeAttributes);
-	const layers = [];
-	if (signals.has("logs")) layers.push(OtlpLogger.layerFromConfig({
-		resource,
-		headers: options.headers,
-		excludeLogSpans: options.loggerExcludeLogSpans,
-		mergeWithExisting: options.loggerMergeWithExisting
-	}));
-	if (signals.has("traces")) layers.push(OtlpTracer.layerFromConfig({
-		resource,
-		headers: options.headers,
-		context: options.tracerContext
-	}));
-	if (signals.has("metrics")) layers.push(OtlpMetrics.layerFromConfig({
-		resource,
-		headers: options.headers
-	}));
-	if (layers.length === 0) return OtlpExporter.layerFlusher;
-	return mergeSignalLayers(layers).pipe(Layer.provide(cloudflareConfigProviderLayer), Layer.provide(serializationLayer(options.serialization)), Layer.provide(FetchHttpClient.layer));
-};
-/**
-* Base OTLP telemetry layer for Cloudflare-compatible runtimes.
-*
-* Standard OpenTelemetry environment variables are resolved by Effect's OTLP
-* layers. In Cloudflare Workers and Durable Objects, the current `env` object is
-* installed as the primary `ConfigProvider`; outside Cloudflare, the ambient
-* Effect `ConfigProvider` remains the fallback.
-*
-* The layer provides {@link OtlpExporter.Flusher} for draining buffered
-* telemetry before the isolate freezes.
-*/
-const layer$12 = (options = {}) => makeLayer(options);
-/** Base OTLP telemetry layer forced to JSON serialization. */
-const layerJson = (options = {}) => layer$12({
-	...options,
-	serialization: "json"
-});
-/** Base OTLP telemetry layer forced to protobuf serialization. */
-const layerProtobuf = (options = {}) => layer$12({
-	...options,
-	serialization: "protobuf"
-});
-/**
-* OTLP layer with Cloudflare Worker resource attributes.
-*
-* Provide this layer at runtime scope for long-lived metrics aggregation, or at
-* handler scope when traces/logs should flush as the Cloudflare event finishes.
-* A handler-scoped exporter can delay scope closure while its own finalizer
-* flushes; the two-second background flush limit does not bound layer shutdown.
-*/
-const layerWorker = (options = {}) => makeLayer(options, {
-	"cloudflare.resource_type": "worker",
-	"cloudflare.worker.name": options.workerName
-});
-/**
-* OTLP layer with Cloudflare Durable Object resource attributes.
-*
-* The layer reads {@link DurableObjectState} so it can optionally include the
-* Durable Object id. Prefer leaving `includeObjectId` disabled unless the
-* backend can tolerate high-cardinality resource attributes.
-*/
-const layerDurableObject = (options = {}) => Layer.unwrap(Effect.map(DurableObjectState, (state) => makeLayer(options, {
-	"cloudflare.resource_type": "durable_object",
-	"cloudflare.durable_object.class": options.className,
-	"cloudflare.durable_object.id": options.includeObjectId ? state.id.toString() : void 0
-})));
-//#endregion
-//#region src/CloudflareTracer.ts
-var CloudflareTracer_exports = /* @__PURE__ */ __exportAll({ layer: () => layer$11 });
-var Span = class extends Tracer.NativeSpan {
-	runInContext;
-	cloudflareSpan;
-	constructor(options, runInContext, cloudflareSpan) {
-		super({
-			...options,
-			sampled: options.sampled && (cloudflareSpan?.isTraced ?? false)
-		});
-		this.runInContext = runInContext;
-		this.cloudflareSpan = cloudflareSpan;
-	}
-	attribute(key, value) {
-		super.attribute(key, value);
-		if (Predicate.isString(value) || Predicate.isNumber(value) || Predicate.isBoolean(value)) this.cloudflareSpan?.setAttribute(key, value);
-	}
-	end(endTime, exit) {
-		if (this.status._tag === "Ended") return;
-		super.end(endTime, exit);
-		this.cloudflareSpan?.setAttribute("effect.exit", Exit.isSuccess(exit) ? "success" : Cause.hasInterruptsOnly(exit.cause) ? "interrupted" : "failure");
-		this.cloudflareSpan?.end();
-	}
-};
-/**
-* Sends Effect spans to Cloudflare Workers Observability using the runtime's
-* custom span API. Build this layer inside each invocation, for example with
-* `Worker.make(Services, { eventLayer: CloudflareTracer.layer, fetch })`.
-* It captures the invocation's async context and must not be cached across requests.
-*
-* Enable `observability.traces.enabled` in Wrangler. Cloudflare owns sampling
-* and export; no OTLP exporter or flush is required. Scalar attributes are
-* forwarded; other attributes, events, and links remain Effect-local. Completion
-* is recorded as `effect.exit`, since Cloudflare has no outcome-setting API.
-* Effect trace/span IDs remain independent of Cloudflare's opaque IDs. External
-* parents and `root: true` cannot override the invocation's Cloudflare trace.
-*/
-const layer$11 = Layer.effect(Tracer.Tracer, Effect.sync(() => {
-	const invocationContext = AsyncLocalStorage.snapshot();
-	const contextFor = (span) => {
-		while (span?._tag === "Span") {
-			if (span instanceof Span) return span.runInContext;
-			span = Option.getOrUndefined(span.parent);
-		}
-		return invocationContext;
-	};
-	return Tracer.make({
-		span(options) {
-			const parentContext = options.root ? invocationContext : contextFor(Option.getOrUndefined(options.parent));
-			if (!options.sampled) return new Span(options, parentContext);
-			return parentContext(() => tracing.startActiveSpan(options.name, (span) => new Span(options, AsyncLocalStorage.snapshot(), span)));
-		},
-		context(primitive, fiber) {
-			return contextFor(fiber.currentSpan)(() => primitive["~effect/Effect/evaluate"](fiber));
-		}
-	});
-}));
-//#endregion
-//#region src/ContainerNamespace.ts
-var ContainerNamespace_exports = /* @__PURE__ */ __exportAll({
-	ContainerNamespace: () => ContainerNamespace,
-	ContainerOperationError: () => ContainerOperationError,
-	ContainerState: () => ContainerState,
-	Tag: () => Tag$9,
-	isContainerNamespaceResource: () => isContainerNamespaceResource,
-	layer: () => layer$10,
-	make: () => make$10,
-	makeClient: () => makeClient$8
-});
-const expectedContainerNamespace = "Container namespace binding with getByName()";
-/** Serializable state reported by a Cloudflare Container instance. */
-const ContainerState = Schema.Union([Schema.Struct({
-	lastChange: Schema.Finite,
-	status: Schema.Literals([
-		"running",
-		"stopping",
-		"stopped",
-		"healthy"
-	])
-}), Schema.Struct({
-	lastChange: Schema.Finite,
-	status: Schema.Literal("stopped_with_code"),
-	exitCode: Schema.optionalKey(Schema.Int)
-})]);
-var ContainerOperationError = class extends Data.TaggedError("ContainerOperationError") {
-	get message() {
-		return `Container ${this.operation} failed for binding "${this.binding}" instance "${this.instance}": ${causeMessage(this.cause)}`;
-	}
-};
-const tryContainerPromise = (definition, instance, operation, evaluate) => Effect.tryPromise({
-	try: evaluate,
-	catch: (cause) => new ContainerOperationError({
-		binding: definition.binding,
-		instance,
-		operation,
-		cause
-	})
-});
-const makeInstanceClient = (definition, instance, stub) => {
-	const spanOptions = (operation) => ({ attributes: {
-		binding: definition.binding,
-		instance,
-		operation
-	} });
-	const hostListOperation = (operation) => Effect.fn(`ContainerNamespace.${operation}`, spanOptions(operation))(function* (hosts) {
-		return yield* tryContainerPromise(definition, instance, operation, () => stub[operation]([...hosts]));
-	});
-	const hostnameOperation = (operation) => Effect.fn(`ContainerNamespace.${operation}`, spanOptions(operation))(function* (hostname) {
-		return yield* tryContainerPromise(definition, instance, operation, () => stub[operation](hostname));
-	});
-	return {
-		rawUnsafe: Effect.succeed(stub),
-		state: tryContainerPromise(definition, instance, "state", () => stub.getState()).pipe(Effect.flatMap(Schema.decodeUnknownEffect(ContainerState)), Effect.mapError((cause) => cause instanceof ContainerOperationError ? cause : new ContainerOperationError({
-			binding: definition.binding,
-			instance,
-			operation: "state",
-			cause
-		})), Effect.withSpan("ContainerNamespace.state", spanOptions("state"))),
-		fetch: Effect.fn("ContainerNamespace.fetch", spanOptions("fetch"))(function* (input, init) {
-			return yield* tryContainerPromise(definition, instance, "fetch", () => stub.fetch(input, init));
-		}),
-		start: Effect.fn("ContainerNamespace.start", spanOptions("start"))(function* (options, waitOptions) {
-			return yield* tryContainerPromise(definition, instance, "start", () => stub.start(options, waitOptions));
-		}),
-		startAndWaitForPorts: Effect.fn("ContainerNamespace.startAndWaitForPorts", spanOptions("startAndWaitForPorts"))(function* (options) {
-			return yield* tryContainerPromise(definition, instance, "startAndWaitForPorts", () => stub.startAndWaitForPorts(options));
-		}),
-		waitForPort: Effect.fn("ContainerNamespace.waitForPort", spanOptions("waitForPort"))(function* (options) {
-			return yield* tryContainerPromise(definition, instance, "waitForPort", () => stub.waitForPort(options));
-		}),
-		stop: Effect.fn("ContainerNamespace.stop", spanOptions("stop"))(function* (signal) {
-			return yield* tryContainerPromise(definition, instance, "stop", () => stub.stop(signal));
-		}),
-		destroy: tryContainerPromise(definition, instance, "destroy", () => stub.destroy()).pipe(Effect.withSpan("ContainerNamespace.destroy", spanOptions("destroy"))),
-		setAllowedHosts: hostListOperation("setAllowedHosts"),
-		setDeniedHosts: hostListOperation("setDeniedHosts"),
-		allowHost: hostnameOperation("allowHost"),
-		denyHost: hostnameOperation("denyHost"),
-		removeAllowedHost: hostnameOperation("removeAllowedHost"),
-		removeDeniedHost: hostnameOperation("removeDeniedHost")
-	};
-};
-const isContainerNamespaceResource = (value) => Predicate.hasProperty(value, "getByName") && Predicate.isFunction(value.getByName);
-const makeClient$8 = (definition) => (namespace) => {
-	const getByName = (name, options) => Effect.try({
-		try: () => makeInstanceClient(definition, name, namespace.getByName(name, options)),
-		catch: (cause) => new ContainerOperationError({
-			binding: definition.binding,
-			instance: name,
-			operation: "getByName",
-			cause
-		})
-	});
-	const byName = (name, options) => {
-		const instance = getByName(name, options);
-		return {
-			rawUnsafe: Effect.flatMap(instance, (client) => client.rawUnsafe),
-			state: Effect.flatMap(instance, (client) => client.state),
-			fetch: (input, init) => Effect.flatMap(instance, (client) => client.fetch(input, init)),
-			start: (startOptions, waitOptions) => Effect.flatMap(instance, (client) => client.start(startOptions, waitOptions)),
-			startAndWaitForPorts: (startOptions) => Effect.flatMap(instance, (client) => client.startAndWaitForPorts(startOptions)),
-			waitForPort: (waitOptions) => Effect.flatMap(instance, (client) => client.waitForPort(waitOptions)),
-			stop: (signal) => Effect.flatMap(instance, (client) => client.stop(signal)),
-			destroy: Effect.flatMap(instance, (client) => client.destroy),
-			setAllowedHosts: (hosts) => Effect.flatMap(instance, (client) => client.setAllowedHosts(hosts)),
-			setDeniedHosts: (hosts) => Effect.flatMap(instance, (client) => client.setDeniedHosts(hosts)),
-			allowHost: (hostname) => Effect.flatMap(instance, (client) => client.allowHost(hostname)),
-			denyHost: (hostname) => Effect.flatMap(instance, (client) => client.denyHost(hostname)),
-			removeAllowedHost: (hostname) => Effect.flatMap(instance, (client) => client.removeAllowedHost(hostname)),
-			removeDeniedHost: (hostname) => Effect.flatMap(instance, (client) => client.removeDeniedHost(hostname))
-		};
-	};
-	return {
-		definition,
-		getByName,
-		byName,
-		rawUnsafe: Effect.succeed(namespace)
-	};
-};
-const layer$10 = (tag, definition) => layer$18(tag, definition.binding, (value) => isContainerNamespaceResource(value), makeClient$8(definition), { expected: expectedContainerNamespace });
-const make$10 = (id) => Tag$9()(id);
-const Tag$9 = () => (id) => {
-	const tag = Context.Service()(`effect-cf/Container/${id}`);
-	const makeLayer = (definition) => layer$10(tag, definition);
-	const getByName = Effect.fnUntraced(function* (name, options) {
-		return yield* (yield* tag).getByName(name, options);
-	});
-	const byName = (name, options) => ({
-		state: Effect.flatMap(getByName(name, options), (instance) => instance.state),
-		fetch: (input, init) => Effect.flatMap(getByName(name, options), (instance) => instance.fetch(input, init)),
-		start: (startOptions, waitOptions) => Effect.flatMap(getByName(name, options), (instance) => instance.start(startOptions, waitOptions)),
-		startAndWaitForPorts: (startOptions) => Effect.flatMap(getByName(name, options), (instance) => instance.startAndWaitForPorts(startOptions)),
-		waitForPort: (waitOptions) => Effect.flatMap(getByName(name, options), (instance) => instance.waitForPort(waitOptions)),
-		stop: (signal) => Effect.flatMap(getByName(name, options), (instance) => instance.stop(signal)),
-		destroy: Effect.flatMap(getByName(name, options), (instance) => instance.destroy),
-		setAllowedHosts: (hosts) => Effect.flatMap(getByName(name, options), (instance) => instance.setAllowedHosts(hosts)),
-		setDeniedHosts: (hosts) => Effect.flatMap(getByName(name, options), (instance) => instance.setDeniedHosts(hosts)),
-		allowHost: (hostname) => Effect.flatMap(getByName(name, options), (instance) => instance.allowHost(hostname)),
-		denyHost: (hostname) => Effect.flatMap(getByName(name, options), (instance) => instance.denyHost(hostname)),
-		removeAllowedHost: (hostname) => Effect.flatMap(getByName(name, options), (instance) => instance.removeAllowedHost(hostname)),
-		removeDeniedHost: (hostname) => Effect.flatMap(getByName(name, options), (instance) => instance.removeDeniedHost(hostname)),
-		rawUnsafe: Effect.flatMap(getByName(name, options), (instance) => instance.rawUnsafe)
-	});
-	const rawUnsafe = Effect.flatMap(tag, (namespace) => namespace.rawUnsafe);
-	return Object.assign(tag, {
-		id,
-		layer: makeLayer,
-		getByName,
-		byName,
-		rawUnsafe
-	});
-};
-const ContainerNamespace = Tag$9;
-//#endregion
-//#region src/D1.ts
-var D1_exports = /* @__PURE__ */ __exportAll({
-	Service: () => Service,
-	make: () => make$9
-});
-const TypeId$1 = "~effect-cf/D1";
-const expectedD1Database = "D1 database binding with prepare(), batch(), and exec()";
-const isD1Database = (value) => Predicate.hasProperty(value, "prepare") && Predicate.isFunction(value.prepare) && Predicate.hasProperty(value, "batch") && Predicate.isFunction(value.batch) && Predicate.hasProperty(value, "exec") && Predicate.isFunction(value.exec);
-const make$9 = (id, definition) => Service()(id, definition);
-const Service = () => (id, definition) => {
-	const tag = Service$1()(id, definition.binding, isD1Database, void 0, { expected: expectedD1Database });
-	const sqlLayer = (options) => Layer.unwrap(Effect.gen(function* () {
-		const db = yield* tag;
-		return D1Client.layer({
-			...options,
-			db
-		});
-	})).pipe(Layer.provide(tag.layer));
-	return Object.assign(tag, {
-		[TypeId$1]: TypeId$1,
-		definition,
-		sqlLayer
-	});
-};
-//#endregion
-//#region src/DurableObjectNamespace.ts
-var DurableObjectNamespace_exports = /* @__PURE__ */ __exportAll({
-	DurableObjectFetchError: () => DurableObjectFetchError,
-	DurableObjectRpcError: () => DurableObjectRpcError,
-	isDurableObjectNamespaceClient: () => isDurableObjectNamespaceClient,
-	layer: () => layer$9,
-	makeClient: () => makeClient$7,
-	makeDirectMethods: () => makeDirectMethods
-});
-const expectedDurableObjectNamespace = "Durable Object namespace binding with getByName(), get(), idFromName(), idFromString(), newUniqueId(), and jurisdiction()";
-/**
-* Failure raised when invoking an RPC method on a Durable Object stub.
-*/
-var DurableObjectRpcError = class extends Data.TaggedError("DurableObjectRpcError") {
-	get message() {
-		return `Durable Object RPC method "${this.method}" failed for binding "${this.binding}": ${causeMessage(this.cause)}`;
-	}
-};
-/**
-* Failure raised when forwarding a request to a Durable Object stub.
-*/
-var DurableObjectFetchError = class extends Data.TaggedError("DurableObjectFetchError") {
-	get message() {
-		return `Durable Object fetch failed for binding "${this.binding}": ${causeMessage(this.cause)}`;
-	}
-};
-const hasFunction$1 = (value, key) => Predicate.hasProperty(value, key) && Predicate.isFunction(value[key]);
-const isDurableObjectNamespaceClient = (value) => hasFunction$1(value, "getByName") && hasFunction$1(value, "get") && hasFunction$1(value, "idFromName") && hasFunction$1(value, "idFromString") && hasFunction$1(value, "newUniqueId") && hasFunction$1(value, "jurisdiction");
-const makeClient$7 = (definition) => {
-	return (namespace) => {
-		const newUniqueId = (options) => Effect.sync(() => namespace.newUniqueId(options));
-		const idFromName = (name) => Effect.sync(() => namespace.idFromName(name));
-		const idFromString = (id) => Effect.sync(() => namespace.idFromString(id));
-		const get = (id, options) => Effect.sync(() => namespace.get(id, options));
-		const getByName = (name, options) => Effect.sync(() => namespace.getByName(name, options));
-		const jurisdiction = (value) => Effect.sync(() => namespace.jurisdiction(value));
-		const fetch = (stub, input, init) => Effect.tryPromise({
-			try: (signal) => {
-				const callerSignal = init?.signal !== void 0 ? init.signal : input instanceof Request ? input.signal : void 0;
-				return stub.fetch(input, {
-					...init,
-					signal: callerSignal === null || callerSignal === void 0 ? signal : AbortSignal.any([callerSignal, signal])
-				});
-			},
-			catch: (cause) => new DurableObjectFetchError({
-				binding: definition.binding,
-				cause
-			})
-		});
-		const rpc = Effect.fnUntraced(function* (stub, method, ...args) {
-			const methodName = String(method);
-			const encodedArgs = definition.definition === void 0 ? args : yield* encodeArgs(definition.definition, methodName, args).pipe(Effect.mapError((cause) => new DurableObjectRpcError({
-				binding: definition.binding,
-				method: methodName,
-				cause
-			})));
-			const nativeArgs = definition.rpcTracing ? yield* withRpcTraceContext(encodedArgs) : encodedArgs;
-			return yield* invokeRpcMethod(stub, method, nativeArgs, (cause) => new DurableObjectRpcError({
-				binding: definition.binding,
-				method: methodName,
-				cause
-			}));
-		});
-		const decodeSuccess$1 = Effect.fnUntraced(function* (methodName, value) {
-			if (definition.definition === void 0) return value;
-			return yield* decodeSuccess(definition.definition, methodName, value).pipe(Effect.mapError((cause) => new DurableObjectRpcError({
-				binding: definition.binding,
-				method: methodName,
-				cause
-			})));
-		});
-		const call = Effect.fnUntraced(function* (stub, method, ...args) {
-			const methodName = String(method);
-			const value = yield* resolve(yield* rpc(stub, method, ...args)).pipe(Effect.mapError((cause) => new DurableObjectRpcError({
-				binding: definition.binding,
-				method: methodName,
-				cause
-			})));
-			return yield* decodeSuccess$1(methodName, value);
-		}, (effect, ...args) => withRpcClientSpan(effect, definition.binding, String(args[1])));
-		const scopedCall = Effect.fnUntraced(function* (stub, method, ...args) {
-			const methodName = String(method);
-			const result = yield* rpc(stub, method, ...args);
-			const value = yield* scoped(result).pipe(Effect.mapError((cause) => new DurableObjectRpcError({
-				binding: definition.binding,
-				method: methodName,
-				cause
-			})));
-			return yield* decodeSuccess$1(methodName, value);
-		}, (effect, ...args) => withRpcClientSpan(effect, definition.binding, String(args[1])));
-		const directMethods = makeDirectMethods(definition.definition, {
-			call,
-			fetch,
-			get,
-			getByName
-		});
-		return Object.assign(directMethods, {
-			newUniqueId,
-			idFromName,
-			idFromString,
-			get,
-			getByName,
-			jurisdiction,
-			fetch,
-			rpc,
-			call,
-			scopedCall,
-			rawUnsafe: Effect.succeed(namespace)
-		});
-	};
-};
-const layer$9 = (tag, definition) => layer$18(tag, definition.binding, (value) => isDurableObjectNamespaceClient(value), makeClient$7(definition), { expected: expectedDurableObjectNamespace });
-const makeDirectMethods = (rpcDefinition, helpers) => {
-	const methods = {};
-	if (rpcDefinition !== void 0) {
-		for (const methodName of Object.keys(rpcDefinition.methods)) methods[methodName] = (stub, ...args) => helpers.call(stub, methodName, ...args);
-		const makeClient = (getStub) => {
-			const client = { fetch: (input, init) => Effect.gen(function* () {
-				const stub = yield* getStub();
-				return yield* helpers.fetch(stub, input, init);
-			}) };
-			for (const methodName of Object.keys(rpcDefinition.methods)) client[methodName] = (...args) => Effect.gen(function* () {
-				const stub = yield* getStub();
-				return yield* helpers.call(stub, methodName, ...args);
-			});
-			return client;
-		};
-		methods.byName = (name, options) => makeClient(() => helpers.getByName(name, options));
-		methods.byId = (id, options) => makeClient(() => helpers.get(id, options));
-	}
-	return methods;
-};
-//#endregion
-//#region src/DurableObjectDefinition.ts
-var DurableObjectDefinition_exports = /* @__PURE__ */ __exportAll({
-	DurableObject: () => DurableObject$1,
-	Tag: () => Tag$8,
-	implement: () => implement$2,
-	make: () => make$8,
-	method: () => method
-});
-const reservedMethodNames$1 = /* @__PURE__ */ new Set([
-	"constructor",
-	"dup",
-	"fetch",
-	"alarm",
-	"webSocketMessage",
-	"webSocketClose",
-	"webSocketError"
-]);
-function method(definition) {
-	return method$1(definition);
-}
-const makeDefinition$2 = (id, methods) => {
-	assertNoReservedMethods("Durable Object", methods, reservedMethodNames$1);
-	const definition = make$15(id, methods);
-	return Object.assign(definition, { make: (layer, options) => make$7(layer, {
-		...options,
-		rpc: wrapHandlers(definition, options.rpc)
-	}) });
-};
-const make$8 = (id, methods) => Tag$8()(id, methods);
-const Tag$8 = () => (id, methods) => {
-	const definition = makeDefinition$2(id, methods);
-	const serviceKey = `effect-cf/DurableObject/${id}`;
-	const tag = Context.Service()(serviceKey);
-	const bindingDefinition = (binding) => ({
-		...binding,
-		definition
-	});
-	const layer = (binding) => layer$9(tag, bindingDefinition(binding));
-	const newUniqueId = Effect.fn("DurableObject.newUniqueId")(function* (options) {
-		return yield* (yield* tag).newUniqueId(options);
-	});
-	const idFromName = Effect.fn("DurableObject.idFromName")(function* (name) {
-		return yield* (yield* tag).idFromName(name);
-	});
-	const idFromString = Effect.fn("DurableObject.idFromString")(function* (value) {
-		return yield* (yield* tag).idFromString(value);
-	});
-	const get = Effect.fn("DurableObject.get")(function* (objectId, options) {
-		return yield* (yield* tag).get(objectId, options);
-	});
-	const getByName = Effect.fn("DurableObject.getByName")(function* (name, options) {
-		return yield* (yield* tag).getByName(name, options);
-	});
-	const jurisdiction = Effect.fn("DurableObject.jurisdiction")(function* (value) {
-		return yield* (yield* tag).jurisdiction(value);
-	});
-	const fetch = Effect.fn("DurableObject.fetch")(function* (stub, input, init) {
-		return yield* (yield* tag).fetch(stub, input, init);
-	});
-	const rpc = Effect.fnUntraced(function* (stub, methodName, ...args) {
-		const invokeRpc = (yield* tag).rpc;
-		return yield* invokeRpc(stub, methodName, ...args);
-	});
-	const call = Effect.fnUntraced(function* (stub, methodName, ...args) {
-		const invokeCall = (yield* tag).call;
-		return yield* invokeCall(stub, methodName, ...args);
-	});
-	const scopedCall = Effect.fnUntraced(function* (stub, methodName, ...args) {
-		const invokeScopedCall = (yield* tag).scopedCall;
-		return yield* invokeScopedCall(stub, methodName, ...args);
-	});
-	const rawUnsafe = Effect.fnUntraced(function* () {
-		return yield* (yield* tag).rawUnsafe;
-	});
-	const directMethods = makeDirectMethods(definition, {
-		call,
-		fetch,
-		get,
-		getByName
-	});
-	return Object.assign(tag, directMethods, {
-		id: definition.id,
-		methods: definition.methods,
-		make: definition.make,
-		layer,
-		newUniqueId,
-		idFromName,
-		idFromString,
-		get,
-		getByName,
-		jurisdiction,
-		fetch,
-		rpc,
-		call,
-		scopedCall,
-		rawUnsafe
-	});
-};
-const DurableObject$1 = Tag$8;
-const wrapHandlers = (definition, handlers) => {
-	const wrapped = Object.create(Object.prototype);
-	for (const key of Object.keys(definition.methods)) {
-		const handler = handlers[key];
-		wrapped[key] = (...args) => Effect.gen(function* () {
-			const decodedArgs = yield* decodeArgs(definition, key, args);
-			yield* recordDecodedArgs(decodedArgs);
-			const value = yield* handler(...decodedArgs);
-			return yield* encodeSuccess(definition, key, value);
-		});
-	}
-	return wrapped;
-};
-/**
-* Helper for implementing handlers with the exact method shape of a definition.
-*/
-const implement$2 = (_definition, handlers) => handlers;
-//#endregion
-//#region src/DurableObject.ts
-var DurableObject_exports = /* @__PURE__ */ __exportAll({
-	RunSymbol: () => RunSymbol,
-	Tag: () => Tag$8,
-	implement: () => implement$2,
-	make: () => make$7,
-	method: () => method
-});
-const reservedMethodNames = reservedMethodNames$2;
-/** Override to instrument the whole event, then call super[RunSymbol]. */
-const RunSymbol = Symbol.for("effect-cf/DurableObject/run");
-const scheduleTelemetryFlush = scheduleTelemetryFlush$1((flush) => Effect.flatMap(DurableObjectState, (state) => state.waitUntil(flush)));
-/**
-* Builds a Durable Object whose base `layer` lives for the in-memory instance.
-* Cloudflare does not expose an eviction or shutdown hook, so finalizers in
-* that layer are not guaranteed to run. Put resources that require timely
-* release in `eventLayer`, whose scope closes after each handled event.
-*/
-const make$7 = (layer, options = {}) => {
-	class EffectDurableObject extends DurableObject {
-		runtime;
-		constructor(state, env) {
-			super(state, env);
-			this.runtime = makeEntrypointRuntime(layer, env, Layer.succeed(DurableObjectState, fromDurableObjectState(state)));
-			const initialize = options.initialize;
-			if (initialize !== void 0) state.waitUntil(this[RunSymbol](initialize, { eventLayer: false }));
-		}
-		[RunSymbol](effect, runOptions = {}) {
-			const eventLayer = runOptions.eventLayer === false ? void 0 : options.eventLayer;
-			const parent = runOptions.rpc?.parent;
-			const parentSpan = parent === void 0 ? void 0 : Tracer.externalSpan(parent);
-			if (eventLayer === void 0) return runEventPromise(this.runtime, effect, void 0, parentSpan);
-			return runEventPromise(this.runtime, effect, eventLayer, parentSpan);
-		}
-		fetch(request) {
-			const fetchHandler = options.fetch;
-			if (fetchHandler === void 0) return Promise.resolve(new Response("Not Found", { status: 404 }));
-			return this[RunSymbol](Effect.provideService(fetchHandler, NativeRequest, request), { event: "fetch" });
-		}
-		alarm(alarmInfo) {
-			const logicalAlarms = options.alarms?.pipe(Effect.asVoid);
-			const rawAlarm = options.alarm?.(alarmInfo);
-			const alarmEffect = logicalAlarms !== void 0 && rawAlarm !== void 0 ? Effect.gen(function* () {
-				yield* logicalAlarms;
-				yield* rawAlarm;
-			}) : logicalAlarms ?? rawAlarm;
-			if (alarmEffect !== void 0) return this[RunSymbol](alarmEffect.pipe(Effect.onExit(() => scheduleTelemetryFlush)), { event: "alarm" });
-		}
-		webSocketMessage(socket, message) {
-			if (options.webSocketMessage !== void 0) return this[RunSymbol](options.webSocketMessage(fromWebSocket(socket), message), { event: "webSocketMessage" });
-		}
-		webSocketClose(socket, code, reason, wasClean) {
-			if (options.webSocketClose !== void 0) return this[RunSymbol](options.webSocketClose(fromWebSocket(socket), code, reason, wasClean), { event: "webSocketClose" });
-		}
-		webSocketError(socket, cause) {
-			if (options.webSocketError !== void 0) return this[RunSymbol](options.webSocketError(fromWebSocket(socket), cause), { event: "webSocketError" });
-		}
-	}
-	defineEntrypointRpcMethods("Durable Object", EffectDurableObject.prototype, options.rpc, reservedMethodNames, (self, effect, rpc) => self[RunSymbol](effect, {
-		event: "rpc",
-		rpc
-	}), () => scheduleTelemetryFlush, options.rpcTracing);
-	return assumeEntrypointClass(EffectDurableObject);
-};
-//#endregion
-//#region src/DurableObjectAlarm.ts
-var DurableObjectAlarm_exports = /* @__PURE__ */ __exportAll({
-	DurableObjectAlarm: () => DurableObjectAlarm,
-	DurableObjectAlarmEvent: () => DurableObjectAlarmEvent,
-	InvalidAlarmPayloadError: () => InvalidAlarmPayloadError,
-	InvalidAlarmRefError: () => InvalidAlarmRefError,
-	InvalidProcessDueAlarmsOptionsError: () => InvalidProcessDueAlarmsOptionsError,
-	InvalidRepeatEveryError: () => InvalidRepeatEveryError,
-	StoredAlarmDecodeError: () => StoredAlarmDecodeError,
-	define: () => define,
-	processDue: () => processDue
-});
-const INIT_TABLE_SQL = `
-CREATE TABLE IF NOT EXISTS effect_cf_scheduled_alarms (
-  storage_id TEXT PRIMARY KEY,
-  alarm_id TEXT NOT NULL,
-  tag TEXT NOT NULL,
-  run_at INTEGER NOT NULL,
-  repeat_every_ms INTEGER,
-  payload TEXT NOT NULL
-);
-CREATE INDEX IF NOT EXISTS idx_effect_cf_scheduled_alarms_run_at_storage_id
-  ON effect_cf_scheduled_alarms (run_at, storage_id);
-`;
-const DEFAULT_PROCESS_DUE_ALARMS_LIMIT = 100;
-const DEFAULT_PROCESS_DUE_ALARMS_FAILURE_RESCHEDULE_AFTER = "30 seconds";
-const getScheduledEventId = (input) => `effect-cf-alarm:${encodeURIComponent(input.tag)}:${encodeURIComponent(input.id)}`;
-var InvalidAlarmRefError = class extends Data.TaggedError("InvalidAlarmRefError") {
-	get message() {
-		return `Invalid Durable Object alarm ref: ${causeMessage(this.cause)}`;
-	}
-};
-var InvalidAlarmPayloadError = class extends Data.TaggedError("InvalidAlarmPayloadError") {
-	get message() {
-		return `Invalid Durable Object alarm payload: ${causeMessage(this.cause)}`;
-	}
-};
-var InvalidRepeatEveryError = class extends Data.TaggedError("InvalidRepeatEveryError") {
-	get message() {
-		return `Invalid Durable Object alarm repeatEvery: ${causeMessage(this.cause)}`;
-	}
-};
-var InvalidProcessDueAlarmsOptionsError = class extends Data.TaggedError("InvalidProcessDueAlarmsOptionsError") {
-	get message() {
-		return `Invalid processDueAlarms options: ${causeMessage(this.cause)}`;
-	}
-};
-var StoredAlarmDecodeError = class extends Data.TaggedError("StoredAlarmDecodeError") {
-	get message() {
-		return `Failed to decode stored alarm "${this.storageId}": ${causeMessage(this.cause)}`;
-	}
-};
-const DurableObjectAlarmEvent = Schema.TaggedUnion({ AlarmDue: {
-	id: Schema.NonEmptyString,
-	payload: Schema.Json,
-	/** Persisted due time, which can differ from the invocation time during retries. */
-	scheduledAt: Schema.DateTimeUtc,
-	tag: Schema.NonEmptyString
-} });
-const AlarmRefSchema = Schema.Struct({
-	id: Schema.NonEmptyString,
-	tag: Schema.NonEmptyString
-});
-const decodeAlarmRef = (input) => Schema.decodeUnknownEffect(AlarmRefSchema)(input).pipe(Effect.mapError((cause) => new InvalidAlarmRefError({ cause })));
-const StoredPayloadString = Schema.fromJsonString(Schema.Json);
-const decodeStoredPayload = (row) => Schema.decodeUnknownEffect(StoredPayloadString)(row.payload).pipe(Effect.mapError((cause) => new StoredAlarmDecodeError({
-	cause,
-	storageId: row.storage_id
-})));
-const encodeStoredPayload = (payload) => Schema.encodeEffect(StoredPayloadString)(payload).pipe(Effect.mapError((cause) => new InvalidAlarmPayloadError({ cause })));
-const ensureTable = (state) => state.storage.sql.exec(INIT_TABLE_SQL).pipe(Effect.asVoid);
-const toRepeatEveryMillis = (input) => {
-	if (input === void 0) return Effect.succeed(null);
-	return Effect.try({
-		try: () => {
-			const millis = Duration.toMillis(input);
-			if (!Number.isFinite(millis) || millis <= 0) throw new Error("Alarm repeatEvery must be a positive finite duration");
-			return Math.ceil(millis);
-		},
-		catch: (cause) => new InvalidRepeatEveryError({ cause })
-	});
-};
-const toAlarmDue = (row) => Effect.gen(function* () {
-	if (!Number.isFinite(row.run_at)) return yield* Effect.fail(new StoredAlarmDecodeError({
-		cause: /* @__PURE__ */ new Error("Stored alarm run_at must be a finite number"),
-		storageId: row.storage_id
-	}));
-	return DurableObjectAlarmEvent.make({
-		_tag: "AlarmDue",
-		id: row.alarm_id,
-		payload: yield* decodeStoredPayload(row),
-		scheduledAt: DateTime.makeUnsafe(row.run_at),
-		tag: row.tag
-	});
-});
-const getProcessLimit = (options) => {
-	const limit = options?.limit ?? DEFAULT_PROCESS_DUE_ALARMS_LIMIT;
-	if (!Number.isSafeInteger(limit) || limit <= 0) return Effect.fail(new InvalidProcessDueAlarmsOptionsError({ cause: /* @__PURE__ */ new Error("processDueAlarms limit must be a positive safe integer") }));
-	return Effect.succeed(limit);
-};
-const toFailureRescheduleMillis = (input) => Effect.try({
-	try: () => {
-		const millis = Duration.toMillis(input);
-		if (!Number.isFinite(millis) || millis <= 0) throw new Error("Alarm failure rescheduleAfter must be a positive finite duration");
-		return Math.ceil(millis);
-	},
-	catch: (cause) => new InvalidProcessDueAlarmsOptionsError({ cause })
-});
-const getFailureRetryDelay = (options) => toFailureRescheduleMillis(options?.retryFailedAfter ?? DEFAULT_PROCESS_DUE_ALARMS_FAILURE_RESCHEDULE_AFTER);
-const getFailureActionMode = (action) => Predicate.isString(action) ? action : action.mode;
-const getFailureActionRetryDelay = (action) => Predicate.isString(action) || action.mode !== "retry" ? void 0 : action.retryFailedAfter;
-const processDue = (handle, options = {}) => Effect.gen(function* () {
-	return yield* (yield* DurableObjectAlarm).processDueAlarms(handle, options);
-});
-const isAlarmDefinitionConfig = (definition) => Predicate.isObject(definition) && "payload" in definition;
-const getAlarmDefinitionSchema = (definition) => isAlarmDefinitionConfig(definition) ? definition.payload : definition;
-const getAlarmDefinitionFailureAction = (definition) => {
-	if (definition === void 0 || !isAlarmDefinitionConfig(definition)) return;
-	if (definition.failure === void 0) return;
-	return definition.failure === "retry" ? {
-		mode: "retry",
-		retryFailedAfter: definition.retry?.initialDelay
-	} : { mode: definition.failure };
-};
-const define = (definitions) => ({ handlers: (handlers, options) => processDue((event) => Effect.gen(function* () {
-	const definition = definitions[event.tag];
-	if (definition === void 0) return;
-	const schema = getAlarmDefinitionSchema(definition);
-	const payload = yield* Schema.decodeUnknownEffect(schema)(event.payload).pipe(Effect.mapError((cause) => new StoredAlarmDecodeError({
-		cause,
-		storageId: getScheduledEventId(event)
-	})));
-	const handler = handlers[event.tag];
-	yield* handler({
-		...event,
-		payload
-	});
-}), {
-	...options,
-	onFailure: (failure) => Effect.gen(function* () {
-		const action = getAlarmDefinitionFailureAction(definitions[failure.tag]);
-		const optionAction = options?.onFailure === void 0 ? void 0 : yield* options.onFailure(failure);
-		return action ?? optionAction;
-	})
-}) });
-var DurableObjectAlarm = class DurableObjectAlarm extends Context.Service()("effect-cf/DurableObjectAlarm") {
-	static layer = Layer.effect(DurableObjectAlarm, Effect.gen(function* () {
-		const state = yield* DurableObjectState;
-		const reconcileAlarm = Effect.fn("DurableObjectAlarm.reconcileAlarm")(function* () {
-			const next = (yield* (yield* state.storage.sql.exec(`SELECT run_at FROM effect_cf_scheduled_alarms ORDER BY run_at ASC, storage_id ASC LIMIT 1`)).toArray())[0];
-			if (next === void 0) {
-				yield* state.storage.deleteAlarm();
-				return;
-			}
-			yield* state.storage.setAlarm(next.run_at);
-		});
-		const rescheduleFailedAlarm = Effect.fn("DurableObjectAlarm.rescheduleFailedAlarm")(function* (row, retryDelayMillis) {
-			const retryAt = (yield* Clock.currentTimeMillis) + retryDelayMillis;
-			if (row.repeat_every_ms === null) {
-				yield* (yield* state.storage.sql.exec(`UPDATE effect_cf_scheduled_alarms
-                  SET run_at = ?
-                WHERE storage_id = ?
-                  AND run_at = ?
-                  AND repeat_every_ms IS NULL
-                  AND payload = ?`, retryAt, row.storage_id, row.run_at, row.payload)).rowsWritten;
-				return;
-			}
-			yield* (yield* state.storage.sql.exec(`UPDATE effect_cf_scheduled_alarms
-                SET run_at = ?
-              WHERE storage_id = ?
-                AND run_at = ?
-                AND repeat_every_ms = ?
-                AND payload = ?`, retryAt, row.storage_id, row.run_at, row.repeat_every_ms, row.payload)).rowsWritten;
-		});
-		const acknowledgeAlarm = Effect.fn("DurableObjectAlarm.acknowledgeAlarm")(function* (row) {
-			if (row.repeat_every_ms === null) {
-				yield* (yield* state.storage.sql.exec(`DELETE FROM effect_cf_scheduled_alarms
-              WHERE storage_id = ?
-                AND run_at = ?
-                AND repeat_every_ms IS NULL
-                AND payload = ?`, row.storage_id, row.run_at, row.payload)).rowsWritten;
-				return;
-			}
-			const acknowledgedAt = yield* Clock.currentTimeMillis;
-			yield* (yield* state.storage.sql.exec(`UPDATE effect_cf_scheduled_alarms
-              SET run_at = ?
-            WHERE storage_id = ?
-              AND run_at = ?
-              AND repeat_every_ms = ?
-              AND payload = ?`, acknowledgedAt + row.repeat_every_ms, row.storage_id, row.run_at, row.repeat_every_ms, row.payload)).rowsWritten;
-		});
-		const cancelAlarm = Effect.fn("DurableObjectAlarm.cancelAlarm")(function* (input) {
-			const ref = yield* decodeAlarmRef(input);
-			yield* state.storage.sql.exec(`DELETE FROM effect_cf_scheduled_alarms WHERE storage_id = ?`, getScheduledEventId(ref));
-		});
-		const scheduleAlarm = Effect.fn("DurableObjectAlarm.scheduleAlarm")(function* (input) {
-			const ref = yield* decodeAlarmRef(input);
-			const repeatEveryMillis = yield* toRepeatEveryMillis(input.repeatEvery);
-			const payload = yield* encodeStoredPayload(input.payload);
-			const runAt = DateTime.toEpochMillis(input.runAt);
-			yield* state.storage.sql.exec(`INSERT OR REPLACE INTO effect_cf_scheduled_alarms
-                   (storage_id, alarm_id, tag, run_at, repeat_every_ms, payload)
-                 VALUES (?, ?, ?, ?, ?, ?)`, getScheduledEventId(ref), ref.id, ref.tag, runAt, repeatEveryMillis, payload);
-		});
-		const transaction = (closure) => state.storage.transaction(() => Effect.withFiber((owner) => {
-			let active = true;
-			const requireActive = (effect) => Effect.withFiber((fiber) => active && fiber === owner ? effect : Effect.fail(new StorageOperationError({
-				operation: "alarm.transaction",
-				cause: /* @__PURE__ */ new Error("Alarm mutations require their active transaction callback")
-			})));
-			return Effect.gen(function* () {
-				yield* ensureTable(state);
-				const result = yield* Effect.suspend(() => closure({
-					cancelAlarm: (input) => requireActive(cancelAlarm(input)),
-					scheduleAlarm: (input) => requireActive(scheduleAlarm(input))
-				})).pipe(Effect.ensuring(Effect.sync(() => {
-					active = false;
-				})));
-				yield* reconcileAlarm();
-				return result;
-			});
-		}));
-		const processDueAlarms = Effect.fn("DurableObjectAlarm.processDueAlarms")(function* (handle, options) {
-			yield* ensureTable(state);
-			const mode = options?.mode ?? "isolated";
-			const limit = yield* getProcessLimit(options);
-			const now = yield* Clock.currentTimeMillis;
-			const dueRows = yield* (yield* state.storage.sql.exec(`SELECT storage_id, alarm_id, tag, run_at, repeat_every_ms, payload
-             FROM effect_cf_scheduled_alarms
-            WHERE run_at <= ?
-            ORDER BY run_at ASC, storage_id ASC
-            LIMIT ?`, now, limit)).toArray();
-			const handled = [];
-			const failed = [];
-			const handleFailure = function* (row, event, cause) {
-				const failure = {
-					cause,
-					event,
-					id: row.alarm_id,
-					storageId: row.storage_id,
-					tag: row.tag
-				};
-				failed.push(failure);
-				const failureAction = options?.onFailure === void 0 ? void 0 : yield* options.onFailure(failure);
-				const actionMode = failureAction === void 0 ? mode : getFailureActionMode(failureAction);
-				if (actionMode === "retry" || actionMode === "isolated") {
-					const actionRetryDelay = failureAction === void 0 ? void 0 : getFailureActionRetryDelay(failureAction);
-					const retryDelay = actionRetryDelay === void 0 ? yield* getFailureRetryDelay(options) : yield* toFailureRescheduleMillis(actionRetryDelay);
-					yield* rescheduleFailedAlarm(row, retryDelay);
-					return "continue";
-				}
-				if (actionMode === "skip-and-advance-repeat") {
-					yield* acknowledgeAlarm(row);
-					return "continue";
-				}
-				yield* reconcileAlarm();
-				return "stop";
-			};
-			for (const row of dueRows) {
-				const eventExit = yield* Effect.exit(toAlarmDue(row));
-				if (Exit.isFailure(eventExit)) {
-					if ((yield* handleFailure(row, void 0, eventExit.cause)) === "stop") return yield* Effect.failCause(eventExit.cause);
-					continue;
-				}
-				const event = eventExit.value;
-				const handleExit = yield* Effect.exit(handle(event));
-				if (Exit.isFailure(handleExit)) {
-					if ((yield* handleFailure(row, event, handleExit.cause)) === "stop") return yield* Effect.failCause(handleExit.cause);
-					continue;
-				}
-				yield* acknowledgeAlarm(row);
-				handled.push(event);
-			}
-			yield* reconcileAlarm();
-			return {
-				failed,
-				handled
-			};
-		});
-		return DurableObjectAlarm.of({
-			cancelAlarm: (input) => transaction((alarms) => alarms.cancelAlarm(input)),
-			processDueAlarms,
-			scheduleAlarm: (input) => transaction((alarms) => alarms.scheduleAlarm(input)),
-			transaction
-		});
-	}).pipe(Effect.withSpan("DurableObjectAlarm.layer")));
-};
-//#endregion
-//#region src/DurableObjectRpcWebSocket.ts
-var DurableObjectRpcWebSocket_exports = /* @__PURE__ */ __exportAll({
-	DurableObjectRpcWebSocket: () => DurableObjectRpcWebSocket,
-	layer: () => layer$8,
-	resumableStream: () => resumableStream
-});
-const defaultAttachmentKey = "effectCloudflareRpcClientId";
-const defaultTag = "effect-cf-rpc";
-const legacyAttachmentVersion = 1;
-const resumableAttachmentVersion = 2;
-const serviceRestartCode = 1012;
-const serviceRestartReason = "Durable Object RPC activation reset";
-/** Declares an explicitly resumable RPC stream. */
-const resumableStream = (declaration) => declaration;
-const PersistedPendingBatchSchema = Schema.Struct({ checkpointTokens: Schema.Array(Schema.String) });
-const PersistedSubscriptionSchema = Schema.Struct({
-	definitionId: Schema.String,
-	subscriptionKey: Schema.String,
-	requestId: Schema.Union([Schema.String, Schema.Finite]),
-	rpcTag: Schema.String,
-	resumeDescriptor: Schema.Unknown,
-	acknowledgedCheckpoint: Schema.Unknown,
-	pending: Schema.optionalKey(PersistedPendingBatchSchema)
-});
-const ResumableAttachmentMetadataSchema = Schema.Struct({
-	version: Schema.Literal(resumableAttachmentVersion),
-	clientId: Schema.Finite,
-	hasPendingRequests: Schema.Boolean,
-	hasNonResumableRequests: Schema.Boolean,
-	subscriptions: Schema.Array(PersistedSubscriptionSchema)
-});
-const decodeResumableAttachment = Schema.decodeUnknownOption(ResumableAttachmentMetadataSchema);
-var DurableObjectRpcWebSocket = class extends Context.Service()("effect-cf/DurableObjectRpcWebSocket") {};
-/**
-* Builds a hibernation-aware transport that bridges Durable Object websocket
-* events to `RpcServer.Protocol`.
-*
-* The layer restores idle tagged sockets and explicitly declared resumable
-* streams after constructor recreation. A socket that lost any other in-flight
-* request is closed with code 1012, which the stock Effect socket protocol
-* reports as an `RpcClientError` containing `SocketCloseError`.
-*/
-const layer$8 = (options = {}) => Layer.effectContext(Effect.gen(function* () {
-	const tag = options.tag ?? defaultTag;
-	const attachmentKey = options.attachmentKey ?? defaultAttachmentKey;
-	const heartbeatPolicy = options.heartbeat ?? "auto-response";
-	const declarations = options.resumableStreams ?? [];
-	const durableObjectState = yield* DurableObjectState;
-	const serialization = yield* RpcSerialization.RpcSerialization;
-	const encodeDefect = Schema.encodeSync(serialization.codecFor(Schema.Defect()));
-	const disconnects = yield* Queue.make();
-	const connectionsBySocket = /* @__PURE__ */ new Map();
-	const connectionsById = /* @__PURE__ */ new Map();
-	const resetSockets = /* @__PURE__ */ new WeakSet();
-	const declarationsById = /* @__PURE__ */ new Map();
-	const declarationsByTag = /* @__PURE__ */ new Map();
-	const replayRequests = [];
-	let nextClientId = 0;
-	let activeNonResumableRequestCount = 0;
-	let writeRequest;
-	for (const declaration of declarations) {
-		if (declaration.id.length === 0 || declaration.rpcTag.length === 0) return yield* Effect.die(/* @__PURE__ */ new Error("Resumable RPC stream declaration ids and tags must be non-empty"));
-		if (declarationsById.has(declaration.id)) return yield* Effect.die(/* @__PURE__ */ new Error(`Duplicate resumable RPC stream declaration id: ${declaration.id}`));
-		if (declarationsByTag.has(declaration.rpcTag)) return yield* Effect.die(/* @__PURE__ */ new Error(`Duplicate resumable RPC stream tag: ${declaration.rpcTag}`));
-		declarationsById.set(declaration.id, declaration);
-		declarationsByTag.set(declaration.rpcTag, declaration);
-	}
-	const reserveClientId = (socket) => {
-		const id = nextClientId++;
-		const created = {
-			version: legacyAttachmentVersion,
-			clientId: id,
-			hasPendingRequests: false
-		};
-		writeAttachment(socket.raw, attachmentKey, created);
-		return created;
-	};
-	const addSubscription = (connection, subscription) => {
-		if (connection.subscriptionsByRequestId.has(subscription.requestId)) return false;
-		let byKey = connection.subscriptionsByDefinition.get(subscription.definitionId);
-		if (byKey?.has(subscription.subscriptionKey) === true) return false;
-		if (byKey === void 0) {
-			byKey = /* @__PURE__ */ new Map();
-			connection.subscriptionsByDefinition.set(subscription.definitionId, byKey);
-		}
-		byKey.set(subscription.subscriptionKey, subscription);
-		connection.subscriptionsByRequestId.set(subscription.requestId, subscription);
-		connection.requestIds.add(subscription.requestId);
-		connection.metadataVersion = resumableAttachmentVersion;
-		return true;
-	};
-	const removeSubscription = (connection, requestId) => {
-		const subscription = connection.subscriptionsByRequestId.get(requestId);
-		if (subscription === void 0) return;
-		connection.subscriptionsByRequestId.delete(requestId);
-		const byKey = connection.subscriptionsByDefinition.get(subscription.definitionId);
-		byKey?.delete(subscription.subscriptionKey);
-		if (byKey?.size === 0) connection.subscriptionsByDefinition.delete(subscription.definitionId);
-		return subscription;
-	};
-	const register = (socket, restoredMetadata, restoredSubscriptions = []) => {
-		const existing = connectionsBySocket.get(socket.raw);
-		if (existing !== void 0) return existing;
-		const metadata = restoredMetadata ?? reserveClientId(socket);
-		const connection = {
-			id: metadata.clientId,
-			socket,
-			parser: serialization.makeUnsafe(),
-			requestIds: /* @__PURE__ */ new Set(),
-			nonResumableRequestIds: /* @__PURE__ */ new Set(),
-			subscriptionsByRequestId: /* @__PURE__ */ new Map(),
-			subscriptionsByDefinition: /* @__PURE__ */ new Map(),
-			suppressedAckRequestIds: /* @__PURE__ */ new Set(),
-			currentPendingRequestIds: /* @__PURE__ */ new Set(),
-			metadataVersion: metadata.version
-		};
-		if (connectionsById.has(connection.id)) throw new Error(`Duplicate Durable Object RPC websocket client id: ${connection.id}`);
-		for (const subscription of restoredSubscriptions) if (!addSubscription(connection, subscription)) throw new Error("Duplicate restored resumable RPC stream subscription identity");
-		connectionsBySocket.set(socket.raw, connection);
-		connectionsById.set(connection.id, connection);
-		nextClientId = Math.max(nextClientId, connection.id + 1);
-		return connection;
-	};
-	const heartbeat = yield* makeHeartbeatController(durableObjectState, serialization, heartbeatPolicy);
-	const syncHeartbeat = () => heartbeat.setEnabled(connectionsBySocket.size > 0 && activeNonResumableRequestCount === 0);
-	const persistConnection = Effect.fn("DurableObjectRpcWebSocket.persistConnection")(function* (connection) {
-		return yield* Effect.try({
-			try: () => {
-				if (connection.metadataVersion === legacyAttachmentVersion) {
-					writeAttachment(connection.socket.raw, attachmentKey, {
-						version: legacyAttachmentVersion,
-						clientId: connection.id,
-						hasPendingRequests: connection.requestIds.size > 0
-					});
-					return;
-				}
-				const subscriptions = Array.from(connection.subscriptionsByRequestId.values()).map(({ declaration: _, ...subscription }) => subscription);
-				writeAttachment(connection.socket.raw, attachmentKey, {
-					version: resumableAttachmentVersion,
-					clientId: connection.id,
-					hasPendingRequests: connection.requestIds.size > 0,
-					hasNonResumableRequests: connection.nonResumableRequestIds.size > 0,
-					subscriptions
-				});
-			},
-			catch: (cause) => new DurableWebSocketAttachmentError({
-				operation: "serialize",
-				cause
-			})
-		});
-	});
-	const unregister = Effect.fn("DurableObjectRpcWebSocket.unregister")(function* (socket) {
-		const connection = connectionsBySocket.get(socket.raw);
-		if (connection === void 0) return;
-		connectionsBySocket.delete(socket.raw);
-		connectionsById.delete(connection.id);
-		activeNonResumableRequestCount -= connection.nonResumableRequestIds.size;
-		connection.requestIds.clear();
-		connection.nonResumableRequestIds.clear();
-		connection.subscriptionsByRequestId.clear();
-		connection.subscriptionsByDefinition.clear();
-		connection.suppressedAckRequestIds.clear();
-		connection.currentPendingRequestIds.clear();
-		Queue.offerUnsafe(disconnects, connection.id);
-		yield* syncHeartbeat();
-	});
-	const resetSocket = Effect.fn("DurableObjectRpcWebSocket.resetSocket")(function* (socket, cause) {
-		resetSockets.add(socket.raw);
-		yield* unregister(socket).pipe(Effect.catchCause((unregisterCause) => Effect.logDebug("Failed to unregister Durable Object RPC websocket", unregisterCause)));
-		if (cause !== void 0) yield* Effect.logDebug("Resetting Durable Object RPC websocket", cause);
-		yield* socket.close(serviceRestartCode, serviceRestartReason).pipe(Effect.catch((closeError) => Effect.logDebug("Failed to close Durable Object RPC websocket", closeError)));
-	});
-	const persistOrReset = Effect.fn("DurableObjectRpcWebSocket.persistOrReset")(function* (connection) {
-		return yield* persistConnection(connection).pipe(Effect.as(true), Effect.catch((cause) => resetSocket(connection.socket, cause).pipe(Effect.as(false))));
-	});
-	const trackRequest = Effect.fn("DurableObjectRpcWebSocket.trackRequest")(function* (connection, request) {
-		if (connection.requestIds.has(request.id)) return true;
-		const declaration = declarationsByTag.get(request.tag);
-		const identified = declaration === void 0 ? Option.none() : yield* Effect.sync(() => declaration.identify(request));
-		if (declaration !== void 0 && Option.isSome(identified)) {
-			if (!addSubscription(connection, {
-				declaration,
-				definitionId: declaration.id,
-				subscriptionKey: identified.value.subscriptionKey,
-				requestId: request.id,
-				rpcTag: declaration.rpcTag,
-				resumeDescriptor: identified.value.resumeDescriptor,
-				acknowledgedCheckpoint: identified.value.acknowledgedCheckpoint
-			})) {
-				yield* resetSocket(connection.socket, /* @__PURE__ */ new Error(`Duplicate resumable RPC stream subscription: ${declaration.id}`));
-				return false;
-			}
-		} else {
-			connection.requestIds.add(request.id);
-			connection.nonResumableRequestIds.add(request.id);
-			activeNonResumableRequestCount++;
-		}
-		if (!(yield* persistOrReset(connection))) return false;
-		yield* syncHeartbeat();
-		return true;
-	});
-	const completeRequest = Effect.fn("DurableObjectRpcWebSocket.completeRequest")(function* (connection, requestId, preserveAckFilter = false) {
-		if (connection.requestIds.delete(requestId)) {
-			if (connection.nonResumableRequestIds.delete(requestId)) activeNonResumableRequestCount--;
-			const subscription = removeSubscription(connection, requestId);
-			connection.currentPendingRequestIds.delete(requestId);
-			if (preserveAckFilter && subscription !== void 0) connection.suppressedAckRequestIds.add(requestId);
-			if (!(yield* persistOrReset(connection))) return;
-		}
-		if (!preserveAckFilter) connection.suppressedAckRequestIds.delete(requestId);
-		yield* syncHeartbeat();
-	});
-	const completeAllRequests = Effect.fn("DurableObjectRpcWebSocket.completeAllRequests")(function* (connection) {
-		const hadRequests = connection.requestIds.size > 0;
-		if (connection.requestIds.size > 0) activeNonResumableRequestCount -= connection.nonResumableRequestIds.size;
-		connection.requestIds.clear();
-		connection.nonResumableRequestIds.clear();
-		connection.subscriptionsByRequestId.clear();
-		connection.subscriptionsByDefinition.clear();
-		connection.suppressedAckRequestIds.clear();
-		connection.currentPendingRequestIds.clear();
-		if (hadRequests && !(yield* persistOrReset(connection))) return;
-		yield* syncHeartbeat();
-	});
-	const restoredAttachments = (yield* durableObjectState.getWebSockets(tag)).map((socket) => ({
-		socket,
-		attachment: readAttachment(socket.raw, attachmentKey)
-	}));
-	for (const { attachment, socket } of restoredAttachments) {
-		if (attachment._tag === "Invalid") {
-			yield* resetSocket(socket);
-			continue;
-		}
-		if (attachment._tag === "Missing") {
-			yield* resetSocket(socket);
-			continue;
-		}
-		const metadata = attachment.metadata;
-		if (metadata.version === legacyAttachmentVersion) {
-			if (metadata.hasPendingRequests) yield* resetSocket(socket);
-			else if (connectionsById.has(metadata.clientId)) yield* resetSocket(socket);
-			else yield* persistOrReset(register(socket, metadata));
-			continue;
-		}
-		const prepared = yield* Effect.sync(() => {
-			try {
-				if (metadata.hasNonResumableRequests || metadata.hasPendingRequests !== (metadata.hasNonResumableRequests || metadata.subscriptions.length > 0)) throw new Error("Dirty resumable RPC websocket attachment metadata");
-				const requestIds = /* @__PURE__ */ new Set();
-				const subscriptionKeys = /* @__PURE__ */ new Map();
-				const subscriptions = [];
-				const requests = [];
-				for (const persisted of metadata.subscriptions) {
-					const declaration = declarationsById.get(persisted.definitionId);
-					if (declaration === void 0 || declaration.rpcTag !== persisted.rpcTag) throw new Error("Missing resumable RPC stream declaration");
-					let keys = subscriptionKeys.get(persisted.definitionId);
-					if (keys === void 0) {
-						keys = /* @__PURE__ */ new Set();
-						subscriptionKeys.set(persisted.definitionId, keys);
-					}
-					if (requestIds.has(persisted.requestId) || keys.has(persisted.subscriptionKey)) throw new Error("Duplicate persisted resumable RPC stream subscription");
-					requestIds.add(persisted.requestId);
-					keys.add(persisted.subscriptionKey);
-					if (persisted.pending !== void 0) {
-						const { checkpointTokens } = persisted.pending;
-						if (checkpointTokens.length === 0 || checkpointTokens.some((token) => token.length === 0) || new Set(checkpointTokens).size !== checkpointTokens.length) throw new Error("Invalid persisted resumable RPC stream pending batch");
-					}
-					const resumeDescriptor = Schema.decodeUnknownOption(declaration.resumeDescriptorSchema)(persisted.resumeDescriptor);
-					const acknowledgedCheckpoint = Schema.decodeUnknownOption(declaration.checkpointSchema)(persisted.acknowledgedCheckpoint);
-					if (Option.isNone(resumeDescriptor) || Option.isNone(acknowledgedCheckpoint)) throw new Error("Invalid persisted resumable RPC stream state");
-					const rebuilt = declaration.rebuild({
-						subscriptionKey: persisted.subscriptionKey,
-						resumeDescriptor: resumeDescriptor.value,
-						acknowledgedCheckpoint: acknowledgedCheckpoint.value
-					});
-					const request = {
-						_tag: "Request",
-						id: persisted.requestId,
-						tag: declaration.rpcTag,
-						payload: rebuilt.payload,
-						headers: rebuilt.headers?.map(([name, value]) => [name, value]) ?? []
-					};
-					if (rebuilt.traceId !== void 0) Object.assign(request, { traceId: rebuilt.traceId });
-					if (rebuilt.spanId !== void 0) Object.assign(request, { spanId: rebuilt.spanId });
-					if (rebuilt.sampled !== void 0) Object.assign(request, { sampled: rebuilt.sampled });
-					subscriptions.push({
-						...persisted,
-						resumeDescriptor: resumeDescriptor.value,
-						acknowledgedCheckpoint: acknowledgedCheckpoint.value,
-						declaration
-					});
-					requests.push(request);
-				}
-				return {
-					_tag: "Success",
-					requests,
-					subscriptions
-				};
-			} catch (cause) {
-				return {
-					_tag: "Failure",
-					cause
-				};
-			}
-		});
-		if (prepared._tag === "Failure") {
-			yield* Effect.logDebug("Invalid resumable RPC websocket attachment", prepared.cause);
-			yield* resetSocket(socket);
-			continue;
-		}
-		if (connectionsById.has(metadata.clientId)) {
-			yield* resetSocket(socket);
-			continue;
-		}
-		const connection = register(socket, metadata, prepared.subscriptions);
-		for (const request of prepared.requests) replayRequests.push({
-			clientId: connection.id,
-			request
-		});
-	}
-	yield* syncHeartbeat();
-	const send = (connection, response) => Effect.gen(function* () {
-		let delivered = response;
-		if (response._tag === "Chunk") {
-			const subscription = connection.subscriptionsByRequestId.get(response.requestId);
-			if (subscription !== void 0) {
-				subscription.pending = { checkpointTokens: yield* Effect.sync(() => {
-					const tokens = [];
-					for (const value of response.values) {
-						const checkpoint = subscription.declaration.checkpointFromValue(value);
-						if (Option.isNone(checkpoint)) throw new Error(`Resumable RPC stream ${subscription.definitionId} did not identify a checkpoint`);
-						const token = subscription.declaration.checkpointToken(checkpoint.value);
-						if (token.length === 0 || tokens.includes(token)) throw new Error(`Resumable RPC stream ${subscription.definitionId} produced invalid checkpoint tokens`);
-						tokens.push(token);
-					}
-					if (tokens.length === 0) throw new Error("Resumable RPC stream chunks must contain checkpointed values");
-					return tokens;
-				}) };
-				connection.currentPendingRequestIds.add(subscription.requestId);
-				if (!(yield* persistOrReset(connection))) return;
-			}
-		}
-		if (!(yield* Effect.sync(() => {
-			try {
-				const encoded = connection.parser.encode(response);
-				if (encoded === void 0) return false;
-				connection.socket.raw.send(encoded);
-				return true;
-			} catch (cause) {
-				delivered = RpcMessage.ResponseDefectEncoded(encodeDefect(cause));
-				const encoded = connection.parser.encode(delivered);
-				if (encoded === void 0) return false;
-				connection.socket.raw.send(encoded);
-				return true;
-			}
-		}).pipe(Effect.catchCause((cause) => Effect.logDebug("Durable Object RPC websocket send failed", cause).pipe(Effect.as(false)))))) {
-			resetSockets.add(connection.socket.raw);
-			yield* connection.socket.close(serviceRestartCode, serviceRestartReason).pipe(Effect.ignore);
-			yield* unregister(connection.socket);
-			return;
-		}
-		if (delivered._tag === "Exit") yield* completeRequest(connection, delivered.requestId);
-		else if (delivered._tag === "Defect" || delivered._tag === "ClientProtocolError") yield* completeAllRequests(connection);
-	});
-	const protocol = yield* RpcServer.Protocol.make((writeRequest_) => {
-		writeRequest = writeRequest_;
-		return Effect.succeed({
-			disconnects,
-			send: (clientId, response) => {
-				const connection = connectionsById.get(clientId);
-				return connection === void 0 ? Effect.void : send(connection, response);
-			},
-			end: (clientId) => Effect.sync(() => {
-				connectionsById.get(clientId)?.socket.raw.close();
-			}),
-			clientIds: Effect.sync(() => new Set(connectionsById.keys())),
-			initialMessage: Effect.succeedNone,
-			supportsAck: true,
-			supportsTransferables: false,
-			supportsSpanPropagation: true,
-			supportsNotifications: true,
-			codecFor: serialization.codecFor
-		});
-	});
-	const replay = writeRequest;
-	if (replay === void 0) return yield* Effect.die(/* @__PURE__ */ new Error("RPC server protocol did not install its request writer"));
-	for (const restoredRequest of replayRequests) yield* replay(restoredRequest.clientId, restoredRequest.request);
-	const checkpoint = Effect.fn("DurableObjectRpcWebSocket.checkpoint")(function* (declaration, checkpointOptions) {
-		const connection = connectionsById.get(checkpointOptions.clientId);
-		const configured = declarationsById.get(declaration.id);
-		const subscription = connection?.subscriptionsByDefinition.get(declaration.id)?.get(checkpointOptions.subscriptionKey);
-		if (connection === void 0 || configured === void 0 || configured.rpcTag !== declaration.rpcTag || subscription === void 0 || subscription.pending === void 0) return false;
-		const token = configured.checkpointToken(checkpointOptions.checkpoint);
-		const checkpointIndex = subscription.pending.checkpointTokens.indexOf(token);
-		if (token.length === 0 || checkpointIndex < 0) return false;
-		const pending = subscription.pending;
-		const isFinal = checkpointIndex === pending.checkpointTokens.length - 1;
-		const shouldAck = isFinal && connection.currentPendingRequestIds.has(subscription.requestId);
-		return yield* Effect.uninterruptible(Effect.gen(function* () {
-			subscription.acknowledgedCheckpoint = checkpointOptions.checkpoint;
-			if (isFinal) {
-				connection.currentPendingRequestIds.delete(subscription.requestId);
-				delete subscription.pending;
-			} else subscription.pending = { checkpointTokens: pending.checkpointTokens.slice(checkpointIndex + 1) };
-			yield* persistConnection(connection).pipe(Effect.catch((cause) => Effect.gen(function* () {
-				yield* resetSocket(connection.socket, cause);
-				return yield* cause;
-			})));
-			if (shouldAck) {
-				const run = writeRequest;
-				if (run === void 0) return yield* Effect.die(/* @__PURE__ */ new Error("RPC server is not ready to accept a checkpoint Ack"));
-				yield* run(connection.id, {
-					_tag: "Ack",
-					requestId: subscription.requestId
-				});
-			}
-			return true;
-		}));
-	});
-	const service = DurableObjectRpcWebSocket.of({
-		accept: (socket, tags = []) => Effect.gen(function* () {
-			register(socket);
-			yield* durableObjectState.acceptWebSocket(socket, Array.from(/* @__PURE__ */ new Set([tag, ...tags])));
-			yield* syncHeartbeat();
-		}),
-		acceptUpgrade: (upgradeOptions = {}) => Effect.gen(function* () {
-			const pair = new WebSocketPair();
-			const client = pair[0];
-			const server = fromWebSocket(pair[1]);
-			if (upgradeOptions.attachment !== void 0) yield* server.serializeAttachment(upgradeOptions.attachment);
-			yield* service.accept(server, upgradeOptions.tags);
-			return {
-				client,
-				server,
-				response: new Response(null, {
-					status: 101,
-					webSocket: client
-				})
-			};
-		}),
-		message: (socket, message) => Effect.gen(function* () {
-			if (resetSockets.has(socket.raw)) return;
-			const connection = register(socket);
-			const decoded = yield* Effect.try({
-				try: () => connection.parser.decode(normalizeMessage(message)),
-				catch: (cause) => cause
-			});
-			const run = writeRequest;
-			if (run === void 0) {
-				yield* send(connection, RpcMessage.ResponseDefectEncoded(encodeDefect("RPC server is not ready")));
-				return;
-			}
-			for (const current of decoded) {
-				const request = current;
-				if (request._tag === "Request" && request.isNotification !== true) {
-					if (!(yield* trackRequest(connection, request))) return;
-				}
-				if (request._tag === "Ack" && (connection.subscriptionsByRequestId.has(request.requestId) || connection.suppressedAckRequestIds.has(request.requestId))) continue;
-				if (request._tag === "Interrupt" && connection.subscriptionsByRequestId.has(request.requestId)) yield* completeRequest(connection, request.requestId, true);
-				yield* run(connection.id, request);
-				if (request._tag === "Interrupt" && !connection.suppressedAckRequestIds.has(request.requestId)) yield* completeRequest(connection, request.requestId);
-			}
-		}).pipe(Effect.catch((cause) => {
-			const connection = register(socket);
-			return Predicate.isTagged(cause, "MaxBufferSizeExceeded") ? Effect.ignore(connection.socket.close(1009, String(cause))) : send(connection, RpcMessage.ResponseDefectEncoded(encodeDefect(cause)));
-		})),
-		close: unregister,
-		error: resetSocket,
-		checkpoint
-	});
-	return Context.mergeAll(Context.make(RpcServer.Protocol, protocol), Context.make(DurableObjectRpcWebSocket, service));
-}));
-const normalizeMessage = (message) => Predicate.isString(message) ? message : new Uint8Array(message);
-const readAttachment = (socket, key) => {
-	const value = socket.deserializeAttachment();
-	if (value === null || value === void 0) return { _tag: "Missing" };
-	if (!Predicate.isObject(value)) return { _tag: "Invalid" };
-	if (!Predicate.hasProperty(value, key)) return { _tag: "Missing" };
-	const metadata = value[key];
-	if (Predicate.isNumber(metadata) && isClientId(metadata)) return {
-		_tag: "Valid",
-		metadata: {
-			version: legacyAttachmentVersion,
-			clientId: metadata,
-			hasPendingRequests: false
-		}
-	};
-	if (!Predicate.isObject(metadata)) return { _tag: "Invalid" };
-	if (Predicate.hasProperty(metadata, "version") && metadata.version === resumableAttachmentVersion) {
-		const decoded = decodeResumableAttachment(metadata);
-		return Option.isSome(decoded) && isClientId(decoded.value.clientId) ? {
-			_tag: "Valid",
-			metadata: decoded.value
-		} : { _tag: "Invalid" };
-	}
-	const hasPendingRequests = Predicate.hasProperty(metadata, "hasPendingRequests") ? metadata.hasPendingRequests : false;
-	if ((!Predicate.hasProperty(metadata, "version") || metadata.version === legacyAttachmentVersion) && Predicate.hasProperty(metadata, "clientId") && Predicate.isNumber(metadata.clientId) && isClientId(metadata.clientId) && Predicate.isBoolean(hasPendingRequests)) return {
-		_tag: "Valid",
-		metadata: {
-			version: legacyAttachmentVersion,
-			clientId: metadata.clientId,
-			hasPendingRequests
-		}
-	};
-	return { _tag: "Invalid" };
-};
-const isClientId = (value) => Number.isSafeInteger(value) && value >= 0;
-const writeAttachment = (socket, key, metadata) => {
-	const current = socket.deserializeAttachment();
-	if (current !== null && current !== void 0 && !Predicate.isObject(current)) throw new Error("DurableObjectRpcWebSocket requires object-shaped websocket attachments so adapter metadata can preserve application fields");
-	const attachment = Predicate.isObject(current) ? current : {};
-	socket.serializeAttachment({
-		...attachment,
-		[key]: metadata
-	});
-};
-const makeHeartbeatController = (state, serialization, policy) => Effect.gen(function* () {
-	if (policy === "passthrough") return { setEnabled: () => Effect.void };
-	const parser = serialization.makeUnsafe();
-	const request = parser.encode(RpcMessage.constPing);
-	const response = parser.encode(RpcMessage.constPong);
-	if (!Predicate.isString(request) || !Predicate.isString(response)) return yield* Effect.die(/* @__PURE__ */ new Error("DurableObjectRpcWebSocket heartbeat auto-response requires a text RPC serialization; use heartbeat: \"passthrough\" to manage heartbeats externally"));
-	const configured = yield* state.getWebSocketAutoResponse;
-	if (configured !== null && (configured.request !== request || configured.response !== response)) return yield* Effect.die(/* @__PURE__ */ new Error("DurableObjectRpcWebSocket cannot replace the application WebSocket auto-response; use heartbeat: \"passthrough\" to preserve it"));
-	const pair = new WebSocketRequestResponsePair(request, response);
-	let enabled = configured !== null;
-	return { setEnabled: (nextEnabled) => {
-		if (enabled === nextEnabled) return Effect.void;
-		return state.setWebSocketAutoResponse(nextEnabled ? pair : void 0).pipe(Effect.tap(() => Effect.sync(() => {
-			enabled = nextEnabled;
-		})));
-	} };
-});
-//#endregion
-//#region src/DurableObjectSqlite.ts
-var DurableObjectSqlite_exports = /* @__PURE__ */ __exportAll({ layer: () => layer$7 });
-const layer$7 = (options) => Layer.unwrap(Effect.gen(function* () {
-	const state = yield* DurableObjectState;
-	return SqliteClient.layer({
-		...options,
-		storage: state.raw.storage
-	});
-}));
-//#endregion
-//#region src/Email.ts
-var Email_exports = /* @__PURE__ */ __exportAll({
-	EmailOperationError: () => EmailOperationError,
-	EmailValidationError: () => EmailValidationError,
-	Tag: () => Tag$7,
-	emailErrorCodes: () => emailErrorCodes,
-	isEmailBinding: () => isEmailBinding,
-	layer: () => layer$6,
-	make: () => make$6,
-	makeClient: () => makeClient$6,
-	sendLimits: () => sendLimits,
-	validateMessage: () => validateMessage
-});
-const expectedSendEmailBinding = "Send Email binding with send()";
-const textEncoder = new TextEncoder();
-const sendLimits = {
-	maxRecipients: 50,
-	maxAttachments: 32,
-	maxMessageBytes: 5242880,
-	maxHeaderNameBytes: 100,
-	maxHeaderValueBytes: 2048,
-	maxHeadersBytes: 16384,
-	maxAllowlistHeaders: 20
-};
-/**
-* Error codes reported by Cloudflare Email Sending.
-*
-* Surfaced on {@link EmailOperationError} `code` on a best-effort basis: the
-* runtime attaches them as a non-standard `code` property on thrown errors,
-* which may be missing depending on the runtime or dev-time proxying
-* (miniflare remote bindings serialize errors and can strip it).
-*/
-const emailErrorCodes = [
-	"E_VALIDATION_ERROR",
-	"E_FIELD_MISSING",
-	"E_TOO_MANY_RECIPIENTS",
-	"E_TOO_MANY_ATTACHMENTS",
-	"E_SENDER_NOT_VERIFIED",
-	"E_RECIPIENT_NOT_ALLOWED",
-	"E_RECIPIENT_SUPPRESSED",
-	"E_SENDER_DOMAIN_NOT_AVAILABLE",
-	"E_CONTENT_TOO_LARGE",
-	"E_DELIVERY_FAILED",
-	"E_RATE_LIMIT_EXCEEDED",
-	"E_DAILY_LIMIT_EXCEEDED",
-	"E_INTERNAL_SERVER_ERROR",
-	"E_HEADER_NOT_ALLOWED",
-	"E_HEADER_USE_API_FIELD",
-	"E_HEADER_VALUE_INVALID",
-	"E_HEADER_VALUE_TOO_LONG",
-	"E_HEADER_NAME_INVALID",
-	"E_HEADERS_TOO_LARGE",
-	"E_HEADERS_TOO_MANY"
-];
-var EmailOperationError = class extends Data.TaggedError("EmailOperationError") {
-	get message() {
-		const code = this.code === void 0 ? "" : ` (${this.code})`;
-		return `Email ${this.operation} failed for binding "${this.binding}"${code}: ${causeMessage(this.cause)}`;
-	}
-};
-var EmailValidationError = class extends Data.TaggedError("EmailValidationError") {
-	get message() {
-		return `Email ${this.operation} for binding "${this.binding}" failed validation: ${violationsMessage(this.violations)}`;
-	}
-};
-/**
-* Best-effort extraction of the Cloudflare error `code` from a thrown error.
-* Returns `undefined` when the property is absent — e.g. when a dev-time
-* proxy such as a miniflare remote binding (`"remote": true`) serializes the
-* error and strips non-standard properties.
-*/
-const emailErrorCode = (cause) => {
-	if (!Predicate.isObject(cause)) return;
-	const code = Predicate.hasProperty(cause, "code") ? cause.code : void 0;
-	return Predicate.isString(code) ? code : void 0;
-};
-const emailError = (binding, operation, cause) => new EmailOperationError({
-	binding,
-	operation,
-	cause,
-	code: emailErrorCode(cause)
-});
-const emailValidationError = (binding, operation, violations) => new EmailValidationError({
-	binding,
-	operation,
-	violations
-});
-const tryEmailPromise = (binding, operation, evaluate) => Effect.tryPromise({
-	try: evaluate,
-	catch: (cause) => emailError(binding, operation, cause)
-});
-const byteLength = (value) => textEncoder.encode(value).byteLength;
-const limitViolation = (path, label, actual, limit) => ({
-	path,
-	message: `${label} exceeds Cloudflare Email Sending limit`,
-	actual,
-	limit
-});
-const addressList = (value) => {
-	if (value === void 0) return [];
-	return Array.isArray(value) ? value : [value];
-};
-const addressViolations = (path, value) => {
-	if (Predicate.isString(value)) return value.includes("@") ? [] : [{
-		path,
-		message: "Email address must contain an @ symbol"
-	}];
-	if (!Predicate.isObject(value)) return [{
-		path,
-		message: "Email address must be a string or { name, email } object"
-	}];
-	const email = Predicate.hasProperty(value, "email") ? value.email : void 0;
-	if (!Predicate.isString(email) || !email.includes("@")) return [{
-		path: `${path}.email`,
-		message: "Email address must contain an @ symbol"
-	}];
-	return [];
-};
-const recipientViolations = (field, value) => addressList(value).flatMap((address, index) => addressViolations(`${field}[${index}]`, address));
-const attachmentViolations = (attachments) => {
-	const violations = [];
-	if (attachments.length > sendLimits.maxAttachments) violations.push(limitViolation("attachments", "attachments", attachments.length, sendLimits.maxAttachments));
-	for (let index = 0; index < attachments.length; index++) {
-		const attachment = attachments[index];
-		const path = `attachments[${index}]`;
-		if (!Predicate.isObject(attachment)) {
-			violations.push({
-				path,
-				message: "Attachment must be an object"
-			});
-			continue;
-		}
-		if (!Predicate.isString(attachment.filename) || attachment.filename === "") violations.push({
-			path: `${path}.filename`,
-			message: "Attachment filename is required"
-		});
-		if (!Predicate.isString(attachment.type) || attachment.type === "") violations.push({
-			path: `${path}.type`,
-			message: "Attachment MIME type is required"
-		});
-		if (attachment.content === void 0 || attachment.content === null) violations.push({
-			path: `${path}.content`,
-			message: "Attachment content is required"
-		});
-		if (attachment.disposition === "inline" && !Predicate.isString(attachment.contentId)) violations.push({
-			path: `${path}.contentId`,
-			message: "Inline attachments require a contentId"
-		});
-	}
-	return violations;
-};
-const headerViolations = (headers) => {
-	const violations = [];
-	const entries = Object.entries(headers);
-	let totalBytes = 0;
-	let allowlistHeaders = 0;
-	for (const [name, value] of entries) {
-		const path = `headers["${name}"]`;
-		const nameBytes = byteLength(name);
-		if (nameBytes > sendLimits.maxHeaderNameBytes) violations.push(limitViolation(path, "header name bytes", nameBytes, sendLimits.maxHeaderNameBytes));
-		if (!Predicate.isString(value)) {
-			violations.push({
-				path,
-				message: "Header value must be a string"
-			});
-			continue;
-		}
-		const valueBytes = byteLength(value);
-		if (valueBytes > sendLimits.maxHeaderValueBytes) violations.push(limitViolation(path, "header value bytes", valueBytes, sendLimits.maxHeaderValueBytes));
-		totalBytes += nameBytes + valueBytes;
-		if (!name.toLowerCase().startsWith("x-")) allowlistHeaders += 1;
-	}
-	if (totalBytes > sendLimits.maxHeadersBytes) violations.push(limitViolation("headers", "header bytes", totalBytes, sendLimits.maxHeadersBytes));
-	if (allowlistHeaders > sendLimits.maxAllowlistHeaders) violations.push(limitViolation("headers", "allowlisted custom headers", allowlistHeaders, sendLimits.maxAllowlistHeaders));
-	return violations;
-};
-/**
-* Validates a structured message against documented Cloudflare Email Sending
-* limits and returns every violation found. Total message size is not checked
-* because the encoded MIME size is only known once Cloudflare composes it.
-*/
-const validateMessage = (message) => {
-	const violations = [];
-	const fields = message;
-	if (fields.from === void 0) violations.push({
-		path: "from",
-		message: "A from address is required"
-	});
-	else violations.push(...addressViolations("from", fields.from));
-	if (fields.replyTo !== void 0) violations.push(...addressViolations("replyTo", fields.replyTo));
-	if (!Predicate.isString(fields.subject) || fields.subject === "") violations.push({
-		path: "subject",
-		message: "A subject is required"
-	});
-	if (!Predicate.isString(fields.text) && !Predicate.isString(fields.html)) violations.push({
-		path: "$",
-		message: "A message requires either text or html content"
-	});
-	const recipients = addressList(fields.to).length + addressList(fields.cc).length + addressList(fields.bcc).length;
-	if (recipients === 0) violations.push({
-		path: "$",
-		message: "A message requires at least one to, cc, or bcc address"
-	});
-	if (recipients > sendLimits.maxRecipients) violations.push(limitViolation("$", "combined to, cc, and bcc addresses", recipients, sendLimits.maxRecipients));
-	violations.push(...recipientViolations("to", fields.to));
-	violations.push(...recipientViolations("cc", fields.cc));
-	violations.push(...recipientViolations("bcc", fields.bcc));
-	if (fields.attachments !== void 0) violations.push(...attachmentViolations(fields.attachments));
-	if (fields.headers !== void 0) violations.push(...headerViolations(fields.headers));
-	return violations;
-};
-const validateSendInput = (binding, operation, message) => {
-	const violations = validateMessage(message);
-	return violations.length > 0 ? Effect.fail(emailValidationError(binding, operation, violations)) : Effect.succeed(message);
-};
-const isEmailBinding = (value) => Predicate.hasProperty(value, "send") && Predicate.isFunction(value.send);
-const makeClient$6 = (definition, options) => (email) => {
-	const runtime = email;
-	const validate = options?.validate ?? true;
-	return {
-		definition,
-		send: Effect.fn("Email.send")(function* (message) {
-			if (validate) yield* validateSendInput(definition.binding, "send", message);
-			return yield* tryEmailPromise(definition.binding, "send", () => runtime.send(message));
-		}),
-		rawUnsafe: Effect.succeed(email)
-	};
-};
-const layer$6 = (tag, definition) => layer$18(tag, definition.binding, isEmailBinding, makeClient$6(definition, definition.send), { expected: expectedSendEmailBinding });
-const make$6 = (id) => Tag$7()(id);
-const Tag$7 = () => (id) => {
-	const tag = Context.Service()(id);
-	const makeLayer = (definition) => layer$6(tag, definition);
-	return Object.assign(tag, {
-		id,
-		layer: makeLayer
-	});
-};
-//#endregion
-//#region src/Hyperdrive.ts
-var Hyperdrive_exports = /* @__PURE__ */ __exportAll({
-	Tag: () => Tag$6,
-	isHyperdrive: () => isHyperdrive,
-	layer: () => layer$5,
-	make: () => make$5,
-	makeClient: () => makeClient$5
-});
-const expectedHyperdrive = "Hyperdrive binding with connectionString";
-const isHyperdrive = (value) => Predicate.hasProperty(value, "connectionString") && Predicate.isString(value.connectionString);
-const makeClient$5 = (definition) => (hyperdrive) => ({
-	definition,
-	connectionString: hyperdrive.connectionString,
-	rawUnsafe: Effect.succeed(hyperdrive)
-});
-const layer$5 = (tag, definition) => layer$18(tag, definition.binding, isHyperdrive, makeClient$5(definition), { expected: expectedHyperdrive });
-const make$5 = (id) => Tag$6()(id);
-const Tag$6 = () => (id) => {
-	const tag = Context.Service()(id);
-	const makeLayer = (definition) => layer$5(tag, definition);
-	return Object.assign(tag, {
-		id,
-		layer: makeLayer
-	});
-};
-//#endregion
-//#region src/Images.ts
-var Images_exports = /* @__PURE__ */ __exportAll({
-	ImagesOperationError: () => ImagesOperationError,
-	Step: () => Step,
-	Tag: () => Tag$5,
-	draw: () => draw,
-	empty: () => empty,
-	isImagesBinding: () => isImagesBinding,
-	layer: () => layer$4,
-	make: () => make$4,
-	makeClient: () => makeClient$4,
-	transform: () => transform
-});
-const TypeId = "~effect-cf/Images/Steps";
-const expectedImagesBinding = "Images binding with info() and input()";
-var ImagesOperationError = class extends Data.TaggedError("ImagesOperationError") {
-	get message() {
-		return `Images ${this.operation} failed for binding "${this.binding}": ${causeMessage(this.cause)}`;
-	}
-};
-const Step = Data.taggedEnum();
-const makeSteps = (steps) => ({
-	[TypeId]: TypeId,
-	steps
-});
-const empty = makeSteps([]);
-const transform = Function$1.dual(2, (steps, transformValue) => makeSteps([...steps.steps, Step.Transform({ transform: transformValue })]));
-const draw = Function$1.dual(2, (steps, drawValue) => makeSteps([...steps.steps, Step.Draw(drawValue)]));
-const imagesError = (binding, operation, cause) => new ImagesOperationError({
-	binding,
-	operation,
-	cause
-});
-const tryImagesPromise = (binding, operation, evaluate) => Effect.tryPromise({
-	try: evaluate,
-	catch: (cause) => imagesError(binding, operation, cause)
-});
-const tryImagesSync = (binding, operation, evaluate) => Effect.try({
-	try: evaluate,
-	catch: (cause) => imagesError(binding, operation, cause)
-});
-const maybe = (value) => value === null ? Option.none() : Option.some(value);
-const hasFunction = (value, key) => Predicate.hasProperty(value, key) && Predicate.isFunction(value[key]);
-const isHostedImagesBinding = (value) => hasFunction(value, "image") && hasFunction(value, "upload") && hasFunction(value, "list") && hasFunction(value, "createDirectUpload");
-const isImagesBinding = (value) => hasFunction(value, "info") && hasFunction(value, "input");
-const wrapResult = (binding, result) => ({
-	raw: result,
-	response: (options) => tryImagesSync(binding, "response", () => result.response(options)),
-	contentType: tryImagesSync(binding, "contentType", () => result.contentType()),
-	image: (options) => tryImagesSync(binding, "image", () => result.image(options))
-});
-const wrapHandle = (binding, handle) => ({
-	raw: handle,
-	details: tryImagesPromise(binding, "details", () => handle.details()).pipe(Effect.map(maybe), Effect.withSpan("Images.details")),
-	bytes: tryImagesPromise(binding, "bytes", () => handle.bytes()).pipe(Effect.map(maybe), Effect.withSpan("Images.bytes")),
-	signedUrl: Effect.fn("Images.signedUrl")((options) => tryImagesPromise(binding, "signedUrl", () => handle.signedUrl(options))),
-	update: Effect.fn("Images.update")((options) => tryImagesPromise(binding, "update", () => handle.update(options))),
-	delete: tryImagesPromise(binding, "delete", () => handle.delete()).pipe(Effect.withSpan("Images.delete"))
-});
-const wrapHosted = (binding, hosted) => ({
-	image: (imageId) => wrapHandle(binding, hosted.image(imageId)),
-	upload: Effect.fn("Images.upload")((image, options) => tryImagesPromise(binding, "upload", () => hosted.upload(image, options))),
-	list: Effect.fn("Images.list")((options) => tryImagesPromise(binding, "list", () => hosted.list(options))),
-	createDirectUpload: Effect.fn("Images.createDirectUpload")((options) => tryImagesPromise(binding, "createDirectUpload", () => hosted.createDirectUpload(options))),
-	rawUnsafe: Effect.succeed(hosted)
-});
-const makeClient$4 = (definition) => (images) => {
-	const input = (image, options) => tryImagesSync(definition.binding, "input", () => images.input(image, options));
-	const text = (content, options) => tryImagesSync(definition.binding, "text", () => {
-		if (!hasFunction(images, "text")) throw new Error("Images binding is missing text()");
-		return images.text(content, options);
-	});
-	const process = Effect.fn("Images.process")(function* (steps, options) {
-		let transformer = "text" in options ? yield* text(options.text, options.textOptions) : yield* input(options.stream, options.inputOptions);
-		for (const step of steps.steps) transformer = yield* Step.$match(step, {
-			Draw: (drawStep) => tryImagesSync(definition.binding, "draw", () => transformer.draw(drawStep.image, drawStep.options)),
-			Transform: (transformStep) => tryImagesSync(definition.binding, "transform", () => transformer.transform(transformStep.transform))
-		});
-		const result = yield* tryImagesPromise(definition.binding, "output", () => transformer.output(options.outputOptions));
-		return wrapResult(definition.binding, result);
-	});
-	return {
-		definition,
-		info: Effect.fn("Images.info")((image, options) => tryImagesPromise(definition.binding, "info", () => images.info(image, options))),
-		input,
-		text,
-		process,
-		hosted: isHostedImagesBinding(images.hosted) ? Option.some(wrapHosted(definition.binding, images.hosted)) : Option.none(),
-		rawUnsafe: Effect.succeed(images)
-	};
-};
-const layer$4 = (tag, definition) => layer$18(tag, definition.binding, isImagesBinding, makeClient$4(definition), { expected: expectedImagesBinding });
-const make$4 = (id) => Tag$5()(id);
-const Tag$5 = () => (id) => {
-	const tag = Context.Service()(id);
-	const makeLayer = (definition) => layer$4(tag, definition);
-	return Object.assign(tag, {
-		id,
-		layer: makeLayer
-	});
-};
-//#endregion
-//#region src/Kv.ts
-var Kv_exports = /* @__PURE__ */ __exportAll({
-	KvOperationError: () => KvOperationError,
-	Tag: () => Tag$4,
-	isKvNamespace: () => isKvNamespace,
-	layer: () => layer$3,
-	makeClient: () => makeClient$3
-});
-const expectedKvNamespace = "KV namespace binding with get(), put(), delete(), getWithMetadata(), and list()";
-var KvOperationError = class extends Data.TaggedError("KvOperationError") {
-	get message() {
-		return `Kv ${this.operation} failed for binding "${this.binding}": ${causeMessage(this.cause)}`;
-	}
-};
-const kvError = (binding, operation, cause) => new KvOperationError({
-	binding,
-	operation,
-	cause
-});
-const tryKvPromise = (binding, operation, evaluate) => Effect.tryPromise({
-	try: evaluate,
-	catch: (cause) => kvError(binding, operation, cause)
-});
-const isKvNamespace = (value) => Predicate.hasProperty(value, "get") && Predicate.isFunction(value.get) && Predicate.hasProperty(value, "put") && Predicate.isFunction(value.put) && Predicate.hasProperty(value, "delete") && Predicate.isFunction(value.delete) && Predicate.hasProperty(value, "getWithMetadata") && Predicate.isFunction(value.getWithMetadata) && Predicate.hasProperty(value, "list") && Predicate.isFunction(value.list);
-const makeClient$3 = (definition) => {
-	const encodeKey = Schema.encodeEffect(definition.key);
-	const decodeKey = Schema.decodeUnknownEffect(definition.key);
-	const jsonValue = Schema.fromJsonString(Schema.toCodecJson(definition.value));
-	const encodeValue = Schema.encodeEffect(jsonValue);
-	const decodeValue = Schema.decodeUnknownEffect(jsonValue);
-	return (kv) => ({
-		definition,
-		put: Effect.fn("Kv.put", { attributes: {
-			binding: definition.binding,
-			operation: "put"
-		} })(function* (key, value, options) {
-			const keyEncoded = yield* encodeKey(key);
-			const valueEncoded = yield* encodeValue(value);
-			yield* tryKvPromise(definition.binding, "put", () => kv.put(keyEncoded, valueEncoded, options));
-		}),
-		get: Effect.fn("Kv.get", { attributes: {
-			binding: definition.binding,
-			operation: "get"
-		} })(function* (key) {
-			const keyEncoded = yield* encodeKey(key);
-			const valueEncoded = yield* tryKvPromise(definition.binding, "get", () => kv.get(keyEncoded));
-			if (valueEncoded === null) return Option.none();
-			return yield* decodeValue(valueEncoded).pipe(Effect.map(Option.some));
-		}),
-		getWithMetadata: Effect.fn("Kv.getWithMetadata", { attributes: {
-			binding: definition.binding,
-			operation: "getWithMetadata"
-		} })(function* (key, metadataSchema) {
-			const keyEncoded = yield* encodeKey(key);
-			const result = yield* tryKvPromise(definition.binding, "getWithMetadata", () => kv.getWithMetadata(keyEncoded));
-			if (result.value === null) return Option.none();
-			const value = yield* decodeValue(result.value);
-			const metadata = result.metadata === null ? Option.none() : Option.some(yield* Schema.decodeUnknownEffect(metadataSchema)(result.metadata));
-			return Option.some({
-				value,
-				metadata,
-				cacheStatus: Option.fromNullishOr(result.cacheStatus)
-			});
-		}),
-		list: Effect.fn("Kv.list", { attributes: {
-			binding: definition.binding,
-			operation: "list"
-		} })(function* (options) {
-			const { metadataSchema, ...kvOptions } = options ?? {};
-			const result = yield* tryKvPromise(definition.binding, "list", () => kv.list(kvOptions));
-			const keys = [];
-			for (const key of result.keys) {
-				const decodedName = yield* decodeKey(key.name);
-				const decodedMetadata = key.metadata === void 0 ? Option.none() : metadataSchema === void 0 ? Option.some(key.metadata) : Option.some(yield* Schema.decodeUnknownEffect(metadataSchema)(key.metadata));
-				keys.push({
-					name: decodedName,
-					expiration: Option.fromUndefinedOr(key.expiration),
-					metadata: decodedMetadata
-				});
-			}
-			return {
-				keys,
-				listComplete: result.list_complete,
-				cursor: Option.fromNullishOr("cursor" in result ? result.cursor : void 0),
-				cacheStatus: Option.fromNullishOr(result.cacheStatus)
-			};
-		}),
-		delete: Effect.fn("Kv.delete", { attributes: {
-			binding: definition.binding,
-			operation: "delete"
-		} })(function* (key) {
-			const keyEncoded = yield* encodeKey(key);
-			yield* tryKvPromise(definition.binding, "delete", () => kv.delete(keyEncoded));
-		}),
-		rawUnsafe: Effect.succeed(kv)
-	});
-};
-const layer$3 = (tag, definition) => layer$18(tag, definition.binding, isKvNamespace, makeClient$3(definition), { expected: expectedKvNamespace });
-const makeDefinition$1 = (id, definition) => {
-	const kvDefinition = {
-		id,
-		key: definition.key,
-		value: definition.value
-	};
-	return Object.assign(kvDefinition, { layer: (tag, binding) => layer$3(tag, {
-		...binding,
-		key: definition.key,
-		value: definition.value
-	}) });
-};
-const Tag$4 = () => (id, definition) => {
-	const kvDefinition = makeDefinition$1(id, definition);
-	const tag = Context.Service()(id);
-	const makeLayer = (binding) => kvDefinition.layer(tag, binding);
-	return Object.assign(tag, {
-		id: kvDefinition.id,
-		keySchema: kvDefinition.key,
-		valueSchema: kvDefinition.value,
-		layer: makeLayer
-	});
-};
-//#endregion
-//#region src/R2.ts
-var R2_exports = /* @__PURE__ */ __exportAll({
-	R2OperationError: () => R2OperationError,
-	Tag: () => Tag$3,
-	isR2Bucket: () => isR2Bucket,
-	layer: () => layer$2,
-	make: () => make$3,
-	makeClient: () => makeClient$2
-});
-const expectedR2Bucket = "R2 bucket binding with head(), get(), put(), createMultipartUpload(), resumeMultipartUpload(), delete(), and list()";
-var R2OperationError = class extends Data.TaggedError("R2OperationError") {
-	get message() {
-		return `R2 ${this.operation} failed for binding "${this.binding}": ${causeMessage(this.cause)}`;
-	}
-};
-const r2Error = (binding, operation, cause) => new R2OperationError({
-	binding,
-	operation,
-	cause
-});
-const tryR2Promise = (binding, operation, evaluate) => Effect.tryPromise({
-	try: evaluate,
-	catch: (cause) => r2Error(binding, operation, cause)
-});
-const tryR2Sync = (binding, operation, evaluate) => Effect.try({
-	try: evaluate,
-	catch: (cause) => r2Error(binding, operation, cause)
-});
-const spanOptions$1 = (binding, operation) => ({ attributes: {
-	binding,
-	operation
-} });
-const isR2ObjectBody = (value) => "body" in value && Predicate.isFunction(value.arrayBuffer) && Predicate.isFunction(value.bytes) && Predicate.isFunction(value.text) && Predicate.isFunction(value.json) && Predicate.isFunction(value.blob);
-const wrapObjectBody = (binding, object) => ({
-	key: object.key,
-	version: object.version,
-	size: object.size,
-	etag: object.etag,
-	httpEtag: object.httpEtag,
-	checksums: object.checksums,
-	uploaded: object.uploaded,
-	httpMetadata: object.httpMetadata,
-	customMetadata: object.customMetadata,
-	range: object.range,
-	storageClass: object.storageClass,
-	ssecKeyMd5: object.ssecKeyMd5,
-	writeHttpMetadata: (headers) => object.writeHttpMetadata(headers),
-	raw: object,
-	body: object.body,
-	get bodyUsed() {
-		return object.bodyUsed;
-	},
-	arrayBuffer: tryR2Promise(binding, "arrayBuffer", () => object.arrayBuffer()).pipe(Effect.withSpan("R2.arrayBuffer", spanOptions$1(binding, "arrayBuffer"))),
-	bytes: tryR2Promise(binding, "bytes", () => object.bytes()).pipe(Effect.withSpan("R2.bytes", spanOptions$1(binding, "bytes"))),
-	text: tryR2Promise(binding, "text", () => object.text()).pipe(Effect.withSpan("R2.text", spanOptions$1(binding, "text"))),
-	json: () => tryR2Promise(binding, "json", () => object.json()).pipe(Effect.withSpan("R2.json", spanOptions$1(binding, "json"))),
-	blob: tryR2Promise(binding, "blob", () => object.blob()).pipe(Effect.withSpan("R2.blob", spanOptions$1(binding, "blob")))
-});
-const wrapGetResult = (binding, object) => {
-	if (object === null || !isR2ObjectBody(object)) return object;
-	return wrapObjectBody(binding, object);
-};
-const R2BucketSchema = Schema.declare((value) => Predicate.hasProperty(value, "head") && Predicate.isFunction(value.head) && Predicate.hasProperty(value, "get") && Predicate.isFunction(value.get) && Predicate.hasProperty(value, "put") && Predicate.isFunction(value.put) && Predicate.hasProperty(value, "createMultipartUpload") && Predicate.isFunction(value.createMultipartUpload) && Predicate.hasProperty(value, "resumeMultipartUpload") && Predicate.isFunction(value.resumeMultipartUpload) && Predicate.hasProperty(value, "delete") && Predicate.isFunction(value.delete) && Predicate.hasProperty(value, "list") && Predicate.isFunction(value.list));
-const decodeR2Bucket = Schema.decodeUnknownOption(R2BucketSchema);
-const isR2Bucket = (value) => Option.isSome(decodeR2Bucket(value));
-const makeClient$2 = (definition) => {
-	const wrapUpload = (upload) => ({
-		raw: upload,
-		key: upload.key,
-		uploadId: upload.uploadId,
-		uploadPart: Effect.fn("R2.uploadPart", spanOptions$1(definition.binding, "uploadPart"))((partNumber, value, options) => tryR2Promise(definition.binding, "uploadPart", () => upload.uploadPart(partNumber, value, options))),
-		abort: tryR2Promise(definition.binding, "abortMultipartUpload", () => upload.abort()).pipe(Effect.withSpan("R2.abortMultipartUpload", spanOptions$1(definition.binding, "abortMultipartUpload"))),
-		complete: Effect.fn("R2.completeMultipartUpload", spanOptions$1(definition.binding, "completeMultipartUpload"))((uploadedParts) => tryR2Promise(definition.binding, "completeMultipartUpload", () => upload.complete([...uploadedParts])))
-	});
-	return (bucket) => {
-		const get = Effect.fn("R2.get", spanOptions$1(definition.binding, "get"))((key, options) => tryR2Promise(definition.binding, "get", () => bucket.get(key, options)).pipe(Effect.map((object) => Option.fromNullOr(wrapGetResult(definition.binding, object)))));
-		return {
-			definition,
-			head: Effect.fn("R2.head", spanOptions$1(definition.binding, "head"))((key) => tryR2Promise(definition.binding, "head", () => bucket.head(key)).pipe(Effect.map(Option.fromNullOr))),
-			get,
-			put: Effect.fn("R2.put", spanOptions$1(definition.binding, "put"))((key, value, options) => tryR2Promise(definition.binding, "put", () => bucket.put(key, value, options)).pipe(Effect.map((object) => {
-				if (object === null) return Option.none();
-				if (options !== void 0 && "onlyIf" in options) return Option.some(object);
-				return object;
-			}))),
-			createMultipartUpload: Effect.fn("R2.createMultipartUpload", spanOptions$1(definition.binding, "createMultipartUpload"))((key, options) => tryR2Promise(definition.binding, "createMultipartUpload", () => bucket.createMultipartUpload(key, options)).pipe(Effect.map(wrapUpload))),
-			resumeMultipartUpload: Effect.fn("R2.resumeMultipartUpload", spanOptions$1(definition.binding, "resumeMultipartUpload"))((key, uploadId) => tryR2Sync(definition.binding, "resumeMultipartUpload", () => wrapUpload(bucket.resumeMultipartUpload(key, uploadId)))),
-			delete: Effect.fn("R2.delete", spanOptions$1(definition.binding, "delete"))((keys) => {
-				const nativeKeys = Predicate.isString(keys) ? keys : [...keys];
-				return tryR2Promise(definition.binding, "delete", () => bucket.delete(nativeKeys));
-			}),
-			list: Effect.fn("R2.list", spanOptions$1(definition.binding, "list"))((options) => tryR2Promise(definition.binding, "list", () => bucket.list(options))),
-			rawUnsafe: Effect.succeed(bucket)
-		};
-	};
-};
-const layer$2 = (tag, definition) => layer$18(tag, definition.binding, isR2Bucket, makeClient$2(definition), { expected: expectedR2Bucket });
-const make$3 = (id) => Tag$3()(id);
-const Tag$3 = () => (id) => {
-	const tag = Context.Service()(id);
-	const makeLayer = (definition) => layer$2(tag, definition);
-	return Object.assign(tag, {
-		id,
-		layer: makeLayer
-	});
-};
-//#endregion
-//#region src/Vectorize.ts
-var Vectorize_exports = /* @__PURE__ */ __exportAll({
-	Tag: () => Tag$2,
-	VectorizeOperationError: () => VectorizeOperationError,
-	isVectorizeBinding: () => isVectorizeBinding,
-	layer: () => layer$1,
-	make: () => make$2,
-	makeClient: () => makeClient$1
-});
-const expectedVectorizeBinding = "Vectorize index binding with describe(), query(), insert(), upsert(), deleteByIds(), and getByIds()";
-var VectorizeOperationError = class extends Data.TaggedError("VectorizeOperationError") {
-	get message() {
-		return `Vectorize ${this.operation} failed for binding "${this.binding}": ${causeMessage(this.cause)}`;
-	}
-};
-const vectorizeError = (binding, operation, cause) => new VectorizeOperationError({
-	binding,
-	operation,
-	cause
-});
-const tryVectorizePromise = (binding, operation, evaluate) => Effect.tryPromise({
-	try: evaluate,
-	catch: (cause) => vectorizeError(binding, operation, cause)
-});
-const spanOptions = (binding, operation) => ({ attributes: {
-	binding,
-	operation
-} });
-const invokeVectorizeMethod = (method, receiver, args) => {
-	return Function.prototype.apply.call(method, receiver, args);
-};
-const VectorizeBindingSchema = Schema.declare((value) => Predicate.hasProperty(value, "describe") && Predicate.isFunction(value.describe) && Predicate.hasProperty(value, "query") && Predicate.isFunction(value.query) && Predicate.hasProperty(value, "insert") && Predicate.isFunction(value.insert) && Predicate.hasProperty(value, "upsert") && Predicate.isFunction(value.upsert) && Predicate.hasProperty(value, "deleteByIds") && Predicate.isFunction(value.deleteByIds) && Predicate.hasProperty(value, "getByIds") && Predicate.isFunction(value.getByIds));
-const decodeVectorizeBinding = Schema.decodeUnknownOption(VectorizeBindingSchema);
-const isVectorizeBinding = (value) => Option.isSome(decodeVectorizeBinding(value));
-const makeClient$1 = (definition) => (index) => {
-	const runtime = index;
-	const deleteByIds = Effect.fn("Vectorize.deleteByIds", spanOptions(definition.binding, "deleteByIds"))((ids) => tryVectorizePromise(definition.binding, "deleteByIds", () => runtime.deleteByIds([...ids])));
-	return {
-		definition,
-		describe: tryVectorizePromise(definition.binding, "describe", () => runtime.describe()).pipe(Effect.withSpan("Vectorize.describe", spanOptions(definition.binding, "describe"))),
-		query: Effect.fn("Vectorize.query", spanOptions(definition.binding, "query"))((vector, options) => tryVectorizePromise(definition.binding, "query", () => {
-			return runtime.query(vector, options);
-		})),
-		queryById: Effect.fn("Vectorize.queryById", spanOptions(definition.binding, "queryById"))((vectorId, options) => runtime.queryById !== void 0 ? tryVectorizePromise(definition.binding, "queryById", () => {
-			const queryById = runtime.queryById;
-			return queryById === void 0 ? Promise.reject(/* @__PURE__ */ new TypeError("Vectorize binding does not expose queryById()")) : invokeVectorizeMethod(queryById, runtime, [vectorId, options]);
-		}) : Effect.fail(vectorizeError(definition.binding, "queryById", /* @__PURE__ */ new TypeError("Vectorize binding does not expose queryById()")))),
-		insert: Effect.fn("Vectorize.insert", spanOptions(definition.binding, "insert"))((vectors) => tryVectorizePromise(definition.binding, "insert", () => runtime.insert([...vectors]))),
-		upsert: Effect.fn("Vectorize.upsert", spanOptions(definition.binding, "upsert"))((vectors) => tryVectorizePromise(definition.binding, "upsert", () => runtime.upsert([...vectors]))),
-		deleteByIds,
-		delete: deleteByIds,
-		getByIds: Effect.fn("Vectorize.getByIds", spanOptions(definition.binding, "getByIds"))((ids) => tryVectorizePromise(definition.binding, "getByIds", () => runtime.getByIds([...ids]))),
-		rawUnsafe: Effect.succeed(index)
-	};
-};
-const layer$1 = (tag, definition) => layer$18(tag, definition.binding, isVectorizeBinding, makeClient$1(definition), { expected: expectedVectorizeBinding });
-const make$2 = (id) => Tag$2()(id);
-const Tag$2 = () => (id) => {
-	const tag = Context.Service()(id);
-	const makeLayer = (definition) => layer$1(tag, definition);
-	return Object.assign(tag, {
-		id,
-		layer: makeLayer
-	});
-};
-//#endregion
-//#region src/WebTransport.ts
-var WebTransport_exports = /* @__PURE__ */ __exportAll({
-	InboundTransport: () => InboundTransport,
-	WebTransportUnsupportedError: () => WebTransportUnsupportedError,
-	capabilities: () => capabilities,
-	inboundSessionsUnsupported: () => inboundSessionsUnsupported,
-	inboundTransport: () => inboundTransport,
-	isHttp3: () => isHttp3
-});
-/**
-* Metadata Cloudflare's edge reports about the inbound client connection.
-*
-* `httpProtocol` and `clientTcpRtt` are declared in
-* `@cloudflare/workers-types`; `clientQuicRtt` is documented by Cloudflare
-* ("only present when the client connected over QUIC (HTTP/3)") but not yet
-* present in the published types, so it is decoded from the open
-* `Record<string, unknown>` side of `request.cf`.
-*/
-var InboundTransport = class extends Schema.Class("InboundTransport")({
-	httpProtocol: Schema.String,
-	clientQuicRtt: Schema.optional(Schema.Number),
-	clientTcpRtt: Schema.optional(Schema.Number)
-}) {};
-const decodeInboundTransport = Schema.decodeUnknownResult(InboundTransport);
-/**
-* Decodes the inbound transport metadata from `request.cf`.
-*
-* Returns `None` when the metadata is absent (for example in local `wrangler
-* dev` or when a Worker invokes another Worker directly) or does not match
-* the expected shape.
-*/
-const inboundTransport = (request) => Result.getSuccess(decodeInboundTransport(request.cf));
-const isHttp3 = (transport) => transport.clientQuicRtt !== void 0 || transport.httpProtocol === "HTTP/3";
-const capabilities = Effect.sync(() => {
-	const runtime = globalThis;
-	return {
-		inboundSessions: false,
-		outboundSessions: Predicate.hasProperty(runtime, "WebTransport") && Predicate.isFunction(runtime["WebTransport"])
-	};
-});
-var WebTransportUnsupportedError = class extends Data.TaggedError("WebTransportUnsupportedError") {
-	get message() {
-		return this.capability === "inbound-sessions" ? "Cloudflare Workers cannot accept inbound WebTransport sessions: the edge terminates QUIC and no runtime session API exists (cloudflare/workerd#6451). Use Durable Object WebSockets for bidirectional push." : "This Workers runtime provides no WebTransport client: workerd has no QUIC stack and cloudflare:sockets is TCP-only.";
-	}
-};
-/**
-* The explicit typed boundary for inbound WebTransport sessions.
-*
-* Always fails with {@link WebTransportUnsupportedError} today. Route the
-* code path that would accept a session through this effect so the
-* limitation is visible in the type system and greppable when Cloudflare
-* ships a real API.
-*/
-const inboundSessionsUnsupported = Effect.fail(new WebTransportUnsupportedError({ capability: "inbound-sessions" }));
-//#endregion
-//#region src/WorkflowBinding.ts
-var WorkflowBinding_exports = /* @__PURE__ */ __exportAll({
-	WorkflowOperationError: () => WorkflowOperationError,
-	WorkflowResultDecodeError: () => WorkflowResultDecodeError,
-	isWorkflow: () => isWorkflow,
-	layer: () => layer,
-	makeClient: () => makeClient
-});
-const expectedWorkflow = "Workflow binding with create(), createBatch(), and get()";
-var WorkflowOperationError = class extends Data.TaggedError("WorkflowOperationError") {
-	get message() {
-		return `Workflow ${this.operation} failed for binding "${this.binding}": ${causeMessage(this.cause)}`;
-	}
-};
-var WorkflowResultDecodeError = class extends Data.TaggedError("WorkflowResultDecodeError") {
-	get message() {
-		return `Workflow result decode failed for binding "${this.binding}" instance "${this.instanceId}": ${causeMessage(this.cause)}`;
-	}
-};
-const workflowError = (binding, operation, cause) => new WorkflowOperationError({
-	binding,
-	operation,
-	cause
-});
-const tryWorkflowPromise = (binding, operation, evaluate) => Effect.tryPromise({
-	try: evaluate,
-	catch: (cause) => workflowError(binding, operation, cause)
-});
-const WorkflowBindingSchema = Schema.declare((value) => Predicate.hasProperty(value, "create") && Predicate.isFunction(value.create) && Predicate.hasProperty(value, "createBatch") && Predicate.isFunction(value.createBatch) && Predicate.hasProperty(value, "get") && Predicate.isFunction(value.get));
-const decodeWorkflowBinding = Schema.decodeUnknownOption(WorkflowBindingSchema);
-const isWorkflow = (value) => Option.isSome(decodeWorkflowBinding(value));
-const makeClient = (definition) => {
-	const encodePayload = Schema.encodeEffect(definition.payload);
-	const decodeResult = Schema.decodeUnknownEffect(definition.result);
-	const wrapInstance = (raw) => {
-		const operation = (name, evaluate) => tryWorkflowPromise(definition.binding, name, evaluate);
-		return {
-			raw,
-			id: raw.id,
-			pause: operation("pause", () => raw.pause()),
-			resume: operation("resume", () => raw.resume()),
-			terminate: (options) => operation("terminate", () => raw.terminate(options)),
-			restart: (options) => operation("restart", () => raw.restart(options)),
-			delete: operation("delete", () => raw.delete()),
-			status: operation("status", () => raw.status()).pipe(Effect.flatMap((status) => Effect.gen(function* () {
-				const output = status.output === void 0 || status.output === null && status.status !== "complete" ? Option.none() : Option.some(yield* decodeResult(status.output).pipe(Effect.mapError((cause) => new WorkflowResultDecodeError({
-					binding: definition.binding,
-					instanceId: raw.id,
-					cause
-				}))));
-				return {
-					status: status.status,
-					output,
-					error: status.error === null || status.error === void 0 ? Option.none() : Option.some(status.error)
-				};
-			}))),
-			sendEvent: (event) => operation("sendEvent", () => raw.sendEvent(event))
-		};
-	};
-	return (workflow) => ({
-		create: Effect.fn("WorkflowBinding.create", { attributes: {
-			binding: definition.binding,
-			operation: "create"
-		} })(function* (payload, options) {
-			const encoded = yield* encodePayload(payload);
-			const raw = yield* tryWorkflowPromise(definition.binding, "create", () => workflow.create({
-				...options,
-				params: encoded
-			}));
-			return wrapInstance(raw);
-		}),
-		createBatch: Effect.fn("WorkflowBinding.createBatch", { attributes: {
-			binding: definition.binding,
-			operation: "createBatch"
-		} })(function* (batch) {
-			const encodedBatch = [];
-			for (const item of batch) {
-				const { payload, ...options } = item;
-				encodedBatch.push({
-					...options,
-					params: yield* encodePayload(payload)
-				});
-			}
-			return (yield* tryWorkflowPromise(definition.binding, "createBatch", () => workflow.createBatch(encodedBatch))).map(wrapInstance);
-		}),
-		get: (instanceId) => tryWorkflowPromise(definition.binding, "get", () => workflow.get(instanceId)).pipe(Effect.map(wrapInstance)),
-		rawUnsafe: Effect.succeed(workflow)
-	});
-};
-const layer = (tag, definition) => layer$18(tag, definition.binding, (value) => isWorkflow(value), makeClient(definition), { expected: expectedWorkflow });
-//#endregion
-//#region src/WorkflowDefinition.ts
-var WorkflowDefinition_exports = /* @__PURE__ */ __exportAll({
-	Tag: () => Tag$1,
-	Workflow: () => Workflow,
-	implement: () => implement$1,
-	make: () => make$1
-});
-const makeDefinition = (id, definition) => {
-	const workflowDefinition = {
-		id,
-		payload: definition.payload,
-		result: definition.result
-	};
-	return Object.assign(workflowDefinition, { make: (layer, options) => make(layer, { run: wrapHandler(workflowDefinition, options.run) }) });
-};
-const make$1 = (id, definition) => Tag$1()(id, definition);
-const Tag$1 = () => (id, definition) => {
-	const workflowDefinition = makeDefinition(id, definition);
-	const tag = Context.Service()(`effect-cf/Workflow/${id}`);
-	const layer$19 = (binding) => layer(tag, {
-		...binding,
-		payload: definition.payload,
-		result: definition.result
-	});
-	const create = Effect.fnUntraced(function* (payload, options) {
-		return yield* (yield* tag).create(payload, options);
-	});
-	const createBatch = Effect.fnUntraced(function* (batch) {
-		return yield* (yield* tag).createBatch(batch);
-	});
-	const get = Effect.fnUntraced(function* (instanceId) {
-		return yield* (yield* tag).get(instanceId);
-	});
-	const rawUnsafe = Effect.flatMap(tag, (workflow) => workflow.rawUnsafe);
-	return Object.assign(tag, {
-		id: workflowDefinition.id,
-		payload: workflowDefinition.payload,
-		result: workflowDefinition.result,
-		make: workflowDefinition.make,
-		layer: layer$19,
-		create,
-		createBatch,
-		get,
-		rawUnsafe
-	});
-};
-const Workflow = Tag$1;
-const wrapHandler = (definition, handler) => {
-	const decodePayload = Schema.decodeUnknownEffect(definition.payload);
-	const encodeResult = Schema.encodeEffect(definition.result);
-	return Effect.fnUntraced(function* (payload) {
-		const decodedPayload = yield* decodePayload(payload);
-		const decodedEvent = {
-			...yield* WorkflowEvent$1,
-			payload: decodedPayload
-		};
-		const result = yield* handler(decodedPayload).pipe(Effect.provideService(WorkflowEvent$1, decodedEvent));
-		return yield* encodeResult(result);
-	});
-};
-const implement$1 = (_definition, handler) => handler;
-//#endregion
-//#region src/Workflow.ts
-var Workflow_exports = /* @__PURE__ */ __exportAll({
-	Tag: () => Tag,
-	WorkflowEvent: () => WorkflowEvent$1,
-	WorkflowStep: () => WorkflowStep$1,
-	WorkflowStepContext: () => WorkflowStepContext$1,
-	WorkflowStepError: () => WorkflowStepError,
-	WorkflowStepNonRetryableError: () => WorkflowStepNonRetryableError,
-	implement: () => implement,
-	make: () => make,
-	sleep: () => sleep,
-	sleepUntil: () => sleepUntil,
-	step: () => step,
-	waitForEvent: () => waitForEvent
-});
-var WorkflowEvent$1 = class extends Context.Service()("effect-cf/WorkflowEvent") {};
-var WorkflowStepError = class extends Data.TaggedError("WorkflowStepError") {
-	get message() {
-		const step = this.step === void 0 ? "" : ` in step "${this.step}"`;
-		return `Workflow ${this.operation} failed${step}: ${causeMessage(this.cause)}`;
-	}
-};
-/**
-* Typed step failure that Cloudflare must treat as terminal instead of retrying.
-*
-* The workflow boundary converts this value into Cloudflare's native
-* `NonRetryableError` while preserving the original cause and its message.
-*/
-var WorkflowStepNonRetryableError = class extends Data.TaggedError("WorkflowStepNonRetryableError") {
-	get message() {
-		return `Workflow step failed without retry: ${causeMessage(this.cause)}`;
-	}
-};
-var WorkflowStep$1 = class extends Context.Service()("effect-cf/WorkflowStep") {};
-var WorkflowStepContext$1 = class extends Context.Service()("effect-cf/WorkflowStepContext") {};
-const fromWorkflowEvent = (event) => ({
-	raw: event,
-	payload: event.payload,
-	timestamp: event.timestamp,
-	instanceId: event.instanceId,
-	workflowName: event.workflowName
-});
-const toCloudflareNonRetryableError = (error) => {
-	const cloudflareError = new NonRetryableError(error.message);
-	cloudflareError.cause = error.cause;
-	return cloudflareError;
-};
-const exposeCloudflareNonRetryableError = (effect) => Effect.catchCause(effect, (cause) => {
-	const error = Cause.findErrorOption(cause);
-	return Option.isSome(error) && error.value instanceof WorkflowStepNonRetryableError ? Effect.die(toCloudflareNonRetryableError(error.value)) : Effect.failCause(cause);
-});
-const fromWorkflowStep = (step) => ({
-	raw: step,
-	do: (name, effect, config) => Effect.gen(function* () {
-		const context = yield* Effect.context();
-		return yield* Effect.scoped(Effect.gen(function* () {
-			const runPromise = yield* FiberSet.makeRuntimePromise();
-			return yield* Effect.tryPromise({
-				try: () => {
-					const run = (stepContext) => {
-						const stepEffect = Effect.scoped(Effect.provideService(effect, WorkflowStepContext$1, stepContext));
-						return runPromise(exposeCloudflareNonRetryableError(Effect.provideContext(stepEffect, context)));
-					};
-					const rawStep = step;
-					return config === void 0 ? rawStep.do(name, run) : rawStep.do(name, config, run);
-				},
-				catch: (cause) => new WorkflowStepError({
-					step: name,
-					operation: "do",
-					cause
-				})
-			});
-		}));
-	}),
-	sleep: (name, duration) => Effect.tryPromise({
-		try: () => step.sleep(name, duration),
-		catch: (cause) => new WorkflowStepError({
-			step: name,
-			operation: "sleep",
-			cause
-		})
-	}),
-	sleepUntil: (name, timestamp) => Effect.tryPromise({
-		try: () => step.sleepUntil(name, timestamp),
-		catch: (cause) => new WorkflowStepError({
-			step: name,
-			operation: "sleepUntil",
-			cause
-		})
-	}),
-	waitForEvent: (name, options) => Effect.tryPromise({
-		try: () => {
-			return step.waitForEvent(name, options);
-		},
-		catch: (cause) => new WorkflowStepError({
-			step: name,
-			operation: "waitForEvent",
-			cause
-		})
-	})
-});
-const make = (layer, options) => {
-	class EffectWorkflow extends WorkflowEntrypoint {
-		runtime;
-		constructor(ctx, env) {
-			super(ctx, env);
-			this.runtime = makeEntrypointRuntime(layer, env, Layer.mergeAll(Layer.succeed(ExecutionContext, ctx), Layer.succeed(WorkerContext, fromExecutionContext(ctx))));
-		}
-		run(event, step) {
-			const workflowServices = Layer.mergeAll(Layer.succeed(WorkflowEvent$1, fromWorkflowEvent(event)), Layer.succeed(WorkflowStep$1, fromWorkflowStep(step)));
-			return runEventPromise(this.runtime, options.run(event.payload), workflowServices);
-		}
-	}
-	return assumeEntrypointClass(EffectWorkflow);
-};
-const step = (name, effect, config) => Effect.flatMap(WorkflowStep$1, (workflowStep) => workflowStep.do(name, effect, config));
-const sleep = (name, duration) => Effect.flatMap(WorkflowStep$1, (workflowStep) => workflowStep.sleep(name, duration));
-const sleepUntil = (name, timestamp) => Effect.flatMap(WorkflowStep$1, (workflowStep) => workflowStep.sleepUntil(name, timestamp));
-const waitForEvent = (name, options) => Effect.flatMap(WorkflowStep$1, (workflowStep) => workflowStep.waitForEvent(name, options));
-const Tag = Tag$1;
-const implement = implement$1;
-//#endregion
+import { Environment_exports, WorkerConfig, WorkerEnvironment } from "./Environment.mjs";
+import { Binding_exports } from "./Binding.mjs";
+import { WorkersAi_exports } from "./WorkersAi.mjs";
+import { AiGateway_exports } from "./AiGateway.mjs";
+import { AnalyticsEngine_exports } from "./AnalyticsEngine.mjs";
+import { Artifacts_exports } from "./Artifacts.mjs";
+import { BrowserRendering_exports } from "./BrowserRendering.mjs";
+import { Cache_exports } from "./Cache.mjs";
+import { DurableObjectStorage_exports } from "./DurableObjectStorage.mjs";
+import { DurableObjectWebSocket_exports } from "./DurableObjectWebSocket.mjs";
+import { DurableObjectState_exports } from "./DurableObjectState.mjs";
+import { CloudflareOtlp_exports } from "./CloudflareOtlp.mjs";
+import { CloudflareTracer_exports } from "./CloudflareTracer.mjs";
+import { ContainerNamespace_exports } from "./ContainerNamespace.mjs";
+import { D1_exports } from "./D1.mjs";
+import { QueueBinding_exports } from "./QueueBinding.mjs";
+import { QueueDefinition_exports } from "./QueueDefinition.mjs";
+import { Queue_exports } from "./Queue.mjs";
+import { RpcDefinition_exports } from "./RpcDefinition.mjs";
+import { RpcTracing_exports } from "./RpcTracing.mjs";
+import { Rpc_exports } from "./Rpc.mjs";
+import { ServiceBinding_exports } from "./ServiceBinding.mjs";
+import { WorkerDefinition_exports } from "./WorkerDefinition.mjs";
+import { Worker_exports } from "./Worker.mjs";
+import { DurableObjectAlarm_exports } from "./DurableObjectAlarm.mjs";
+import { DurableObjectNamespace_exports } from "./DurableObjectNamespace.mjs";
+import { DurableObjectDefinition_exports } from "./DurableObjectDefinition.mjs";
+import { DurableObject_exports } from "./DurableObject.mjs";
+import { DurableObjectRpcWebSocket_exports } from "./DurableObjectRpcWebSocket.mjs";
+import { DurableObjectSqlite_exports } from "./DurableObjectSqlite.mjs";
+import { Email_exports } from "./Email.mjs";
+import { Hyperdrive_exports } from "./Hyperdrive.mjs";
+import { Images_exports } from "./Images.mjs";
+import { Kv_exports } from "./Kv.mjs";
+import { R2_exports } from "./R2.mjs";
+import { Vectorize_exports } from "./Vectorize.mjs";
+import { WebTransport_exports } from "./WebTransport.mjs";
+import { WorkflowBinding_exports } from "./WorkflowBinding.mjs";
+import { WorkflowDefinition_exports } from "./WorkflowDefinition.mjs";
+import { Workflow_exports } from "./Workflow.mjs";
 export { AiGateway_exports as AiGateway, AnalyticsEngine_exports as AnalyticsEngine, Artifacts_exports as Artifacts, Binding_exports as Binding, BrowserRendering_exports as BrowserRendering, Cache_exports as Cache, CloudflareOtlp_exports as CloudflareOtlp, CloudflareTracer_exports as CloudflareTracer, ContainerNamespace_exports as ContainerNamespace, D1_exports as D1, DurableObject_exports as DurableObject, DurableObjectAlarm_exports as DurableObjectAlarm, DurableObjectDefinition_exports as DurableObjectDefinition, DurableObjectNamespace_exports as DurableObjectNamespace, DurableObjectRpcWebSocket_exports as DurableObjectRpcWebSocket, DurableObjectSqlite_exports as DurableObjectSqlite, DurableObjectState_exports as DurableObjectState, DurableObjectStorage_exports as DurableObjectStorage, DurableObjectWebSocket_exports as DurableObjectWebSocket, Email_exports as Email, Environment_exports as Environment, Hyperdrive_exports as Hyperdrive, Images_exports as Images, Kv_exports as Kv, Queue_exports as Queue, QueueBinding_exports as QueueBinding, QueueDefinition_exports as QueueDefinition, R2_exports as R2, Rpc_exports as Rpc, RpcDefinition_exports as RpcDefinition, RpcTracing_exports as RpcTracing, ServiceBinding_exports as ServiceBinding, Vectorize_exports as Vectorize, WebTransport_exports as WebTransport, Worker_exports as Worker, WorkerConfig, WorkerDefinition_exports as WorkerDefinition, WorkerEnvironment, WorkersAi_exports as WorkersAi, Workflow_exports as Workflow, WorkflowBinding_exports as WorkflowBinding, WorkflowDefinition_exports as WorkflowDefinition };