effect-cf 0.39.1 → 0.40.1

package/dist/Worker-XsGJsCJX.mjs

@@ -1,885 +0,0 @@
-import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
-import { a as WorkerEnvironment, i as WorkerConfig, t as causeMessage } from "./ErrorMessage-Byx2OgNd.mjs";
-import { n as Service$1, r as layer$2 } from "./Binding-C82jRhdr.mjs";
-import { t as fromExecutionContext } from "./WorkerContext-Yobnfw-K.mjs";
-import { Cause, Clock, ConfigProvider, Context, Data, Effect, Exit, Layer, ManagedRuntime, Option, Predicate, References, Schema, Tracer } from "effect";
-import { HttpEffect, HttpMiddleware, HttpServerRequest, HttpServerResponse } from "effect/unstable/http";
-import { OtlpExporter } from "effect/unstable/observability";
-import { RpcStub, RpcTarget, WorkerEntrypoint } from "cloudflare:workers";
-//#region src/QueueBinding.ts
-var QueueBinding_exports = /* @__PURE__ */ __exportAll({
-	QueueOperationError: () => QueueOperationError,
-	isQueue: () => isQueue,
-	layer: () => layer$1,
-	makeClient: () => makeClient$1
-});
-const expectedQueueProducer = "Queue producer binding with send(); optional sendBatch()/metrics()";
-var QueueOperationError = class extends Data.TaggedError("QueueOperationError") {};
-const tryQueuePromise = (binding, operation, evaluate) => Effect.tryPromise({
-	try: evaluate,
-	catch: (cause) => new QueueOperationError({
-		binding,
-		operation,
-		cause,
-		message: `Cloudflare queue binding "${binding}" operation "${operation}" failed`
-	})
-});
-const isQueue = (value) => Predicate.hasProperty(value, "send") && Predicate.isFunction(value.send);
-const makeClient$1 = (definition) => {
-	const encodeMessage = Schema.encodeEffect(definition.message);
-	return (queue) => ({
-		send: Effect.fn("QueueBinding.send", { attributes: {
-			binding: definition.binding,
-			operation: "send"
-		} })(function* (message, options) {
-			const encoded = yield* encodeMessage(message);
-			yield* tryQueuePromise(definition.binding, "send", () => queue.send(encoded, options));
-		}),
-		sendBatch: Effect.fn("QueueBinding.sendBatch", { attributes: {
-			binding: definition.binding,
-			operation: "sendBatch"
-		} })(function* (messages, options) {
-			const encodedMessages = [];
-			for (const message of messages) encodedMessages.push({
-				...message,
-				body: yield* encodeMessage(message.body)
-			});
-			const sendBatch = queue.sendBatch;
-			if (sendBatch === void 0) return yield* new QueueOperationError({
-				binding: definition.binding,
-				operation: "sendBatch",
-				cause: /* @__PURE__ */ new Error(`Queue binding "${definition.binding}" does not provide sendBatch()`),
-				message: `Cloudflare queue binding "${definition.binding}" does not provide sendBatch()`
-			});
-			yield* tryQueuePromise(definition.binding, "sendBatch", () => sendBatch.call(queue, encodedMessages, options));
-		}),
-		metrics: () => {
-			const metrics = queue.metrics;
-			if (metrics === void 0) return Effect.fail(new QueueOperationError({
-				binding: definition.binding,
-				operation: "metrics",
-				cause: /* @__PURE__ */ new Error(`Queue binding "${definition.binding}" does not provide metrics()`),
-				message: `Cloudflare queue binding "${definition.binding}" does not provide metrics()`
-			}));
-			return tryQueuePromise(definition.binding, "metrics", () => metrics.call(queue));
-		},
-		rawUnsafe: Effect.succeed(queue)
-	});
-};
-const layer$1 = (tag, definition) => layer$2(tag, definition.binding, (value) => isQueue(value), makeClient$1(definition), { expected: expectedQueueProducer });
-//#endregion
-//#region src/QueueDefinition.ts
-var QueueDefinition_exports = /* @__PURE__ */ __exportAll({
-	Queue: () => Queue$1,
-	Tag: () => Tag$2,
-	implement: () => implement$2,
-	make: () => make$3
-});
-const makeDefinition$1 = (id, definition) => {
-	const queueDefinition = {
-		id,
-		message: definition.message
-	};
-	return Object.assign(queueDefinition, { make: (layer, options) => make(layer, {
-		...options,
-		queue: wrapHandler(queueDefinition, options.queue)
-	}) });
-};
-const make$3 = (id, definition) => Tag$2()(id, definition);
-const Tag$2 = () => (id, definition) => {
-	const queueDefinition = makeDefinition$1(id, definition);
-	const tag = Context.Service()(`effect-cf/Queue/${id}`);
-	const layer = (binding) => layer$1(tag, {
-		...binding,
-		message: definition.message
-	});
-	const send = Effect.fnUntraced(function* (message, options) {
-		yield* (yield* tag).send(message, options);
-	});
-	const sendBatch = Effect.fnUntraced(function* (messages, options) {
-		yield* (yield* tag).sendBatch(messages, options);
-	});
-	const metrics = Effect.fnUntraced(function* () {
-		return yield* (yield* tag).metrics();
-	});
-	const rawUnsafe = Effect.flatMap(tag, (queue) => queue.rawUnsafe);
-	return Object.assign(tag, {
-		id: queueDefinition.id,
-		message: queueDefinition.message,
-		make: queueDefinition.make,
-		layer,
-		send,
-		sendBatch,
-		metrics,
-		rawUnsafe
-	});
-};
-const Queue$1 = Tag$2;
-const wrapHandler = (definition, handler) => {
-	const decodeBody = Schema.decodeUnknownEffect(definition.message);
-	return Effect.fnUntraced(function* (batch) {
-		yield* handler(yield* decodeBatch(batch.raw, decodeBody));
-	});
-};
-const implement$2 = (_definition, handler) => handler;
-//#endregion
-//#region src/Queue.ts
-var Queue_exports = /* @__PURE__ */ __exportAll({
-	QueueMessageDecodeError: () => QueueMessageDecodeError,
-	Tag: () => Tag$1,
-	decodeBatch: () => decodeBatch,
-	fromMessage: () => fromMessage,
-	fromMessageBatch: () => fromMessageBatch,
-	implement: () => implement$1
-});
-var QueueMessageDecodeError = class extends Data.TaggedError("QueueMessageDecodeError") {
-	get message() {
-		return `Queue "${this.queue}" failed to decode message "${this.messageId}" at index ${this.index}: ${causeMessage(this.cause)}`;
-	}
-};
-const fromMessage = (message, body) => ({
-	raw: message,
-	id: message.id,
-	timestamp: message.timestamp,
-	body,
-	attempts: message.attempts,
-	ack: Effect.sync(() => message.ack()),
-	retry: (options) => Effect.sync(() => message.retry(options))
-});
-const fromMessageBatch = (batch, messages) => ({
-	raw: batch,
-	messages,
-	queue: batch.queue,
-	metadata: batch.metadata,
-	ackAll: Effect.sync(() => batch.ackAll()),
-	retryAll: (options) => Effect.sync(() => batch.retryAll(options))
-});
-const decodeBatch = (batch, decodeBody) => Effect.gen(function* () {
-	const messages = [];
-	for (let index = 0; index < batch.messages.length; index++) {
-		const message = batch.messages[index];
-		const body = yield* decodeBody(message.body).pipe(Effect.mapError((cause) => new QueueMessageDecodeError({
-			queue: batch.queue,
-			messageId: message.id,
-			index,
-			cause
-		})));
-		messages.push(fromMessage(message, body));
-	}
-	return fromMessageBatch(batch, messages);
-});
-const Tag$1 = Tag$2;
-const implement$1 = implement$2;
-//#endregion
-//#region src/RpcDefinition.ts
-var RpcDefinition_exports = /* @__PURE__ */ __exportAll({
-	RpcArgumentCountError: () => RpcArgumentCountError,
-	RpcArgumentDecodeError: () => RpcArgumentDecodeError,
-	RpcArgumentEncodeError: () => RpcArgumentEncodeError,
-	RpcReservedMethodNameError: () => RpcReservedMethodNameError,
-	RpcSuccessDecodeError: () => RpcSuccessDecodeError,
-	RpcSuccessEncodeError: () => RpcSuccessEncodeError,
-	assertNoReservedMethods: () => assertNoReservedMethods,
-	decodeArgs: () => decodeArgs,
-	decodeSuccess: () => decodeSuccess,
-	decodeWireError: () => decodeWireError,
-	encodeArgs: () => encodeArgs,
-	encodeSuccess: () => encodeSuccess,
-	encodeWireError: () => encodeWireError,
-	isWireError: () => isWireError,
-	make: () => make$2,
-	method: () => method$1,
-	reservedMethodNames: () => reservedMethodNames$2
-});
-var RpcReservedMethodNameError = class extends Data.TaggedError("RpcReservedMethodNameError") {
-	get message() {
-		return `${this.definition} RPC method "${this.method}" is reserved by Cloudflare Workers RPC`;
-	}
-};
-var RpcArgumentCountError = class extends Schema.TaggedError()("RpcArgumentCountError", {
-	definition: Schema.String,
-	method: Schema.String,
-	expected: Schema.Number,
-	actual: Schema.Number
-}) {
-	get message() {
-		return `${this.definition} RPC method "${this.method}" expected ${this.expected} arguments but received ${this.actual}`;
-	}
-};
-var RpcArgumentDecodeError = class extends Schema.TaggedError()("RpcArgumentDecodeError", {
-	definition: Schema.String,
-	method: Schema.String,
-	cause: Schema.Defect()
-}) {
-	get message() {
-		return `${this.definition} RPC method "${this.method}" argument decode failed: ${causeMessage(this.cause)}`;
-	}
-};
-var RpcArgumentEncodeError = class extends Data.TaggedError("RpcArgumentEncodeError") {
-	get message() {
-		return `${this.definition} RPC method "${this.method}" argument encode failed: ${causeMessage(this.cause)}`;
-	}
-};
-var RpcSuccessDecodeError = class extends Data.TaggedError("RpcSuccessDecodeError") {
-	get message() {
-		return `${this.definition} RPC method "${this.method}" success decode failed: ${causeMessage(this.cause)}`;
-	}
-};
-var RpcSuccessEncodeError = class extends Schema.TaggedError()("RpcSuccessEncodeError", {
-	definition: Schema.String,
-	method: Schema.String,
-	cause: Schema.Defect()
-}) {
-	get message() {
-		return `${this.definition} RPC method "${this.method}" success encode failed: ${causeMessage(this.cause)}`;
-	}
-};
-const WireErrorSchema = Schema.Union([
-	RpcArgumentCountError,
-	RpcArgumentDecodeError,
-	RpcSuccessEncodeError
-]);
-const wireErrorKey = "effect-cf/RpcDefinition/wireError";
-const isWireError = (error) => error instanceof RpcArgumentCountError || error instanceof RpcArgumentDecodeError || error instanceof RpcSuccessEncodeError;
-/**
-* Encodes package RPC errors into a plain `Error` envelope so their tags
-* survive Cloudflare RPC serialization, which drops custom error properties.
-*/
-const encodeWireError = (error) => {
-	if (!isWireError(error)) return error;
-	try {
-		return new Error(JSON.stringify({ [wireErrorKey]: Schema.encodeSync(WireErrorSchema)(error) }));
-	} catch {
-		return error;
-	}
-};
-const decodeWireError = (cause) => {
-	if (!(cause instanceof Error)) return cause;
-	try {
-		const parsed = Schema.decodeUnknownSync(Schema.Unknown)(JSON.parse(cause.message));
-		if (!Predicate.hasProperty(parsed, wireErrorKey)) return cause;
-		return Schema.decodeUnknownSync(WireErrorSchema)(parsed[wireErrorKey]);
-	} catch {
-		return cause;
-	}
-};
-const reservedMethodNames$2 = /* @__PURE__ */ new Set([
-	"constructor",
-	"fetch",
-	"connect",
-	"alarm",
-	"webSocketMessage",
-	"webSocketClose",
-	"webSocketError",
-	"then",
-	"dup",
-	"dispose",
-	"serialize",
-	"deserialize"
-]);
-/**
-* Workers RPC structured-clones every value that crosses an isolate boundary
-* and rejects class instances. Declaration schemas such as `Schema.Result`
-* keep their container instance in their `Encoded` form, so the declared
-* schemas are lowered to their canonical JSON codec before touching the wire.
-*/
-const wireCodec = (schema) => Schema.toCodecJson(schema);
-const assertNoReservedMethods = (target, methods, reserved) => {
-	for (const method of Object.keys(methods)) if (reserved.has(method)) throw new RpcReservedMethodNameError({
-		definition: target,
-		method
-	});
-};
-function method$1(definition) {
-	return {
-		args: definition.args ?? [],
-		success: definition.success
-	};
-}
-const decodeArgs = Effect.fnUntraced(function* (definition, methodName, args) {
-	const methodDefinition = definition.methods[methodName];
-	if (args.length !== methodDefinition.args.length) return yield* new RpcArgumentCountError({
-		definition: definition.id,
-		method: methodName,
-		expected: methodDefinition.args.length,
-		actual: args.length
-	});
-	return yield* Schema.decodeUnknownEffect(wireCodec(Schema.Tuple(methodDefinition.args)))(args).pipe(Effect.mapError((cause) => new RpcArgumentDecodeError({
-		definition: definition.id,
-		method: methodName,
-		cause
-	})));
-});
-const encodeArgs = Effect.fnUntraced(function* (definition, methodName, args) {
-	const methodDefinition = definition.methods[methodName];
-	if (args.length !== methodDefinition.args.length) return yield* new RpcArgumentCountError({
-		definition: definition.id,
-		method: methodName,
-		expected: methodDefinition.args.length,
-		actual: args.length
-	});
-	return yield* Schema.encodeUnknownEffect(wireCodec(Schema.Tuple(methodDefinition.args)))(args).pipe(Effect.mapError((cause) => new RpcArgumentEncodeError({
-		definition: definition.id,
-		method: methodName,
-		cause
-	})));
-});
-const encodeSuccess = (definition, methodName, value) => {
-	const methodDefinition = definition.methods[methodName];
-	return Schema.encodeUnknownEffect(wireCodec(methodDefinition.success))(value).pipe(Effect.mapError((cause) => new RpcSuccessEncodeError({
-		definition: definition.id,
-		method: methodName,
-		cause
-	})));
-};
-const decodeSuccess = (definition, methodName, value) => {
-	const methodDefinition = definition.methods[methodName];
-	return Schema.decodeUnknownEffect(wireCodec(methodDefinition.success))(value).pipe(Effect.mapError((cause) => new RpcSuccessDecodeError({
-		definition: definition.id,
-		method: methodName,
-		cause
-	})));
-};
-const make$2 = (id, methods) => {
-	assertNoReservedMethods(id, methods, reservedMethodNames$2);
-	return {
-		id,
-		methods
-	};
-};
-//#endregion
-//#region src/RpcTracing.ts
-var RpcTracing_exports = /* @__PURE__ */ __exportAll({
-	RpcTraceContext: () => RpcTraceContext,
-	withRpcClientSpan: () => withRpcClientSpan,
-	withRpcServerSpan: () => withRpcServerSpan,
-	withRpcTraceContext: () => withRpcTraceContext
-});
-/**
-* Live native RPC metadata. Opted-in receivers reserve a valid trailing value
-* with this tag for transport context; do not use it as a final domain argument.
-* Never store this in durable messages or envelopes.
-*/
-const RpcTraceContext = Schema.Struct({
-	_tag: Schema.Literal("effect-cf/RpcTraceContext/v1"),
-	traceId: Schema.String.check(Schema.isPattern(/^(?!0{32}$)[0-9a-f]{32}$/)),
-	spanId: Schema.String.check(Schema.isPattern(/^(?!0{16}$)[0-9a-f]{16}$/)),
-	sampled: Schema.Boolean
-});
-const isRpcTraceContext$1 = Schema.is(RpcTraceContext);
-/**
-* Appends the current live parent only for a receiver that has opted in.
-* Call this inside the CLIENT span, immediately before the native invocation.
-* With no valid propagating parent, the original argument array is returned.
-*/
-const withRpcTraceContext = Effect.fnUntraced(function* (args) {
-	if (yield* Tracer.DisablePropagation) return args;
-	const parent = yield* Effect.serviceOption(Tracer.ParentSpan);
-	if (Option.isNone(parent) || Context.get(parent.value.annotations, Tracer.DisablePropagation)) return args;
-	const context = {
-		_tag: "effect-cf/RpcTraceContext/v1",
-		traceId: parent.value.traceId,
-		spanId: parent.value.spanId,
-		sampled: parent.value.sampled
-	};
-	return isRpcTraceContext$1(context) ? [...args, context] : args;
-});
-const attributes = (service, method) => ({
-	"sentry.op": "rpc",
-	"rpc.system.name": "cloudflare",
-	"rpc.method": `${service}/${method}`,
-	"server.address": service
-});
-const withRpcSpan = (effect, service, method, options) => Effect.useSpan(`${service}/${method}`, {
-	...options,
-	attributes: attributes(service, method)
-}, (span) => effect.pipe(Effect.withParentSpan(span), Effect.onExit((exit) => {
-	if (Exit.isSuccess(exit) || Cause.hasInterruptsOnly(exit.cause) || span.status._tag === "Ended") return Effect.void;
-	return Effect.gen(function* () {
-		const endTime = (yield* References.TracerTimingEnabled) ? yield* Clock.currentTimeNanos : 0n;
-		span.attribute("error.type", "_OTHER");
-		span.end(endTime, Exit.fail("RPC failed"));
-	});
-})));
-/** Wrap the whole call, including native result resolution and success decoding. */
-const withRpcClientSpan = (effect, binding, method) => withRpcSpan(effect, binding, method, { kind: "client" });
-/**
-* Optional application instrumentation for the entire receiver effect.
-* Use in a RunSymbol override to include argument decode, handler and encode.
-* Records stable service/method attributes and failure status, not argument or
-* error payloads. The original typed failure still propagates to the caller.
-*/
-const withRpcServerSpan = (effect, invocation) => withRpcSpan(effect, invocation.service, invocation.method, {
-	kind: "server",
-	parent: invocation.parent === void 0 ? void 0 : Tracer.externalSpan(invocation.parent)
-});
-//#endregion
-//#region src/internal/RpcInvocation.ts
-/** Scoped to the incoming event effect, never the instance runtime or storage. */
-var CurrentInvocation = class extends Context.Service()("effect-cf/internal/RpcInvocation") {};
-const recordDecodedArgs = (args) => Effect.map(Effect.serviceOption(CurrentInvocation), (invocation) => {
-	if (Option.isSome(invocation)) invocation.value.decodedArgs = args;
-});
-const invokeWithReceiver = (value, receiver, args) => {
-	return Function.prototype.apply.call(value, receiver, args);
-};
-const lookupRpcMethod = (target, method, makeError) => Effect.try({
-	try: () => {
-		if (!Predicate.isObjectKeyword(target)) throw new TypeError(`RPC target is not object-like`);
-		const receiver = target;
-		const value = receiver[method];
-		if (!Predicate.isFunction(value)) throw new TypeError(`RPC method "${String(method)}" is not callable`);
-		const callable = value;
-		return (...args) => invokeWithReceiver(callable, receiver, args);
-	},
-	catch: makeError
-});
-const invokeRpcMethod = Effect.fnUntraced(function* (target, method, args, makeError) {
-	const fn = yield* lookupRpcMethod(target, method, makeError);
-	return yield* Effect.try({
-		try: () => fn(...args),
-		catch: makeError
-	});
-});
-//#endregion
-//#region src/internal/Entrypoint.ts
-const isRpcTraceContext = Schema.is(RpcTraceContext);
-const invokeEntrypointRpcMethod = (self, method, args, run, onExit, service, key, rpcTracing) => {
-	const last = args.at(-1);
-	const parent = rpcTracing !== void 0 && isRpcTraceContext(last) ? last : void 0;
-	const handlerArgs = parent === void 0 ? args : args.slice(0, -1);
-	const invocation = {
-		service: rpcTracing?.service ?? service,
-		method: key,
-		args: handlerArgs,
-		parent
-	};
-	const handler = Effect.suspend(() => method(...handlerArgs)).pipe(Effect.provideService(CurrentInvocation, invocation), Effect.mapError(encodeWireError));
-	return run(self, onExit === void 0 ? handler : handler.pipe(Effect.onExit(() => onExit(self))), invocation);
-};
-const provideEntrypointServices = (layer, services) => layer.pipe(Layer.provideMerge(services));
-const defineEntrypointRpcMethods = (target, prototype, rpc, reservedMethodNames, run, onExit, rpcTracing) => {
-	const methods = rpc ?? {};
-	assertNoReservedMethods(target, methods, reservedMethodNames);
-	for (const [key, method] of Object.entries(methods)) Object.defineProperty(prototype, key, {
-		enumerable: true,
-		value(...args) {
-			return invokeEntrypointRpcMethod(this, method, args, run, onExit, target, key, rpcTracing);
-		}
-	});
-};
-const assumeEntrypointClass = (entrypoint) => {
-	return entrypoint;
-};
-//#endregion
-//#region src/internal/Runtime.ts
-/**
-* Assembles the shared `ManagedRuntime` used by the Cloudflare entrypoint
-* classes (Worker, Durable Object, Workflow).
-*
-* The entrypoint-specific services are merged with the env-backed
-* `ConfigProvider` and `WorkerEnvironment`, then provided to the user-supplied
-* layer so the resulting runtime satisfies both the user services and the
-* platform services.
-*/
-const makeEntrypointRuntime = (layer, env, services) => {
-	const entrypointServices = Layer.mergeAll(services, ConfigProvider.layer(WorkerConfig.providerFromEnv(env)), Layer.succeed(WorkerEnvironment, env));
-	return ManagedRuntime.make(provideEntrypointServices(layer, entrypointServices));
-};
-function runEventPromise(...args) {
-	const [runtime, effect, eventLayer, parent] = args;
-	if (eventLayer === void 0) {
-		const event = Effect.scoped(effect);
-		return runtime.runPromise(parent === void 0 ? event : Effect.withParentSpan(event, parent));
-	}
-	const event = Effect.scoped(effect.pipe(Effect.provide(eventLayer, { local: true })));
-	return runtime.runPromise(parent === void 0 ? event : Effect.withParentSpan(event, parent));
-}
-//#endregion
-//#region src/internal/Telemetry.ts
-/** Maximum event lifetime spent on an internally scheduled telemetry flush. */
-const scheduledFlushTimeout = "2 seconds";
-/**
-* Schedules a configured OTLP flusher through the current Cloudflare event.
-*
-* The handed-off effect is best-effort: it settles within two seconds and
-* silently absorbs every failure cause so telemetry cannot extend or fail the
-* user event, or recursively log through an unhealthy exporter.
-*/
-const scheduleTelemetryFlush$1 = (waitUntil) => Effect.gen(function* () {
-	const flusher = yield* Effect.serviceOption(OtlpExporter.Flusher);
-	if (Option.isNone(flusher)) return;
-	yield* waitUntil(flusher.value.flush.pipe(Effect.timeoutOption(scheduledFlushTimeout), Effect.ignoreCause, Effect.asVoid));
-}).pipe(Effect.ignoreCause);
-//#endregion
-//#region src/Rpc.ts
-var Rpc_exports = /* @__PURE__ */ __exportAll({
-	RpcStub: () => RpcStub,
-	RpcTarget: () => RpcTarget,
-	dispose: () => dispose,
-	isDisposable: () => isDisposable,
-	resolve: () => resolve,
-	scoped: () => scoped
-});
-const isDisposable = (value) => Predicate.hasProperty(value, Symbol.dispose) && Predicate.isFunction(value[Symbol.dispose]);
-const dispose = (value) => Effect.sync(() => {
-	if (isDisposable(value)) value[Symbol.dispose]();
-});
-const resolve = (value) => Predicate.isPromiseLike(value) ? Effect.tryPromise({
-	try: () => Promise.resolve(value),
-	catch: (cause) => decodeWireError(cause)
-}) : Effect.sync(() => {
-	return value;
-});
-const scoped = (value) => Effect.acquireRelease(resolve(value), (resolved) => dispose(resolved));
-//#endregion
-//#region src/ServiceBinding.ts
-var ServiceBinding_exports = /* @__PURE__ */ __exportAll({
-	Service: () => Service,
-	ServiceBindingFetchError: () => ServiceBindingFetchError,
-	ServiceBindingRpcError: () => ServiceBindingRpcError,
-	isServiceBindingClient: () => isServiceBindingClient,
-	layer: () => layer,
-	makeClient: () => makeClient,
-	makeDirectMethods: () => makeDirectMethods
-});
-const TypeId = "effect-cf/ServiceBinding";
-const expectedServiceBinding = "Worker service binding with fetch()";
-/**
-* Failure raised when calling `fetch` on a service binding.
-*/
-var ServiceBindingFetchError = class extends Data.TaggedError("ServiceBindingFetchError") {
-	get message() {
-		return `Service binding "${this.binding}" fetch failed: ${causeMessage(this.cause)}`;
-	}
-};
-/**
-* Failure raised when invoking an RPC method on a service binding.
-*/
-var ServiceBindingRpcError = class extends Data.TaggedError("ServiceBindingRpcError") {
-	get message() {
-		return `Service binding "${this.binding}" RPC method "${this.method}" failed: ${causeMessage(this.cause)}`;
-	}
-};
-const ServiceBindingSchema = Schema.declare((value) => Predicate.hasProperty(value, "fetch") && Predicate.isFunction(value.fetch));
-const decodeServiceBinding = Schema.decodeUnknownOption(ServiceBindingSchema);
-const isServiceBindingClient = (value) => Option.isSome(decodeServiceBinding(value));
-const makeClient = (definition) => {
-	return (service) => {
-		const fetch = Effect.fn("ServiceBinding.fetch")(function* (input, init) {
-			return yield* Effect.tryPromise({
-				try: (signal) => {
-					const callerSignal = init?.signal !== void 0 ? init.signal : input instanceof Request ? input.signal : void 0;
-					return service.fetch(input, {
-						...init,
-						signal: callerSignal === null || callerSignal === void 0 ? signal : AbortSignal.any([callerSignal, signal])
-					});
-				},
-				catch: (cause) => new ServiceBindingFetchError({
-					binding: definition.binding,
-					cause
-				})
-			});
-		});
-		const rpc = Effect.fnUntraced(function* (method, ...args) {
-			const methodName = String(method);
-			const encodedArgs = definition.definition === void 0 ? args : yield* encodeArgs(definition.definition, methodName, args).pipe(Effect.mapError((cause) => new ServiceBindingRpcError({
-				binding: definition.binding,
-				method: methodName,
-				cause
-			})));
-			const nativeArgs = definition.rpcTracing ? yield* withRpcTraceContext(encodedArgs) : encodedArgs;
-			return yield* invokeRpcMethod(service, method, nativeArgs, (cause) => new ServiceBindingRpcError({
-				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 ServiceBindingRpcError({
-				binding: definition.binding,
-				method: methodName,
-				cause
-			})));
-		});
-		const call = Effect.fnUntraced(function* (method, ...args) {
-			const methodName = String(method);
-			const value = yield* resolve(yield* rpc(method, ...args)).pipe(Effect.mapError((cause) => new ServiceBindingRpcError({
-				binding: definition.binding,
-				method: methodName,
-				cause
-			})));
-			return yield* decodeSuccess$1(methodName, value);
-		}, (effect, ...args) => withRpcClientSpan(effect, definition.binding, String(args[0])));
-		const scopedCall = Effect.fnUntraced(function* (method, ...args) {
-			const methodName = String(method);
-			const result = yield* rpc(method, ...args);
-			const value = yield* scoped(result).pipe(Effect.mapError((cause) => new ServiceBindingRpcError({
-				binding: definition.binding,
-				method: methodName,
-				cause
-			})));
-			return yield* decodeSuccess$1(methodName, value);
-		}, (effect, ...args) => withRpcClientSpan(effect, definition.binding, String(args[0])));
-		const directMethods = makeDirectMethods(definition.definition, call);
-		return Object.assign(directMethods, {
-			fetch,
-			rpc,
-			call,
-			scopedCall
-		});
-	};
-};
-const layer = (tag, definition) => layer$2(tag, definition.binding, (value) => isServiceBindingClient(value), makeClient(definition), { expected: expectedServiceBinding });
-const Service = () => (id, definition) => {
-	const tag = Service$1()(id, definition.binding, (value) => isServiceBindingClient(value), makeClient(definition));
-	const fetch = Effect.fnUntraced(function* (input, init) {
-		return yield* (yield* tag).fetch(input, init);
-	});
-	const rpc = Effect.fnUntraced(function* (method, ...args) {
-		return yield* (yield* tag).rpc(method, ...args);
-	});
-	const call = Effect.fnUntraced(function* (method, ...args) {
-		return yield* (yield* tag).call(method, ...args);
-	});
-	const scopedCall = Effect.fnUntraced(function* (method, ...args) {
-		return yield* (yield* tag).scopedCall(method, ...args);
-	});
-	const directMethods = makeDirectMethods(definition.definition, call);
-	return Object.assign(tag, directMethods, {
-		[TypeId]: TypeId,
-		definition,
-		fetch,
-		rpc,
-		call,
-		scopedCall
-	});
-};
-const makeDirectMethods = (rpcDefinition, call) => {
-	const methods = {};
-	if (rpcDefinition !== void 0) {
-		const invoke = call;
-		for (const methodName of Object.keys(rpcDefinition.methods)) methods[methodName] = (...args) => invoke(methodName, ...args);
-	}
-	return methods;
-};
-//#endregion
-//#region src/WorkerDefinition.ts
-var WorkerDefinition_exports = /* @__PURE__ */ __exportAll({
-	Tag: () => Tag,
-	Worker: () => Worker,
-	implement: () => implement,
-	make: () => make$1,
-	method: () => method
-});
-const reservedMethodNames$1 = /* @__PURE__ */ new Set([
-	"constructor",
-	"dup",
-	"fetch",
-	"connect",
-	"queue",
-	"scheduled",
-	"tail",
-	"tailStream",
-	"test",
-	"trace",
-	"alarm",
-	"webSocketMessage",
-	"webSocketClose",
-	"webSocketError"
-]);
-const assumeTagClass = (value) => {
-	return value;
-};
-/**
-* Defines a single RPC method schema in a worker definition.
-*/
-const method = method$1;
-const makeDefinition = (id, methods) => {
-	assertNoReservedMethods("Worker", methods, reservedMethodNames$1);
-	const definition = make$2(id, methods);
-	return Object.assign(definition, { make: (layer, options) => {
-		const workerOptions = {
-			...options,
-			rpc: wrapHandlers(definition, options.rpc)
-		};
-		if (workerOptions.eventLayer === void 0) return make(layer, workerOptions);
-		return make(layer, workerOptions);
-	} });
-};
-const make$1 = (id, methods) => Tag()(id, methods);
-const Tag = () => (id, methods) => {
-	const definition = makeDefinition(id, methods);
-	const tag = Context.Service()(id);
-	const bindingDefinition = (binding) => ({
-		...binding,
-		definition
-	});
-	const layer$3 = (binding) => layer(tag, bindingDefinition(binding));
-	const fetch = (input, init) => Effect.gen(function* () {
-		return yield* (yield* tag).fetch(input, init);
-	});
-	const rpc = (method, ...args) => Effect.gen(function* () {
-		return yield* (yield* tag).rpc(method, ...args);
-	});
-	const call = (method, ...args) => Effect.gen(function* () {
-		return yield* (yield* tag).call(method, ...args);
-	});
-	const scopedCall = (method, ...args) => Effect.gen(function* () {
-		return yield* (yield* tag).scopedCall(method, ...args);
-	});
-	const directMethods = makeDirectMethods(definition, call);
-	return assumeTagClass(Object.assign(tag, directMethods, {
-		id: definition.id,
-		methods: definition.methods,
-		make: definition.make,
-		layer: layer$3,
-		fetch,
-		rpc,
-		call,
-		scopedCall
-	}));
-};
-const Worker = Tag;
-const wrapHandlers = (definition, handlers) => {
-	const wrapped = Object.create(null);
-	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 = (_definition, handlers) => handlers;
-//#endregion
-//#region src/Worker.ts
-var Worker_exports = /* @__PURE__ */ __exportAll({
-	ExecutionContext: () => ExecutionContext,
-	NativeRequest: () => NativeRequest,
-	RunSymbol: () => RunSymbol,
-	Tag: () => Tag,
-	WorkerContext: () => WorkerContext,
-	implement: () => implement,
-	isWebSocketUpgrade: () => isWebSocketUpgrade,
-	make: () => make,
-	makeFetchHandler: () => makeFetchHandler,
-	method: () => method
-});
-var ExecutionContext = class extends Context.Service()("effect-cf/ExecutionContext") {};
-var WorkerContext = class extends Context.Service()("effect-cf/WorkerContext") {};
-var NativeRequest = class extends Context.Service()("effect-cf/NativeRequest") {};
-const isWebSocketUpgrade = (request) => request.headers.get("Upgrade")?.toLowerCase() === "websocket";
-const reservedMethodNames = /* @__PURE__ */ new Set([
-	...reservedMethodNames$2,
-	"queue",
-	"scheduled",
-	"tail",
-	"tailStream",
-	"test",
-	"trace"
-]);
-/** Override to instrument the whole event, then call super[RunSymbol]. */
-const RunSymbol = Symbol.for("effect-cf/Worker/run");
-const FetchSymbol = Symbol.for("effect-cf/Worker/fetch");
-const renderFetchSuccess = (effect, eventLayer) => Effect.suspend(() => {
-	let nativeResponse;
-	let webResponse;
-	const httpApp = Effect.flatMap(effect, (response) => {
-		if (response instanceof Response) {
-			nativeResponse = response;
-			return Effect.succeed(HttpServerResponse.empty());
-		}
-		return Effect.succeed(response);
-	});
-	const handleResponse = (request, response) => nativeResponse !== void 0 ? Effect.void : Effect.map(Effect.context(), (context) => {
-		webResponse = HttpServerResponse.toWeb(HttpEffect.scopeTransferToStream(response), {
-			withoutBody: request.method === "HEAD",
-			context
-		});
-	});
-	const telemetryMiddleware = HttpMiddleware.make((self) => Effect.gen(function* () {
-		yield* Effect.addFinalizer(() => scheduleTelemetryFlush);
-		return yield* self;
-	}));
-	const handled = eventLayer === void 0 ? HttpEffect.toHandled(httpApp, handleResponse, telemetryMiddleware) : Effect.flatMap(References.TracerEnabled, (tracerEnabled) => HttpEffect.toHandled(httpApp, handleResponse, HttpMiddleware.make((self) => Effect.provideService(Effect.gen(function* () {
-		const context = yield* Layer.build(Layer.fresh(eventLayer));
-		yield* Effect.addFinalizer(() => Effect.provideContext(scheduleTelemetryFlush, context));
-		return yield* HttpMiddleware.tracer(self).pipe(Effect.onExit(() => Effect.yieldNow), Effect.provideContext(context));
-	}), References.TracerEnabled, tracerEnabled))).pipe(Effect.withTracerEnabled(false)));
-	const captured = () => nativeResponse ?? webResponse ?? new Response(null, { status: 500 });
-	return Effect.matchCause(handled, {
-		onFailure: captured,
-		onSuccess: captured
-	});
-});
-const isWorkerOptions = (options) => !Effect.isEffect(options);
-/**
-* Drains buffered OTLP telemetry when the fetch Effect scope closes. Effect
-* response streams transfer that scope to the body and schedule the flush when
-* the body finishes or is canceled.
-*
-* The flush is handed to `ctx.waitUntil` instead of being awaited by the
-* handler. It is a no-op when the context does not contain an
-* `OtlpExporter.Flusher`, and silently settles within two seconds.
-*/
-const scheduleTelemetryFlush = scheduleTelemetryFlush$1((flush) => Effect.flatMap(WorkerContext, (workerContext) => workerContext.waitUntil(flush)));
-function make(layer, optionsOrFetch) {
-	const options = isWorkerOptions(optionsOrFetch) ? optionsOrFetch : { fetch: optionsOrFetch };
-	class EffectWorker extends WorkerEntrypoint {
-		runtime;
-		constructor(ctx, env) {
-			super(ctx, env);
-			this.runtime = makeEntrypointRuntime(layer, env, Layer.mergeAll(Layer.succeed(ExecutionContext, ctx), Layer.succeed(WorkerContext, fromExecutionContext(ctx))));
-		}
-		[RunSymbol](effect, runOptions = {}) {
-			const eventLayer = runOptions.event === "fetch" ? 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) {
-			return this[FetchSymbol](request);
-		}
-		[FetchSymbol](request, requestContext) {
-			const fetchHandler = options.fetch;
-			if (fetchHandler === void 0) return Promise.resolve(new Response("Not Found", { status: 404 }));
-			const ctx = requestContext ?? this.ctx;
-			const requestServices = Layer.mergeAll(Layer.succeed(NativeRequest, request), Layer.succeed(HttpServerRequest.HttpServerRequest, HttpServerRequest.fromWeb(request)), Layer.succeed(ExecutionContext, ctx), Layer.succeed(WorkerContext, fromExecutionContext(ctx)));
-			return this[RunSymbol](renderFetchSuccess(fetchHandler, options.eventLayer).pipe(Effect.provide(requestServices)), { event: "fetch" });
-		}
-		queue(batch) {
-			const queueHandler = options.queue;
-			if (queueHandler === void 0) return Promise.resolve();
-			const messages = batch.messages.map((message) => fromMessage(message, message.body));
-			return this[RunSymbol](queueHandler(fromMessageBatch(batch, messages)).pipe(Effect.onExit(() => scheduleTelemetryFlush)), { event: "queue" });
-		}
-	}
-	defineEntrypointRpcMethods("Worker", EffectWorker.prototype, options.rpc, reservedMethodNames, (self, effect, rpc) => self[RunSymbol](effect, {
-		event: "rpc",
-		rpc
-	}), () => scheduleTelemetryFlush, options.rpcTracing);
-	return assumeEntrypointClass(EffectWorker);
-}
-function makeFetchHandler(layer, options) {
-	const WorkerClass = options.eventLayer === void 0 ? make(layer, options) : make(layer, options);
-	const instances = /* @__PURE__ */ new WeakMap();
-	return { fetch: (request, env, ctx) => {
-		let instance = instances.get(env);
-		if (instance === void 0) {
-			instance = new WorkerClass(ctx, env);
-			instances.set(env, instance);
-		}
-		return instance[FetchSymbol](request, ctx);
-	} };
-}
-//#endregion
-export { QueueDefinition_exports as A, decodeSuccess as C, method$1 as D, make$2 as E, reservedMethodNames$2 as O, decodeArgs as S, encodeSuccess as T, RpcTracing_exports as _, WorkerDefinition_exports as a, RpcDefinition_exports as b, resolve as c, makeEntrypointRuntime as d, runEventPromise as f, recordDecodedArgs as g, invokeRpcMethod as h, Worker_exports as i, QueueBinding_exports as j, Queue_exports as k, scoped as l, defineEntrypointRpcMethods as m, NativeRequest as n, ServiceBinding_exports as o, assumeEntrypointClass as p, WorkerContext as r, Rpc_exports as s, ExecutionContext as t, scheduleTelemetryFlush$1 as u, withRpcClientSpan as v, encodeArgs as w, assertNoReservedMethods as x, withRpcTraceContext as y };