@gjermundgaraba/effect-actions 0.19.0 → 0.21.0

package/dist/http/placed.mjs

@@ -0,0 +1,71 @@
+import { Implementation, memoized } from "../contract/implementation.mjs";
+import { EventImplementation } from "../contract/feed.mjs";
+import { SubscriptionError, allowAll } from "../Event.mjs";
+import { isNotFound } from "./watch.mjs";
+import { sendersWith } from "./client.mjs";
+import { allowAll as allowAll$1 } from "../Action.mjs";
+import { Context, Effect, Option, Predicate, Schema, Stream } from "effect";
+import { Headers, HttpClient, HttpClientRequest, HttpServerRequest } from "effect/http";
+// src/http/placed.ts
+const ownedByTheRequest = (name) => [
+	"host",
+	"connection",
+	"keep-alive",
+	"te",
+	"trailer",
+	"transfer-encoding",
+	"upgrade"
+].includes(name) || [
+	"content-",
+	"accept",
+	"proxy-",
+	"sec-websocket-",
+	"mcp-"
+].some((family) => name.startsWith(family));
+const forwarded = Effect.map(Effect.serviceOption(HttpServerRequest.HttpServerRequest), Option.match({
+	onNone: () => Headers.empty,
+	onSome: ({ headers }) => Headers.fromInput(Object.entries(headers).filter(([name]) => !ownedByTheRequest(name)))
+}));
+var Sending = class extends Context.Service()("effect-actions/ActionHttp/placed/Sending") {};
+const dispatching = HttpClient.makeWith((request) => Effect.flatMap(Effect.all([request, Effect.service(Sending)]), ([sent, client]) => client.execute(sent)), (request) => Effect.succeed(request));
+const isSubscriptionError = Schema.is(SubscriptionError);
+const isNotServed = Predicate.compose(isSubscriptionError, (error) => Predicate.isTagged(error.reason, "NotServed"));
+const notServedThere = (name) => /* @__PURE__ */ new Error(`ActionHttp.placed: the server its client reaches does not serve ${name} (serve its implementation in that server's ActionHttp.layer of this binding)`);
+/**
+* The actions and event types of `binding` served where another server serves them, as a
+* surface's implementations: each call and subscription sent on over `binding` with the client
+* `client` answers for its decoded input and its contract, one of the binding's, carrying the
+* caller's headers, and its answer, its errors and its occurrences passed back as they are. The
+* surface serving them authenticates a protected one as its own and authorizes every caller; the
+* server reached authenticates and authorizes again.
+*
+* **Gotchas**
+*
+* - The caller's credential is verified twice, by the surface serving these and by the server reached, so both are given the verifier: a credential expiring between the two is refused by the second.
+* - The server reached builds its own verifier: one caching signing keys in memory fetches them in each of its instances, a Durable Object's again after each eviction.
+* - Every header of the caller's request is sent on but its connection's, its body's, what it accepts and an MCP request's routing headers (`mcp-*`): one that must not reach the server reached is removed per contract by the client `client` returns, `HttpClient.mapRequest(HttpClientRequest.removeHeader("cookie"))`, which runs after them.
+* - A header `client`'s client sets replaces the caller's of that name, as it is set after them: a service's own `authorization` is sent in place of the caller's.
+* - A call with no HTTP request, as through `Action.client` in process or an MCP stdio surface, sends no header on: a protected one reaches the server reached with no credential, which refuses it with `Unauthenticated`.
+* - An error the server reached declares beyond the action's own and the built-in ones, its binding's `error` or its verifier's, is a defect where it is passed back, answered as one.
+* - A server reached that does not serve one of them, its route a 404, is a defect naming it, with the fix: a declared error whose status is 404 is passed back as it is.
+* - A refusal of a subscription by the server reached comes after the surface admitted it, so it ends the subscription's stream where the surface's own would have answered its 401 or 403.
+*/
+const placed = (binding, client) => {
+	const route = client;
+	const sendingTo = (input, contract) => HttpClient.mapRequestInputEffect(route(input, contract), (request) => Effect.map(forwarded, (headers) => HttpClientRequest.setHeaders(request, headers)));
+	const senders = sendersWith(binding, dispatching, void 0);
+	const handlerOf = ({ method }, action) => {
+		const send = method(action);
+		return (input, reporting) => {
+			const sent = send(input, ...reporting === void 0 ? [] : [{ onProgress: reporting.progress }]);
+			const sending = sendingTo(input, action);
+			return Stream.isStream(sent) ? sent.pipe(Stream.provideService(Sending, sending), Stream.catchIf(isNotFound, () => Stream.die(notServedThere(action.name)))) : sent.pipe(Effect.provideService(Sending, sending), Effect.catchIf(isNotFound, () => Effect.die(notServedThere(action.name))));
+		};
+	};
+	const runOf = ({ transport }, event) => ({
+		poll: (input, cursor) => transport(event, input).poll(cursor).pipe(Effect.provideService(Sending, sendingTo(input, event)), Effect.catchIf(isNotServed, () => Effect.die(notServedThere(event.name)))),
+		stream: (input, cursor) => transport(event, input).stream(cursor).pipe(Stream.provideService(Sending, sendingTo(input, event)), Stream.catchIf(isNotServed, () => Stream.die(notServedThere(event.name))))
+	});
+	return [...binding.actions.length === 0 ? [] : [new Implementation(binding.actions, memoized(Effect.map(senders, (built) => binding.actions.map((action) => [action, handlerOf(built, action)]))), memoized(Effect.succeed(allowAll$1)))], ...binding.events.length === 0 ? [] : [new EventImplementation(binding.events, binding.events.map((event) => [event, memoized(Effect.map(senders, (built) => runOf(built, event)))]), memoized(Effect.succeed(allowAll)))]];
+};
+export { placed };

package/dist/http/schema-errors.mjs

@@ -1,9 +1,8 @@
 import { InvalidInput } from "../contract/errors.mjs";
 import { Effect } from "effect";
 import { HttpApiMiddleware } from "effect/http-api";
-//#region src/http/schema-errors.ts
+// src/http/schema-errors.ts
 const responseEncodingKinds = /* @__PURE__ */ new Set(["Body", "ResponseHeaders"]);
 var SchemaErrors = class extends HttpApiMiddleware.Service()("effect-actions/http/SchemaErrors", { error: [InvalidInput] }) {};
-const schemaErrors = () => HttpApiMiddleware.layerSchemaErrorTransform(SchemaErrors, (failure) => Effect.fail(responseEncodingKinds.has(failure.kind) ? failure : InvalidInput.fromSchemaError(failure.cause)));
-//#endregion
+const schemaErrors = HttpApiMiddleware.layerSchemaErrorTransform(SchemaErrors, (failure) => Effect.fail(responseEncodingKinds.has(failure.kind) ? failure : InvalidInput.fromSchemaError(failure.cause)));
 export { SchemaErrors, schemaErrors };

package/dist/http/streamed.d.mts

@@ -0,0 +1,21 @@
+import { Codec } from "../contract/codec.mjs";
+import "../contract/progress.mjs";
+import { ErasedValue } from "../contract/implementation.mjs";
+import { StreamOf } from "../contract/stream.mjs";
+import { Any } from "../Action.mjs";
+import { Effect, Schema, Stream } from "effect";
+import { HttpApiSchema } from "effect/http-api";
+/** One event a route streams: a progress value, an element, or the answer it ends with. */
+interface Sent {
+  readonly event: "progress" | "element" | "final";
+  readonly data: ErasedValue;
+}
+declare const eventOf: <const N extends Sent["event"], D extends Codec>(event: N, data: D) => Schema.Struct<{
+  readonly id: Schema.optional<Schema.String>;
+  readonly event: Schema.Literal<N>;
+  readonly data: Schema.fromJsonString<Schema.toCodecJson<D>>;
+}>;
+type EventOf<N extends Sent["event"], D extends Codec> = ReturnType<typeof eventOf<N, D>>;
+/** The success of the endpoint of action `A` declaring errors `E`, as `ActionHttp` builds it. */
+export type SuccessOf<A extends Any, E extends Schema.Top> = A["success"] extends StreamOf<infer Element> ? HttpApiSchema.StreamSse<Schema.Union<A["progress"] extends Codec ? readonly [EventOf<"element", Element>, EventOf<"progress", A["progress"]>] : readonly [EventOf<"element", Element>]>, E> : A["progress"] extends Codec ? Schema.toCodecJson<A["success"]> | HttpApiSchema.StreamSse<Schema.Union<readonly [EventOf<"progress", A["progress"]>, EventOf<"final", A["success"]>]>, E> : Schema.toCodecJson<A["success"]>;
+export {};

package/dist/http/streamed.mjs

@@ -0,0 +1,94 @@
+import { Progressed, answerFrom, elementsFrom } from "../contract/progress.mjs";
+import { elementsOf } from "../contract/implementation.mjs";
+import { concealed } from "../contract/reported.mjs";
+import { Cause, Effect, ErrorReporter, Queue, Schema, Stream } from "effect";
+import { HttpServerRequest } from "effect/http";
+import { HttpApiSchema } from "effect/http-api";
+// src/http/streamed.ts
+const eventOf = (event, data) => Schema.Struct({
+	id: Schema.optional(Schema.String),
+	event: Schema.Literal(event),
+	data: Schema.fromJsonString(Schema.toCodecJson(data))
+});
+/** What a route of an action declaring `progress` answers without its stream: `success`. */
+const answeredWithProgress = (success) => HttpApiSchema.isNoContent(success.ast) ? HttpApiSchema.NoContent : success;
+/**
+* What a route of an action declaring `progress` answers a request accepting
+* `text/event-stream`: a `progress` event for each value its handler reports, then a `final`
+* event with its answer. A declared failure after the first event ends the stream as Effect's
+* stream failure event, and a defect as one saying `Internal server error`.
+*/
+const progressStreamOf = (progress, success, errors) => HttpApiSchema.StreamSse({
+	events: Schema.Union([eventOf("progress", progress), eventOf("final", success)]),
+	error: Schema.Union(errors)
+});
+/**
+* What a route of an action answering a stream answers: an `element` event for each element,
+* beside a `progress` event for each value its handler reports where it declares `progress`. A
+* declared failure after the first event ends the stream as Effect's stream failure event, and
+* a defect as one saying `Internal server error`.
+*/
+const elementStreamOf = (element, progress, errors) => HttpApiSchema.StreamSse({
+	events: Schema.Union(progress === void 0 ? [eventOf("element", element)] : [eventOf("element", element), eventOf("progress", progress)]),
+	error: Schema.Union(errors)
+});
+const streamed = (answer) => Effect.gen(function* () {
+	const sent = yield* Queue.bounded(1);
+	let streaming = false;
+	const send = (event) => Effect.andThen(Queue.offer(sent, event), Effect.sync(() => {
+		streaming = true;
+	}));
+	const reporting = { progress: (data) => send({
+		event: "progress",
+		data
+	}) };
+	const ended = (cause) => {
+		if (Cause.hasDies(cause)) return concealed(cause);
+		return streaming ? Effect.andThen(ErrorReporter.report(cause), Effect.failCause(cause)) : Effect.failCause(cause);
+	};
+	yield* answer(reporting, send).pipe(Effect.catchCause(ended), Queue.into(sent), Effect.forkScoped({ startImmediately: true }));
+	const first = yield* Effect.catchIf(Queue.take(sent), Cause.isDone, () => Effect.undefined);
+	return first === void 0 ? Stream.empty : Stream.concat(Stream.make(first), Stream.fromQueue(sent));
+});
+/** A check of `schema` failing as a defect, inside the call's boundary. */
+const checkedBy = (schema) => {
+	const encode = Schema.encodeUnknownEffect(Schema.toCodecJson(schema));
+	return (data) => Effect.orDie(encode(data));
+};
+/**
+* The route handler of an action declaring `progress`: its answer streamed with its progress
+* where the request's `Accept` names `text/event-stream`, its answer alone otherwise.
+*/
+const answeringWithProgress = (success, run) => {
+	const check = checkedBy(success);
+	return (payload) => Effect.flatMap(HttpServerRequest.HttpServerRequest, (request) => (request.headers["accept"] ?? "").includes("text/event-stream") ? streamed((reporting, send) => run(payload, reporting).pipe(Effect.tap(check), Effect.flatMap((data) => send({
+		event: "final",
+		data
+	})))) : run(payload));
+};
+/** The route handler of an action answering a stream: its elements and its progress, streamed. */
+const answeringElements = (element, run) => {
+	const check = checkedBy(element);
+	return (payload) => streamed((reporting, send) => Stream.runForEach(elementsOf(run(payload, reporting)), (data) => Effect.andThen(check(data), send({
+		event: "element",
+		data
+	}))));
+};
+const progressedOf = ({ event, data }) => {
+	if (event === "progress") return Progressed.Progress({ value: data });
+	return event === "final" ? Progressed.Final({ value: data }) : Progressed.Element({ value: data });
+};
+const answeredWithout = /* @__PURE__ */ new Error("A route of an action declaring progress or answering a stream answered without its event stream");
+/** The events of a route's answer, as one stream of `Progressed`. */
+const sentFrom = (answer) => Stream.isStream(answer) ? Stream.map(answer, progressedOf) : Stream.die(answeredWithout);
+/**
+* A client's answer from a route of an action declaring `progress`: each `progress` event handed
+* to `onProgress`, where the call gave one, then the `final` event's answer.
+*/
+const readWithProgress = (answer, onProgress) => answerFrom(sentFrom(answer), onProgress);
+/**
+* A client's elements from a route of an action answering a stream: each `element` event's
+* data, each `progress` event's handed to `onProgress`.
+*/
+const readElements = (answer, onProgress) => elementsFrom(sentFrom(answer), onProgress);
+export { answeredWithProgress, answeringElements, answeringWithProgress, elementStreamOf, progressStreamOf, readElements, readWithProgress };

package/dist/http/watch.mjs

@@ -0,0 +1,50 @@
+import { fedOf } from "../contract/pages.mjs";
+import { NotServed, SubscriptionError } from "../Event.mjs";
+import { Receiving, webhookFed } from "../contract/receiving.mjs";
+import { answeredStatus, failingWhenUnanswered, isTransient, receivedFrom } from "../contract/transient.mjs";
+import { Effect, Predicate, Stream } from "effect";
+import { HttpClientError } from "effect/http";
+// src/http/watch.ts
+/** Whether `error` is an HTTP client's failure on a 404 answer. */
+const isNotFound = Predicate.compose(HttpClientError.isHttpClientError, (error) => answeredStatus(error) === 404);
+/**
+* The transport of one subscription to `event` over its route, `input` its decoded input: each
+* page from `poll`, the stream from `stream`, and a webhook subscription from `webhook`'s routes
+* where the binding has them, a 404 failing as `NotServed`.
+*/
+const transportOf = (event, poll, stream, webhook, input) => {
+	const notServed = Effect.fail(SubscriptionError.of(event.name, new NotServed()));
+	const answered = (request) => request.pipe(failingWhenUnanswered, Effect.catchIf(isNotFound, () => notServed));
+	const webhooks = webhook === void 0 ? void 0 : {
+		receiver: Effect.service(Receiving),
+		subscribe: (request) => answered(webhook.subscribe({ payload: {
+			input,
+			...request
+		} })),
+		unsubscribe: (request) => answered(webhook.unsubscribe({ payload: {
+			input,
+			...request
+		} })),
+		read: webhookFed(event)
+	};
+	const read = (sent) => sent.pipe(Stream.catchIf(Predicate.isTagged("Retry"), () => Stream.empty), receivedFrom("HTTP", event.name));
+	return {
+		name: event.name,
+		poll: (cursor) => answered(poll({ payload: {
+			input,
+			cursor
+		} })),
+		stream: (cursor) => Stream.unwrap(answered(stream({ payload: {
+			input,
+			cursor
+		} })).pipe(Effect.map((answer) => Stream.isStream(answer) ? read(answer) : Stream.fromIterable(fedOf({
+			items: answer.events,
+			truncated: answer.truncated,
+			from: cursor,
+			to: answer.cursor ?? cursor
+		}))))),
+		webhook: webhooks,
+		transient: isTransient
+	};
+};
+export { isNotFound, transportOf };

package/dist/mcp/bridge.mjs

@@ -0,0 +1,283 @@
+import { Anyone, principalOf } from "../contract/caller.mjs";
+import { inputParseOptions } from "../contract/call.mjs";
+import { reported } from "../contract/reported.mjs";
+import { encodeUntaggedOf } from "../contract/occurrence.mjs";
+import { acquireFeeds, unkeyedHook } from "../contract/feed.mjs";
+import { NotServed, SubscriptionError, Unsupported } from "../Event.mjs";
+import { sentError } from "../contract/codes.mjs";
+import { Webhooks, offersWebhook, servedWebhooks, webhookSubscriber } from "../contract/webhooks.mjs";
+import { pushed, refusalIn } from "../contract/push.mjs";
+import { promote } from "../authentication/provider.mjs";
+import { recordStepUp } from "../authentication/refusal.mjs";
+import { Active, EventsError, Failed, Heartbeat, Notifications, Occurred, Requests, Terminated, codes, extension, subscriptionIdKey } from "./events.mjs";
+import { isObjectSchema, routingFormsOf, toolJsonSchema } from "./protocol.mjs";
+import { Cause, Context, Duration, Effect, Exit, Match, Option, Predicate, Result, Schema } from "effect";
+import { HttpEffect, HttpServerRequest, HttpServerResponse } from "effect/http";
+import { McpSchema } from "effect/ai";
+// src/mcp/bridge.ts
+const isGroup = (u) => Predicate.isObjectKeyword(u) && "merge" in u && Predicate.isFunction(u.merge) && "requests" in u && u.requests instanceof Map;
+const groupOf = (adapter, key) => {
+	const group = Predicate.hasProperty(adapter, key) ? adapter[key] : void 0;
+	if (!isGroup(group)) throw new Error(`Effect's MCP ${adapter.protocolVersion} adapter holds no ${key} group: effect-actions supports MCP events on effect 4.0.x (install the effect version its peer range names)`);
+	return group;
+};
+/**
+* The JSON Schemas `events/list` lists for `event`, refusing an input or a payload that is no
+* object.
+*/
+const eventSchemasOf = (event) => {
+	const inputSchema = toolJsonSchema(Schema.toCodecJson(event.input), true);
+	if (!isObjectSchema(inputSchema)) throw new Error(`MCP event input must be one object with keys, such as a struct: ${event.name} (wrap a union, an array or a scalar in a field, or omit input for no arguments)`);
+	const payloadSchema = toolJsonSchema(Schema.toCodecJson(event.payload), false);
+	if (!isObjectSchema(payloadSchema)) throw new Error(`MCP event payload must be one object, such as a struct: ${event.name} (wrap an array or a scalar in a field)`);
+	return {
+		inputSchema,
+		payloadSchema
+	};
+};
+const encodeServerInfo = Schema.encodeEffect(McpSchema.Implementation);
+const internalError = new EventsError({
+	code: codes.internal,
+	message: "Internal error"
+});
+const isSubscriptionError = Schema.is(SubscriptionError);
+const wireErrorOf = (cause) => {
+	const refusal = refusalIn(cause);
+	if (refusal !== void 0) return Effect.succeed(new EventsError(sentError(refusal)));
+	const failure = Cause.hasDies(cause) ? void 0 : Result.getOrUndefined(Cause.findFail(cause));
+	return isSubscriptionError(failure?.error) ? Effect.succeed(new EventsError(sentError(failure.error))) : Effect.as(reported(cause), internalError);
+};
+const headerMismatch = (request) => Effect.andThen(HttpEffect.appendPreResponseHandler((_request, response) => Effect.succeed(HttpServerResponse.setStatus(response, 400))).pipe(Effect.provideService(HttpServerRequest.HttpServerRequest, request)), Effect.fail(new EventsError({
+	code: codes.headerMismatch,
+	message: "Mcp-Name header does not match request parameters"
+})));
+const routedTo = (name) => Effect.flatMap(Effect.serviceOption(HttpServerRequest.HttpServerRequest), (request) => Option.isNone(request) || routingFormsOf(name).includes(request.value.headers["mcp-name"] ?? "") ? Effect.void : headerMismatch(request.value));
+const servedOf = (feed, delivery) => {
+	const { event } = feed;
+	const decode = Schema.decodeUnknownEffect(Schema.toCodecJson(event.input), inputParseOptions);
+	return {
+		feed,
+		decode: (args) => Effect.mapError(decode(args ?? {}), ({ message }) => new EventsError({
+			code: codes.invalidParams,
+			message: `Invalid arguments for event '${event.name}': ${message}`
+		})),
+		wire: encodeUntaggedOf(event),
+		listing: {
+			name: event.name,
+			description: event.description,
+			delivery,
+			...eventSchemasOf(event)
+		}
+	};
+};
+/**
+* Dies with the reason the endpoint of `serving` cannot serve one of its events, run where the
+* endpoint's layer is built: a protected one with a `subscription` hook, under an authentication
+* without a principal to key its polls by.
+*/
+const refuseUnservable = ({ events, authentication }) => authentication === void 0 ? Effect.void : Effect.flatMap(acquireFeeds(events), (feeds) => {
+	const refusal = unkeyedHook("MCP", feeds, authentication.principal !== void 0);
+	return refusal === void 0 ? Effect.void : Effect.die(new Error(refusal));
+});
+/**
+* Serves the feeds the endpoint of `serving` offers by webhook to `Webhooks`, where it is
+* provided, run where the endpoint's layer is built: it restores their kept subscriptions, and
+* dies where they cannot be kept.
+*/
+const serveWebhooks = (serving) => Effect.asVoid(Effect.flatMap(acquireFeeds(serving.events), (feeds) => servedWebhooks(feeds, serving.authentication)));
+/**
+* One push subscription, as `events/stream` holds it: what the feed's `pushed` sends, as
+* SEP-3415's notifications. Its confirmation is `active`, a later gap a fresh `active`, a
+* position a heartbeat, and a failure it reads on through `error`. A failure before `active` is
+* the request's error; a refusal after it ends the subscription with `terminated`.
+*/
+const delivered = ({ send, clientId, requestId, wire, _meta: resultMeta }, run) => {
+	const notify = (rpc, payload) => send("2026-07-28", clientId, {
+		tag: rpc._tag,
+		payload
+	});
+	return Effect.gen(function* () {
+		const _meta = { [subscriptionIdKey]: requestId };
+		let active = false;
+		const activate = (cursor, truncated) => {
+			active = true;
+			return notify(Active, {
+				_meta,
+				cursor,
+				truncated
+			});
+		};
+		const deliver = (sent) => Match.valueTags(sent, {
+			Gap: ({ cursor }) => activate(cursor, true),
+			Checked: ({ cursor }) => active ? notify(Heartbeat, {
+				_meta,
+				cursor
+			}) : activate(cursor, false),
+			Occurrence: (occurrence) => Effect.flatMap(wire(occurrence), (event) => notify(Occurred, {
+				...event,
+				_meta
+			})),
+			Failed: () => notify(Failed, {
+				_meta,
+				error: {
+					code: internalError.code,
+					message: internalError.message
+				}
+			})
+		});
+		const exit = yield* Effect.exit(run(deliver));
+		if (Exit.isFailure(exit)) {
+			if (Cause.hasInterruptsOnly(exit.cause)) return yield* Effect.interrupt;
+			const error = yield* wireErrorOf(exit.cause);
+			if (!active) return yield* error;
+			const { code, message, data } = error;
+			yield* notify(Terminated, {
+				_meta,
+				error: {
+					code,
+					message,
+					...data === void 0 ? {} : { data }
+				}
+			});
+		}
+		return {
+			resultType: "complete",
+			_meta: {
+				...resultMeta,
+				..._meta
+			}
+		};
+	});
+};
+/**
+* `base`, the 2026-07-28 adapter, also serving SEP-3415's `events/list`, `events/poll` and
+* `events/stream` for the event implementations of `serving`, and advertising the extension in
+* its discovery.
+*/
+const withEvents = (base, serving) => {
+	const { authentication } = serving;
+	const asSubscriber = (event, run) => authentication === void 0 || event.caller === Anyone ? run : recordStepUp(promote(authentication, run));
+	const installHandlers = (core, lifecycle, target) => Effect.gen(function* () {
+		const feeds = yield* acquireFeeds(serving.events);
+		const built = yield* Effect.context();
+		const send = target.context.sendNotification;
+		const meta = Effect.map(Effect.orDie(encodeServerInfo(target.context.serverInfo)), (serverInfo) => ({ "io.modelcontextprotocol/serverInfo": serverInfo }));
+		const webhooks = Context.getOption(built, Webhooks);
+		const webhookOffered = (event) => Option.isSome(webhooks) && offersWebhook(event, authentication);
+		const deliveryOf = (event) => [
+			"poll",
+			...send === void 0 ? [] : ["push"],
+			...webhookOffered(event) ? ["webhook"] : []
+		];
+		const served = new Map(feeds.map((feed) => [feed.event.name, servedOf(feed, deliveryOf(feed.event))]));
+		const servedNamed = (name) => {
+			const found = served.get(name);
+			return found === void 0 ? Effect.fail(new EventsError(sentError(SubscriptionError.of(name, new NotServed())))) : Effect.succeed(found);
+		};
+		const asWebhook = (feed, run) => Effect.catchCause(asSubscriber(feed.event, Effect.flatMap(webhookSubscriber(feed, authentication, webhooks), run)), (cause) => Effect.flatMap(wireErrorOf(cause), Effect.fail));
+		const fromBuilt = (handled) => Effect.updateContext(handled, (request) => Context.merge(built, request));
+		const handlers = Requests.of({
+			"events/list": () => Effect.map(meta, (_meta) => ({
+				resultType: "complete",
+				events: [...served.values()].map(({ listing }) => listing),
+				_meta
+			})),
+			"events/poll": ({ name, arguments: args, cursor, maxEvents }) => Effect.gen(function* () {
+				yield* routedTo(name);
+				const { feed, decode, wire } = yield* servedNamed(name);
+				const input = yield* decode(args);
+				const { page, events } = yield* Effect.gen(function* () {
+					const polled = yield* asSubscriber(feed.event, Effect.flatMap(principalOf(feed.event, authentication), (subscriber) => feed.poll(input, cursor ?? null, {
+						subscriber,
+						maxEvents
+					})));
+					return {
+						page: polled,
+						events: yield* Effect.forEach(polled.events, wire)
+					};
+				}).pipe(Effect.catchCause((cause) => Effect.flatMap(wireErrorOf(cause), Effect.fail)));
+				return {
+					resultType: "complete",
+					events,
+					cursor: page.cursor,
+					truncated: page.truncated,
+					hasMore: page.hasMore,
+					nextPollMs: Duration.toMillis(page.nextPoll),
+					_meta: yield* meta
+				};
+			}).pipe(fromBuilt),
+			"events/stream": ({ name, arguments: args, cursor }, { client, requestId }) => Effect.gen(function* () {
+				yield* routedTo(name);
+				const { feed, decode, wire } = yield* servedNamed(name);
+				const input = yield* decode(args);
+				if (send === void 0) return yield* new EventsError(sentError(SubscriptionError.of(name, new Unsupported({
+					feature: "deliveryMode",
+					value: "push"
+				}))));
+				return yield* delivered({
+					send,
+					clientId: client.id,
+					requestId,
+					wire,
+					_meta: yield* meta
+				}, (deliver) => asSubscriber(feed.event, Effect.flatMap(feed.stream(input), (open) => pushed(open, cursor ?? null, deliver))));
+			}).pipe(fromBuilt),
+			"events/subscribe": ({ name, arguments: args, delivery: { url, secret }, cursor, ttlMs }) => Effect.gen(function* () {
+				yield* routedTo(name);
+				const { feed, decode } = yield* servedNamed(name);
+				const input = yield* decode(args);
+				return {
+					resultType: "complete",
+					...yield* asWebhook(feed, ({ webhooks: service, ...subscriber }) => service.subscribe({
+						...subscriber,
+						input,
+						delivery: {
+							url,
+							secret
+						},
+						cursor: cursor ?? null,
+						ttlMs
+					})),
+					_meta: yield* meta
+				};
+			}).pipe(fromBuilt),
+			"events/unsubscribe": ({ name, arguments: args, delivery }) => Effect.gen(function* () {
+				yield* routedTo(name);
+				const { feed, decode } = yield* servedNamed(name);
+				const input = yield* decode(args);
+				yield* asWebhook(feed, ({ webhooks: service, feed: subscribed, principal }) => service.unsubscribe({
+					feed: subscribed,
+					principal,
+					input,
+					delivery
+				}));
+				return {
+					resultType: "complete",
+					_meta: yield* meta
+				};
+			}).pipe(fromBuilt)
+		});
+		yield* Effect.asVoid(base.installHandlers(core, lifecycle, {
+			...target,
+			context: {
+				...target.context,
+				serverInfo: {
+					...target.context.serverInfo,
+					extensions: {
+						...target.context.serverInfo.extensions,
+						[extension]: { listChanged: false }
+					}
+				}
+			}
+		}));
+		yield* target.install(base, Requests, handlers);
+	});
+	return {
+		...base,
+		clientRpcs: groupOf(base, "clientRpcs").merge(Requests),
+		handlerRpcs: groupOf(base, "handlerRpcs").merge(Requests),
+		serverNotificationRpcs: groupOf(base, "serverNotificationRpcs").merge(Notifications),
+		installHandlers
+	};
+};
+export { eventSchemasOf, refuseUnservable, serveWebhooks, withEvents };