@gjermundgaraba/effect-actions 0.19.0 → 0.21.0

package/dist/mcp/reply.d.mts

@@ -0,0 +1,79 @@
+import "../contract/progress.mjs";
+import "../Action.mjs";
+import { Effect, Schema, Stream } from "effect";
+import { HttpClientError } from "effect/http";
+declare const StatusError_base: Schema.Class<StatusError, Schema.TaggedStruct<"StatusError", {
+  readonly status: Schema.Int;
+  readonly body: Schema.String;
+}>, import("effect/Cause").YieldableError & {
+  readonly brand: unique symbol;
+}>;
+/** The endpoint answered with an HTTP status other than 200, and a body no declared error decodes. */
+export declare class StatusError extends StatusError_base {}
+declare const ProtocolError_base: Schema.Class<ProtocolError, Schema.TaggedStruct<"ProtocolError", {
+  readonly code: Schema.Finite;
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError & {
+  readonly brand: unique symbol;
+}>;
+/**
+ * The endpoint answered with a JSON-RPC error, such as the native server's for an unknown tool.
+ */
+export declare class ProtocolError extends ProtocolError_base {}
+declare const NoReply_base: Schema.Class<NoReply, Schema.TaggedStruct<"NoReply", {
+  readonly body: Schema.String;
+}>, import("effect/Cause").YieldableError & {
+  readonly brand: unique symbol;
+}>;
+/** The endpoint answered 200 without a JSON-RPC reply to read, as JSON or as an event stream. */
+export declare class NoReply extends NoReply_base {}
+declare const UndeclaredError_base: Schema.Class<UndeclaredError, Schema.TaggedStruct<"UndeclaredError", {
+  readonly text: Schema.String;
+}>, import("effect/Cause").YieldableError & {
+  readonly brand: unique symbol;
+}>;
+/** The tool returned an error whose text decodes as none of the action's declared errors. */
+export declare class UndeclaredError extends UndeclaredError_base {}
+declare const NoStructuredContent_base: Schema.Class<NoStructuredContent, Schema.TaggedStruct<"NoStructuredContent", {
+  readonly body: Schema.String;
+}>, import("effect/Cause").YieldableError & {
+  readonly brand: unique symbol;
+}>;
+/** The tool returned a result without the structured content its action's success needs. */
+export declare class NoStructuredContent extends NoStructuredContent_base {}
+declare const FrameTooLarge_base: Schema.Class<FrameTooLarge, Schema.TaggedStruct<"FrameTooLarge", {
+  readonly maxEventSize: Schema.Int;
+}>, import("effect/Cause").YieldableError & {
+  readonly brand: unique symbol;
+}>;
+/**
+ * The endpoint's event stream held more than `maxEventSize` characters with no frame ending, the
+ * most a client holds while it waits for one.
+ *
+ * **Gotchas**
+ *
+ * - The limit is on what is held unended, as Effect's SSE parser checks it after each chunk: a frame larger than it that ends within the chunk carrying it is read.
+ */
+export declare class FrameTooLarge extends FrameTooLarge_base {}
+declare const McpCallError_base: Schema.Class<McpCallError, Schema.TaggedStruct<"McpCallError", {
+  readonly method: Schema.String;
+  readonly target: Schema.String;
+  readonly reason: Schema.Union<readonly [typeof StatusError, typeof ProtocolError, typeof NoReply, typeof UndeclaredError, typeof NoStructuredContent, typeof FrameTooLarge]>;
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError & {
+  readonly brand: unique symbol;
+}>;
+/**
+ * An answer a client cannot read as the contract's: `method` is the request, `tools/call` or an
+ * `events/*` one, `target` the tool or event it named, and `reason` says what was wrong, with what
+ * the endpoint sent, so a caller branches on it with
+ * `Effect.catchReason("McpCallError", "StatusError", ...)`. `message` names all three.
+ * Structured content that does not decode as the success is a `SchemaError` instead, and a
+ * request that fails an `HttpClientError`.
+ *
+ * **Gotchas**
+ *
+ * - `returned an error: Invalid parameters for tool …`, an `UndeclaredError`, from a call its types allowed: the endpoint serves another contract under that name; give `client` the served contract value.
+ */
+export declare class McpCallError extends McpCallError_base {}
+export {};

package/dist/mcp/reply.mjs

@@ -0,0 +1,99 @@
+import { progressOf } from "./progress.mjs";
+import { Effect, Match, Option, Predicate, Schema, Stream } from "effect";
+import { Sse } from "effect/encoding";
+// src/mcp/reply.ts
+/** The endpoint answered with an HTTP status other than 200, and a body no declared error decodes. */
+var StatusError = class extends Schema.TaggedError()("StatusError", {
+	status: Schema.Int,
+	body: Schema.String
+}) {};
+/**
+* The endpoint answered with a JSON-RPC error, such as the native server's for an unknown tool.
+*/
+var ProtocolError = class extends Schema.TaggedError()("ProtocolError", {
+	code: Schema.Finite,
+	message: Schema.String
+}) {};
+/** The endpoint answered 200 without a JSON-RPC reply to read, as JSON or as an event stream. */
+var NoReply = class extends Schema.TaggedError()("NoReply", { body: Schema.String }) {};
+/** The tool returned an error whose text decodes as none of the action's declared errors. */
+var UndeclaredError = class extends Schema.TaggedError()("UndeclaredError", { text: Schema.String }) {};
+/** The tool returned a result without the structured content its action's success needs. */
+var NoStructuredContent = class extends Schema.TaggedError()("NoStructuredContent", { body: Schema.String }) {};
+/**
+* The endpoint's event stream held more than `maxEventSize` characters with no frame ending, the
+* most a client holds while it waits for one.
+*
+* **Gotchas**
+*
+* - The limit is on what is held unended, as Effect's SSE parser checks it after each chunk: a frame larger than it that ends within the chunk carrying it is read.
+*/
+var FrameTooLarge = class extends Schema.TaggedError()("FrameTooLarge", { maxEventSize: Schema.Int }) {};
+const Reason = Schema.Union([
+	StatusError,
+	ProtocolError,
+	NoReply,
+	UndeclaredError,
+	NoStructuredContent,
+	FrameTooLarge
+]);
+const sentenceOf = Match.typeTags()({
+	StatusError: ({ status, body }) => `answered ${status}: ${body}`,
+	ProtocolError: ({ code, message }) => `failed with ${code}: ${message}`,
+	NoReply: ({ body }) => `had no reply: ${body}`,
+	UndeclaredError: ({ text }) => `returned an error: ${text}`,
+	NoStructuredContent: ({ body }) => `returned no structured content: ${body}`,
+	FrameTooLarge: ({ maxEventSize }) => `sent more than ${maxEventSize} characters of an event stream with no frame ending`
+});
+/**
+* An answer a client cannot read as the contract's: `method` is the request, `tools/call` or an
+* `events/*` one, `target` the tool or event it named, and `reason` says what was wrong, with what
+* the endpoint sent, so a caller branches on it with
+* `Effect.catchReason("McpCallError", "StatusError", ...)`. `message` names all three.
+* Structured content that does not decode as the success is a `SchemaError` instead, and a
+* request that fails an `HttpClientError`.
+*
+* **Gotchas**
+*
+* - `returned an error: Invalid parameters for tool …`, an `UndeclaredError`, from a call its types allowed: the endpoint serves another contract under that name; give `client` the served contract value.
+*/
+var McpCallError = class extends Schema.TaggedError()("McpCallError", {
+	method: Schema.String,
+	target: Schema.String,
+	reason: Reason,
+	message: Schema.String
+}) {};
+const callError = (method, target, reason) => new McpCallError({
+	method,
+	target,
+	reason,
+	message: `MCP ${method} "${target}" ${sentenceOf(reason)}`
+});
+const isEventStream = (response) => (response.headers["content-type"] ?? "").startsWith("text/event-stream");
+/**
+* The data of each frame of the event stream `response` is, as it arrives: more than the parser
+* holds with no frame ending fails `method` on `name` with `FrameTooLarge`.
+*/
+const framesOf = (method, name, response) => Stream.suspend(() => {
+	const data = [];
+	const parser = Sse.makeParser((event) => {
+		if (Predicate.isTagged(event, "Event")) data.push(event.data);
+	});
+	return Stream.decodeText(response.stream).pipe(Stream.mapEffect((chunk) => {
+		const error = parser.feed(chunk);
+		return error === void 0 ? Effect.succeed(data.splice(0)) : Effect.fail(callError(method, name, new FrameTooLarge({ maxEventSize: error.reason.maxEventSize })));
+	}), Stream.flattenIterable);
+});
+/**
+* The messages of `response`, read as it arrives: the data of each frame of an event stream, or
+* the body itself as one. Each `notifications/progress` frame hands its value to `sink` and is
+* left out, so a long call holds the frames its reply is read from, not every value it reported.
+* A stateless request's notifications are its own.
+*/
+const bodyOf = (method, name, response, sink) => isEventStream(response) ? Stream.runCollect(Stream.filterEffect(framesOf(method, name, response), (data) => Option.match(progressOf(data), {
+	onNone: () => Effect.succeed(true),
+	onSome: (value) => sink === void 0 ? Effect.succeed(false) : Effect.as(sink.progress(value), false)
+}))) : Effect.map(response.text, (text) => [text]);
+/** Fails with the error of `errors` that `text` decodes as, or with `otherwise`. */
+const failWith = (errors, text, otherwise) => Schema.decodeEffect(Schema.fromJsonString(Schema.toCodecJson(Schema.Union(errors))))(text).pipe(Effect.mapError(() => otherwise), Effect.flatMap(Effect.fail));
+export { FrameTooLarge, McpCallError, NoReply, NoStructuredContent, ProtocolError, StatusError, UndeclaredError, bodyOf, callError, failWith, framesOf, isEventStream };

package/dist/mcp/request.d.mts

@@ -0,0 +1,40 @@
+import { Schema } from "effect";
+import { Headers, HttpClientRequest } from "effect/http";
+/**
+ * An MCP request's parameters, as `request` takes them: JSON, with any `_meta`, leaving
+ * out an `undefined` one, as a caller may. A helper passing on whole params types them as this,
+ * and a tool's `arguments` as `Schema.Json`, never `unknown`.
+ */
+export interface Params {
+  readonly _meta?: {
+    readonly [key: string]: Schema.Json;
+  };
+  readonly [key: string]: Schema.Json | undefined;
+}
+/** Where a `request` goes, and with what headers. */
+export interface RequestOptions {
+  /**
+   * The endpoint, resolved by the `HttpClient` that sends the request: relative under `Testing.layer`.
+   * Defaults to `/mcp`, as `client`'s does; converting to a web `Request` needs an absolute
+   * one.
+   */
+  readonly url?: string;
+  /**
+   * Headers sent beside the routing ones `request` fills in, such as `Authorization`; a routing
+   * header wins over a given one of its name.
+   */
+  readonly headers?: Headers.Input;
+}
+/**
+ * One stateless MCP request of `method` with `params`, as `layerHttp` serves it,
+ * as the native request value: the JSON-RPC envelope, the 2026-07-28 headers (`Accept`,
+ * `MCP-Protocol-Version`, `MCP-Method`), `mcp-name` from
+ * `params.uri` for `resources/read` and `params.name` otherwise, and the client metadata in
+ * `_meta` are filled in, under any `_meta` given, such as a `progressToken`; the protocol
+ * version is always the request's own. The test sends it: `HttpClient.execute` answers the
+ * response as the endpoint sent it, whatever its status, and `HttpClientRequest.toWebResult`
+ * gives the web `Request` a web handler or `fetch` takes, once `url` is absolute. It is for a test
+ * asserting on what `client` decodes away, such as `tools/list`, a refusal's challenge, or
+ * a call its types would not send.
+ */
+export declare const request: (method: string, params?: Params, { headers, url }?: RequestOptions) => HttpClientRequest.HttpClientRequest;

package/dist/mcp/request.mjs

@@ -0,0 +1,51 @@
+import { defaultPath, httpProtocol } from "./protocol.mjs";
+import { Predicate } from "effect";
+import { HttpClientRequest } from "effect/http";
+// src/mcp/request.ts
+/** The routing headers and JSON-RPC body of the request `request` builds. */
+const statelessRequest = (method, params) => {
+	const { protocolVersion } = httpProtocol;
+	const name = method === "resources/read" ? params["uri"] : params["name"];
+	return {
+		headers: {
+			accept: "application/json, text/event-stream",
+			"mcp-protocol-version": protocolVersion,
+			"mcp-method": method,
+			...Predicate.isString(name) ? { "mcp-name": name } : {}
+		},
+		body: {
+			jsonrpc: "2.0",
+			id: 1,
+			method,
+			params: {
+				...params,
+				_meta: {
+					"io.modelcontextprotocol/clientCapabilities": {},
+					"io.modelcontextprotocol/clientInfo": {
+						name: "effect-actions",
+						version: "0"
+					},
+					...params._meta,
+					"io.modelcontextprotocol/protocolVersion": protocolVersion
+				}
+			}
+		}
+	};
+};
+/**
+* One stateless MCP request of `method` with `params`, as `layerHttp` serves it,
+* as the native request value: the JSON-RPC envelope, the 2026-07-28 headers (`Accept`,
+* `MCP-Protocol-Version`, `MCP-Method`), `mcp-name` from
+* `params.uri` for `resources/read` and `params.name` otherwise, and the client metadata in
+* `_meta` are filled in, under any `_meta` given, such as a `progressToken`; the protocol
+* version is always the request's own. The test sends it: `HttpClient.execute` answers the
+* response as the endpoint sent it, whatever its status, and `HttpClientRequest.toWebResult`
+* gives the web `Request` a web handler or `fetch` takes, once `url` is absolute. It is for a test
+* asserting on what `client` decodes away, such as `tools/list`, a refusal's challenge, or
+* a call its types would not send.
+*/
+const request = (method, params = {}, { headers = {}, url = defaultPath } = {}) => {
+	const { headers: routingHeaders, body } = statelessRequest(method, params);
+	return HttpClientRequest.post(url).pipe(HttpClientRequest.setHeaders(headers), HttpClientRequest.setHeaders(routingHeaders), HttpClientRequest.bodyJsonUnsafe(body));
+};
+export { request, statelessRequest };

package/dist/mcp/watch.mjs

@@ -0,0 +1,115 @@
+import { InvalidInput } from "../contract/errors.mjs";
+import { isTransientStatus } from "../contract/status.mjs";
+import { Checked, Gap, untaggedOccurrenceOf } from "../contract/occurrence.mjs";
+import { defaultNextPoll } from "../contract/feed.mjs";
+import { reasonOf } from "../contract/codes.mjs";
+import { Receiving, webhookFed } from "../contract/receiving.mjs";
+import { Failed, readOn } from "../contract/push.mjs";
+import { WebhookCallback, WebhookTarget } from "../contract/subscribe.mjs";
+import { failingWhenSilent, failingWhenUnanswered, isTransient } from "../contract/transient.mjs";
+import { Active, Failed as Failed$1, Heartbeat, Occurred, PollEvents, SubscribeEvents, Terminated, UnsubscribeEvents, WireError, codes } from "./events.mjs";
+import { McpCallError, NoReply, ProtocolError, StatusError, bodyOf, callError, failWith, framesOf, isEventStream } from "./reply.mjs";
+import { request } from "./request.mjs";
+import { Duration, Effect, Match, Option, Predicate, Schema, Stream } from "effect";
+// src/mcp/watch.ts
+/** Reads one message as a request's reply: its result, by `success`, or its error. */
+const replyOf = (success) => Schema.decodeUnknownOption(Schema.fromJsonString(Schema.Union([Schema.Struct({ result: success }), Schema.Struct({ error: WireError })])));
+const pollReplyOf = replyOf(PollEvents.successSchema);
+const Frame = Schema.Union([
+	Schema.Struct({ error: WireError }),
+	Schema.Struct({
+		method: Schema.String,
+		params: Schema.optional(Schema.Json)
+	}),
+	Schema.Struct({ result: Schema.Unknown })
+]);
+const decodeFrame = Schema.decodeUnknownOption(Schema.fromJsonString(Frame));
+const reading = (rpc, read) => {
+	const decode = Schema.decodeUnknownOption(rpc.payloadSchema);
+	return (params) => Option.map(decode(params), read);
+};
+const subscribeReplyOf = replyOf(SubscribeEvents.successSchema);
+const unsubscribeReplyOf = replyOf(UnsubscribeEvents.successSchema);
+const encodeCallback = Schema.encodeSync(WebhookCallback);
+const encodeTarget = Schema.encodeSync(WebhookTarget);
+const transientReason = (reason) => Match.value(reason).pipe(Match.tag("StatusError", ({ status }) => isTransientStatus(status)), Match.tag("ProtocolError", ({ code }) => code === codes.internal), Match.orElse(() => false));
+const isMcpCallError = Schema.is(McpCallError);
+const transient = Predicate.or(isTransient, Predicate.compose(isMcpCallError, ({ reason }) => transientReason(reason)));
+/**
+* The transport of one subscription over an MCP endpoint served by `layerHttp`: `events/poll`
+* for each page, and `events/stream` read as it arrives, each failing as the endpoint answered.
+*/
+const transportOf = ({ http, url, event, refusedWith }, input) => {
+	const { name } = event;
+	const untagged = untaggedOccurrenceOf(event);
+	const occurrenceOf = (wire) => untagged({
+		...wire,
+		cursor: wire.cursor ?? null
+	});
+	const failed = (method, error) => reasonOf(name, error) ?? (error.code === codes.invalidParams ? new InvalidInput({ message: error.message }) : callError(method, name, new ProtocolError(error)));
+	const sent = (method, params) => Effect.filterOrElse(http.execute(request(method, {
+		name,
+		arguments: input,
+		...params
+	}, { url })), (response) => response.status === 200, (response) => Effect.flatMap(response.text, (body) => failWith(refusedWith, body, callError(method, name, new StatusError({
+		status: response.status,
+		body
+	})))));
+	/** The result of one `method` request, or what its error reply fails with. */
+	const answered = (method, params, decodeReply) => Effect.gen(function* () {
+		const messages = yield* bodyOf(method, name, yield* sent(method, params));
+		const reply = messages.flatMap((message) => Option.toArray(decodeReply(message))).at(-1);
+		if (reply === void 0) return yield* callError(method, name, new NoReply({ body: messages.join("\n") }));
+		if ("error" in reply) return yield* failed(method, reply.error);
+		return reply.result;
+	}).pipe(failingWhenUnanswered);
+	const poll = (cursor) => Effect.gen(function* () {
+		const result = yield* answered("events/poll", { cursor }, pollReplyOf);
+		return {
+			events: yield* Effect.forEach(result.events, occurrenceOf),
+			cursor: result.cursor ?? null,
+			truncated: result.truncated === true,
+			hasMore: result.hasMore === true,
+			nextPoll: result.nextPollMs === void 0 ? defaultNextPoll : Duration.millis(result.nextPollMs)
+		};
+	});
+	const readers = new Map(Object.entries({
+		[Active._tag]: reading(Active, ({ cursor = null, truncated }) => Effect.succeed([truncated === true ? Gap.make({ cursor }) : Checked.make({ cursor })])),
+		[Occurred._tag]: reading(Occurred, (params) => Effect.map(occurrenceOf(params), (occurrence) => [occurrence])),
+		[Heartbeat._tag]: reading(Heartbeat, ({ cursor = null }) => Effect.succeed([Checked.make({ cursor })])),
+		[Failed$1._tag]: reading(Failed$1, () => Effect.succeed([Failed.make({})])),
+		[Terminated._tag]: reading(Terminated, ({ error }) => Effect.fail(failed("events/stream", error)))
+	}));
+	const framed = (data) => Option.match(decodeFrame(data), {
+		onNone: () => Effect.succeed([]),
+		onSome: (frame) => {
+			if ("error" in frame) return Effect.fail(failed("events/stream", frame.error));
+			if (!("method" in frame)) return Effect.succeed([]);
+			const reader = readers.get(frame.method);
+			if (reader === void 0) return Effect.succeed([]);
+			return Option.getOrElse(reader(frame.params), () => Effect.as(Effect.logWarning(`MCP event "${name}" sent a frame that does not decode: ${data}`), []));
+		}
+	});
+	const read = (response) => framesOf("events/stream", name, response).pipe(failingWhenSilent, Stream.mapEffect(framed), Stream.flattenIterable);
+	const stream = (cursor) => Stream.unwrap(Effect.map(failingWhenUnanswered(sent("events/stream", { cursor })), (response) => isEventStream(response) ? read(response) : Stream.fromIterableEffect(failingWhenUnanswered(Effect.flatMap(response.text, framed))))).pipe(readOn("MCP", name));
+	return {
+		name,
+		poll,
+		stream,
+		webhook: {
+			receiver: Effect.service(Receiving),
+			subscribe: ({ delivery, cursor, ttlMs }) => answered("events/subscribe", {
+				delivery: {
+					mode: "webhook",
+					...encodeCallback(delivery)
+				},
+				cursor,
+				...ttlMs === void 0 ? {} : { ttlMs }
+			}, subscribeReplyOf),
+			unsubscribe: ({ delivery }) => Effect.asVoid(answered("events/unsubscribe", { delivery: encodeTarget(delivery) }, unsubscribeReplyOf)),
+			read: webhookFed(event)
+		},
+		transient
+	};
+};
+export { transportOf };

package/dist/rpc/watch.mjs

@@ -0,0 +1,39 @@
+import { NotServed, SubscriptionError, Unsupported } from "../Event.mjs";
+import { readOn } from "../contract/push.mjs";
+import { isTransientReason, receivedFrom } from "../contract/transient.mjs";
+import { Cause, Effect, Match, Predicate, Schema, Stream } from "effect";
+import { HttpClientError } from "effect/http";
+import { RpcClientError } from "effect/rpc";
+// src/rpc/watch.ts
+const isRpcClientError = Schema.is(RpcClientError.RpcClientError);
+const isAnsweredReason = Schema.is(Schema.Union([
+	Schema.instanceOf(HttpClientError.TransportError),
+	Schema.instanceOf(HttpClientError.StatusCodeError),
+	Schema.instanceOf(HttpClientError.DecodeError)
+]));
+const cutResponses = ["HTTP response ended before RPC request completed", "Received empty HTTP response"];
+/** Whether a watch's failure over an rpc protocol is one a reconnect may outlast. */
+const isRpcTransient = Predicate.or(Cause.isTimeoutError, (error) => isRpcClientError(error) && Match.value(error.reason).pipe(Match.tag("SocketReadError", "SocketWriteError", "SocketOpenError", () => true), Match.tag("SocketCloseError", ({ code }) => code < 4e3 || code > 4999), Match.tag("HttpError", ({ cause }) => isAnsweredReason(cause) && isTransientReason(cause)), Match.tag("RpcClientDefect", ({ message }) => cutResponses.some((fragment) => message.includes(fragment))), Match.orElse(() => false)));
+const isUnknownTag = (tag) => {
+	const message = `Unknown request tag: ${tag}`;
+	return (cause) => cause.reasons.some((reason) => Cause.isDieReason(reason) && (Predicate.hasProperty(reason.defect, "message") ? reason.defect.message === message : reason.defect === message));
+};
+/**
+* The transport of one subscription to `event` over its stream rpc: the stream alone, since an
+* rpc serves no poll, failing as `NotServed` where the server serves no such rpc, and once it goes
+* silent where `silenceEnds`.
+*/
+const transportOf = (event, stream, silenceEnds) => {
+	const notServed = Stream.fail(SubscriptionError.of(event.name, new NotServed()));
+	const unknownTag = isUnknownTag(event.name);
+	return {
+		name: event.name,
+		poll: () => Effect.fail(SubscriptionError.of(event.name, new Unsupported({
+			feature: "deliveryMode",
+			value: "poll"
+		}))),
+		stream: (cursor) => stream(cursor).pipe(Stream.catchCauseIf(unknownTag, () => notServed), silenceEnds ? receivedFrom("RPC", event.name) : readOn("RPC", event.name)),
+		transient: isRpcTransient
+	};
+};
+export { isRpcTransient, transportOf };

package/dist/stdio/console.mjs

@@ -1,9 +1,11 @@
 import { Clock, Console, Effect, Function, Predicate } from "effect";
-//#region src/stdio/console.ts
+// src/stdio/console.ts
 const stderrConsole = (console, clock) => {
 	const counts = /* @__PURE__ */ new Map();
 	const timers = /* @__PURE__ */ new Map();
-	const write = (...args) => console.error(...args);
+	const write = (...args) => {
+		console.error(...args);
+	};
 	const elapsed = (label, data) => {
 		const start = timers.get(label);
 		if (start !== void 0) {
@@ -32,7 +34,9 @@ const stderrConsole = (console, clock) => {
 			counts.delete(label);
 		},
 		debug: write,
-		dir: (item) => write("%O", item),
+		dir: (item) => {
+			write("%O", item);
+		},
 		dirxml: write,
 		error: write,
 		group,
@@ -40,7 +44,9 @@ const stderrConsole = (console, clock) => {
 		groupEnd: Function.constVoid,
 		info: write,
 		log: write,
-		table: (data) => write(data),
+		table: (data) => {
+			write(data);
+		},
 		time: (label = "default") => {
 			if (!timers.has(label)) timers.set(label, clock.monotonicTimeNanosUnsafe());
 		},
@@ -48,9 +54,11 @@ const stderrConsole = (console, clock) => {
 			elapsed(label, []);
 			timers.delete(label);
 		},
-		timeLog: (label = "default", ...data) => elapsed(label, data),
+		timeLog: (label = "default", ...data) => {
+			elapsed(label, data);
+		},
 		trace: (...args) => {
-			const { stack = "" } = /* @__PURE__ */ new Error();
+			const { stack = "" } = /* @__PURE__ */ new Error("console.trace");
 			const [_header, _traceFrame, ...callerFrames] = stack.split("\n");
 			const callerStack = callerFrames.join("\n");
 			writeLabelKeepingFormat("Trace", args);
@@ -60,5 +68,4 @@ const stderrConsole = (console, clock) => {
 	};
 };
 const withStderrConsole = (effect) => Effect.provideServiceEffect(effect, Console.Console, Effect.zipWith(Effect.service(Console.Console), Effect.service(Clock.Clock), stderrConsole));
-//#endregion
 export { withStderrConsole };

package/dist/testing/memory.d.mts

@@ -1,6 +1,4 @@
 import { Layer } from "effect";
 import { HttpClient, HttpRouter, HttpServer } from "effect/http";
-//#region src/testing/memory.d.ts
 /** What in-memory routes may leave to the host: the router, the platform, nothing per request. */
-export type Served = HttpRouter.HttpRouter | HttpRouter.Request<"Requires", never> | HttpRouter.Request<"GlobalRequires", never> | HttpRouter.Request<"Error", any> | HttpRouter.Request<"GlobalError", any> | Layer.Success<typeof HttpServer.layerServices>;
-//#endregion
+export type Served = HttpRouter.HttpRouter | HttpRouter.Request<"Requires", never> | HttpRouter.Request<"GlobalRequires", never> | HttpRouter.Request<"Error", unknown> | HttpRouter.Request<"GlobalError", unknown> | Layer.Success<typeof HttpServer.layerServices>;

package/dist/testing/memory.mjs

@@ -1,9 +1,9 @@
 import { Effect, Layer, Predicate, Stream } from "effect";
 import { FetchHttpClient, HttpBody, HttpClient, HttpClientRequest } from "effect/http";
-//#region src/testing/memory.ts
+// src/testing/memory.ts
 const relativeUrlOrigin = "http://localhost/";
 const withWebStreamBodyInCurrentContext = (request) => {
-	const body = request.body;
+	const { body } = request;
 	if (!Predicate.isTagged(body, "Stream")) return Effect.succeed(request);
 	return Effect.map(Stream.toReadableStreamEffect(body.stream), (readable) => HttpClientRequest.setBody(request, HttpBody.raw(readable, {
 		contentType: body.contentType,
@@ -11,10 +11,10 @@ const withWebStreamBodyInCurrentContext = (request) => {
 	})).pipe(HttpClientRequest.updateHeaders(() => request.headers)));
 };
 const clientOf = (handler) => {
-	const fetch = (input, init) => {
+	const fetch = async (input, init) => {
 		const request = new Request(input, init);
 		if (!request.headers.has("host")) request.headers.set("host", new URL(request.url).host);
-		return handler(request);
+		return await handler(request);
 	};
 	return Layer.effect(HttpClient.HttpClient, Effect.map(HttpClient.HttpClient, (native) => HttpClient.makeWith((request) => Effect.flatMap(request, (mapped) => {
 		const resolved = URL.canParse(mapped.url) ? null : URL.parse(mapped.url, relativeUrlOrigin);
@@ -22,5 +22,4 @@ const clientOf = (handler) => {
 		return Effect.flatMap(withWebStreamBodyInCurrentContext(sent), (ready) => native.postprocess(Effect.succeed(ready)).pipe(Effect.provideService(FetchHttpClient.Fetch, fetch)));
 	}), native.preprocess))).pipe(Layer.provide(Layer.fresh(FetchHttpClient.layer)));
 };
-//#endregion
 export { clientOf };

package/dist/webhook/address.mjs

@@ -0,0 +1,47 @@
+import { Effect, Function, Result } from "effect";
+import { Host, IpNetwork, NetAddress } from "effect/net";
+// src/webhook/address.ts
+const notGlobal = [
+	"0.0.0.0/8",
+	"10.0.0.0/8",
+	"100.64.0.0/10",
+	"127.0.0.0/8",
+	"169.254.0.0/16",
+	"172.16.0.0/12",
+	"192.0.0.0/24",
+	"192.0.2.0/24",
+	"192.88.99.0/24",
+	"192.168.0.0/16",
+	"198.18.0.0/15",
+	"198.51.100.0/24",
+	"203.0.113.0/24",
+	"224.0.0.0/4",
+	"240.0.0.0/4",
+	"::/127",
+	"::ffff:0:0/96",
+	"64:ff9b::/96",
+	"64:ff9b:1::/48",
+	"100::/64",
+	"2001::/23",
+	"2001:db8::/32",
+	"2002::/16",
+	"3fff::/20",
+	"5f00::/16",
+	"fc00::/7",
+	"fe80::/10",
+	"ff00::/8"
+].map(IpNetwork.fromStringUnsafe);
+/** Whether `address` is globally reachable, in no special-purpose range. */
+const isGlobal = (address) => !notGlobal.some((network) => IpNetwork.contains(network, address));
+/**
+* Checks the host of `url`, failing unless every address it names is globally reachable: a
+* literal address is checked as it is, a name through `dns`, or passed where there is none, and a
+* scoped IPv6 literal refused.
+*/
+const checkedHost = (url, dns) => {
+	const host = Result.getOrUndefined(Host.hostFromString(url.hostname.replace(/^\[(?<address>.*)\]$/u, "$<address>")));
+	if (!NetAddress.isIpAddress(host) && !Host.isDomainName(host)) return Effect.fail(void 0);
+	const addresses = NetAddress.isIpAddress(host) ? Effect.succeed([host]) : dns?.lookup(host) ?? Effect.succeed([]);
+	return Effect.flatMap(Effect.mapError(addresses, Function.constUndefined), (resolved) => resolved.every(isGlobal) ? Effect.void : Effect.fail(void 0));
+};
+export { checkedHost };

package/dist/webhook/attempt.mjs

@@ -0,0 +1,65 @@
+import { signature } from "./signing.mjs";
+import { Clock, Data, Duration, Effect, Option, Schema, Stream } from "effect";
+import { FetchHttpClient, HttpClient, HttpClientRequest } from "effect/http";
+// src/webhook/attempt.ts
+/**
+* One attempt of a delivery that failed: `category` is SEP-3415's for it, and `final` says a
+* retry would not help, as for a `410 Gone` or a `413 Payload Too Large`.
+*/
+var AttemptFailed = class extends Data.TaggedError("AttemptFailed") {};
+const timeout = Duration.seconds(5);
+const statusCategory = (status) => status >= 500 ? "http_5xx" : "http_4xx";
+const outbound = (effect) => Effect.flatMap(Effect.serviceOption(FetchHttpClient.RequestInit), (init) => effect.pipe(Effect.provideService(FetchHttpClient.RequestInit, {
+	...Option.getOrUndefined(init),
+	redirect: "manual"
+}), Effect.provideService(HttpClient.TracerPropagationEnabled, false)));
+const sent = ({ url, subscriptionId, webhookId, body, keys }, checked, answer) => Effect.gen(function* () {
+	const unreached = new AttemptFailed({
+		category: "connection_refused",
+		final: false
+	});
+	const timestamp = Math.floor((yield* Clock.currentTimeMillis) / 1e3);
+	const signed = yield* signature(keys, webhookId, timestamp, body);
+	const client = HttpClient.withScope(yield* HttpClient.HttpClient);
+	const request = HttpClientRequest.post(url).pipe(HttpClientRequest.setHeaders({
+		"webhook-id": webhookId,
+		"webhook-timestamp": String(timestamp),
+		"webhook-signature": signed,
+		"x-mcp-subscription-id": subscriptionId
+	}), HttpClientRequest.bodyText(body, "application/json"));
+	const answered = Effect.flatMap(Effect.mapError(client.execute(request), () => unreached), (response) => response.status >= 200 && response.status < 300 ? answer(response) : Effect.fail(new AttemptFailed({
+		category: statusCategory(response.status),
+		final: response.status === 410 || response.status === 413
+	})));
+	return yield* Effect.andThen(Effect.mapError(checked, () => unreached), outbound(answered)).pipe(Effect.timeoutOrElse({
+		duration: timeout,
+		orElse: () => Effect.fail(new AttemptFailed({
+			category: "timeout",
+			final: false
+		}))
+	}), Effect.scoped);
+});
+/**
+* POSTs `body` to the callback, signed with a fresh timestamp, once `checked`, its address check,
+* passes, and succeeds at a 2xx without reading its body. The timeout bounds the check and the
+* POST together.
+*/
+const attempt = (posting, checked) => sent(posting, checked, () => Effect.void);
+const Challenged = Schema.fromJsonString(Schema.Struct({ challenge: Schema.String }));
+const answerLimit = 4096;
+const textOf = (response) => Effect.suspend(() => {
+	const decoder = new TextDecoder();
+	return response.stream.pipe(Stream.scan(() => ({
+		bytes: 0,
+		text: ""
+	}), ({ bytes, text }, chunk) => ({
+		bytes: bytes + chunk.length,
+		text: text + decoder.decode(chunk, { stream: true })
+	})), Stream.takeUntil(({ bytes }) => bytes > answerLimit), Stream.runLast, Effect.map((last) => Option.map(Option.filter(last, ({ bytes }) => bytes <= answerLimit), ({ text }) => text + decoder.decode())), Effect.orElseSucceed(() => Option.none()));
+});
+/**
+* `attempt` of a verification: the challenge its 2xx answer echoes, where its first 4 KiB hold
+* one.
+*/
+const challenged = (posting, checked) => sent(posting, checked, (response) => Effect.map(textOf(response), (text) => Option.getOrUndefined(Option.map(Option.flatMap(text, Schema.decodeUnknownOption(Challenged)), ({ challenge }) => challenge))));
+export { AttemptFailed, attempt, challenged };