@gjermundgaraba/effect-actions 0.1.0-rc.0 → 0.1.0-rc.2

package/dist/Testing.mjs

@@ -0,0 +1,42 @@
+import { Effect, Layer, Predicate } from "effect";
+import { HttpApiClient } from "effect/unstable/httpapi";
+import { FetchHttpClient } from "effect/unstable/http";
+//#region src/Testing.ts
+/**
+* The native grouped HTTP client, calling `handler` in memory instead of the network.
+* `baseUrl` defaults to `http://localhost`.
+*/
+const httpClient = (api, handler, options) => HttpApiClient.make(api, {
+	baseUrl: "http://localhost",
+	...options
+}).pipe(Effect.provide(FetchHttpClient.layer.pipe(Layer.provide(Layer.succeed(FetchHttpClient.Fetch, (input, init) => handler(new Request(input, init)))))));
+/** Build one stateless 2026-07-28 JSON-RPC request, with client metadata defaulted. */
+const mcpRequest = ({ url, method, params = {}, headers: init }) => {
+	const headers = new Headers(init);
+	headers.set("content-type", "application/json");
+	headers.set("accept", "application/json, text/event-stream");
+	headers.set("mcp-protocol-version", "2026-07-28");
+	headers.set("mcp-method", method);
+	if (Predicate.isString(params.name)) headers.set("mcp-name", params.name);
+	return new Request(url, {
+		method: "POST",
+		headers,
+		body: JSON.stringify({
+			jsonrpc: "2.0",
+			id: 1,
+			method,
+			params: {
+				...params,
+				_meta: Object.assign({
+					"io.modelcontextprotocol/clientCapabilities": {},
+					"io.modelcontextprotocol/clientInfo": {
+						name: "test",
+						version: "0"
+					}
+				}, params._meta, { "io.modelcontextprotocol/protocolVersion": "2026-07-28" })
+			}
+		})
+	});
+};
+//#endregion
+export { httpClient, mcpRequest };

package/dist/TestingClient.d.mts

@@ -0,0 +1,16 @@
+import { Client, ClientOptions } 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;
+  /** Passed directly to the official client; omitted options use its native default. */
+  readonly versionNegotiation?: ClientOptions["versionNegotiation"];
+  /** Defaults to `http://localhost`. */
+  readonly baseUrl?: string | URL;
+  readonly headers?: ConstructorParameters<typeof Headers>[0];
+}
+/** Connect an official client and always close its transport after the callback. */
+export declare const withMcpClient: <A>({ fetch, path, baseUrl, headers, versionNegotiation }: McpClientOptions, run: (client: Client) => Promise<A>) => Promise<A>;
+//#endregion

package/dist/{testing/client.mjs → TestingClient.mjs}

@@ -1,16 +1,15 @@
 import { Client, StreamableHTTPClientTransport } from "@modelcontextprotocol/client";
 //#region src/TestingClient.ts
 /** Connect an official client and always close its transport after the callback. */
-const withMcpClient = async (fetch, run, { mode = "modern", path, baseUrl = "http://localhost", headers }) => {
+const withMcpClient = async ({ fetch, path, baseUrl = "http://localhost", headers, versionNegotiation }, run) => {
 	const client = new Client({
 		name: "test",
 		version: "0"
-	}, { versionNegotiation: { mode: mode === "modern" ? { pin: "2026-07-28" } : "legacy" } });
+	}, versionNegotiation === void 0 ? {} : { versionNegotiation });
 	try {
-		await client.connect(new StreamableHTTPClientTransport(new URL(path, baseUrl), {
-			...headers === void 0 ? {} : { requestInit: { headers } },
-			fetch: (input, init) => fetch(new Request(input, init))
-		}));
+		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();

package/dist/{rolldown-runtime-D7D4PA-g.mjs → _virtual/_rolldown/runtime.mjs}

@@ -10,4 +10,4 @@ var __exportAll = (all, no_symbols) => {
 	return target;
 };
 //#endregion
-export { __exportAll as t };
+export { __exportAll };

package/dist/internal/actions.d.mts

@@ -0,0 +1,18 @@
+import { Action_d_exports, Any, Codec } from "../Action.mjs";
+import { HttpApiError } from "effect/unstable/httpapi";
+//#region src/internal/actions.d.ts
+/** Pure HTTP policy for native schema decoding and encoding failures. */
+export interface SchemaErrorPolicy<Errors extends ReadonlyArray<Codec>> {
+  readonly errors: Errors;
+  readonly map: (failure: HttpApiError.HttpApiSchemaError) => NoInfer<Errors[number]["Type"]>;
+}
+/** The contract half of a group: what adapters and clients need, without `implement`. */
+export interface Actions<Name extends string = string, A extends ReadonlyArray<Any> = ReadonlyArray<Any>, PolicyErrors extends ReadonlyArray<Codec> = ReadonlyArray<Codec>> {
+  readonly name: Name;
+  readonly actions: A;
+  /** How HTTP answers failed decoding or encoding; native behavior without one. MCP is unaffected. */
+  readonly schemaError: SchemaErrorPolicy<PolicyErrors> | undefined;
+}
+/** The errors a group's policy may answer with, by lookup rather than a conditional type. */
+export type PolicyError<G extends Actions> = NonNullable<G["schemaError"]>["errors"][number];
+//#endregion

package/dist/internal/actions.mjs

@@ -0,0 +1,16 @@
+//#region src/internal/actions.ts
+const validName = /^[A-Za-z0-9_-]+$/;
+/** Names become path segments, OpenAPI identifiers and client method keys. */
+const assertName = (what, name) => {
+	if (!validName.test(name) || name === "then") throw new Error(`Invalid ${what}: ${name}`);
+};
+/** Each namespace is checked by whoever owns it: a group, the routes, or the MCP tools. */
+const assertDistinct = (what, names) => {
+	const seen = /* @__PURE__ */ new Set();
+	for (const name of names) {
+		if (seen.has(name)) throw new Error(`Duplicate ${what}: ${name}`);
+		seen.add(name);
+	}
+};
+//#endregion
+export { assertDistinct, assertName };

package/dist/internal/cli.d.mts

@@ -0,0 +1,29 @@
+import "../Action.mjs";
+import { Effect, Schema } from "effect";
+import { Command } from "effect/unstable/cli";
+//#region src/internal/cli.d.ts
+/** Options shared by the local and HTTP command projections. */
+interface CommonOptions<Output> {
+  /** Override the command name. The action name is used by default. */
+  readonly name?: string;
+  /** Human output. JSON remains available with `--json`. */
+  readonly render?: (output: Output) => string;
+}
+/** The default projection accepts a whole canonical JSON input with `--input`. */
+export interface JsonOptions<Output> extends CommonOptions<Output> {
+  readonly parameters?: never;
+  readonly input?: never;
+}
+/** Supply native CLI parameters and map their parsed values to canonical action JSON. */
+export interface ParametersOptions<Output, Parameters extends Command.Command.Config> extends CommonOptions<Output> {
+  /** Native Effect CLI flags and arguments. */
+  readonly parameters: Parameters;
+  /** Maps native parsed parameters to the action's canonical JSON input. */
+  readonly input: (parsed: Command.Command.Config.Infer<Parameters>) => Schema.Json;
+}
+/**
+ * A command either accepts whole JSON input or has explicit native CLI parameters.
+ * The latter intentionally has no implicit `--input` mode.
+ */
+export type Options<Output, Parameters extends Command.Command.Config = never> = JsonOptions<Output> | ParametersOptions<Output, Parameters>;
+//#endregion

package/dist/internal/cli.mjs

@@ -0,0 +1,36 @@
+import { Console, Effect, Option, Schema } from "effect";
+import { Command, Flag } from "effect/unstable/cli";
+//#region src/internal/cli.ts
+const isParametersOptions = (options) => options?.parameters !== void 0;
+const jsonOutput = Flag.Boolean("json").pipe(Flag.optional, Flag.withDescription("Print machine-readable JSON"));
+const output = (action, execute, input, render, useJson) => Effect.gen(function* () {
+	const value = yield* execute(input);
+	const encoded = yield* Schema.encodeEffect(Schema.toCodecJson(action.success))(value);
+	const text = render !== void 0 && !useJson ? render(value) : JSON.stringify(encoded, null, 2);
+	yield* Console.log(text);
+});
+const defaultCommand = (action, execute, options) => {
+	const input = Flag.String("input").pipe(Flag.withDefault("{}"), Flag.withSchema(Schema.fromJsonString(Schema.toCodecJson(action.input))), Flag.withDescription("Whole canonical action input as JSON"));
+	const config = options?.render === void 0 ? { input } : {
+		input,
+		output: { json: jsonOutput }
+	};
+	return Command.make(options?.name ?? action.name, config, (parsed) => Effect.gen(function* () {
+		const useJson = "output" in parsed && Option.isSome(parsed.output.json) && parsed.output.json.value === true;
+		return yield* output(action, execute, parsed.input, options?.render, useJson);
+	})).pipe(Command.withDescription(action.description));
+};
+const parametersCommand = (action, execute, options) => {
+	if (options.render === void 0) return Command.make(options.name ?? action.name, options.parameters, (parsed) => Effect.flatMap(Schema.decodeUnknownEffect(Schema.toCodecJson(action.input))(options.input(parsed)), (input) => output(action, execute, input, void 0, true))).pipe(Command.withDescription(action.description));
+	return Command.make(options.name ?? action.name, {
+		parameters: options.parameters,
+		output: { json: jsonOutput }
+	}, (parsed) => Effect.flatMap(Schema.decodeUnknownEffect(Schema.toCodecJson(action.input))(options.input(parsed.parameters)), (input) => output(action, execute, input, options.render, Option.isSome(parsed.output.json) && parsed.output.json.value === true))).pipe(Command.withDescription(action.description));
+};
+/** Build one native command around an action-bound operation. */
+const command = (action, execute, options) => {
+	if (isParametersOptions(options)) return parametersCommand(action, execute, options);
+	return defaultCommand(action, execute, options);
+};
+//#endregion
+export { command };

package/dist/internal/implementation.d.mts

@@ -0,0 +1,39 @@
+import { Action_d_exports, Any } from "../Action.mjs";
+import { Actions } from "./actions.mjs";
+import { Effect, Scope } from "effect";
+//#region src/internal/implementation.d.ts
+/** Decoded values at the adapter dispatch boundary. */
+export type ErasedValue = Any["input"]["Type"];
+type ErasedHandler<R> = {
+  handle(input: ErasedValue): Effect.Effect<ErasedValue, ErasedValue, R>;
+}["handle"];
+/** An adapter's erased view of a record of handlers with request requirements `R`. */
+export type Handlers<R> = Readonly<Record<string, ErasedHandler<R>>>;
+/** Per-request requirements of the handler selected by an action name. */
+export type HandlerContext<H, Name extends keyof H> = H[Name] extends ((input: never) => Effect.Effect<infer _A, infer _E, infer R>) ? R : never;
+/** The union of per-request requirements declared by a handler record. */
+export type HandlersContext<H> = { readonly [K in keyof H]: HandlerContext<H, K>; }[keyof H];
+/**
+ * An acquired handler record for a group.
+ *
+ * The private field makes this class nominal: a structurally similar object,
+ * including one made by spreading an implementation, is not an implementation.
+ */
+export declare class Implementation<G extends Actions, H, EX, RX> {
+  #private;
+  /** The group whose exact handler record was built. */
+  readonly group: G;
+  private constructor();
+  /** Acquire the exact handler record in the adapter layer's scope. */
+  get build(): Effect.Effect<H, EX, RX | Scope.Scope>;
+  static make<G extends Actions, H, EX, RX>(group: G, build: Effect.Effect<H, EX, RX | Scope.Scope>): Implementation<G, H, EX, RX>;
+}
+/** Any nominal implementation of `G`, with its record and channels erased. */
+export type AnyImplementation<G extends Actions = Actions> = Implementation<G, any, any, any>;
+/** Per-request requirements of one implementation, or of a union of them. */
+export type RequestContext<App> = App extends Implementation<any, infer H, any, any> ? HandlersContext<H> : never;
+/** Handler-acquisition failures of one implementation, or of a union of them. */
+export type BuildError<App> = App extends Implementation<any, any, infer EX, any> ? EX : never;
+/** Handler-acquisition requirements of one implementation, or of a union of them. */
+export type BuildContext<App> = App extends Implementation<any, any, any, infer RX> ? RX : never;
+//#endregion

package/dist/internal/implementation.mjs

@@ -0,0 +1,37 @@
+import { Effect } from "effect";
+//#region src/internal/implementation.ts
+/**
+* An acquired handler record for a group.
+*
+* The private field makes this class nominal: a structurally similar object,
+* including one made by spreading an implementation, is not an implementation.
+*/
+var Implementation = class Implementation {
+	group;
+	#build;
+	constructor(group, build) {
+		this.group = group;
+		this.#build = build;
+	}
+	/** Acquire the exact handler record in the adapter layer's scope. */
+	get build() {
+		return this.#build;
+	}
+	static make(group, build) {
+		return new Implementation(group, build);
+	}
+};
+/**
+* Select and invoke a handler after an adapter has selected a concrete action.
+* `R` remains in the returned effect so transport layers cannot erase required
+* per-request services while assembling routes.
+*/
+const dispatch = (group, action, handlers) => {
+	const handle = handlers[action.name];
+	if (handle === void 0) throw new Error(`Missing handler: ${action.name}`);
+	return (input) => {
+		return Effect.withSpan(Effect.suspend(() => handle(input)), `${group.name}.${action.name}`, { captureStackTrace: false });
+	};
+};
+//#endregion
+export { Implementation, dispatch };

package/dist/internal/tools.mjs

@@ -0,0 +1,84 @@
+import { dispatch } from "./implementation.mjs";
+import { Effect, Schema } from "effect";
+import { Tool, Toolkit } from "effect/unstable/ai";
+//#region src/internal/tools.ts
+const isToolAction = (action) => action.mcp !== false;
+/** Only tool-enabled groups are acquired; each implementation appears once. */
+const toolApps = (apps) => apps.flatMap((app) => {
+	const actions = app.group.actions.filter(isToolAction);
+	return actions.length === 0 ? [] : [{
+		app,
+		actions
+	}];
+});
+/** Flatten the projected contracts only after deciding which groups are served. */
+const entries = (apps) => apps.flatMap(({ app, actions }) => actions.map((action) => ({
+	app,
+	action
+})));
+/** Fail before acquiring handlers when two exposed tools share a name. */
+const assertDistinctToolNames = (tools) => {
+	const names = /* @__PURE__ */ new Set();
+	for (const { action } of tools) {
+		const name = action.mcp.name;
+		if (names.has(name)) throw new Error(`Duplicate MCP tool: ${name}`);
+		names.add(name);
+	}
+};
+const annotate = (tool, mcp) => tool.annotate(Tool.Readonly, mcp.readOnly).annotate(Tool.Destructive, mcp.destructive).annotate(Tool.Idempotent, mcp.idempotent).annotate(Tool.OpenWorld, mcp.openWorld);
+/**
+* A native Effect AI tool. Its schemas retain action transforms and its result
+* is the action result itself, rather than an MCP response envelope.
+*/
+const nativeTool = (action) => annotate(Tool.make(action.mcp.name, {
+	description: action.description,
+	parameters: action.input,
+	success: action.success,
+	failure: Schema.Union(action.errors),
+	failureMode: "return"
+}), action.mcp);
+/**
+* MCP has a JSON-only wire contract. Success uses its documented `{ value }`
+* structured-content envelope; declared failures are returned as JSON text.
+*/
+const mcpTool = (action) => annotate(Tool.make(action.mcp.name, {
+	description: action.description,
+	parameters: Schema.toCodecJson(action.input),
+	success: Schema.toCodecJson(Schema.Struct({ value: action.success })),
+	failure: Schema.toCodecJson(Schema.Union(action.errors)),
+	failureMode: "return"
+}), action.mcp);
+/** MCP's input schema must describe a JSON object, including no-argument tools. */
+const assertMcpObjectInput = (action, tool) => {
+	const root = Tool.getJsonSchemaFromSchema(tool.parametersSchema);
+	if (root.$ref === void 0 && root.type !== "object") throw new Error(`${action.name}: MCP input must have an object root; omit input for no arguments`);
+};
+const project = (projection, entry) => {
+	const tool = projection === "native" ? nativeTool(entry.action) : mcpTool(entry.action);
+	if (projection === "mcp") assertMcpObjectInput(entry.action, tool);
+	return tool;
+};
+const handler = (projection, app, action, handlers) => {
+	const run = (input) => dispatch(app.group, action, handlers)(input);
+	return projection === "native" ? run : (input) => Effect.map(run(input), (value) => ({ value }));
+};
+/**
+* Project MCP-enabled actions and acquire their handlers exactly once per adapter layer.
+* Native and MCP differ only in tool codecs and the MCP success envelope; selection,
+* scoped acquisition, dispatch and native Toolkit binding stay identical.
+*/
+const bindTools = (apps, projection) => {
+	const served = toolApps(apps);
+	const selected = entries(served);
+	assertDistinctToolNames(selected);
+	const toolkit = Toolkit.make(...selected.map((entry) => project(projection, entry)));
+	return {
+		toolkit,
+		layer: toolkit.toLayer(Effect.map(Effect.forEach(served, ({ app, actions }) => Effect.map(app.build, (handlers) => {
+			const record = handlers;
+			return actions.map((action) => [action.mcp.name, handler(projection, app, action, record)]);
+		})), (built) => Object.fromEntries(built.flat())))
+	};
+};
+//#endregion
+export { bindTools };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@gjermundgaraba/effect-actions",
-  "version": "0.1.0-rc.0",
-  "description": "Define Effect action contracts once and expose them over HTTP and MCP.",
+  "version": "0.1.0-rc.2",
+  "description": "Define Effect action contracts once and project them onto HTTP, MCP, native Toolkits, catalogs, and CLIs.",
   "homepage": "https://github.com/gjermundgaraba/effect-actions#readme",
   "bugs": {
     "url": "https://github.com/gjermundgaraba/effect-actions/issues"
@@ -16,24 +16,28 @@
   ],
   "type": "module",
   "exports": {
-    ".": "./dist/index.mjs",
     "./Action": "./dist/Action.mjs",
+    "./ActionCatalog": "./dist/ActionCatalog.mjs",
+    "./ActionCli": "./dist/ActionCli.mjs",
+    "./ActionCliClient": "./dist/ActionCliClient.mjs",
     "./ActionGroup": "./dist/ActionGroup.mjs",
-    "./authentication": "./dist/authentication.mjs",
-    "./http": "./dist/http.mjs",
-    "./mcp": "./dist/mcp.mjs",
-    "./testing": "./dist/testing.mjs",
-    "./testing/client": "./dist/testing/client.mjs",
+    "./ActionHttp": "./dist/ActionHttp.mjs",
+    "./ActionMcp": "./dist/ActionMcp.mjs",
+    "./ActionToolkit": "./dist/ActionToolkit.mjs",
+    "./Authentication": "./dist/Authentication.mjs",
+    "./Testing": "./dist/Testing.mjs",
+    "./TestingClient": "./dist/TestingClient.mjs",
     "./package.json": "./package.json"
   },
   "publishConfig": {
-    "access": "public"
+    "access": "public",
+    "tag": "rc"
   },
   "devDependencies": {
-    "@effect/platform-node": "https://pkg.pr.new/Effect-TS/effect/@effect/platform-node@4e4a3a6",
+    "@effect/platform-node": "4.0.0-rc.116",
     "@modelcontextprotocol/client": "2.0.0",
     "@types/node": "26.5.1",
-    "effect": "https://pkg.pr.new/Effect-TS/effect/effect@4e4a3a6",
+    "effect": "4.0.0-rc.116",
     "tsx": "4.23.13",
     "typescript": "7.0.2",
     "vite": "npm:@voidzero-dev/vite-plus-core@0.3.2",
@@ -41,7 +45,7 @@
   },
   "peerDependencies": {
     "@modelcontextprotocol/client": "^2.0.0",
-    "effect": "4.0.0-rc.115"
+    "effect": "4.0.0-rc.116"
   },
   "peerDependenciesMeta": {
     "@modelcontextprotocol/client": {

package/dist/authentication.d.mts

@@ -1,27 +0,0 @@
-import { Codec, t as Action_d_exports } from "./Action.mjs";
-import { Context, Effect } from "effect";
-import { Headers, HttpRouter } from "effect/unstable/http";
-declare namespace Authentication_d_exports {
-  export { Options, middleware };
-}
-export interface Options<A, Errors extends ReadonlyArray<Codec>, R> {
-  readonly authenticate: Effect.Effect<A, Errors[number]["Type"], R>;
-  readonly errors: Errors;
-  readonly headers?: (error: Errors[number]["Type"]) => Headers.Input;
-}
-/**
- * Authenticate each request and provide its identity to the downstream handler.
- * Only authentication failures are encoded, using each schema's httpApiStatus.
- * Dependencies remain native router request requirements. Acquired resources live
- * until the request scope closes, including while the handler is running.
- */
-export declare const middleware: <I, A, const Errors extends ReadonlyArray<Codec>, R>(service: Context.Key<I, A>, options: Options<NoInfer<A>, Errors, R>) => HttpRouter.Middleware<{
-  provides: I;
-  handles: never;
-  error: never;
-  requires: Exclude<R, HttpRouter.Provided> | Exclude<Exclude<import("effect/Types").NoInfer<I>, I>, HttpRouter.Provided>;
-  layerError: never;
-  layerRequires: never;
-}>;
-//#endregion
-export { Authentication_d_exports as t };

package/dist/authentication.mjs

@@ -1,31 +0,0 @@
-import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
-import { Effect, Schema, SchemaAST } from "effect";
-import { HttpEffect, HttpRouter, HttpServerResponse } from "effect/unstable/http";
-//#region src/Authentication.ts
-var Authentication_exports = /* @__PURE__ */ __exportAll({ middleware: () => middleware });
-/**
-* Authenticate each request and provide its identity to the downstream handler.
-* Only authentication failures are encoded, using each schema's httpApiStatus.
-* Dependencies remain native router request requirements. Acquired resources live
-* until the request scope closes, including while the handler is running.
-*/
-const middleware = (service, options) => {
-	const errors = options.errors.map((schema) => ({
-		matches: Schema.is(schema),
-		encode: HttpServerResponse.schemaJson(schema),
-		status: SchemaAST.resolveAt("httpApiStatus")(schema.ast) ?? 500
-	}));
-	return HttpRouter.middleware()((httpEffect) => options.authenticate.pipe(Effect.matchEffect({
-		onFailure: (error) => {
-			const selected = errors.find((candidate) => candidate.matches(error));
-			if (selected === void 0) return Effect.die(/* @__PURE__ */ new Error("Undeclared authentication error"));
-			return selected.encode(error, {
-				status: selected.status,
-				...options.headers === void 0 ? {} : { headers: options.headers(error) }
-			}).pipe(Effect.orDie);
-		},
-		onSuccess: (identity) => Effect.provideService(httpEffect, service, identity)
-	}), HttpEffect.withPreResponseHandler((_request, response) => Effect.succeed(HttpServerResponse.setHeader(response, "cache-control", "no-store")))));
-};
-//#endregion
-export { middleware, Authentication_exports as t };

package/dist/http.d.mts

@@ -1,53 +0,0 @@
-import { Any, Codec, SchemaErrorPolicy, t as Action_d_exports } from "./Action.mjs";
-import { t as Implementation } from "./implementation-D75QAcD3.mjs";
-import { Effect, Layer, Schema } from "effect";
-import { HttpApi, HttpApiClient, HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/unstable/httpapi";
-import { Etag, HttpClient, HttpPlatform, HttpRouter } from "effect/unstable/http";
-import { FileSystem } from "effect/FileSystem";
-import { Path } from "effect/Path";
-declare namespace ActionHttp_d_exports {
-  export { Actions, Client, ClientOptions, LayerOptions, Options, api, client, configure, layer, openapi };
-}
-export interface Options<Errors extends ReadonlyArray<Codec> = []> {
-  readonly apiPath: `/${string}`;
-  readonly schemaError?: SchemaErrorPolicy<Errors>;
-}
-/** Layer/configure options: mount path plus OpenAPI document route. */
-export interface LayerOptions<Errors extends ReadonlyArray<Codec> = []> extends Options<Errors> {
-  /** Set false when the host serves a combined document for multiple groups. */
-  readonly openapiPath: `/${string}` | false;
-}
-/** A group or its implementation. */
-export interface Actions<A extends ReadonlyArray<Any> = ReadonlyArray<Any>> {
-  readonly actions: A;
-}
-/** Distribute over the tuple so each name retains its own codecs. */
-type Endpoint<A extends Any, E extends Codec> = A extends {
-  readonly http: false;
-} ? never : A extends Any ? HttpApiEndpoint.HttpApiEndpoint<A["name"], "POST", `/${string}`, never, never, Schema.toCodecJson<A["input"]>, never, Schema.toCodecJson<A["success"]>, Schema.toCodecJson<A["errors"][number] | E>> : never;
-/** The native `HttpApi` for every HTTP-enabled action: `POST <apiPath>/<name>`. */
-export declare function api<A extends ReadonlyArray<Any>, Errors extends ReadonlyArray<Codec> = []>(group: Actions<A>, options: Options<Errors>): HttpApi.HttpApi<"actions", HttpApiGroup.HttpApiGroup<"actions", Endpoint<A[number], Errors[number]>>>;
-/** The OpenAPI 3.1 document Effect derives from `api`. */
-export declare const openapi: <Errors extends ReadonlyArray<Codec> = []>(group: Actions, options: Options<Errors>) => OpenApi.OpenAPISpec;
-/**
- * Register the endpoints and optional OpenAPI document route on the router.
- * Handler requirements are request-level requirements, exactly as native
- * `HttpApiBuilder` handlers' are. Groups with no HTTP action register nothing.
- */
-export declare const layer: <Actions extends ReadonlyArray<Any>, R, EX, RX, Errors extends ReadonlyArray<Codec> = []>(app: Implementation<Actions, R, EX, RX>, options: LayerOptions<Errors>) => Layer.Layer<never, EX, RX | HttpRouter.HttpRouter | HttpRouter.Request.From<"Requires", R> | Etag.Generator | FileSystem | HttpPlatform.HttpPlatform | Path>;
-type NativeClientOptions = NonNullable<Parameters<typeof HttpApiClient.make>[1]>;
-/** Connection options plus the transport configuration used by HTTP clients. */
-export type ClientOptions<Errors extends ReadonlyArray<Codec> = []> = NativeClientOptions & Options<Errors>;
-/** Direct decoded-input methods, excluding MCP-only actions. */
-export type Client<A extends ReadonlyArray<Any>, E extends Codec = never> = { readonly [Item in A[number] as Item["http"] extends false ? never : Item["name"]]: (...args: {} extends Item["input"]["Type"] ? [input?: Item["input"]["Type"]] : [input: Item["input"]["Type"]]) => HttpApiClient.Client.MethodReturn<Endpoint<Item, E>, never, never, "decoded-only">; };
-/** Bind transport configuration once for contracts, routes, documents and clients. */
-export declare const configure: <Errors extends ReadonlyArray<Codec> = []>(options: LayerOptions<Errors>) => {
-  api: <A extends ReadonlyArray<Any>>(group: Actions<A>) => HttpApi.HttpApi<"actions", HttpApiGroup.HttpApiGroup<"actions", Endpoint<A[number], Errors[number]>, false>>;
-  openapi: (group: Actions) => OpenApi.OpenAPISpec;
-  layer: <A extends ReadonlyArray<Any>, R, EX, RX>(app: Implementation<A, R, EX, RX>) => Layer.Layer<never, EX, RX | FileSystem | Etag.Generator | HttpPlatform.HttpPlatform | HttpRouter.HttpRouter | Path | HttpRouter.Request.From<"Requires", R>>;
-  client: <A extends ReadonlyArray<Any>>(group: Actions<A>, { baseUrl, transformClient, transformResponse }?: NativeClientOptions) => Effect.Effect<Client<A, Errors[number]>, never, HttpClient.HttpClient>;
-};
-/** Direct action methods backed by the native HTTP client and its codecs. */
-export declare function client<A extends ReadonlyArray<Any>, Errors extends ReadonlyArray<Codec> = []>(group: Actions<A>, options: ClientOptions<Errors>): Effect.Effect<Client<A, Errors[number]>, never, HttpClient.HttpClient>;
-//#endregion
-export { ActionHttp_d_exports as t };

package/dist/http.mjs

@@ -1,74 +0,0 @@
-import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
-import { n as handlerFor, t as Implementation } from "./implementation-BkLqMWtv.mjs";
-import { Context, Effect, Layer, Schema } from "effect";
-import { HttpApi, HttpApiBuilder, HttpApiClient, HttpApiEndpoint, HttpApiGroup, HttpApiMiddleware, OpenApi } from "effect/unstable/httpapi";
-//#region src/ActionHttp.ts
-var ActionHttp_exports = /* @__PURE__ */ __exportAll({
-	api: () => api,
-	client: () => client,
-	configure: () => configure,
-	layer: () => layer,
-	openapi: () => openapi
-});
-const endpoint = (apiPath, action, errors) => HttpApiEndpoint.post(action.name, `${apiPath}/${action.name}`, {
-	payload: action.input,
-	success: action.success,
-	error: [...action.errors, ...errors]
-}).annotate(OpenApi.Description, action.description);
-function api(group, options) {
-	const [first, ...rest] = group.actions.filter((action) => action.http).map((action) => endpoint(options.apiPath, action, options.schemaError?.errors ?? []));
-	if (first === void 0) throw new Error("No HTTP-enabled actions");
-	return HttpApi.make("actions").add(HttpApiGroup.make("actions").add(first, ...rest));
-}
-/** The OpenAPI 3.1 document Effect derives from `api`. */
-const openapi = (group, options) => OpenApi.fromApi(api(group, options));
-/**
-* Register the endpoints and optional OpenAPI document route on the router.
-* Handler requirements are request-level requirements, exactly as native
-* `HttpApiBuilder` handlers' are. Groups with no HTTP action register nothing.
-*/
-const layer = (app, options) => {
-	const exposed = app.actions.filter((action) => action.http);
-	if (exposed.length === 0) return Layer.empty;
-	const policy = options.schemaError;
-	class SchemaErrors extends HttpApiMiddleware.Service()("effect-actions/http/SchemaErrors", { error: policy?.errors ?? [] }) {}
-	const schemaErrors = HttpApiMiddleware.layerSchemaErrorTransform(SchemaErrors, (failure) => Effect.fail(policy === void 0 ? failure : policy.map({
-		phase: failure.kind === "Body" || failure.kind === "ResponseHeaders" ? "output" : "input",
-		cause: failure.cause
-	})));
-	const httpApi = api(app, options).middleware(SchemaErrors);
-	return Implementation.register(app, (table) => {
-		const group = HttpApiBuilder.group(httpApi, "actions", (handlers) => handlers.handleAll(Object.fromEntries(exposed.map((action) => {
-			const handle = handlerFor(table, action);
-			return [action.name, (request) => handle(request.payload)];
-		}))));
-		const isolated = Layer.fromBuildMemo((memoMap, scope) => Layer.buildWithMemoMap(group.pipe(Layer.provide(schemaErrors)), memoMap, scope).pipe(Effect.setContext(Context.empty())));
-		return HttpApiBuilder.layer(httpApi, { openapiPath: options.openapiPath === false ? void 0 : options.openapiPath }).pipe(Layer.provide(isolated));
-	});
-};
-/** Bind transport configuration once for contracts, routes, documents and clients. */
-const configure = (options) => ({
-	api: (group) => api(group, options),
-	openapi: (group) => openapi(group, options),
-	layer: (app) => layer(app, options),
-	client: (group, { baseUrl, transformClient, transformResponse } = {}) => client(group, {
-		...options,
-		baseUrl,
-		transformClient,
-		transformResponse
-	})
-});
-function client(group, options) {
-	return Effect.map(HttpApiClient.make(api(group, options), options), (native) => {
-		const acceptsUndefined = new Set(group.actions.filter((action) => Schema.is(action.input)(void 0)).map((action) => action.name));
-		return Object.fromEntries(Object.entries(native.actions).map(([name, method]) => {
-			if (name === "then") throw new Error("Action \"then\" requires the native grouped HttpApiClient");
-			return [name, (input) => method({
-				payload: input === void 0 && !acceptsUndefined.has(name) ? {} : input,
-				responseMode: "decoded-only"
-			})];
-		}));
-	});
-}
-//#endregion
-export { api, client, configure, layer, openapi, ActionHttp_exports as t };

package/dist/implementation-BkLqMWtv.mjs

@@ -1,32 +0,0 @@
-import { Context, Effect, Layer } from "effect";
-//#region src/internal/implementation.ts
-const handlerFor = (table, action) => {
-	const handle = table[action.name];
-	if (handle === void 0) throw new Error(`Missing handler: ${action.name}`);
-	return handle;
-};
-let implementations = 0;
-/**
-* Opaque implementation value; only its type is public. `R` is required per
-* request, `EX`/`RX` describe handler acquisition at Layer build. Layer
-* memoization lets both adapters share one handler build per runtime.
-*/
-var Implementation = class Implementation {
-	actions;
-	#handlers;
-	#layer;
-	constructor(actions, handlers, layer) {
-		this.actions = actions;
-		this.#handlers = handlers;
-		this.#layer = layer;
-	}
-	static make(actions, build) {
-		const handlers = Context.Service(`effect-actions/Handlers#${++implementations}`);
-		return new Implementation(actions, handlers, Layer.effect(handlers, build));
-	}
-	static register(app, make) {
-		return Layer.unwrap(Effect.map(app.#handlers, make)).pipe(Layer.provide(app.#layer));
-	}
-};
-//#endregion
-export { handlerFor as n, Implementation as t };