@gjermundgaraba/effect-actions 0.20.0 → 0.21.0

package/dist/http/client.d.mts

@@ -1,8 +1,15 @@
+import { Codec } from "../contract/codec.mjs";
 import { BuiltIns } from "../contract/errors.mjs";
+import { Any, Received, SubscriptionError, WatchOptions } from "../Event.mjs";
+import "../contract/implementation.mjs";
 import { Call } from "../contract/call.mjs";
-import { Any, Errors } from "../Action.mjs";
-import { Any as Any$1, VerifierError } from "../authentication/provider.mjs";
-import { Effect, Schema } from "effect";
+import { Answer, StreamOf } from "../contract/stream.mjs";
+import "../contract/receiving.mjs";
+import { WatchArgs, WatchRequirement } from "../contract/watch.mjs";
+import { Any as Any$1, Errors } from "../Action.mjs";
+import { Any as Any$2, VerifierError } from "../authentication/provider.mjs";
+import { sentOf } from "./events.mjs";
+import { Effect, Schema, Stream } from "effect";
 import { HttpClient, HttpClientError } from "effect/http";
 import { HttpApi, HttpApiClient } from "effect/http-api";
 /**
@@ -31,30 +38,48 @@ export interface Options<E = HttpClientError.HttpClientError, R = never> {
   readonly transformClient?: ((client: HttpClient.HttpClient) => HttpClient.HttpClient.With<E, R>) | undefined;
 }
 type BindingError = Errors[number];
+type SseFailure = Extract<Stream.Error<HttpApiClient.SuccessType<ReturnType<typeof sentOf<Any>>>>, {
+  readonly _tag: "SseError" | "Retry";
+}>;
+type SseError = Extract<SseFailure, {
+  readonly _tag: "SseError";
+}>;
 /**
  * What one call of `A` fails with: a declared error value (the action's own, one `E` of the
  * binding's, or a built-in `InvalidInput`, `Unauthenticated` or `Forbidden`), a native
  * `HttpClientError` for a failed request or an undeclared answer, or a `SchemaError` when
- * the success does not decode.
+ * the success does not decode. A call reading an event stream, of an action answering a stream or
+ * declaring `progress`, also fails with Effect's `Sse.SseError` or `Sse.Retry`.
  */
-export type MethodError<A extends Any, E extends BindingError = never> = A["error"][number]["Type"] | E["Type"] | BuiltIns["Type"] | HttpClientError.HttpClientError | Schema.SchemaError;
-type Method<A extends Any, E extends BindingError, CE, CR> = Call<A, Effect.Effect<A["success"]["Type"], MethodError<A, E> | CE, CR>>;
+export type MethodError<A extends Any$1, E extends BindingError = never> = A["error"][number]["Type"] | E["Type"] | BuiltIns["Type"] | HttpClientError.HttpClientError | Schema.SchemaError | (A["progress"] extends undefined ? A["success"] extends StreamOf<Codec> ? SseFailure : never : SseFailure);
+type Method<A extends Any$1, E extends BindingError, CE, CR> = Call<A, Answer<A["success"], MethodError<A, E> | CE, CR>>;
 /**
  * Any HTTP binding, with its actions erased: what `layer` and `client` read. The API is a native
  * constraint here because native groups are invariant in their endpoints; `actions` carries the
  * types.
  */
 export interface AnyHttp {
-  readonly authentication?: Any$1 | undefined;
-  readonly actions: ReadonlyArray<Any>;
-  readonly error: ReadonlyArray<BindingError>;
+  readonly authentication?: Any$2 | undefined;
+  readonly actions: readonly Any$1[];
+  readonly events: readonly Any[];
+  readonly error: readonly BindingError[];
   readonly prefix: `/${string}`;
   readonly api: HttpApi.Constraint;
 }
+/**
+ * What a watch of `W` over the binding `H` may fail with: what its route's first answer declares,
+ * a refusal ending it later, an `Event.SubscriptionError` where it is not served, a native
+ * `HttpClientError` that no reconnect outlasts, or a stream or an occurrence that does not decode.
+ */
+export type WatchError<W extends Any, H extends AnyHttp> = SubscriptionError | BuiltIns["Type"] | H["error"][number]["Type"] | VerifierError<W, H["authentication"]>["Type"] | HttpClientError.HttpClientError | Schema.SchemaError | SseError;
+type Watching<H extends AnyHttp, E, R> = [H["events"][number]] extends [never] ? unknown : {
+  readonly watch: <W extends H["events"][number], SE = never, const O extends WatchOptions<unknown> = {}>(event: W, ...args: WatchArgs<W, SE, O>) => Stream.Stream<Received<W>, WatchError<W, H> | E | SE, R | WatchRequirement<O>>;
+};
 /**
  * Every action of the binding `H`, as `client.<action>(input)`: a protected one may also fail
- * with what its descriptor's verifier declares. Each call also fails with `E` and requires `R`,
- * what its `transformClient` adds.
+ * with what its descriptor's verifier declares. Where `H` lists event types, `watch(event, input,
+ * options)` subscribes to one. Each call and watch also fails with `E` and requires `R`, what its
+ * `transformClient` adds.
  */
-export type Client<H extends AnyHttp, E = never, R = never> = { readonly [A in H["actions"][number] as A["name"]]: Method<A, H["error"][number] | VerifierError<A, H["authentication"]>, E, R>; };
+export type Client<H extends AnyHttp, E = never, R = never> = { readonly [A in H["actions"][number] as A["name"]]: Method<A, H["error"][number] | VerifierError<A, H["authentication"]>, E, R>; } & Watching<H, E, R>;
 export {};

package/dist/http/client.mjs

@@ -1,18 +1,57 @@
-import { checked } from "../contract/call.mjs";
-import { Effect } from "effect";
-import { HttpClient } from "effect/http";
+import { elementOf } from "../contract/stream.mjs";
+import { checked, checkedStream, sendingValue, watchInput } from "../contract/call.mjs";
+import { watching } from "../contract/watch.mjs";
+import { readElements, readWithProgress } from "./streamed.mjs";
+import { transportOf } from "./watch.mjs";
+import { Effect, Stream } from "effect";
+import { HttpClient, HttpClientRequest } from "effect/http";
 import { HttpApiClient } from "effect/http-api";
 // src/http/client.ts
-const methodsWith = (http, httpClient, baseUrl) => Effect.map(HttpApiClient.makeWith(http.api, {
+const methodOf = (native, name, what) => {
+	const method = native[name];
+	if (method === void 0) throw new Error(`No client method for ${name} (use the binding \`ActionHttp.make\` returned, whose group holds this ${what})`);
+	return method;
+};
+const acceptingStreams = HttpClient.mapRequest(HttpClientRequest.setHeader("accept", "application/json, text/event-stream"));
+const nativeOf = (http, httpClient, baseUrl) => HttpApiClient.makeWith(http.api, {
 	baseUrl,
 	httpClient
-}), (client) => {
-	const native = client;
-	return Object.fromEntries(http.actions.map((action) => {
-		const method = native[action.name];
-		if (method === void 0) throw new Error(`No client method for ${action.name} (use the binding \`ActionHttp.make\` returned, whose group holds this action)`);
-		return [action.name, checked(action, (payload) => method({ payload }))];
-	}));
+});
+const actionMethodOf = (action, native) => {
+	const method = methodOf(native, action.name, "action");
+	if (elementOf(action.success) !== void 0) return checkedStream(action, sendingValue, (payload, onProgress) => Stream.unwrap(Effect.map(method({ payload }), (answer) => readElements(answer, onProgress))));
+	if (action.progress === void 0) return checked(action, sendingValue, (payload) => method({ payload }));
+	return checked(action, sendingValue, (payload, onProgress) => Effect.flatMap(method({ payload }), (answer) => readWithProgress(answer, onProgress)));
+};
+/** The `Senders` of `http` over `httpClient`: its native clients, built once. */
+const sendersWith = (http, httpClient, baseUrl) => Effect.gen(function* () {
+	const native = yield* nativeOf(http, acceptingStreams(httpClient), baseUrl);
+	const plain = yield* nativeOf(http, httpClient, baseUrl);
+	const polls = plain;
+	const streams = native;
+	const subscribes = plain;
+	const unsubscribes = plain;
+	const webhookOf = (name) => {
+		const subscribe = subscribes[`${name}/subscribe`];
+		const unsubscribe = unsubscribes[`${name}/unsubscribe`];
+		return subscribe === void 0 || unsubscribe === void 0 ? void 0 : {
+			subscribe,
+			unsubscribe
+		};
+	};
+	return {
+		method: (action) => actionMethodOf(action, native),
+		transport: (event, input) => transportOf(event, methodOf(polls, event.name, "event"), methodOf(streams, event.name, "event"), webhookOf(event.name), input)
+	};
+});
+const methodsWith = (http, httpClient, baseUrl) => Effect.map(sendersWith(http, httpClient, baseUrl), ({ method, transport }) => {
+	const actions = Object.fromEntries(http.actions.map((action) => [action.name, method(action)]));
+	if (http.events.length === 0) return actions;
+	const watch = (event, input, options) => Stream.unwrap(Effect.map(watchInput(event, input), ({ value }) => watching(transport(event, value), options)));
+	return {
+		...actions,
+		watch
+	};
 });
 const methods = (http, { baseUrl, transformClient } = {}) => Effect.flatMap(HttpClient.HttpClient, (native) => transformClient === void 0 ? methodsWith(http, native, baseUrl) : methodsWith(http, transformClient(native), baseUrl));
-export { methods };
+export { methods, sendersWith };

package/dist/http/events.d.mts

@@ -0,0 +1,56 @@
+import "../contract/codec.mjs";
+import { Forbidden, Unauthenticated } from "../contract/errors.mjs";
+import { OccurrenceSchema } from "../contract/occurrence.mjs";
+import "../contract/pages.mjs";
+import "../contract/feed.mjs";
+import { Any } from "../Event.mjs";
+import "../contract/subscribe.mjs";
+import "../Action.mjs";
+import "../authentication/provider.mjs";
+import "../contract/push.mjs";
+import "../contract/webhooks.mjs";
+import { Effect, Option, Schema, Stream } from "effect";
+import { HttpApiEndpoint, HttpApiSchema } from "effect/http-api";
+/**
+ * One poll's answer: the occurrences since the cursor, and when to ask again, sent as
+ * `nextPollMs`, its milliseconds.
+ */
+export declare const pageOf: <E extends Any>(event: E) => Schema.encodeKeys<Schema.Struct<{
+  readonly events: Schema.$Array<OccurrenceSchema<E>>;
+  readonly cursor: Schema.NullOr<Schema.String>;
+  readonly truncated: Schema.Boolean;
+  readonly hasMore: Schema.Boolean;
+  readonly nextPoll: Schema.DurationFromMillis;
+}>, {
+  readonly nextPoll: "nextPollMs";
+}>;
+/**
+ * What a subscription's event stream sends, each as one SSE `message`: a `Checked` with the
+ * position it starts from, or a `Gap` where that was no longer served, then each occurrence, a
+ * `Gap` where some were missed, a `Checked` every 30 seconds, and a `Failed` where reading
+ * failed and resumes. A later refusal ends it, as Effect's stream failure event.
+ */
+export declare const sentOf: <E extends Any>(event: E) => HttpApiSchema.StreamSse<HttpApiSchema.SseEventFromData<Schema.toCodecJson<Schema.Union<readonly [OccurrenceSchema<E>, Schema.TaggedStruct<"Gap", {
+  readonly cursor: Schema.NullOr<Schema.String>;
+}>, Schema.TaggedStruct<"Checked", {
+  readonly cursor: Schema.NullOr<Schema.String>;
+}>, Schema.TaggedStruct<"Failed", {}>]>>>, Schema.Union<readonly [typeof Unauthenticated, typeof Forbidden]>, {
+  readonly _tag: "Gap";
+  readonly cursor: string | null;
+} | {
+  readonly _tag: "Checked";
+  readonly cursor: string | null;
+} | {
+  readonly _tag: "Failed";
+} | Schema.Struct.View<{
+  readonly _tag: Schema.tag<"Occurrence">;
+  eventId: Schema.String;
+  name: Schema.Literal<E["name"]>;
+  timestamp: Schema.DateTimeUtc;
+  data: E["payload"];
+  cursor: Schema.NullOr<Schema.String>;
+}, "Type", E["payload"] extends {
+  readonly "~type.optionality": "optional";
+} ? "data" : never, E["payload"] extends {
+  readonly "~type.mutability": "mutable";
+} ? "data" : never>>;

package/dist/http/events.mjs

@@ -0,0 +1,102 @@
+import { principalOf } from "../contract/caller.mjs";
+import { Refusal } from "../contract/errors.mjs";
+import { declared } from "../contract/status.mjs";
+import { assertDistinctTags } from "../contract/declared.mjs";
+import { OccurrenceOf } from "../contract/occurrence.mjs";
+import { SubscriptionError } from "../Event.mjs";
+import { webhookSubscriber } from "../contract/webhooks.mjs";
+import { PushedOf, SubscriptionOf, queuedPush } from "../contract/push.mjs";
+import { Subscribed, WebhookCancellationOf, WebhookSubscriptionOf } from "../contract/subscribe.mjs";
+import { Effect, Schema, Stream } from "effect";
+import { HttpServerRequest } from "effect/http";
+import { HttpApiEndpoint, HttpApiSchema, OpenApi } from "effect/http-api";
+// src/http/events.ts
+/**
+* One poll's answer: the occurrences since the cursor, and when to ask again, sent as
+* `nextPollMs`, its milliseconds.
+*/
+const pageOf = (event) => Schema.Struct({
+	events: Schema.Array(OccurrenceOf(event)),
+	cursor: Schema.NullOr(Schema.String),
+	truncated: Schema.Boolean,
+	hasMore: Schema.Boolean,
+	nextPoll: Schema.DurationFromMillis
+}).pipe(Schema.encodeKeys({ nextPoll: "nextPollMs" }));
+/**
+* What a subscription's event stream sends, each as one SSE `message`: a `Checked` with the
+* position it starts from, or a `Gap` where that was no longer served, then each occurrence, a
+* `Gap` where some were missed, a `Checked` every 30 seconds, and a `Failed` where reading
+* failed and resumes. A later refusal ends it, as Effect's stream failure event.
+*/
+const sentOf = (event) => HttpApiSchema.StreamSse({
+	data: Schema.toCodecJson(PushedOf(event)),
+	error: Refusal
+});
+/** What a served subscription's event stream sends: each element's JSON, as `sentOf` encodes it. */
+const servedSent = HttpApiSchema.StreamSse({
+	data: Schema.Json,
+	error: Refusal
+});
+/**
+* The route of one event type at `path`, its poll answered as JSON and its stream as SSE, as
+* `sent` declares it.
+*/
+const eventEndpointOf = (event, path, errors, sent = sentOf(event)) => HttpApiEndpoint.post(event.name, path, {
+	payload: SubscriptionOf(event).pipe(HttpApiSchema.asJson()),
+	success: [pageOf(event), sent],
+	error: errors.map(declared)
+}).annotate(OpenApi.Description, event.description);
+/**
+* The webhook routes of one protected event type at `path`: `/subscribe`, which starts or
+* refreshes a subscription and answers its grant, and `/unsubscribe`, which ends it.
+*/
+const webhookEndpointsOf = (event, path, errors) => {
+	const withWebhooks = [...errors, SubscriptionError];
+	assertDistinctTags(`ActionHttp binding of event "${event.name}"'s webhook routes`, withWebhooks);
+	const error = withWebhooks.map(declared);
+	return [HttpApiEndpoint.post(`${event.name}/subscribe`, `${path}/subscribe`, {
+		payload: WebhookSubscriptionOf(event).pipe(HttpApiSchema.asJson()),
+		success: Subscribed,
+		error
+	}).annotate(OpenApi.Description, `Deliver ${event.name} to a webhook, or refresh its grant.`), HttpApiEndpoint.post(`${event.name}/unsubscribe`, `${path}/unsubscribe`, {
+		payload: WebhookCancellationOf(event).pipe(HttpApiSchema.asJson()),
+		success: HttpApiSchema.NoContent,
+		error
+	}).annotate(OpenApi.Description, `Stop delivering ${event.name} to a webhook.`)];
+};
+/**
+* The handlers of `feed`'s webhook routes, through `webhooks` where the host provided
+* `Webhook.layer`; without it, both fail with `Unsupported`.
+*/
+const webhookAnswers = (feed, authentication, webhooks) => {
+	const served = webhookSubscriber(feed, authentication, webhooks);
+	return {
+		subscribe: ({ payload }) => Effect.flatMap(served, ({ webhooks: service, ...subscriber }) => service.subscribe({
+			...payload,
+			...subscriber
+		})),
+		unsubscribe: ({ payload }) => Effect.flatMap(served, ({ webhooks: service, feed: subscribed, principal }) => service.unsubscribe({
+			...payload,
+			feed: subscribed,
+			principal
+		}))
+	};
+};
+/**
+* Answers a subscription's request to `feed`: a page, or, where it accepts `text/event-stream`,
+* the subscription's stream, each element its JSON. Both admit the subscriber first, so a refusal
+* is the route's error; `authentication`'s principal names a poll's subscriber, for its
+* `subscription` hook.
+*/
+const answering = (feed, authentication) => {
+	const encode = Schema.encodeEffect(Schema.toCodecJson(PushedOf(feed.event)));
+	return ({ payload: { input, cursor } }) => Effect.gen(function* () {
+		if (((yield* HttpServerRequest.HttpServerRequest).headers["accept"] ?? "").includes("text/event-stream")) {
+			const open = yield* feed.stream(input);
+			return Stream.fromQueue(yield* queuedPush(open, cursor, encode));
+		}
+		const subscriber = yield* principalOf(feed.event, authentication);
+		return yield* feed.poll(input, cursor, { subscriber });
+	});
+};
+export { answering, eventEndpointOf, pageOf, sentOf, servedSent, webhookAnswers, webhookEndpointsOf };

package/dist/http/placed.d.mts

@@ -0,0 +1,36 @@
+import { EventImplementation } from "../contract/feed.mjs";
+import { Any } from "../Event.mjs";
+import { Implementation } from "../contract/implementation.mjs";
+import { Any as Any$1 } from "../Action.mjs";
+import { AnyHttp } from "./client.mjs";
+import { HttpClient } from "effect/http";
+type Contract<H extends AnyHttp> = H["actions"][number] | H["events"][number];
+/** A call's or a subscription's decoded input, beside its contract, one of `C`. */
+/** What the contracts `C` require per request, by name: nothing. */
+type Nothing<C extends Any$1 | Any> = { readonly [K in C["name"]]: never; };
+/**
+ * What `placed` returns: an implementation of the binding's actions where it has some, and one of
+ * its event types where it has some, which require nothing.
+ */
+export type Placed<H extends AnyHttp> = ReadonlyArray<Implementation<H["actions"][number], Nothing<H["actions"][number]>, never, never> | EventImplementation<H["events"][number], Nothing<H["events"][number]>, never, never>>;
+/**
+ * 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.
+ */
+export declare const placed: <const H extends AnyHttp>(binding: H, client: (input: Contract<H>["input"]["Type"], contract: Contract<H>) => HttpClient.HttpClient) => Placed<H>;
+export {};

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

@@ -4,5 +4,5 @@ import { HttpApiMiddleware } from "effect/http-api";
 // 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)));
+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 };