effect-cf 0.35.0 → 0.37.0

package/dist/Worker-XsGJsCJX.mjs

@@ -0,0 +1,885 @@
+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 };