@gjermundgaraba/effect-actions 0.8.0 → 0.10.0

package/dist/ActionCliClient.mjs

@@ -1,43 +0,0 @@
-import { selectNamed } from "./internal/actions.mjs";
-import { command as command$1 } from "./internal/cli.mjs";
-import { Effect } from "effect";
-import { HttpClient } from "effect/http";
-import { HttpApiClient } from "effect/http-api";
-import { Command } from "effect/cli";
-//#region src/ActionCliClient.ts
-/**
-* The native endpoint builder needs string selectors for a runtime-selected route.
-* `http.groups` is checked before this widening, and `NativeMethod` restores the
-* corresponding precise endpoint type at that one dynamic client boundary.
-*/
-const erasedApi = (api) => {
-	return api;
-};
-/**
-* Project one action of the binding into a native Effect CLI command.
-* Group and action selectors resolve exclusively from `http.groups`; runtime guards
-* keep dynamically supplied selector strings from reaching the native client.
-*/
-const command = (http, groupName, actionName, options) => {
-	const group = selectNamed(http.groups, groupName, `HTTP group "${groupName}"`);
-	const action = selectNamed(group.actions, actionName, `HTTP action "${groupName}.${actionName}"`);
-	return command$1(action, (input) => Effect.flatMap(HttpClient.HttpClient, (httpClient) => {
-		const endpoint = HttpApiClient.endpoint(erasedApi(http.api), {
-			...options?.connection,
-			group: groupName,
-			endpoint: actionName,
-			httpClient
-		});
-		return Effect.flatMap(endpoint, (method) => {
-			return method({ payload: input });
-		});
-	}), options);
-};
-/** Project every action of one bound group below its group namespace. */
-const group = (http, groupName, options) => {
-	const actions = selectNamed(http.groups, groupName, `HTTP group "${groupName}"`);
-	const commands = actions.actions.map((action) => options?.connection === void 0 ? command(http, groupName, action.name) : command(http, groupName, action.name, { connection: options.connection }));
-	return Command.make(options?.name ?? actions.name).pipe(Command.withSubcommands(commands));
-};
-//#endregion
-export { command, group };

package/dist/ActionGroup.d.mts

@@ -1,44 +0,0 @@
-import { Action, Action_d_exports, Any as Any$1, Codec, Handler } from "./Action.mjs";
-import { Actions, SchemaErrorAnswer, SchemaErrorPolicy } from "./internal/actions.mjs";
-import { Implementation } from "./internal/implementation.mjs";
-import { Effect, Scope, Types } from "effect";
-declare namespace ActionGroup_d_exports {
-  export { Any, Contracts, Group, Implementation, Options, SchemaErrorAnswer, SchemaErrorPolicy, contracts, make };
-}
-type HandlersFrom<Actions extends ReadonlyArray<Any$1>> = { readonly [A in Actions[number] as A["name"]]: Handler<A, any>; };
-/** Group-level errors join each action's own, so a shared set is declared once. */
-type WithErrors<Actions extends ReadonlyArray<Any$1>, Errors extends ReadonlyArray<Codec>> = { readonly [K in keyof Actions]: Actions[K] extends Action<infer Name, infer Input, infer Output, infer Own, infer Access, infer Mcp> ? Action<Name, Input, Output, readonly [...Own, ...Errors], Access, Mcp> : never; };
-/** What `make` needs to define a group. */
-export interface Options<Name extends string, Errors extends ReadonlyArray<Codec>, Invalid extends Codec = never, Internal extends Codec = never> {
-  /** The `HttpApiGroup` identifier, and so the OpenAPI tag and operation-ID prefix. */
-  readonly name: Name;
-  /** Failures every action of the group may have, added to each action's own. */
-  readonly errors?: Errors;
-  /**
-   * How HTTP answers a request that fails decoding (`invalid`) and a result that fails
-   * encoding (`internal`); without one, both are Effect's empty 400. MCP keeps its
-   * native answers.
-   */
-  readonly schemaError?: SchemaErrorPolicy<Invalid, Internal>;
-}
-/** A named set of action contracts: what adapters serve and what `implement` binds. */
-export interface Group<Name extends string, Actions$1 extends ReadonlyArray<Any$1>, PolicyError extends Codec = Codec> extends Actions<Name, Actions$1, PolicyError> {
-  /** Bind every handler at once, resolving build-time services once per adapter layer. */
-  readonly implement: <H extends HandlersFrom<Actions$1>, EX = never, RX = never>(build: H | Effect.Effect<H, EX, RX>) => Implementation<Group<Name, Actions$1, PolicyError>, H, NoInfer<EX>, NoInfer<Exclude<RX, Scope.Scope>>>;
-}
-/** Any group, with its actions and error schemas erased. */
-export type Any = Group<string, ReadonlyArray<Any$1>, Codec>;
-/** Define a group. Invalid or duplicate action and MCP names fail here, at definition time. */
-export declare function make<const Name extends string, const Actions extends ReadonlyArray<Any$1>, const Errors extends ReadonlyArray<Codec> = [], Invalid extends Codec = never, Internal extends Codec = never>(options: Options<Name, Errors, Invalid, Internal>, ...actions: Actions): Group<Name, WithErrors<Actions, Errors>, Invalid | Internal>;
-/** `G extends unknown` distributes, so each group maps only its own actions. */
-type PerGroup<G extends Actions> = G extends unknown ? { readonly [A in G["actions"][number] as `${G["name"]}.${A["name"]}`]: A; } : never;
-/** Every action of `Groups`, keyed `<group>.<action>`: the per-group maps merged into one. */
-export type Contracts<Groups extends ReadonlyArray<Actions>> = Types.UnionToIntersection<PerGroup<Groups[number]>>;
-/**
- * Project groups into one map of their action contracts, keyed `<group>.<action>`:
- * the identity routes, tools and commands share. Deriving it from the groups
- * themselves means an added action cannot be missed.
- */
-export declare function contracts<const Groups extends ReadonlyArray<Actions>>(...groups: Groups): Contracts<Groups>;
-//#endregion
-export { ActionGroup_d_exports, type Implementation, type SchemaErrorAnswer, type SchemaErrorPolicy };

package/dist/ActionGroup.mjs

@@ -1,35 +0,0 @@
-import { assertDistinct, assertName } from "./internal/actions.mjs";
-import { Implementation } from "./internal/implementation.mjs";
-import { Effect, Predicate } from "effect";
-//#region src/ActionGroup.ts
-/** Refuse a record without an own-property function for every action, before anything is served. */
-const assertHandlers = (group, handlers) => {
-	const missing = group.actions.filter((action) => !(Object.hasOwn(handlers, action.name) && Predicate.isFunction(handlers[action.name])));
-	if (missing.length > 0) throw new Error(`Missing handlers for group "${group.name}": ${missing.map((action) => action.name).join(", ")}`);
-	return handlers;
-};
-function make(options, ...declared) {
-	const { name } = options;
-	assertName("action group name", name);
-	const actions = declared.map((action) => ({
-		...action,
-		errors: [...action.errors, ...options.errors ?? []]
-	}));
-	assertDistinct("action", actions.map((action) => action.name));
-	const group = {
-		name,
-		actions,
-		schemaError: options.schemaError,
-		implement: (build) => {
-			const built = Effect.isEffect(build) ? Effect.map(build, (handlers) => assertHandlers(group, handlers)) : Effect.succeed(assertHandlers(group, build));
-			return Implementation.make(group, built);
-		}
-	};
-	return group;
-}
-function contracts(...groups) {
-	assertDistinct("contract group", groups.map((group) => group.name));
-	return Object.fromEntries(groups.flatMap((group) => group.actions.map((action) => [`${group.name}.${action.name}`, action])));
-}
-//#endregion
-export { contracts, make };

package/dist/ActionHttpClient.d.mts

@@ -1,33 +0,0 @@
-import { Action_d_exports, Any, Codec } from "./Action.mjs";
-import { Actions } from "./internal/actions.mjs";
-import { ActionHttp_d_exports, Http } from "./ActionHttp.mjs";
-import { ClientOptions } from "./internal/fetchClient.mjs";
-//#region src/ActionHttpClient.d.ts
-/**
- * The native `HttpApiClient.make` options except `transformResponse`, plus `fetch`;
- * see the options table in docs/ActionHttpClient.md.
- */
-export interface Options extends Omit<ClientOptions, "transformResponse"> {
-  readonly fetch?: typeof globalThis.fetch;
-}
-/**
- * One action as a Promise of its decoded success. An action whose input may be empty,
- * such as one declared without `input`, may be called without an argument.
- */
-export type Method<A extends Any> = {} extends A["input"]["Type"] ? (input?: A["input"]["Type"]) => Promise<A["success"]["Type"]> : (input: A["input"]["Type"]) => Promise<A["success"]["Type"]>;
-/** Every action of the binding, as `client.<group>.<action>(input)`. */
-export type Client<Groups extends ReadonlyArray<Actions>> = { readonly [G in Groups[number] as [G["actions"][number]] extends [never] ? never : G["name"]]: { readonly [A in G["actions"][number] as A["name"]]: Method<A>; }; };
-/**
- * A Promise client for an HTTP binding, for code that does not run Effects, such as a
- * browser page. It is Effect's native `HttpApiClient` over `fetch`, built once, and
- * each call runs one request: nothing is retried.
- *
- * A call resolves with the action's decoded success. It rejects with what the native
- * client fails with: a declared error value (the action's, its group's schema-error
- * policy's, or the binding's surface `errors`), a native `HttpClientError` when the
- * server could not be reached or answered with a status or body the contract does not
- * declare, or a `SchemaError` when the input does not encode or the success does not
- * decode.
- */
-export declare function promise<const Groups extends ReadonlyArray<Actions>, const Errors extends ReadonlyArray<Codec>>(http: Http<Groups, Errors>, options?: Options): Client<Groups>;
-//#endregion

package/dist/ActionHttpClient.mjs

@@ -1,16 +0,0 @@
-import { fetchApiClient } from "./internal/fetchClient.mjs";
-import { Effect } from "effect";
-//#region src/ActionHttpClient.ts
-function promise(http, { baseUrl, transformClient, fetch } = {}) {
-	const send = fetch ?? ((input, init) => globalThis.fetch(input, init));
-	const native = Effect.runSync(fetchApiClient(http.api, send, {
-		baseUrl,
-		transformClient
-	}));
-	return Object.fromEntries(Object.entries(native).map(([group, endpoints]) => [group, Object.fromEntries(Object.entries(endpoints).map(([action, endpoint]) => {
-		const method = (input) => Effect.runPromise(endpoint({ payload: input ?? {} }));
-		return [action, method];
-	}))]));
-}
-//#endregion
-export { promise };

package/dist/TestingClient.d.mts

@@ -1,17 +0,0 @@
-import { Client } from "@modelcontextprotocol/client";
-//#region src/TestingClient.d.ts
-/** How `withMcpClient` connects the official client. */
-export interface McpClientOptions {
-  /** A web handler, such as `HttpRouter.toWebHandler(routes).handler`. */
-  readonly fetch: (request: Request) => Promise<Response>;
-  readonly path: string;
-  /** Defaults to `http://localhost`. */
-  readonly baseUrl?: string | URL;
-  readonly headers?: ConstructorParameters<typeof Headers>[0];
-}
-/**
- * Connect an official client pinned to MCP 2026-07-28, the revision `ActionMcp`
- * serves, and always close its transport after the callback.
- */
-export declare const withMcpClient: <A>({ fetch, path, baseUrl, headers }: McpClientOptions, run: (client: Client) => Promise<A>) => Promise<A>;
-//#endregion

package/dist/TestingClient.mjs

@@ -1,22 +0,0 @@
-import { Client, StreamableHTTPClientTransport } from "@modelcontextprotocol/client";
-//#region src/TestingClient.ts
-/**
-* Connect an official client pinned to MCP 2026-07-28, the revision `ActionMcp`
-* serves, and always close its transport after the callback.
-*/
-const withMcpClient = async ({ fetch, path, baseUrl = "http://localhost", headers }, run) => {
-	const client = new Client({
-		name: "test",
-		version: "0"
-	}, { versionNegotiation: { mode: { pin: "2026-07-28" } } });
-	try {
-		const transportOptions = { fetch: (input, init) => fetch(new Request(input, init)) };
-		if (headers !== void 0) transportOptions.requestInit = { headers };
-		await client.connect(new StreamableHTTPClientTransport(new URL(path, baseUrl), transportOptions));
-		return await run(client);
-	} finally {
-		await client.close();
-	}
-};
-//#endregion
-export { withMcpClient };

package/dist/internal/fetchClient.d.mts

@@ -1,6 +0,0 @@
-import { Effect } from "effect";
-import { HttpApi, HttpApiClient, HttpApiGroup } from "effect/http-api";
-//#region src/internal/fetchClient.d.ts
-/** The native `HttpApiClient.make` options: `baseUrl`, `transformClient`, `transformResponse`. */
-export type ClientOptions = NonNullable<Parameters<typeof HttpApiClient.make>[1]>;
-//#endregion

package/dist/internal/fetchClient.mjs

@@ -1,8 +0,0 @@
-import { Effect } from "effect";
-import { FetchHttpClient } from "effect/http";
-import { HttpApiClient } from "effect/http-api";
-//#region src/internal/fetchClient.ts
-/** The native grouped `HttpApiClient` of `api`, sending every request through `fetch`. */
-const fetchApiClient = (api, fetch, options) => HttpApiClient.make(api, options).pipe(Effect.provide(FetchHttpClient.layer), Effect.provideService(FetchHttpClient.Fetch, fetch));
-//#endregion
-export { fetchApiClient };

package/dist/internal/tools.d.mts

@@ -1,22 +0,0 @@
-import { Action_d_exports, Any, Codec } from "../Action.mjs";
-import "./implementation.mjs";
-import { Context, Effect, Layer } from "effect";
-import { Tool, Toolkit } from "effect/ai";
-//#region src/internal/tools.d.ts
-/** What a tool surface binds around the implementations it projects. */
-export interface SurfaceOptions<Errors extends ReadonlyArray<Codec>, R> {
-  /**
-   * Failures the surface answers with instead of a handler: authorization, rate
-   * limits. Declared on every tool, so a refusal is returned exactly like an
-   * action's own error.
-   */
-  readonly errors?: Errors;
-  /**
-   * Runs once per tool call, after the arguments are decoded and before the
-   * selected handler, with the action contract it is about to run. It fails with
-   * this surface's `errors`. Its services are request-time requirements, like a
-   * handler's.
-   */
-  readonly before?: (action: Any) => Effect.Effect<void, Errors[number]["Type"], R>;
-}
-//#endregion

package/docs/ActionCatalog.md

@@ -1,54 +0,0 @@
-# ActionCatalog
-
-An offline JSON document of contract identities, metadata and encoded-value JSON Schemas.
-Built from contracts alone: no implementation, service or server is involved.
-
-## API
-
-Import `@gjermundgaraba/effect-actions/ActionCatalog`.
-
-`make(...groups)` returns `Catalog`: `version: "4"` and an ordered `actions` array of `Entry`.
-
-| Entry field                          | Meaning                                                             |
-| ------------------------------------ | ------------------------------------------------------------------- |
-| `id`, `group`, `name`, `description` | Stable `<group>.<action>` identity and contract metadata.           |
-| `mcp`                                | Resolved MCP enablement, name, hints and text field.                |
-| `input`, `success`                   | Standalone draft 2020-12 JSON Schema objects, not wrappers.         |
-| `errors`                             | JSON Schema objects for own and inherited group errors.             |
-| `httpSchemaErrors`                   | JSON Schema objects for HTTP policy errors; empty without a policy. |
-
-Exported types are `Catalog` and `Entry`.
-
-## Canonical
-
-```ts
-import { NodeRuntime } from "@effect/platform-node";
-import { Console } from "effect";
-import * as ActionCatalog from "@gjermundgaraba/effect-actions/ActionCatalog";
-import { AuditActions, PublicActions, UserActions } from "./contracts.js";
-
-// Contract inspection requires no implementation or domain-service Layer.
-Console.log(
-  JSON.stringify(ActionCatalog.make(PublicActions, UserActions, AuditActions), null, 2),
-).pipe(NodeRuntime.runMain);
-```
-
-## Rules
-
-- Takes groups, not implementations. Nothing is acquired or started.
-- Group names must be unique. Entries preserve group declaration order, then action declaration order.
-- `id` is the stable `<group>.<action>` identity, equal to the HTTP operation ID.
-- Schemas describe encoded action values through native `Schema.toJsonSchemaDocument`, which lowers to the JSON codec first. Objects are closed (`additionalProperties: false`), as in the OpenAPI document. A `Date` is a string, an `Option` a tagged union, a `bigint` a string of digits. These are whole action values, as HTTP sends them, not MCP's split of a text field or deployment URLs.
-- JSON Schema does not preserve arbitrary Effect transformations or filters. Checks on the decoded side of a transformation, such as `FiniteFromString.check(isGreaterThan(0))`, are not described. The server's decode remains authoritative.
-- Each schema root includes its own `$schema` and, where needed, `$defs`. Equal identifiers across entries or fields cannot replace each other; recursive references resolve locally.
-- The catalog contains JSON Schema only. Use Effect's `SchemaRepresentation` directly when native schema persistence or revival is needed.
-- `errors` includes group-level errors. HTTP schema-policy errors are separate in `httpSchemaErrors`. Surface errors belong to bindings and are not listed.
-- `access` is omitted; read it from the contract when needed. Actions hidden from MCP are included. Presence grants no authorization or proof that an endpoint is mounted; the host decides what to publish.
-- No search, catalog HTTP endpoint, or TypeScript code generation is provided.
-
-## Failure modes
-
-- `Duplicate catalog group: <name>`: two supplied groups share a name, including a group passed twice.
-- Type error passing an implementation: pass `app.group` or the group value itself.
-- Native JSON Schema conversion throws: the codec or its annotations cannot be converted.
-- JSON Schema accepts a value the server rejects: custom validation or a decoded-side check is not expressible in the wire schema. Server validation remains authoritative.

package/docs/ActionCliClient.md

@@ -1,63 +0,0 @@
-# ActionCliClient
-
-Native Effect CLI commands that call the HTTP API through Effect's `HttpApiClient`. Runs no
-handler locally and manages no credentials.
-
-## API
-
-Import `@gjermundgaraba/effect-actions/ActionCliClient`.
-
-| API                                              | Purpose                                                                    |
-| ------------------------------------------------ | -------------------------------------------------------------------------- |
-| `command(http, groupName, actionName, options?)` | Call one action of the binding through a native Effect `Command`.          |
-| `group(http, groupName, options?)`               | Every action of a bound group under one command.                           |
-| `Options`, `GroupOptions`, `Connection`          | Single/aggregate command configuration and native HTTP connection options. |
-
-Single-command options: `name`, `render`, paired `parameters`/`input`, and `connection`.
-Group options: `name` and `connection`. Parsing/rendering semantics match [ActionCli.md](ActionCli.md).
-`connection` accepts native `HttpApiClient.make` configuration, including `baseUrl`,
-`transformClient` and `transformResponse`.
-
-Remote commands have no local `before` hook: the server owns authorization. Their Effects
-retain the selected endpoint's client failures and middleware requirements, and require an
-`HttpClient` supplied by the host. Group/action selectors stay checked against the bound API.
-
-## Canonical
-
-```ts
-import { Command } from "effect/cli";
-import { Console, Effect, Logger } from "effect";
-import { NodeHttpClient, NodeRuntime, NodeServices } from "@effect/platform-node";
-import * as ActionCliClient from "@gjermundgaraba/effect-actions/ActionCliClient";
-import { Http } from "./contracts.js";
-
-const command = ActionCliClient.command(Http, "public", "status", {
-  connection: { baseUrl: "http://127.0.0.1:3000" },
-});
-
-Command.runWith(command, { version: "0.1.0" })(process.argv.slice(2)).pipe(
-  Effect.tapCause((cause) => Console.error(cause)),
-  Effect.provideService(Logger.LogToStderr, true),
-  // The host supplies the native client and its connection configuration.
-  Effect.provide(NodeHttpClient.layerUndici),
-  Effect.provide(NodeServices.layer),
-  NodeRuntime.runMain({ disableErrorReporting: true }),
-);
-```
-
-Authentication: `connection: { transformClient: HttpClient.mapRequest(HttpClientRequest.bearerToken(token)) }`.
-
-## Rules
-
-- Selectors resolve from `http.groups` only. `groupName` must be a bound group; `actionName` must be an action of that group. Runtime guards reject dynamically supplied strings that the types would not accept.
-- The host provides `HttpClient` and its configuration. Endpoint selection, credentials, and storage are the host's; nothing is inferred from action arguments.
-- Input (`--input`, `--input-file`, or `input(parsed)`) is encoded JSON. The command decodes it with the action schema, and the native client re-encodes it with `Http.api`'s closed payload codec.
-- Input syntax (`--input`, `--input-file`, or `parameters`) and output (`render` and its `--json` flag) are exactly as in `ActionCli`.
-- Errors are the client's: declared errors (the binding's `errors` included), policy errors, `SchemaError`, and `HttpClientError`.
-
-## Failure modes
-
-- Type error on `actionName`: the action is not in that group, or the group is not bound in this `Http`.
-- `HttpClient` unsatisfied (a type error at `runMain`): provide `NodeHttpClient.layerUndici` (or `FetchHttpClient.layer`) to the runtime.
-- `HttpClientError` with `reason._tag` `InvalidUrlError`: `connection.baseUrl` is absent; it has no default. Connection refused: `baseUrl` points at the wrong host or port.
-- 401 from the server: add `transformClient` to `connection`. The command adds no headers on its own.

package/docs/ActionGroup.md

@@ -1,128 +0,0 @@
-# ActionGroup
-
-A named set of actions. The group is what adapters serve, what clients are grouped by, and
-what `implement` binds handlers to. Shared errors and the HTTP schema-error policy live here.
-The pre-handler hook does not: each surface binds its own (see [guarantees.md](guarantees.md)).
-
-## API
-
-Import `@gjermundgaraba/effect-actions/ActionGroup`.
-
-| API                               | Purpose                                                                                 |
-| --------------------------------- | --------------------------------------------------------------------------------------- |
-| `make(options, ...actions)`       | Group actions under a required `name`; optional `errors` are inherited by each action.  |
-| `group.implement(recordOrEffect)` | Bind every action handler; an Effect builder carries startup requirements and failures. |
-| `app.group`, `app.build`          | Bound contract and scoped handler acquisition.                                          |
-| `contracts(...groups)`            | Exact action types keyed by `<group>.<action>`.                                         |
-
-Exported types: `Group`, `Any`, `Options`, `Implementation`, `Contracts`, `SchemaErrorPolicy`,
-`SchemaErrorAnswer`.
-
-The optional `schemaError` group option is a `SchemaErrorPolicy`: two answers, `invalid` and
-`internal`, each a `schema` (a declared error codec) and `make(failure)` (the native
-`HttpApiSchemaError` to that error's decoded value). The library decides which answer applies.
-It affects HTTP only. Handler records require every action key. Each handler's input, success
-and declared errors come from its action; request requirements stay distinct from the
-builder's requirements.
-
-## Canonical
-
-```ts
-import { Effect, Schema } from "effect";
-import * as ActionGroup from "@gjermundgaraba/effect-actions/ActionGroup";
-import { CurrentActor } from "./auth.js";
-import { Double, GetUser, RenameUser, WhoAmI } from "./contracts.js";
-import { Users } from "./users.js";
-
-class InvalidRequest extends Schema.TaggedError<InvalidRequest>()(
-  "InvalidRequest",
-  { message: Schema.String },
-  { httpApiStatus: 400 },
-) {}
-class InternalError extends Schema.TaggedError<InternalError>()(
-  "InternalError",
-  { message: Schema.String },
-  { httpApiStatus: 500 },
-) {}
-
-// A request that does not decode is the caller's fault; a result that does not
-// encode is the server's. Shared across groups as a constant.
-const schemaError = {
-  invalid: {
-    schema: InvalidRequest,
-    make: () => new InvalidRequest({ message: "The request does not match the action's input." }),
-  },
-  internal: {
-    schema: InternalError,
-    make: () => new InternalError({ message: "The request could not be completed." }),
-  },
-};
-
-export const MathActions = ActionGroup.make({ name: "math" }, Double);
-
-export const UserActions = ActionGroup.make(
-  { name: "users", schemaError },
-  GetUser,
-  RenameUser,
-  WhoAmI,
-);
-
-// Build-time services (Users) are yielded in the builder, once per adapter layer.
-// Request-time services (CurrentActor) are yielded inside handlers. Authorization
-// is not here: each adapter binds one `before` hook for every group it serves.
-export const UserApp = UserActions.implement(
-  Effect.gen(function* () {
-    const users = yield* Users;
-
-    return {
-      getUser: ({ id }) => Effect.flatMap(CurrentActor, (actor) => users.get(actor.tenantId, id)),
-      renameUser: ({ id, name }) =>
-        Effect.flatMap(CurrentActor, (actor) => users.rename(actor, id, name)),
-      whoAmI: () => Effect.map(CurrentActor, ({ id, tenantId }) => ({ id, tenantId })),
-    };
-  }),
-);
-
-// No build-time services: pass the record directly.
-export const MathApp = MathActions.implement({ double: ({ value }) => Effect.succeed(value * 2) });
-
-// One typed map of every contract, keyed "<group>.<action>".
-export const contracts = ActionGroup.contracts(UserActions, MathActions);
-const renames: "renameUser" = contracts["users.renameUser"].name;
-```
-
-## Rules
-
-- `name` matches `[A-Za-z0-9_-]+` and cannot be `then`. Action names are unique within the group. Group and MCP tool names are checked where they are served; see [guarantees.md](guarantees.md#namespaces).
-- Group `errors` are appended to each action's own `errors`, so every handler of the group may fail with them. A failure that only the surface produces belongs on the adapter instead (`ActionHttp.make`'s `errors`, `ActionMcp`'s and `ActionToolkit`'s `errors`), not here.
-- `implement` takes a complete plain record or an Effect producing one. Every action must have a handler; missing keys are compile errors. A handler is an own-property function of the record: an inherited one, such as a class instance's method, does not count. A record that still lacks one at runtime (plain JavaScript, a cast: a missing key, `undefined`, any other non-function, an inherited method) throws at `implement`; a builder's record fails the adapter layer's build. Nothing is served with a handler missing. Handlers are called without a receiver. Additional keys are not dispatched. It takes nothing else.
-- The builder Effect runs once per adapter layer that serves the implementation, in that layer's scope, and once per invocation under `ActionCli`. An implementation served by HTTP and MCP is built twice. Acquire shared state in a Layer you provide to the adapters, not in the builder.
-- Services yielded in the builder are build-time requirements (`RX`). Services yielded in a handler are request-time requirements (`R` of the handler). Adapters keep these separate in their types. Use distinct tags for each kind; never provide a request-identity tag at startup (see [guarantees.md](guarantees.md)).
-- `Implementation` is nominal. Spreading its properties does not produce an implementation. Each `implement` call is a separate binding.
-- `build` exists for direct handler tests under `Effect.scoped`. It bypasses transport validation and the hook, and is not a substitute for adapter tests. There is no public handler service or Layer.
-- `contracts(...groups)` returns one record keyed `<group>.<action>`, with each action's exact contract type. Duplicate group names throw. Use it where routes, tools, jobs or commands must name an action: the key set is derived, so an added action cannot be missed.
-
-### Schema-error policy
-
-- Without a policy, HTTP answers decoding and encoding failures with Effect's native empty 400.
-- With a policy, the library picks the answer from the native `HttpApiSchemaError`'s `kind`. Request-side kinds (`Payload`, `Params`, `Headers`, `Query`: the request did not decode) get `invalid`; response-side kinds (`Body`, `ResponseHeaders`: the handler's result did not encode) get `internal`. `make` receives the failure (`kind`, `cause`) and returns its schema's value. HTTP uses that error's `httpApiStatus`, and both errors appear in `Http.api`, in clients, and in OpenAPI.
-- In practice only `Payload` and `Body` occur: actions declare no parameters, query, or headers, and no response headers.
-- `invalid` and `internal` may share one schema; it is declared once.
-- MCP is unaffected. The native `McpServer` answers invalid arguments and unencodable results itself.
-- Policy errors extend the transport contract, not the handler contract. A handler cannot return them.
-- The policy runs only on the server. Client-side codec failures stay `SchemaError`.
-- HTTP decodes input with `errors: "all"`, so an `invalid` `cause` carries every issue. Issues never retain the rejected values.
-- Groups served by one adapter may have different policies; each action answers with its own group's.
-- Input schema-error policies run before the `before` hook. Invalid input is answered by the policy without invoking the hook or handler.
-- Domain errors, defects, interruptions, and protocol errors are not remapped. An unencodable declared error is a defect. A broken policy error is not recursively remapped.
-
-## Failure modes
-
-- Throws at `make`: `Duplicate action: <name>` or `Invalid action group name: <name>`.
-- `Property 'x' is missing in type` at `implement`: the record lacks a handler for action `x`.
-- Handler compiles but returns an error not in `errors`: type error on the handler's error channel. Declare it on the action or the group.
-- `Expected 1 arguments, but got 2` at `implement`: the second options object is gone. Move `before` to the adapter that serves the group.
-- `Parameter 'failure' implicitly has an 'any' type` in a standalone policy constant: a `make` that reads the failure is typed only inline. Annotate the parameter as `HttpApiError.HttpApiSchemaError` (type import from `effect/http-api`), or annotate the constant as `ActionGroup.SchemaErrorPolicy<typeof Invalid, typeof Internal>`.
-- `Missing handlers for group "<group>": <actions>` thrown at `implement`, or failing the layer build: the handler record has no own-property function for those actions. Add them to the record itself, not to a prototype.
-- A service is resolved once and shared across requests when it should be per request: it was yielded in the builder. Move the `yield*` into the handler.
-- `Duplicate contract group` thrown by `contracts`: two groups share a name, so their keys would collide. Rename one.

package/docs/ActionHttpClient.md

@@ -1,80 +0,0 @@
-# ActionHttpClient
-
-A Promise client for an HTTP binding, for code that does not run Effects, such as a browser
-page. It is Effect's native `HttpApiClient` over `fetch`, built once; each call is one request.
-
-## API
-
-Import `@gjermundgaraba/effect-actions/ActionHttpClient`.
-
-| API                       | Purpose                                                               |
-| ------------------------- | --------------------------------------------------------------------- |
-| `promise(http, options?)` | `client.<group>.<action>(input)` for every action of the binding.     |
-| `Options`                 | Where and how requests are sent.                                      |
-| `Client`, `Method`        | The client's type, derived from the binding, and one action's method. |
-
-The options are the native `HttpApiClient.make` options except `transformResponse`, plus `fetch`.
-`transformResponse` may change a call's success, failure or required services, which neither
-the method types nor a Promise can follow; wrap `fetch` or use `transformClient` instead.
-
-| Option            | Meaning                                                                                                                         |
-| ----------------- | ------------------------------------------------------------------------------------------------------------------------------- |
-| `baseUrl`         | What routes are resolved against, such as `https://api.example.com`. Omitted: relative routes (the page's origin in a browser). |
-| `transformClient` | Wraps the native `HttpClient`. A bearer token: `HttpClient.mapRequest(HttpClientRequest.bearerToken(token))`.                   |
-| `fetch`           | The transport. Defaults to the global `fetch`, looked up on each call.                                                          |
-
-A method takes the action's decoded input and resolves with its decoded success. An action
-whose input may be empty (no `input`, or only optional fields) may be called without an argument.
-
-## Canonical
-
-```ts
-import { HttpClient, HttpClientError, HttpClientRequest } from "effect/http";
-import * as ActionHttpClient from "@gjermundgaraba/effect-actions/ActionHttpClient";
-import { Http, UserNotFound } from "./contracts.js";
-
-// Promises in, Promises out: for code that does not run Effects, such as a browser page.
-// The options are the native `HttpApiClient.make` options plus `fetch`; a bearer token is
-// a `transformClient`.
-const client = ActionHttpClient.promise(Http, {
-  baseUrl: "http://127.0.0.1:3000",
-  transformClient: HttpClient.mapRequest(HttpClientRequest.bearerToken("alice")),
-});
-
-export const userName = async (id: string): Promise<string> => {
-  try {
-    return (await client.users.getUser({ id })).name;
-  } catch (error) {
-    // A declared error rejects as its own value...
-    if (error instanceof UserNotFound) return "(no such user)";
-
-    // ...and what the contract cannot account for as Effect's own `HttpClientError`.
-    if (HttpClientError.isHttpClientError(error) && error.response === undefined) {
-      return "(server unreachable)";
-    }
-
-    throw error;
-  }
-};
-```
-
-Other headers also go through `transformClient` (`HttpClient.mapRequest(HttpClientRequest.setHeader("x-agent", agent))`).
-Reacting to a response every call may meet (a proxy's 401), or a token read per call, goes through
-`fetch`: `fetch: (input, init) => { const request = new Request(input, init); request.headers.set("authorization", "Bearer " + readToken()); return fetch(request); }`.
-
-## Rules
-
-- A call rejects with exactly what the native client's Effect fails with. Declared errors arrive as their decoded values: the action's own (its group's `errors` included), its group's schema-error policy's, and the binding's surface `errors`. Classify them with `instanceof`, their `_tag`, or `Schema.is`.
-- Anything the contract does not account for rejects with Effect's own error. `HttpClientError`: the server could not be reached (`response` is `undefined`), or answered with a status no schema declares, or with a body that could not be read. `SchemaError`: the input did not encode (including a field the action does not declare; nothing is sent), or the success body did not decode.
-- The library adds no error type of its own and interprets no status. Which failures mean "signed out" or "try again" is the caller's decision.
-- Nothing is retried. A rejected write may or may not have happened; only a declared error says what the server did.
-- Every action of a bound group has a method. A group without actions has no namespace.
-- The client holds no connections or timers. Making one is synchronous and sends nothing.
-- A method is not an Effect. Code that runs Effects uses `HttpApiClient.make(Http.api)` directly (see [ActionHttp.md](ActionHttp.md)); its methods take `{ payload }`.
-
-## Failure modes
-
-- Rejects with `HttpClientError` whose `reason._tag` is `DecodeError` (`Decode error (401 POST ...)`) for a 401 or 403: the surface answered with an error the binding does not declare. Add it to `ActionHttp.make`'s `errors`, and have the middleware encode it.
-- Rejects with `HttpClientError` whose `reason._tag` is `InvalidUrlError` outside a browser: `baseUrl` is omitted, and there is no page to resolve relative routes against. Set `baseUrl`.
-- A stubbed global `fetch` is not used: `fetch` was passed as an option, which takes precedence.
-- Property does not exist on the client: the action's group is not bound in this `Http`.