effect-cf 0.40.0 → 0.40.1

package/dist/WebTransport.d.mts

@@ -0,0 +1,66 @@
+import * as Effect from "effect/Effect";
+import * as S from "effect/Schema";
+import * as Option from "effect/Option";
+declare namespace WebTransport_d_exports {
+  export { Capabilities, InboundTransport, WebTransportCapability, WebTransportUnsupportedError, capabilities, inboundSessionsUnsupported, inboundTransport, isHttp3 };
+}
+declare const InboundTransport_base: S.Class<InboundTransport, S.Struct<{
+  readonly httpProtocol: S.String;
+  readonly clientQuicRtt: S.optional<S.Number>;
+  readonly clientTcpRtt: S.optional<S.Number>;
+}>, {}>;
+/**
+ * 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`.
+ */
+declare class InboundTransport extends InboundTransport_base {}
+/**
+ * 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.
+ */
+declare const inboundTransport: (request: Pick<CloudflareRequest, "cf">) => Option.Option<InboundTransport>;
+declare const isHttp3: (transport: InboundTransport) => boolean;
+interface Capabilities {
+  /**
+   * Whether Worker code can accept inbound WebTransport sessions. Typed as
+   * literally `false`: no such runtime API exists (cloudflare/workerd#6451),
+   * so this can only change through a breaking, deliberate update when
+   * Cloudflare ships one.
+   */
+  readonly inboundSessions: false;
+  /**
+   * Whether the runtime exposes a client `WebTransport` constructor global.
+   * Feature-detected at runtime; `false` in workerd today, which has no
+   * QUIC stack.
+   */
+  readonly outboundSessions: boolean;
+}
+declare const capabilities: Effect.Effect<Capabilities>;
+type WebTransportCapability = "inbound-sessions" | "outbound-sessions";
+declare const WebTransportUnsupportedError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "WebTransportUnsupportedError";
+} & Readonly<A>;
+declare class WebTransportUnsupportedError extends WebTransportUnsupportedError_base<{
+  readonly capability: WebTransportCapability;
+}> {
+  get message(): string;
+}
+/**
+ * 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.
+ */
+declare const inboundSessionsUnsupported: Effect.Effect<never, WebTransportUnsupportedError>;
+//#endregion
+export { Capabilities, InboundTransport, WebTransportCapability, WebTransportUnsupportedError, WebTransport_d_exports, capabilities, inboundSessionsUnsupported, inboundTransport, isHttp3 };

package/dist/WebTransport.mjs

@@ -0,0 +1,63 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.mjs";
+import * as Data from "effect/Data";
+import * as Effect from "effect/Effect";
+import * as S from "effect/Schema";
+import * as Predicate from "effect/Predicate";
+import "effect/Option";
+import * as Result from "effect/Result";
+//#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 S.Class("InboundTransport")({
+	httpProtocol: S.String,
+	clientQuicRtt: S.optional(S.Number),
+	clientTcpRtt: S.optional(S.Number)
+}) {};
+const decodeInboundTransport = S.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
+export { InboundTransport, WebTransportUnsupportedError, WebTransport_exports, capabilities, inboundSessionsUnsupported, inboundTransport, isHttp3 };

package/dist/Worker.d.mts

@@ -0,0 +1,139 @@
+import { WorkerEnv, WorkerEnvironment } from "./Environment.mjs";
+import { ReservedMethodName as ReservedMethodName$1 } from "./RpcDefinition.mjs";
+import { QueueHandler } from "./Queue.mjs";
+import { ReceiverOptions, RpcInvocationInfo } from "./RpcTracing.mjs";
+import { Api, Definition, HandlerEffect, Handlers, LayerOptions, Method, Methods, NoReservedMethods, Options, ServerApi, ServiceFreeSchema, Tag, TagClass, implement, method } from "./WorkerDefinition.mjs";
+import * as Context$1 from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer$1 from "effect/Layer";
+import { WorkerEntrypoint } from "cloudflare:workers";
+import * as HttpServerRequest from "effect/unstable/http/HttpServerRequest";
+import * as HttpServerResponse from "effect/unstable/http/HttpServerResponse";
+import { Cause, Scope } from "effect";
+declare namespace Worker_d_exports {
+  export { Api, Definition, ExecutionContext, FetchHandler, FetchWorkerOptions, HandlerEffect, Handlers, LayerOptions, Method, Methods, NativeRequest, NoReservedMethods, Options, ReservedMethodName, RpcHandlers, RunOptions, RunSymbol, ServerApi, ServiceFreeSchema, Tag, TagClass, WorkerClass, WorkerContext, WorkerContextService, WorkerContextWaitUntilOptions, WorkerFetchSuccess, WorkerHandler, WorkerOptions, WorkerRpc, WorkerRpcContract, WorkerRpcHandler, WorkerRpcContract as WorkerRpcShape, implement, isWebSocketUpgrade, make, makeFetchHandler, method };
+}
+declare const ExecutionContext_base: Context$1.ServiceClass<ExecutionContext, "effect-cf/ExecutionContext", globalThis.ExecutionContext<unknown>>;
+declare class ExecutionContext extends ExecutionContext_base {}
+interface WorkerContextWaitUntilOptions<E, R> {
+  /**
+   * Failure mode for the background effect: `"observe"` (default) logs or
+   * routes the failure to `onFailure`, while `"propagate"` also rejects the
+   * native `waitUntil` promise.
+   */
+  readonly mode?: "observe" | "propagate";
+  readonly onFailure?: (cause: Cause.Cause<E>) => Effect.Effect<void, never, R>;
+}
+interface WorkerContextService {
+  readonly raw: globalThis.ExecutionContext;
+  waitUntil<A, E, R, R2 = never>(effect: Effect.Effect<A, E, R>, options?: WorkerContextWaitUntilOptions<E, R2>): Effect.Effect<void, never, R | R2>;
+  waitUntilPropagating<A, E, R, R2 = never>(effect: Effect.Effect<A, E, R>, options?: Omit<WorkerContextWaitUntilOptions<E, R2>, "mode">): Effect.Effect<void, never, R | R2>;
+  readonly passThroughOnException: Effect.Effect<void>;
+  abort(reason?: string): Effect.Effect<void>;
+}
+declare const WorkerContext_base: Context$1.ServiceClass<WorkerContext, "effect-cf/WorkerContext", WorkerContextService>;
+declare class WorkerContext extends WorkerContext_base {}
+declare const NativeRequest_base: Context$1.ServiceClass<NativeRequest, "effect-cf/NativeRequest", Request<unknown, CfProperties<unknown>>>;
+declare class NativeRequest extends NativeRequest_base {}
+declare const isWebSocketUpgrade: (request: Request) => boolean;
+type ReservedMethodName = ReservedMethodName$1 | "fetch" | "connect" | "queue" | "scheduled" | "tail" | "tailStream" | "test" | "trace" | "alarm" | "webSocketMessage" | "webSocketClose" | "webSocketError";
+type WorkerBaseContext<ROut> = ExecutionContext | WorkerContext | WorkerEnvironment | ROut;
+type WorkerFetchContext<ROut> = WorkerBaseContext<ROut> | NativeRequest | HttpServerRequest.HttpServerRequest | Scope.Scope;
+type WorkerRpcContext<ROut> = WorkerBaseContext<ROut> | Scope.Scope;
+/** Override to instrument the whole event, then call super[RunSymbol]. */
+declare const RunSymbol: unique symbol;
+declare const FetchSymbol: unique symbol;
+/** Metadata available before an event effect or its event layer starts. */
+interface RunOptions {
+  readonly event?: "fetch" | "rpc" | "queue";
+  readonly rpc?: RpcInvocationInfo;
+}
+type WorkerFetchSuccess = Response | HttpServerResponse.HttpServerResponse;
+/**
+ * Effect type for `fetch` handlers executed by {@link make}.
+ */
+type WorkerHandler<ROut, A = WorkerFetchSuccess> = Effect.Effect<A, unknown, WorkerFetchContext<ROut>>;
+/**
+ * Effect type for worker RPC handlers.
+ */
+type WorkerRpcHandler<ROut, A = unknown> = Effect.Effect<A, unknown, WorkerRpcContext<ROut>>;
+/**
+ * Shape of worker RPC handlers passed to {@link make}.
+ */
+type WorkerRpc<ROut> = Record<string, (...args: Array<any>) => WorkerRpcHandler<ROut>>;
+type WorkerRpcContract<Rpc extends WorkerRpc<ROut>, ROut> = { readonly [Key in keyof Rpc]: Rpc[Key] extends ((...args: infer Args) => Effect.Effect<infer A, unknown, WorkerRpcContext<ROut>>) ? (...args: Args) => Promise<A> : never; };
+type RpcHandlers<ROut, Api> = { readonly [Key in keyof Api as Key extends keyof WorkerEntrypoint ? never : Key extends string ? Key extends ReservedMethodName ? never : [Api[Key]] extends [never] ? never : Api[Key] extends ((...args: Array<any>) => Promise<any>) ? Key : never : never]: Api[Key] extends ((...args: infer Args) => Promise<infer A>) ? (...args: Args) => WorkerRpcHandler<ROut, A> : never; };
+interface WorkerOptions<RRuntime, REvent = never, EventLayerError = never, Rpc extends WorkerRpc<RRuntime | REvent> = Record<never, never>> {
+  /**
+   * Layer provided around each Cloudflare event handled by this Worker.
+   *
+   * The layer is built inside the event's Effect scope. For fetch handlers that
+   * return an Effect `HttpServerResponse` stream, its scope remains open until
+   * the response body finishes or is canceled. Native `Response` values pass
+   * through unchanged, so their body streams do not carry this scoped-lifetime
+   * guarantee. Fetch, queue, and RPC handlers schedule a best-effort telemetry
+   * flush capped at two seconds.
+   */
+  readonly eventLayer?: Layer$1.Layer<REvent, EventLayerError, WorkerBaseContext<RRuntime>>;
+  readonly fetch?: Effect.Effect<WorkerFetchSuccess, unknown, WorkerFetchContext<RRuntime | REvent>>;
+  readonly queue?: QueueHandler<RRuntime | REvent>;
+  /**
+   * Optional RPC methods exposed as class instance methods.
+   *
+   * After every invocation, the configured OTLP flusher is scheduled through
+   * `WorkerContext.waitUntil`, including when the handler fails. The scheduled
+   * flush silently settles within two seconds even if the exporter does not.
+   */
+  readonly rpc?: Rpc;
+  /** Accept live native trace metadata. The client must also enable rpcTracing. */
+  readonly rpcTracing?: ReceiverOptions;
+}
+type WorkerOptionsWithEventLayer<RRuntime, REvent, EventLayerError, Rpc extends WorkerRpc<RRuntime | REvent> = Record<never, never>> = Omit<WorkerOptions<RRuntime, REvent, EventLayerError, Rpc>, "eventLayer"> & {
+  readonly eventLayer: Layer$1.Layer<REvent, EventLayerError, WorkerBaseContext<RRuntime>>;
+};
+type FetchWorkerOptions<RRuntime, REvent = never, EventLayerError = never> = Omit<WorkerOptions<RRuntime, REvent, EventLayerError, Record<never, never>>, "rpc"> & {
+  readonly rpc?: never;
+};
+type FetchWorkerOptionsWithEventLayer<RRuntime, REvent, EventLayerError> = Omit<FetchWorkerOptions<RRuntime, REvent, EventLayerError>, "eventLayer"> & {
+  readonly eventLayer: Layer$1.Layer<REvent, EventLayerError, WorkerBaseContext<RRuntime>>;
+};
+/**
+ * Cloudflare `WorkerEntrypoint` constructor produced by {@link make}.
+ */
+type WorkerClass<Rpc extends WorkerRpc<ROut>, ROut> = new (ctx: globalThis.ExecutionContext, env: WorkerEnv) => WorkerEntrypoint<WorkerEnv> & {
+  fetch(request: Request): Promise<Response>;
+  queue(batch: globalThis.MessageBatch): Promise<void>;
+  [RunSymbol]<A, E>(effect: Effect.Effect<A, E, WorkerRpcContext<ROut>>, options?: RunOptions): Promise<A>;
+  [FetchSymbol](request: Request, requestContext: globalThis.ExecutionContext): Promise<Response>;
+} & WorkerRpcContract<Rpc, ROut>;
+/**
+ * `ExportedHandler`-compatible fetch object produced by {@link makeFetchHandler}.
+ */
+interface FetchHandler<Env extends WorkerEnv = WorkerEnv> {
+  readonly fetch: (request: Request, env: Env, ctx: globalThis.ExecutionContext) => Promise<Response>;
+}
+/**
+ * Cloudflare creates a new `WorkerEntrypoint` instance for each native
+ * invocation, so this base layer is not shared across invocations. Its managed
+ * runtime has no deterministic disposal point in this adapter; use
+ * `eventLayer` for resources whose finalizers must run with an event.
+ */
+declare function make<ROut, LayerError>(layer: Layer$1.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>, fetch: WorkerHandler<ROut>): WorkerClass<Record<never, never>, ROut>;
+declare function make<ROut, LayerError, REvent, EventLayerError = never, const Rpc extends WorkerRpc<ROut | REvent> = Record<never, never>>(layer: Layer$1.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>, options: WorkerOptionsWithEventLayer<ROut, REvent, EventLayerError, Rpc>): WorkerClass<Rpc, ROut | REvent>;
+declare function make<ROut, LayerError, REvent extends never = never, EventLayerError = never, const Rpc extends WorkerRpc<ROut | REvent> = Record<never, never>>(layer: Layer$1.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>, options: WorkerOptions<ROut, REvent, EventLayerError, Rpc>): WorkerClass<Rpc, ROut | REvent>;
+/**
+ * Creates an `ExportedHandler`-compatible `{ fetch }` object backed by
+ * {@link make}.
+ *
+ * The Effect runtime is cached per `env` identity, so the base layer builds
+ * once for that cached handler. Request handlers and `eventLayer` receive fresh
+ * `ExecutionContext` and `WorkerContext` services. A service constructed by the
+ * cached base layer from either context instead captures the first request's
+ * value, so construct invocation-bound services in `eventLayer`. Cloudflare
+ * provides no isolate shutdown hook, so cached base-layer finalizers are not
+ * guaranteed to run.
+ */
+declare function makeFetchHandler<ROut, LayerError, REvent, EventLayerError = never, Env extends WorkerEnv = WorkerEnv>(layer: Layer$1.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>, options: FetchWorkerOptionsWithEventLayer<ROut, REvent, EventLayerError>): FetchHandler<Env>;
+declare function makeFetchHandler<ROut, LayerError, REvent extends never = never, EventLayerError = never, Env extends WorkerEnv = WorkerEnv>(layer: Layer$1.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>, options: FetchWorkerOptions<ROut, REvent, EventLayerError>): FetchHandler<Env>;
+//#endregion
+export { type Api, type Definition, ExecutionContext, FetchHandler, FetchWorkerOptions, type HandlerEffect, type Handlers, type LayerOptions, type Method, type Methods, NativeRequest, type NoReservedMethods, type Options, ReservedMethodName, RpcHandlers, RunOptions, RunSymbol, type ServerApi, type ServiceFreeSchema, Tag, type TagClass, WorkerClass, WorkerContext, WorkerContextService, WorkerContextWaitUntilOptions, WorkerFetchSuccess, WorkerHandler, WorkerOptions, WorkerRpc, WorkerRpcContract, type WorkerRpcContract as WorkerRpcShape, WorkerRpcHandler, Worker_d_exports, implement, isWebSocketUpgrade, make, makeFetchHandler, method };

package/dist/Worker.mjs

@@ -0,0 +1,141 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.mjs";
+import { fromExecutionContext } from "./internal/WorkerContext.mjs";
+import { fromMessage, fromMessageBatch } from "./Queue.mjs";
+import { reservedMethodNames as reservedMethodNames$1 } from "./RpcDefinition.mjs";
+import { assumeEntrypointClass, defineEntrypointRpcMethods } from "./internal/Entrypoint.mjs";
+import { makeEntrypointRuntime, runEventPromise } from "./internal/Runtime.mjs";
+import { scheduleTelemetryFlush as scheduleTelemetryFlush$1 } from "./internal/Telemetry.mjs";
+import { Tag, implement, method } from "./WorkerDefinition.mjs";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import { WorkerEntrypoint } from "cloudflare:workers";
+import * as Tracer from "effect/Tracer";
+import * as References from "effect/References";
+import * as HttpEffect from "effect/unstable/http/HttpEffect";
+import * as HttpMiddleware from "effect/unstable/http/HttpMiddleware";
+import * as HttpServerRequest from "effect/unstable/http/HttpServerRequest";
+import * as HttpServerResponse from "effect/unstable/http/HttpServerResponse";
+//#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$1,
+	"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 { ExecutionContext, NativeRequest, RunSymbol, Tag, WorkerContext, Worker_exports, implement, isWebSocketUpgrade, make, makeFetchHandler, method };

package/dist/WorkerDefinition.d.mts

@@ -0,0 +1,100 @@
+import { WorkerEnvironment } from "./Environment.mjs";
+import { BindingNotFoundError, BindingValidationError } from "./Binding.mjs";
+import { Provider } from "./Rpc.mjs";
+import { ServiceBindingEffectClient, ServiceBindingStaticClient } from "./ServiceBinding.mjs";
+import { ExecutionContext, ReservedMethodName as ReservedMethodName$1, WorkerClass, WorkerContext, WorkerOptions, WorkerRpcHandler } from "./Worker.mjs";
+import * as Context$1 from "effect/Context";
+import { Layer, Schema } from "effect";
+declare namespace WorkerDefinition_d_exports {
+  export { Api, Definition, HandlerEffect, Handlers, LayerOptions, Method, Methods, NoReservedMethods, Options, ReservedMethodName, ServerApi, ServiceFreeSchema, Tag, TagClass, Worker, implement, make, method };
+}
+type ServiceFreeSchema = Schema.Codec<any, any, never, never>;
+interface Method<Args extends ReadonlyArray<ServiceFreeSchema> = ReadonlyArray<ServiceFreeSchema>, Success extends ServiceFreeSchema = ServiceFreeSchema> {
+  readonly args: Args;
+  readonly success: Success;
+}
+declare namespace Method {
+  export type Any = Method<ReadonlyArray<ServiceFreeSchema>, ServiceFreeSchema>;
+  type ArgsFromSchemas<Args extends ReadonlyArray<ServiceFreeSchema>> = Args extends readonly [] ? [] : Args extends readonly [infer Head extends ServiceFreeSchema, ...infer Tail extends ReadonlyArray<ServiceFreeSchema>] ? [Schema.Schema.Type<Head>, ...ArgsFromSchemas<Tail>] : Array<Schema.Schema.Type<Args[number]>>;
+  type EncodedArgsFromSchemas<Args extends ReadonlyArray<ServiceFreeSchema>> = { [Index in keyof Args]: Schema.Json; };
+  export type Args<Self extends Any> = ArgsFromSchemas<Self["args"]>;
+  export type EncodedArgs<Self extends Any> = EncodedArgsFromSchemas<Self["args"]>;
+  export type Success<Self extends Any> = Schema.Schema.Type<Self["success"]>;
+  export type EncodedSuccess<_Self extends Any> = Schema.Json;
+  export {};
+}
+type Methods = Record<string, Method.Any>;
+/**
+ * RPC contract for a Worker service.
+ *
+ * Create with {@link make} and reuse to type both worker implementations and
+ * service bindings in other workers.
+ */
+interface Definition<Id extends string = string, MethodDefinitions extends Methods = Methods> {
+  readonly id: Id;
+  readonly methods: MethodDefinitions;
+}
+declare namespace Definition {
+  type Any = Definition<string, Methods>;
+}
+type ReservedMethodName = ReservedMethodName$1;
+type NoReservedMethods<MethodDefinitions extends Methods> = Extract<keyof MethodDefinitions, ReservedMethodName> extends never ? MethodDefinitions : never;
+/**
+ * Promise-based client API derived from a {@link Definition}.
+ */
+type ServerApi<Self extends Definition.Any> = { readonly [Key in keyof Self["methods"]]: (...args: Method.Args<Self["methods"][Key]>) => Promise<Method.Success<Self["methods"][Key]>>; };
+type Api<Self extends Definition.Any> = Provider<ServerApi<Self>, ReservedMethodName>;
+/**
+ * Effect handlers for each RPC method in a worker definition.
+ */
+type Handlers<ROut, Self extends Definition.Any> = { readonly [Key in keyof Self["methods"]]: (...args: Method.Args<Self["methods"][Key]>) => WorkerRpcHandler<ROut, Method.Success<Self["methods"][Key]>>; };
+type BaseOptions<ROut, Self extends Definition.Any, REvent, EventLayerError> = Omit<WorkerOptions<ROut, REvent, EventLayerError, Handlers<ROut | REvent, Self>>, "eventLayer" | "rpc"> & {
+  readonly rpc: Handlers<ROut | REvent, Self>;
+};
+type EventLayerOptions<ROut, REvent, EventLayerError> = [REvent] extends [never] ? Pick<WorkerOptions<ROut, never, EventLayerError>, "eventLayer"> : {
+  readonly eventLayer: NonNullable<WorkerOptions<ROut, REvent, EventLayerError>["eventLayer"]>;
+};
+/**
+ * Worker constructor options for a specific RPC definition.
+ */
+type Options<ROut, Self extends Definition.Any, REvent = never, EventLayerError = never> = BaseOptions<ROut, Self, REvent, EventLayerError> & EventLayerOptions<ROut, REvent, EventLayerError>;
+type LayerOptions = {
+  readonly binding: string;
+  readonly rpcTracing?: boolean;
+};
+type TagClass<Self, Id extends string, MethodDefinitions extends Methods> = Context$1.ServiceClass<Self, Id, ServiceBindingEffectClient<Api<Definition<Id, MethodDefinitions>>, Definition<Id, MethodDefinitions>>> & ServiceBindingStaticClient<Self, Api<Definition<Id, MethodDefinitions>>, Definition<Id, MethodDefinitions>> & {
+  readonly id: Id;
+  readonly methods: MethodDefinitions;
+  readonly make: {
+    <ROut, LayerError, REvent, EventLayerError = never>(layer: Layer.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>, options: Options<ROut, Definition<Id, MethodDefinitions>, REvent, EventLayerError> & {
+      readonly eventLayer: NonNullable<WorkerOptions<ROut, REvent, EventLayerError>["eventLayer"]>;
+    }): WorkerClass<Handlers<ROut | REvent, Definition<Id, MethodDefinitions>>, ROut | REvent>;
+    <ROut, LayerError, REvent extends never = never, EventLayerError = never>(layer: Layer.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>, options: Options<ROut, Definition<Id, MethodDefinitions>, REvent, EventLayerError>): WorkerClass<Handlers<ROut | REvent, Definition<Id, MethodDefinitions>>, ROut | REvent>;
+  };
+  readonly layer: (options: LayerOptions) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
+};
+/**
+ * Defines a single RPC method schema in a worker definition.
+ */
+declare const method: {
+  <Success extends ServiceFreeSchema>(definition: {
+    readonly success: Success;
+  }): Method<readonly [], Success>;
+  <const Args extends ReadonlyArray<ServiceFreeSchema>, Success extends ServiceFreeSchema>(definition: {
+    readonly args: Args;
+    readonly success: Success;
+  }): Method<Args, Success>;
+};
+declare const make: <Id extends string, const MethodDefinitions extends Methods>(id: Id, methods: MethodDefinitions & NoReservedMethods<MethodDefinitions>) => TagClass<Definition<Id, MethodDefinitions>, Id, MethodDefinitions>;
+declare const Tag: <Self>() => <Id extends string, const MethodDefinitions extends Methods>(id: Id, methods: MethodDefinitions & NoReservedMethods<MethodDefinitions>) => TagClass<Self, Id, MethodDefinitions>;
+declare const Worker: typeof Tag;
+/**
+ * Helper for implementing handlers with the exact method shape of a definition.
+ */
+declare const implement: <ROut, const Self extends Definition.Any>(_definition: Self, handlers: Handlers<ROut, Self>) => Handlers<ROut, Self>;
+/**
+ * Convenience alias for a single worker RPC handler Effect.
+ */
+type HandlerEffect<ROut, Self extends Definition.Any, Key extends keyof Self["methods"]> = WorkerRpcHandler<ROut, Method.Success<Self["methods"][Key]>>;
+//#endregion
+export { Api, Definition, HandlerEffect, Handlers, LayerOptions, Method, Methods, NoReservedMethods, Options, ReservedMethodName, ServerApi, ServiceFreeSchema, Tag, TagClass, Worker, WorkerDefinition_d_exports, implement, make, method };

package/dist/WorkerDefinition.mjs

@@ -0,0 +1,103 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.mjs";
+import { assertNoReservedMethods, decodeArgs, encodeSuccess, make as make$1, method as method$1 } from "./RpcDefinition.mjs";
+import { recordDecodedArgs } from "./internal/RpcInvocation.mjs";
+import { layer, makeDirectMethods } from "./ServiceBinding.mjs";
+import { make as make$2 } from "./Worker.mjs";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+//#region src/WorkerDefinition.ts
+var WorkerDefinition_exports = /* @__PURE__ */ __exportAll({
+	Tag: () => Tag,
+	Worker: () => Worker,
+	implement: () => implement,
+	make: () => make,
+	method: () => method
+});
+const reservedMethodNames = /* @__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);
+	const definition = make$1(id, methods);
+	return Object.assign(definition, { make: (layer, options) => {
+		const workerOptions = {
+			...options,
+			rpc: wrapHandlers(definition, options.rpc)
+		};
+		if (workerOptions.eventLayer === void 0) return make$2(layer, workerOptions);
+		return make$2(layer, workerOptions);
+	} });
+};
+const make = (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$1 = (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$1,
+		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
+export { Tag, Worker, WorkerDefinition_exports, implement, make, method };