@gjermundgaraba/effect-actions 0.6.0 → 0.7.0

package/dist/Action.d.mts

@@ -30,7 +30,7 @@ type ResolvedMcp<Name extends string, Mcp extends false | McpOptions | undefined
   readonly openWorld: boolean;
 };
 /** What `make` needs to define an action. */
-export interface Options<Input extends Codec, Output extends Codec, Errors extends ReadonlyArray<Codec>, Acc extends Access = Access, Http extends boolean = boolean, Mcp extends false | McpOptions | undefined = McpOptions | undefined> {
+export interface Options<Input extends Codec, Output extends Codec, Errors extends ReadonlyArray<Codec>, Acc extends Access = Access, Mcp extends false | McpOptions | undefined = McpOptions | undefined> {
   readonly description: string;
   /** Omit for an action without arguments. */
   readonly input?: Input;
@@ -43,32 +43,40 @@ export interface Options<Input extends Codec, Output extends Codec, Errors exten
    * library itself authorizes nothing.
    */
   readonly access: Acc;
-  /** `false` hides the action from HTTP routes and clients. */
-  readonly http?: Http;
   /** `false` hides the action from MCP; otherwise tool metadata. */
   readonly mcp?: Mcp;
 }
 /** A pure contract: schemas and transport metadata. Implementations are bound by `ActionGroup.implement`. */
-export interface Action<Name extends string, Input extends Codec, Output extends Codec, Errors extends ReadonlyArray<Codec>, Acc extends Access = Access, Http extends boolean = boolean, Mcp extends false | McpOptions | undefined = McpOptions | undefined> {
+export interface Action<Name extends string, Input extends Codec, Output extends Codec, Errors extends ReadonlyArray<Codec>, Acc extends Access = Access, Mcp extends false | McpOptions | undefined = McpOptions | undefined> {
   readonly name: Name;
   readonly description: string;
   readonly input: Input;
   readonly success: Output;
   readonly errors: Errors;
   readonly access: Acc;
-  readonly http: Http;
   readonly mcp: ResolvedMcp<Name, Mcp>;
 }
 /** Any action, with its schemas erased. */
-export type Any = Action<string, Codec, Codec, ReadonlyArray<Codec>, Access, boolean, false> | Action<string, Codec, Codec, ReadonlyArray<Codec>, Access, boolean, McpOptions> | Action<string, Codec, Codec, ReadonlyArray<Codec>, Access, boolean, undefined>;
+export type Any = Action<string, Codec, Codec, ReadonlyArray<Codec>, Access, false> | Action<string, Codec, Codec, ReadonlyArray<Codec>, Access, McpOptions> | Action<string, Codec, Codec, ReadonlyArray<Codec>, Access, undefined>;
 /** Receives decoded input; may fail only with the declared errors. */
 export type Handler<A extends Any, R = never> = (input: A["input"]["Type"]) => Effect.Effect<A["success"]["Type"], A["errors"][number]["Type"], R>;
 /** An empty object schema that also produces the object root MCP requires. */
 declare const NoInput: Schema.$Record<Schema.String, Schema.Never>;
+type AnyOptions = Options<Codec, Codec, ReadonlyArray<Codec>, Access, false | McpOptions | undefined>;
+/**
+ * The `mcp` option `make` received. Only a required literal `false` hides the action:
+ * options that may carry something else, such as a conditional spread, `false | undefined`
+ * or a broadly typed variable, may serve it, so its requirements are kept.
+ */
+type McpOf<O extends AnyOptions> = [O] extends [{
+  readonly mcp: false;
+}] ? false : O extends {
+  readonly mcp: infer Mcp extends false | McpOptions | undefined;
+} ? Mcp : "mcp" extends keyof O ? O["mcp"] | undefined : undefined;
 /**
  * Define an action contract. Names are `[A-Za-z0-9_-]+`, other than `then`.
- * Actions can be local-only by setting both transports to `false`.
+ * HTTP serves every action of a group it binds; `mcp: false` hides one from MCP.
  */
-export declare function make<const Name extends string, Input extends Codec = typeof NoInput, Output extends Codec = never, const Errors extends ReadonlyArray<Codec> = [], const Acc extends Access = Access, const Http extends boolean = true, const Mcp extends false | McpOptions | undefined = undefined>(name: Name, options: Options<Input, Output, Errors, Acc, Http, Mcp>): Action<Name, Input, Output, Errors, Acc, Http, Mcp>;
+export declare function make<const Name extends string, const O extends AnyOptions>(name: Name, options: O & { readonly [K in Exclude<keyof O, keyof AnyOptions>]: never; }): Action<Name, "input" extends keyof O ? Exclude<O["input"], undefined> : typeof NoInput, O["success"], "errors" extends keyof O ? Exclude<O["errors"], undefined> : [], O["access"], McpOf<O>>;
 //#endregion
 export { Action_d_exports };

package/dist/Action.mjs

@@ -24,7 +24,6 @@ function make(name, options) {
 		success: options.success,
 		errors: options.errors ?? [],
 		access,
-		http: options.http !== false,
 		mcp
 	};
 }

package/dist/ActionCatalog.d.mts

@@ -8,7 +8,6 @@ export interface Entry {
   readonly group: string;
   readonly name: string;
   readonly description: string;
-  readonly http: boolean;
   readonly mcp: Any["mcp"];
   readonly input: JsonSchema.JsonSchema;
   readonly success: JsonSchema.JsonSchema;
@@ -19,13 +18,13 @@ export interface Entry {
 }
 /** An offline contract document, not an authorization decision or a mounted endpoint. */
 export interface Catalog {
-  readonly version: "3";
+  readonly version: "4";
   readonly actions: ReadonlyArray<Entry>;
 }
 /**
  * Describe the supplied groups without acquiring implementations. Schemas describe
  * encoded action values, not MCP's `{ value }` envelope or deployment-specific URLs.
- * Local-only actions are included; the host chooses what, if anything, to publish.
+ * The host chooses what, if anything, to publish.
  */
 export declare const make: (...groups: ReadonlyArray<Any$1>) => Catalog;
 //#endregion

package/dist/ActionCatalog.mjs

@@ -13,23 +13,22 @@ const describe = (codec) => {
 /**
 * Describe the supplied groups without acquiring implementations. Schemas describe
 * encoded action values, not MCP's `{ value }` envelope or deployment-specific URLs.
-* Local-only actions are included; the host chooses what, if anything, to publish.
+* The host chooses what, if anything, to publish.
 */
 const make = (...groups) => {
 	assertDistinct("catalog group", groups.map((group) => group.name));
 	return {
-		version: "3",
+		version: "4",
 		actions: groups.flatMap((group) => group.actions.map((action) => ({
 			id: `${group.name}.${action.name}`,
 			group: group.name,
 			name: action.name,
 			description: action.description,
-			http: action.http,
 			mcp: action.mcp,
 			input: describe(action.input),
 			success: describe(action.success),
 			errors: action.errors.map(describe),
-			httpSchemaErrors: action.http && group.schemaError !== void 0 ? policyErrors(group.schemaError).map(describe) : []
+			httpSchemaErrors: group.schemaError === void 0 ? [] : policyErrors(group.schemaError).map(describe)
 		})))
 	};
 };

package/dist/ActionCliClient.d.mts

@@ -1,6 +1,5 @@
 import { Action_d_exports, Codec } from "./Action.mjs";
 import { Actions } from "./internal/actions.mjs";
-import { ServedNames } from "./internal/implementation.mjs";
 import { Options as Options$1 } from "./internal/cli.mjs";
 import { ActionHttp_d_exports, Api, Http } from "./ActionHttp.mjs";
 import { Effect } from "effect";
@@ -30,20 +29,20 @@ type Group<Groups extends ReadonlyArray<Actions>, Name extends Groups[number]["n
 type Selected<G extends Actions, Name extends G["actions"][number]["name"]> = Extract<G["actions"][number], {
   readonly name: Name;
 }>;
-type HttpNames<G extends Actions> = ServedNames<G, "http">;
+type ActionNames<G extends Actions> = G["actions"][number]["name"];
 type ApiGroups<Groups extends ReadonlyArray<Actions>, Errors extends ReadonlyArray<Codec>> = Api<Groups[number], Errors[number]> extends HttpApi.HttpApi<"actions", infer ApiGroups> ? ApiGroups : never;
-type Endpoint<Groups extends ReadonlyArray<Actions>, Errors extends ReadonlyArray<Codec>, GroupName extends Groups[number]["name"], ActionName extends HttpNames<Group<Groups, GroupName>>> = Extract<HttpApiGroup.EndpointsWithIdentifier<ApiGroups<Groups, Errors>, Extract<GroupName, HttpApiGroup.Identifier<ApiGroups<Groups, Errors>>>>, {
+type Endpoint<Groups extends ReadonlyArray<Actions>, Errors extends ReadonlyArray<Codec>, GroupName extends Groups[number]["name"], ActionName extends ActionNames<Group<Groups, GroupName>>> = Extract<HttpApiGroup.EndpointsWithIdentifier<ApiGroups<Groups, Errors>, Extract<GroupName, HttpApiGroup.Identifier<ApiGroups<Groups, Errors>>>>, {
   readonly identifier: ActionName;
 }>;
-type NativeMethod<Groups extends ReadonlyArray<Actions>, Errors extends ReadonlyArray<Codec>, GroupName extends Groups[number]["name"], ActionName extends HttpNames<Group<Groups, GroupName>>> = HttpApiClient.Client.Method<Extract<Endpoint<Groups, Errors, GroupName, ActionName>, HttpApiEndpoint.ConstraintRequest>, never, never>;
-type RemoteCommand<Groups extends ReadonlyArray<Actions>, Errors extends ReadonlyArray<Codec>, GroupName extends Groups[number]["name"], ActionName extends HttpNames<Group<Groups, GroupName>>> = Command.Command<string, never, {}, Effect.Error<ReturnType<NativeMethod<Groups, Errors, GroupName, ActionName>>>, HttpClient.HttpClient | Effect.Services<ReturnType<NativeMethod<Groups, Errors, GroupName, ActionName>>>>;
-type RemoteGroupCommand<Groups extends ReadonlyArray<Actions>, Errors extends ReadonlyArray<Codec>, GroupName extends Groups[number]["name"]> = Command.Command<string, {}, {}, Effect.Error<ReturnType<NativeMethod<Groups, Errors, GroupName, HttpNames<Group<Groups, GroupName>>>>>, HttpClient.HttpClient | Effect.Services<ReturnType<NativeMethod<Groups, Errors, GroupName, HttpNames<Group<Groups, GroupName>>>>>>;
+type NativeMethod<Groups extends ReadonlyArray<Actions>, Errors extends ReadonlyArray<Codec>, GroupName extends Groups[number]["name"], ActionName extends ActionNames<Group<Groups, GroupName>>> = HttpApiClient.Client.Method<Extract<Endpoint<Groups, Errors, GroupName, ActionName>, HttpApiEndpoint.ConstraintRequest>, never, never>;
+type RemoteCommand<Groups extends ReadonlyArray<Actions>, Errors extends ReadonlyArray<Codec>, GroupName extends Groups[number]["name"], ActionName extends ActionNames<Group<Groups, GroupName>>> = Command.Command<string, never, {}, Effect.Error<ReturnType<NativeMethod<Groups, Errors, GroupName, ActionName>>>, HttpClient.HttpClient | Effect.Services<ReturnType<NativeMethod<Groups, Errors, GroupName, ActionName>>>>;
+type RemoteGroupCommand<Groups extends ReadonlyArray<Actions>, Errors extends ReadonlyArray<Codec>, GroupName extends Groups[number]["name"]> = Command.Command<string, {}, {}, Effect.Error<ReturnType<NativeMethod<Groups, Errors, GroupName, ActionNames<Group<Groups, GroupName>>>>>, HttpClient.HttpClient | Effect.Services<ReturnType<NativeMethod<Groups, Errors, GroupName, ActionNames<Group<Groups, GroupName>>>>>>;
 /**
- * Project one HTTP action retained by the binding into a native Effect CLI command.
+ * 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.
  */
-export declare const command: <const Groups extends ReadonlyArray<Actions>, const Errors extends ReadonlyArray<Codec>, const GroupName extends Groups[number]["name"], const ActionName extends HttpNames<Group<Groups, GroupName>>, ParsedParameters extends Command.Command.Config = never>(http: Http<Groups, Errors>, groupName: GroupName, actionName: ActionName, options?: Options<Selected<Group<Groups, GroupName>, ActionName>["success"]["Type"], ParsedParameters>) => RemoteCommand<Groups, Errors, GroupName, ActionName>;
-/** Project all HTTP-enabled actions retained by one group below its group namespace. */
+export declare const command: <const Groups extends ReadonlyArray<Actions>, const Errors extends ReadonlyArray<Codec>, const GroupName extends Groups[number]["name"], const ActionName extends ActionNames<Group<Groups, GroupName>>, ParsedParameters extends Command.Command.Config = never>(http: Http<Groups, Errors>, groupName: GroupName, actionName: ActionName, options?: Options<Selected<Group<Groups, GroupName>, ActionName>["success"]["Type"], ParsedParameters>) => RemoteCommand<Groups, Errors, GroupName, ActionName>;
+/** Project every action of one bound group below its group namespace. */
 export declare const group: <const Groups extends ReadonlyArray<Actions>, const Errors extends ReadonlyArray<Codec>, const GroupName extends Groups[number]["name"]>(http: Http<Groups, Errors>, groupName: GroupName, options?: GroupOptions) => RemoteGroupCommand<Groups, Errors, GroupName>;
 //#endregion

package/dist/ActionCliClient.mjs

@@ -13,21 +13,14 @@ import { Command } from "effect/unstable/cli";
 const erasedApi = (api) => {
 	return api;
 };
-/** An action hidden from HTTP is unknown to this binding, exactly like a missing one. */
-const selectAction = (group, name) => {
-	const what = `HTTP action "${group.name}.${name}"`;
-	const action = selectNamed(group.actions, name, what);
-	if (!action.http) throw new Error(`Unknown ${what}`);
-	return action;
-};
 /**
-* Project one HTTP action retained by the binding into a native Effect CLI command.
+* 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 = selectAction(group, actionName);
+	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,
@@ -40,10 +33,10 @@ const command = (http, groupName, actionName, options) => {
 		});
 	}), options);
 };
-/** Project all HTTP-enabled actions retained by one group below its group namespace. */
+/** 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.flatMap((action) => action.http ? [options?.connection === void 0 ? command(http, groupName, action.name) : command(http, groupName, action.name, { connection: options.connection })] : []);
+	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

package/dist/ActionGroup.d.mts

@@ -7,7 +7,7 @@ declare namespace ActionGroup_d_exports {
 }
 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 Http, infer Mcp> ? Action<Name, Input, Output, readonly [...Own, ...Errors], Access, Http, Mcp> : never; };
+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. */

package/dist/ActionGroup.mjs

@@ -1,15 +1,10 @@
 import { assertDistinct, assertName } from "./internal/actions.mjs";
 import { Implementation } from "./internal/implementation.mjs";
-import { Effect } from "effect";
+import { Effect, Predicate } from "effect";
 //#region src/ActionGroup.ts
-/**
-* The types require every handler, but a record built in plain JavaScript or through a
-* cast may still lack one, or hold `undefined` under its key. It fails before anything is served rather than on the
-* first request for the missing action.
-*/
+/** Refuse a record without an own-property function for every action, before anything is served. */
 const assertHandlers = (group, handlers) => {
-	const bound = new Map(Object.entries(handlers));
-	const missing = group.actions.filter((action) => bound.get(action.name) === void 0);
+	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;
 };

package/dist/ActionHttp.d.mts

@@ -31,11 +31,9 @@ export interface LayerOptions<Errors extends ReadonlyArray<Codec>, R> {
    */
   readonly before?: (action: Any) => Effect.Effect<void, Errors[number]["Type"], R>;
 }
-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> : never;
+type Endpoint<A extends Any, E extends Codec> = 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> : never;
 type ApiGroup<G extends Actions, E extends Codec> = G extends Actions ? [Endpoint<G["actions"][number], never>] extends [never] ? never : HttpApiGroup.HttpApiGroup<G["name"], Endpoint<G["actions"][number], PolicyError<G> | E>> : never;
-/** The native `HttpApi` of every HTTP-enabled action of `G`, one group per action group. */
+/** The native `HttpApi` of every action of `G`, one group per action group. */
 export type Api<G extends Actions, E extends Codec = never> = HttpApi.HttpApi<"actions", ApiGroup<G, E>>;
 /** A namespaced HTTP binding. */
 export interface Http<Groups extends ReadonlyArray<Actions>, Errors extends ReadonlyArray<Codec> = []> {
@@ -47,7 +45,7 @@ export interface Http<Groups extends ReadonlyArray<Actions>, Errors extends Read
    * around every request they answer. Build failures, build services and request
    * services are unions over precisely those apps and that hook.
    */
-  readonly layer: <const Apps extends ReadonlyArray<AnyImplementation<Groups[number]>>, RB = never>(apps: readonly [...Apps], options?: LayerOptions<Errors, RB>) => Layer.Layer<never, BuildError<Apps[number], "http">, BuildContext<Apps[number], "http"> | HttpRouter.HttpRouter | HttpRouter.Request.From<"Requires", RequestContext<Apps[number], "http"> | RB> | Etag.Generator | FileSystem | HttpPlatform.HttpPlatform | Path>;
+  readonly layer: <const Apps extends ReadonlyArray<AnyImplementation<Groups[number]>>, RB = never>(apps: readonly [...Apps], options?: LayerOptions<Errors, RB>) => Layer.Layer<never, BuildError<Apps[number]>, BuildContext<Apps[number]> | HttpRouter.HttpRouter | HttpRouter.Request.From<"Requires", RequestContext<Apps[number]> | RB> | Etag.Generator | FileSystem | HttpPlatform.HttpPlatform | Path>;
   /**
    * Serve the OpenAPI document of `api` with `GET path`, by default
    * `<apiPath>/openapi.json`. It is a plain route: middleware provided to this layer

package/dist/ActionHttp.mjs

@@ -4,7 +4,6 @@ import { Effect, Layer } from "effect";
 import { HttpRouter, HttpServerResponse } from "effect/unstable/http";
 import { HttpApi, HttpApiBuilder, HttpApiEndpoint, HttpApiGroup, HttpApiMiddleware, OpenApi } from "effect/unstable/httpapi";
 //#region src/ActionHttp.ts
-const httpActions = (group) => group.actions.filter((action) => action.http);
 const endpoint = (options, group, action) => HttpApiEndpoint.post(action.name, `${options.apiPath}/${group.name}/${action.name}`, {
 	payload: action.input,
 	success: action.success,
@@ -19,7 +18,7 @@ const schemaErrorMiddleware = (name, policy) => {
 	};
 };
 function bind(options, group) {
-	const [first, ...rest] = httpActions(group).map((action) => endpoint(options, group, action));
+	const [first, ...rest] = group.actions.map((action) => endpoint(options, group, action));
 	if (first === void 0) return void 0;
 	const bound = HttpApiGroup.make(group.name).add(first, ...rest);
 	if (group.schemaError === void 0) return {
@@ -49,7 +48,7 @@ const erasedHandlers = (handlers) => {
 };
 /** Register one group's handlers. Handler erasure is limited to native dynamic endpoint registration. */
 const groupHandlers = (api, app, middleware, before) => {
-	const entries = (record) => Object.fromEntries(httpActions(app.group).map((action) => {
+	const entries = (record) => Object.fromEntries(app.group.actions.map((action) => {
 		const run = dispatch(app.group, action, record, before);
 		return [action.name, (request) => run(request.payload)];
 	}));

package/dist/ActionHttpClient.d.mts

@@ -1,34 +1,22 @@
 import { Action_d_exports, Any, Codec } from "./Action.mjs";
 import { Actions } from "./internal/actions.mjs";
-import { ServedNames } from "./internal/implementation.mjs";
 import { ActionHttp_d_exports, Http } from "./ActionHttp.mjs";
+import { ClientOptions } from "./internal/fetchClient.mjs";
 //#region src/ActionHttpClient.d.ts
-/** Where and how a Promise client sends its requests. */
-export interface Options {
-  /**
-   * What the binding's routes are resolved against, such as `https://api.example.com`.
-   * Omitted, routes stay relative, which a browser resolves against the page's origin.
-   */
-  readonly baseUrl?: string | URL;
-  /** Sent as `Authorization: Bearer <token>` with every call. */
-  readonly token?: string;
-  /**
-   * The transport. Defaults to the global `fetch`, looked up per call. Wrap it to add
-   * headers or to observe responses, such as a proxy's 401.
-   */
+/**
+ * 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;
 }
-/** The HTTP-served actions of `G`: an action with a literal `http: false` has no method. */
-type HttpAction<G extends Actions> = Extract<G["actions"][number], {
-  readonly name: ServedNames<G, "http">;
-}>;
 /**
  * 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 HTTP-served action of the binding, as `client.<group>.<action>(input)`. */
-export type Client<Groups extends ReadonlyArray<Actions>> = { readonly [G in Groups[number] as [HttpAction<G>] extends [never] ? never : G["name"]]: { readonly [A in HttpAction<G> as A["name"]]: Method<A>; }; };
+/** 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

package/dist/ActionHttpClient.mjs

@@ -1,24 +1,16 @@
+import { fetchApiClient } from "./internal/fetchClient.mjs";
 import { Effect } from "effect";
-import { FetchHttpClient, HttpClient, HttpClientRequest } from "effect/unstable/http";
-import { HttpApiClient } from "effect/unstable/httpapi";
 //#region src/ActionHttpClient.ts
-function promise(http, { baseUrl, token, fetch } = {}) {
+function promise(http, { baseUrl, transformClient, fetch } = {}) {
 	const send = fetch ?? ((input, init) => globalThis.fetch(input, init));
-	const native = Effect.runSync(HttpApiClient.make(http.api, {
+	const native = Effect.runSync(fetchApiClient(http.api, send, {
 		baseUrl,
-		transformClient: token === void 0 ? void 0 : HttpClient.mapRequest(HttpClientRequest.bearerToken(token))
-	}).pipe(Effect.provide(FetchHttpClient.layer), Effect.provideService(FetchHttpClient.Fetch, send)));
-	return Object.fromEntries(http.groups.flatMap((group) => {
-		const endpoints = native[group.name];
-		if (endpoints === void 0) return [];
-		const methods = group.actions.flatMap((action) => {
-			const endpoint = endpoints[action.name];
-			if (endpoint === void 0) return [];
-			const method = (input) => Effect.runPromise(endpoint({ payload: input ?? {} }));
-			return [[action.name, method]];
-		});
-		return [[group.name, Object.fromEntries(methods)]];
+		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/ActionMcp.d.mts

@@ -1,5 +1,5 @@
 import { Action_d_exports, Codec } from "./Action.mjs";
-import { AnyImplementation, BuildContext, BuildError, RequestContext } from "./internal/implementation.mjs";
+import { AnyImplementation, BuildContext, BuildError, HiddenFromMcp, RequestContext } from "./internal/implementation.mjs";
 import { SurfaceOptions } from "./internal/tools.mjs";
 import { Cause, Layer } from "effect";
 import { HttpRouter } from "effect/unstable/http";
@@ -15,20 +15,21 @@ export interface Options<Errors extends ReadonlyArray<Codec> = [], R = never> ex
 /** An MCP subprocess on standard I/O: every native `McpServer.layerStdio` option except `protocols`. */
 export interface StdioOptions<Errors extends ReadonlyArray<Codec> = [], R = never> extends Omit<Parameters<typeof McpServer.layerStdio>[0], "protocols">, SurfaceOptions<Errors, R> {}
 /** The native server supplies its own request context to every tool call. */
-type ToolRequestContext<App, RB> = Exclude<RequestContext<App, "mcp"> | RB, McpSchema.McpRequestContext>;
+type ToolRequestContext<App, RB> = Exclude<RequestContext<App, HiddenFromMcp> | RB, McpSchema.McpRequestContext>;
 /**
  * Serve MCP tools over one Streamable HTTP endpoint, speaking MCP 2026-07-28 only.
  *
  * Middleware provided around this layer has the normal HTTP lifetime. Native
  * context capture applies: never provide request-identity tags at startup.
  */
-export declare function layerHttp<const Apps extends ReadonlyArray<AnyImplementation>, const Errors extends ReadonlyArray<Codec> = [], RB = never>(apps: readonly [...Apps], options: Options<Errors, RB>): Layer.Layer<never, BuildError<Apps[number], "mcp"> | Cause.IllegalArgumentError, BuildContext<Apps[number], "mcp"> | HttpRouter.HttpRouter | HttpRouter.Request.From<"Requires", ToolRequestContext<Apps[number], RB>>>;
+export declare function layerHttp<const Apps extends ReadonlyArray<AnyImplementation>, const Errors extends ReadonlyArray<Codec> = [], RB = never>(apps: readonly [...Apps], options: Options<Errors, RB>): Layer.Layer<never, BuildError<Apps[number], HiddenFromMcp> | Cause.IllegalArgumentError, BuildContext<Apps[number], HiddenFromMcp> | HttpRouter.HttpRouter | HttpRouter.Request.From<"Requires", ToolRequestContext<Apps[number], RB>>>;
 /**
  * Serve MCP tools through newline-delimited JSON-RPC on standard I/O, speaking MCP
- * 2026-07-28 only.
+ * 2026-07-28 only. An older host is refused deliberately, for uniformity with HTTP,
+ * even though stdio has no sessions.
  *
  * The host supplies the `Stdio` service. Arguments are tool input only and
  * never establish request identity or authority.
  */
-export declare function layerStdio<const Apps extends ReadonlyArray<AnyImplementation>, const Errors extends ReadonlyArray<Codec> = [], RB = never>(apps: readonly [...Apps], options: StdioOptions<Errors, RB>): Layer.Layer<never, BuildError<Apps[number], "mcp"> | Cause.IllegalArgumentError, BuildContext<Apps[number], "mcp"> | Stdio | ToolRequestContext<Apps[number], RB>>;
+export declare function layerStdio<const Apps extends ReadonlyArray<AnyImplementation>, const Errors extends ReadonlyArray<Codec> = [], RB = never>(apps: readonly [...Apps], options: StdioOptions<Errors, RB>): Layer.Layer<never, BuildError<Apps[number], HiddenFromMcp> | Cause.IllegalArgumentError, BuildContext<Apps[number], HiddenFromMcp> | Stdio | ToolRequestContext<Apps[number], RB>>;
 //#endregion

package/dist/ActionToolkit.d.mts

@@ -1,16 +1,14 @@
 import { Action_d_exports, Any, Codec } from "./Action.mjs";
-import { AnyImplementation, BuildContext, BuildError, HandlerContext, Implementation } from "./internal/implementation.mjs";
+import { AnyImplementation, BuildContext, BuildError, HandlerContext, HiddenFromMcp, Implementation } from "./internal/implementation.mjs";
 import { SurfaceOptions } from "./internal/tools.mjs";
 import { Layer, Schema } from "effect";
 import { Tool, Toolkit } from "effect/unstable/ai";
 //#region src/ActionToolkit.d.ts
 /** What the in-process caller binds around the implementations it projects. */
 export type Options<Errors extends ReadonlyArray<Codec> = [], R = never> = SurfaceOptions<Errors, R>;
-/** A native tool corresponding to an MCP-enabled action. */
-type NativeTool<A extends Any, E extends Codec, R> = A extends {
-  readonly mcp: {
-    readonly name: infer Name extends string;
-  };
+/** A native tool corresponding to an action MCP may serve, named by its tool metadata. */
+type NativeTool<A extends Any, E extends Codec, R> = Extract<A["mcp"], object> extends {
+  readonly name: infer Name extends string;
 } ? Tool.Tool<Name, {
   readonly parameters: A["input"];
   readonly success: A["success"];
@@ -18,10 +16,11 @@ type NativeTool<A extends Any, E extends Codec, R> = A extends {
   readonly failureMode: "return";
 }, R> : never;
 type HandlersOf<App extends AnyImplementation> = App extends Implementation<any, infer H, any, any> ? H : never;
-/** A tool needs what its handler needs, plus what the binding's `before` hook needs. */
-type ToolForAction<App extends AnyImplementation, A extends Any, E extends Codec, RB> = A extends {
-  readonly mcp: object;
-} ? NativeTool<A, E, HandlerContext<HandlersOf<App>, Extract<A["name"], keyof HandlersOf<App>>> | RB> : never;
+/**
+ * A tool needs what its handler needs, plus what the binding's `before` hook needs. The
+ * rule is `ActionMcp`'s: only an action certainly hidden from MCP has no tool.
+ */
+type ToolForAction<App extends AnyImplementation, A extends Any, E extends Codec, RB> = A extends HiddenFromMcp ? never : NativeTool<A, E, HandlerContext<HandlersOf<App>, Extract<A["name"], keyof HandlersOf<App>>> | RB>;
 type ToolsFor<App extends AnyImplementation, E extends Codec, RB> = App extends AnyImplementation ? ToolForAction<App, App["group"]["actions"][number], E, RB> : never;
 type ToolkitTools<Apps extends ReadonlyArray<AnyImplementation>, E extends Codec, RB> = { readonly [T in ToolsFor<Apps[number], E, RB> as T["name"]]: T; };
 /** Native tools and the layer that binds their action implementations. */
@@ -37,5 +36,5 @@ export interface Binding<Tools extends Record<string, Tool.Any>, E = never, R =
  * Build services are needed to construct `layer`; request services are needed
  * when the resulting toolkit handles a call.
  */
-export declare function make<const Apps extends ReadonlyArray<AnyImplementation>, const Errors extends ReadonlyArray<Codec> = [], RB = never>(apps: readonly [...Apps], options?: Options<Errors, RB>): Binding<ToolkitTools<Apps, Errors[number], RB>, BuildError<Apps[number], "mcp">, BuildContext<Apps[number], "mcp">>;
+export declare function make<const Apps extends ReadonlyArray<AnyImplementation>, const Errors extends ReadonlyArray<Codec> = [], RB = never>(apps: readonly [...Apps], options?: Options<Errors, RB>): Binding<ToolkitTools<Apps, Errors[number], RB>, BuildError<Apps[number], HiddenFromMcp>, BuildContext<Apps[number], HiddenFromMcp>>;
 //#endregion

package/dist/Testing.d.mts

@@ -1,5 +1,6 @@
-import { Effect, Schema } from "effect";
-import { HttpApi, HttpApiClient, HttpApiGroup } from "effect/unstable/httpapi";
+import { ClientOptions } from "./internal/fetchClient.mjs";
+import { Schema } from "effect";
+import { HttpApi, HttpApiGroup } from "effect/unstable/httpapi";
 //#region src/Testing.d.ts
 /** A web handler, such as `HttpRouter.toWebHandler(routes).handler`. */
 export type Handler = (request: Request) => Promise<Response>;
@@ -7,9 +8,9 @@ export type Handler = (request: Request) => Promise<Response>;
  * The native grouped HTTP client, calling `handler` in memory instead of the network.
  * `baseUrl` defaults to `http://localhost`.
  */
-export declare const httpClient: <Id extends string, Groups extends HttpApiGroup.Constraint>(api: HttpApi.HttpApi<Id, Groups>, handler: Handler, options?: NonNullable<Parameters<typeof HttpApiClient.make>[1]>) => Effect.Effect<import("effect/Types").Simplify<{ readonly [Group in Extract<Groups, {
+export declare const httpClient: <Id extends string, Groups extends HttpApiGroup.Constraint>(api: HttpApi.HttpApi<Id, Groups>, handler: Handler, options?: ClientOptions) => import("effect/Effect").Effect<import("effect/Types").Simplify<{ readonly [Group in Extract<Groups, {
   readonly topLevel: false;
-}> as HttpApiGroup.Identifier<Group>]: HttpApiClient.Client.GroupByEndpoint<Group, never, never>; } & HttpApiClient.Client.TopLevelMethods<Groups, never, never>>, never, Exclude<import("effect/unstable/httpapi/HttpApiMiddleware").MiddlewareClient<import("effect/unstable/httpapi/HttpApiEndpoint").Middleware<HttpApiGroup.Endpoints<Groups>>>, import("effect/unstable/http/HttpClient").HttpClient>>;
+}> as HttpApiGroup.Identifier<Group>]: import("effect/unstable/httpapi/HttpApiClient").Client.GroupByEndpoint<Group, never, never>; } & import("effect/unstable/httpapi/HttpApiClient").Client.TopLevelMethods<Groups, never, never>>, never, Exclude<Exclude<import("effect/unstable/httpapi/HttpApiMiddleware").MiddlewareClient<import("effect/unstable/httpapi/HttpApiEndpoint").Middleware<HttpApiGroup.Endpoints<Groups>>>, import("effect/unstable/http/HttpClient").HttpClient>, never>>;
 /** A stateless 2026-07-28 request. */
 export interface McpRequestOptions {
   readonly url: string | URL;
@@ -47,8 +48,8 @@ export interface McpCallOptions {
 /**
  * A tool call's outcome with the library's wire envelope removed: the success from
  * `structuredContent.value`, or the error text of an `isError` result, parsed as JSON
- * when it is JSON (a declared error) and kept as the text otherwise (the native
- * server's own message, such as for invalid arguments).
+ * when it is JSON (a declared error, whatever its shape) and kept as the text otherwise
+ * (the native server's own message, such as for invalid arguments).
  */
 export type McpCallResult = {
   readonly isError: false;
@@ -62,5 +63,5 @@ export type McpCallResult = {
  * outcome. A response that is not an HTTP 200 carrying a tool result, such as an
  * authentication refusal or a JSON-RPC error, throws; use `mcpRequest` to inspect one.
  */
-export declare const mcpCall: (handler: Handler, { url, name, headers, ...options }: McpCallOptions) => Promise<McpCallResult>;
+export declare const mcpCall: (handler: Handler, { url, name, headers, arguments: args }: McpCallOptions) => Promise<McpCallResult>;
 //#endregion

package/dist/Testing.mjs

@@ -1,15 +1,14 @@
-import { Effect, Layer, Option, Predicate, Schema } from "effect";
-import { FetchHttpClient } from "effect/unstable/http";
-import { HttpApiClient } from "effect/unstable/httpapi";
+import { fetchApiClient } from "./internal/fetchClient.mjs";
+import { Option, Predicate, Schema } from "effect";
 //#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, {
+const httpClient = (api, handler, options) => fetchApiClient(api, (input, init) => handler(new Request(input, init)), {
 	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);
@@ -57,13 +56,13 @@ const parseJson = Schema.decodeUnknownOption(Schema.fromJsonString(Schema.Json))
 * outcome. A response that is not an HTTP 200 carrying a tool result, such as an
 * authentication refusal or a JSON-RPC error, throws; use `mcpRequest` to inspect one.
 */
-const mcpCall = async (handler, { url, name, headers, ...options }) => {
+const mcpCall = async (handler, { url, name, headers, arguments: args = {} }) => {
 	const response = await handler(mcpRequest({
 		url,
 		method: "tools/call",
 		params: {
 			name,
-			arguments: options.arguments ?? {}
+			arguments: args
 		},
 		...headers === void 0 ? {} : { headers }
 	}));

package/dist/internal/fetchClient.d.mts

@@ -0,0 +1,6 @@
+import { Effect } from "effect";
+import { HttpApi, HttpApiClient, HttpApiGroup } from "effect/unstable/httpapi";
+//#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

@@ -0,0 +1,8 @@
+import { Effect } from "effect";
+import { FetchHttpClient } from "effect/unstable/http";
+import { HttpApiClient } from "effect/unstable/httpapi";
+//#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/implementation.d.mts

@@ -30,21 +30,20 @@ export declare class Implementation<G extends Actions, 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>;
-/** The transports that serve a subset of a group's actions, by the contract flag that hides an action. */
-export type Transport = "http" | "mcp";
+/** What hides an action from MCP and Toolkit types: an `mcp` type of exactly `false`. The one rule both use. */
+export type HiddenFromMcp = {
+  readonly mcp: false;
+};
 /**
- * Names of the actions of `G` that `T` may serve. Only an action hidden by a
- * literal `false` is excluded; a flag decided at runtime keeps its requirements.
+ * Names of the actions of `G` a surface serves: all of them, less those matching
+ * `Hidden`. An action whose `mcp` may be `false` at runtime does not match, so it keeps
+ * its requirements.
  */
-export type ServedNames<G extends Actions, T extends Transport> = Exclude<G["actions"][number], T extends "http" ? {
-  readonly http: false;
-} : {
-  readonly mcp: false;
-}>["name"];
-/** Per-request requirements of the handlers `T` can invoke, or of a union of implementations. */
-export type RequestContext<App, T extends Transport> = App extends Implementation<infer G, infer H, any, any> ? { readonly [K in Extract<ServedNames<G, T>, keyof H>]: HandlerContext<H, K>; }[Extract<ServedNames<G, T>, keyof H>] : never;
-/** Handler-acquisition failures of the implementations `T` acquires, or of a union of them. */
-export type BuildError<App, T extends Transport> = App extends Implementation<infer G, any, infer EX, any> ? [ServedNames<G, T>] extends [never] ? never : EX : never;
-/** Handler-acquisition requirements of the implementations `T` acquires, or of a union of them. */
-export type BuildContext<App, T extends Transport> = App extends Implementation<infer G, any, any, infer RX> ? [ServedNames<G, T>] extends [never] ? never : RX : never;
+type ServedNames<G extends Actions, Hidden> = Exclude<G["actions"][number], Hidden>["name"];
+/** Per-request requirements of the handlers a surface can invoke, or of a union of implementations. */
+export type RequestContext<App, Hidden = never> = App extends Implementation<infer G, infer H, any, any> ? { readonly [K in Extract<ServedNames<G, Hidden>, keyof H>]: HandlerContext<H, K>; }[Extract<ServedNames<G, Hidden>, keyof H>] : never;
+/** Handler-acquisition failures of the implementations a surface acquires, or of a union of them. */
+export type BuildError<App, Hidden = never> = App extends Implementation<infer G, any, infer EX, any> ? [ServedNames<G, Hidden>] extends [never] ? never : EX : never;
+/** Handler-acquisition requirements of the implementations a surface acquires, or of a union of them. */
+export type BuildContext<App, Hidden = never> = App extends Implementation<infer G, any, any, infer RX> ? [ServedNames<G, Hidden>] extends [never] ? never : RX : never;
 //#endregion

package/dist/internal/implementation.mjs

@@ -1,4 +1,4 @@
-import { Effect } from "effect";
+import { Effect, Predicate } from "effect";
 //#region src/internal/implementation.ts
 /**
 * An acquired handler record for a group.
@@ -30,8 +30,8 @@ var Implementation = class Implementation {
 * per-request services while assembling routes.
 */
 const dispatch = (group, action, handlers, before) => {
-	const handle = handlers[action.name];
-	if (handle === void 0) throw new Error(`Missing handler: ${action.name}`);
+	const handle = Object.hasOwn(handlers, action.name) ? handlers[action.name] : void 0;
+	if (!Predicate.isFunction(handle)) throw new Error(`No handler for ${group.name}.${action.name}`);
 	const attributes = {
 		"action.group": group.name,
 		"action.name": action.name,

package/docs/Action.md

@@ -7,18 +7,17 @@ metadata. An action holds no behavior; handlers are bound by `ActionGroup.implem
 
 Import `@gjermundgaraba/effect-actions/Action`.
 
-| Export                                     | Purpose                                                                            |
-| ------------------------------------------ | ---------------------------------------------------------------------------------- |
-| `make(name, options)`                      | Define a pure contract; literal names, access and transport exclusions stay typed. |
-| `Action`, `Any`, `Options`                 | Concrete contracts, erased contracts and construction options.                     |
-| `Codec`, `Handler`, `Access`, `McpOptions` | Service-free codecs, typed handlers, read/write classification and tool metadata.  |
+| Export                                     | Purpose                                                                           |
+| ------------------------------------------ | --------------------------------------------------------------------------------- |
+| `make(name, options)`                      | Define a pure contract; literal names, access and MCP exclusion stay typed.       |
+| `Action`, `Any`, `Options`                 | Concrete contracts, erased contracts and construction options.                    |
+| `Codec`, `Handler`, `Access`, `McpOptions` | Service-free codecs, typed handlers, read/write classification and tool metadata. |
 
 | Option                             | Meaning                                                                      |
 | ---------------------------------- | ---------------------------------------------------------------------------- |
 | `description`, `success`, `access` | Required description, success codec and `"read"` / `"write"` classification. |
 | `input`                            | Optional codec; omission means an empty object.                              |
 | `errors`                           | Declared error codecs; defaults to none.                                     |
-| `http`                             | Defaults to enabled; `false` removes routes and client methods.              |
 | `mcp`                              | Defaults to enabled; `false` removes tools, otherwise accepts `McpOptions`.  |
 
 MCP options: `name` defaults to the action name; `readOnly` to `access === "read"`;
@@ -65,12 +64,11 @@ export const WhoAmI = Action.make("whoAmI", {
   access: "read",
 });
 
-// MCP-only: no HTTP route, no client method.
+// A tool only: its group is left out of the HTTP binding (see ActionHttp.md).
 export const ListChanges = Action.make("listChanges", {
   description: "List renames in your tenant, oldest first.",
   success: Schema.Struct({ changes: Schema.Array(Schema.String) }),
   access: "read",
-  http: false,
   mcp: { name: "list_changes" },
 });
 
@@ -90,8 +88,10 @@ export const Double = Action.make("double", {
 - `errors` is a list of schemas, default none. Each keeps its own `httpApiStatus` annotation; an unannotated error is served as HTTP 500. Group-level `errors` are appended to every action of the group (see [ActionGroup.md](ActionGroup.md)).
 - A handler may fail only with the declared errors. Anything else is a defect.
 - `access` is `"read"` or `"write"` and is required. `make` also checks it at runtime, so a caller the compiler never sees cannot define an action no rule classifies. It stays a literal on the action, so a rule may switch on it at the type level. It is authorization metadata for a surface's `before` hook (see [guarantees.md](guarantees.md)); the library itself authorizes nothing. Its only built-in uses are default MCP hints and span/log annotations; adapters never enforce an authorization rule from it.
-- `access` is independent of `mcp`. A local-only action (`mcp: false`) still has one, and an action may set `access: "write"` with `mcp: { readOnly: true }` if the tool hint should say something else. Derive authorization from `access`, never from a tool hint.
-- Both transports are on by default. `http: false` removes the route and the client method. `mcp: false` removes the tool. Both `false` makes a local-only action, reachable through `ActionCli` only.
+- `access` is independent of `mcp`. An action hidden from MCP (`mcp: false`) still has one, and an action may set `access: "write"` with `mcp: { readOnly: true }` if the tool hint should say something else. Derive authorization from `access`, never from a tool hint.
+- An action has no HTTP switch. HTTP serves every action of every group it binds; to keep an action off HTTP, put it in a group the HTTP binding leaves out. `ActionCli` runs any action locally.
+- `mcp: false` removes the tool. The action's type is hidden from MCP only when the options' type has a required `mcp: false`, such as a literal `mcp: false` in the object passed to `make`. Options that may serve it type it as served, so MCP layers keep its handler's requirements: a conditional spread of `{ mcp: false }`, `false | undefined`, a flag-driven value such as `enabled ? {} : false`, or an `Options` value whose `mcp` is optional.
+- `make` accepts only the keys `Options` declares. An unknown key, such as a stale `http`, is a compile error.
 - MCP input must have an object-root JSON Schema, an identified or recursive root included. Scalar or array input is fine for HTTP and for a native Toolkit, but the native MCP server refuses it when an `ActionMcp` layer is built. Success and error schemas may be any shape.
 - `mcp.name` is the tool name, matches `[A-Za-z0-9_-]+` except `then`, is at most 128 characters, unique within the group and within any Toolkit or MCP projection that serves the group. Default is the action name.
 - Hint defaults: `readOnly: access === "read"`, `destructive: !readOnly`, `idempotent: false`, `openWorld: true`. Hints are metadata for the model. They do not enforce authorization, approval, or retries.
@@ -105,4 +105,5 @@ export const Double = Action.make("double", {
 - Type error `Effect<..., X, ...> is not assignable` in `implement`: the handler fails with an undeclared error `X`. Add it to `errors` or handle it.
 - Handler receives a string where a number was expected: the schema is `Schema.String`, not a transforming codec such as `Schema.FiniteFromString`.
 - `Property 'access' is missing` at `make`: every action declares `"read"` or `"write"`. There is no default.
+- `Type 'false' is not assignable to type 'never'` on `http` at `make`: the option is gone. Delete it; to keep the action off HTTP, move it to a group the HTTP binding leaves out.
 - A tool shows `readOnlyHint: false` for a read: the action sets `mcp: { readOnly: false }` explicitly, which wins over `access`.

package/docs/ActionCatalog.md

@@ -7,15 +7,15 @@ Built from contracts alone: no implementation, service or server is involved.
 
 Import `@gjermundgaraba/effect-actions/ActionCatalog`.
 
-`make(...groups)` returns `Catalog`: `version: "3"` and an ordered `actions` array of `Entry`.
+`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.                    |
-| `http`, `mcp`                        | HTTP enablement and resolved MCP enablement/name/hints.                      |
-| `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 for HTTP-disabled actions. |
+| Entry field                          | Meaning                                                             |
+| ------------------------------------ | ------------------------------------------------------------------- |
+| `id`, `group`, `name`, `description` | Stable `<group>.<action>` identity and contract metadata.           |
+| `mcp`                                | Resolved MCP enablement, name and hints.                            |
+| `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`.
 
@@ -43,7 +43,7 @@ Console.log(
 - 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. Local-only actions are included. Presence grants no authorization or proof that an endpoint is mounted; the host decides what to publish.
+- `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

package/docs/ActionCli.md

@@ -1,17 +1,17 @@
 # ActionCli
 
 Native Effect CLI commands that run handlers in-process. The host provides every service;
-nothing is fetched over HTTP.
+nothing is fetched over HTTP. Any action runs locally, whether or not HTTP or MCP serves it.
 
 ## API
 
 Import `@gjermundgaraba/effect-actions/ActionCli`.
 
-| API                            | Purpose                                                           |
-| ------------------------------ | ----------------------------------------------------------------- |
-| `command(app, name, options?)` | One selected action as a native Effect `Command`.                 |
-| `group(app, options?)`         | Every action under a group command, including local-only actions. |
-| `Options`, `GroupOptions`      | Configuration for single and aggregate commands.                  |
+| API                            | Purpose                                           |
+| ------------------------------ | ------------------------------------------------- |
+| `command(app, name, options?)` | One selected action as a native Effect `Command`. |
+| `group(app, options?)`         | Every action under a group command.               |
+| `Options`, `GroupOptions`      | Configuration for single and aggregate commands.  |
 
 | Option                | Meaning                                                                                                      |
 | --------------------- | ------------------------------------------------------------------------------------------------------------ |
@@ -56,7 +56,7 @@ Command.runWith(command, { version: "0.1.0" })(process.argv.slice(2)).pipe(
 
 ## Rules
 
-- `command(app, name)` selects one action by name from the bound group; the name is checked at the type level. `group(app)` puts every action under the group command, including actions with `http: false` and `mcp: false`.
+- `command(app, name)` selects one action by name from the bound group; the name is checked at the type level. `group(app)` puts every action under the group command, including actions with `mcp: false` and groups no HTTP binding serves.
 - Default syntax is `--input '<json>'` or `--input-file <path>` carrying the entire encoded input: nested objects, arrays, scalars. The file is read and JSON-parsed by the native `Flag.FileSchema`. Both are decoded by the native parser; if both are given, the file is used. Omitting both decodes `{}` separately on every invocation; result identity follows the codec's behavior. An action that requires input then fails with a `SchemaError`, exactly as a `parameters` command's mapped input does.
 - `parameters` and `input` are supplied together or not at all. With them, the command has explicit native flags and arguments and neither `--input` nor `--input-file`, so its syntax does not change when the schema changes.
 - `input(parsed)` returns encoded JSON. The action schema decodes it before dispatch; a mismatch is a `SchemaError` at runtime. Action fields are never turned into flags automatically.

package/docs/ActionCliClient.md

@@ -9,8 +9,8 @@ Import `@gjermundgaraba/effect-actions/ActionCliClient`.
 
 | API                                              | Purpose                                                                    |
 | ------------------------------------------------ | -------------------------------------------------------------------------- |
-| `command(http, groupName, actionName, options?)` | Call one HTTP-enabled action through a native Effect `Command`.            |
-| `group(http, groupName, options?)`               | Every HTTP-enabled action of a bound group under one command.              |
+| `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`.
@@ -49,7 +49,7 @@ Authentication: `connection: { transformClient: HttpClient.mapRequest(HttpClient
 
 ## Rules
 
-- Selectors resolve from `http.groups` only. `groupName` must be a bound group; `actionName` must be an action of that group with `http: true`. Runtime guards reject dynamically supplied strings that the types would not accept.
+- 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 is decoded by the action schema before dispatch, then passed to the native client at its normal codec boundary. Do not pre-encode values.
 - Input syntax (`--input`, `--input-file`, or `parameters`) and output (`render` and its `--json` flag) are exactly as in `ActionCli`.
@@ -57,7 +57,7 @@ Authentication: `connection: { transformClient: HttpClient.mapRequest(HttpClient
 
 ## Failure modes
 
-- Type error on `actionName`: the action is `http: false`, or the group is not bound in this `Http`.
+- Type error on `actionName`: the action is not in that group, or the group is not bound in this `Http`.
 - `HttpClient` missing at runtime: provide `NodeHttpClient.layerUndici` (or `FetchHttpClient.layer`) to the runtime.
 - Connection refused: `connection.baseUrl` is absent or wrong. It has no default.
 - 401 from the server: add `transformClient` to `connection`. The command adds no headers on its own.

package/docs/ActionGroup.md

@@ -93,7 +93,7 @@ const renames: "renameUser" = contracts["users.renameUser"].name;
 
 - `name` matches `[A-Za-z0-9_-]+`, cannot be `then`, and must be unique within one `ActionHttp.make`. Action names must be unique within the group. MCP tool names must be unique within the group and within each Toolkit or MCP projection that serves it. Duplicates fail at `make`.
 - 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 record or an Effect producing one. Every action must have a handler; missing keys are compile errors. A record that still lacks one at runtime (plain JavaScript, a cast) throws at `implement`; a builder's record fails the adapter layer's build. Nothing is served with a handler missing. Additional keys are not dispatched. It takes nothing else.
+- `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. 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.
@@ -121,6 +121,6 @@ const renames: "renameUser" = contracts["users.renameUser"].name;
 - 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/unstable/httpapi`), 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 lacks those actions. Add them.
+- `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/ActionHttp.md

@@ -23,9 +23,8 @@ Exported types: `Options`, `LayerOptions`, `Http`, `Api`.
 | `make`: `errors`  | Surface error codecs declared on every endpoint; defaults to none.                                                                                          |
 | `layer`: `before` | Effectful hook receiving the selected `Action.Any`, after successful input decoding and before its handler. Failures must belong to the binding's `errors`. |
 
-Layer failures and startup requirements come from the supplied implementations that actually
-serve HTTP actions. Served handlers' and the hook's request services remain router request
-requirements; router/platform services are also required. No request identity is supplied at startup.
+Layer failures and startup requirements come from the supplied implementations. Every
+handler's and the hook's request services remain router request requirements; router/platform services are also required. No request identity is supplied at startup.
 
 Route shape: `POST <apiPath>/<group>/<action>`. Operation ID: `<group>.<action>`.
 
@@ -88,11 +87,12 @@ export const greeting = Effect.gen(function* () {
 
 ## Rules
 
+- HTTP serves every action of every group passed to `make`; an action has no HTTP switch. To keep an action off HTTP, put it in a group left out of `make` and serve that group elsewhere (MCP, Toolkit, CLI).
 - `apiPath` has no default. Group names must be unique within one `make`. Action names need only be unique within their group; equal action names in different groups do not collide.
 - `errors` declares the failures the surface around these endpoints answers with rather than a handler: authentication, authorization, rate limiting, upstream unavailability. They are added to every endpoint's error schemas, so `HttpApiClient`, `ActionCliClient` and the in-memory `Testing.httpClient` decode them as typed failures, and they appear in OpenAPI on every operation. A schema an action already declares is not repeated.
 - Schemas reachable from one endpoint must have distinct `_tag`s: the client decodes a response by trying the schemas declared for its status, and two errors may share a status. Effect unions them per status.
 - `errors` changes only what is declared. Nothing produces them: the middleware that renders those responses must encode a body that matches the schema, or the client sees a decode error again. Handlers cannot fail with them.
-- `Http.layer(apps, options?)` requires each implementation to reference the exact group object passed to `make`; reconstructing an equal-looking group is not sufficient. Each group may occur only once per call. Only supplied implementations are mounted, and a group with no HTTP-enabled actions is not built. Options are optional.
+- `Http.layer(apps, options?)` requires each implementation to reference the exact group object passed to `make`; reconstructing an equal-looking group is not sufficient. Each group may occur only once per call. Only supplied implementations are mounted, and a group without actions is not built. Options are optional.
 - `before` runs after successful native input decoding and before the selected handler. Invalid input skips the hook and handler. A refusal uses the binding's declared error schema and `httpApiStatus`; its services join handler request requirements. Admission that must precede decoding belongs in outer native HTTP middleware.
 - Middleware and the hook are per layer call. Groups that need different middleware or a different policy go in separate `Http.layer` calls, merged with `Layer.mergeAll`.
 - `ActionHttp` sets no response headers of its own. The host owns cache policy; `Authentication.middleware` marks its responses `cache-control: no-store`.
@@ -101,19 +101,19 @@ export const greeting = Effect.gen(function* () {
 - `Http.api` is a plain `HttpApi`. Anything Effect can do with an `HttpApi` works: `OpenApi.fromApi`, `HttpApiSwagger.layer`, `HttpApiScalar.layer`, `HttpApi.addHttpApi` to combine with other APIs, `HttpApiClient.make`.
 - `Http.openApi(path?)` is `OpenApi.fromApi(Http.api)` as one `GET` route, `<apiPath>/openapi.json` unless a path is given. It documents every bound group, not only the served ones. It is a plain route: middleware provided to its layer covers it, and nothing covers it otherwise.
 - Client calls always take `{ payload }`. No-input actions take `{ payload: {} }`. Pass `null` or `undefined` only when the codec accepts it. There is no flat client.
-- Client effects fail with the declared errors, the group's policy errors, the binding's `errors`, `SchemaError` for local codec failures, and native `HttpClientError`. MCP-only actions are absent from the client.
+- Client effects fail with the declared errors, the group's policy errors, the binding's `errors`, `SchemaError` for local codec failures, and native `HttpClientError`.
 - Add authentication headers with the native `transformClient` option. Use `HttpApiClient.makeWith` for custom error or service channels. Native per-call response modes are available.
 - Wire format without a policy: input failure is an empty 400, success is the encoded body, a declared error is its JSON encoding with its `httpApiStatus`, an encoding failure is an empty 400, a defect is an empty 500. Full table in [guarantees.md](guarantees.md).
 - Each handler runs in a span named `<group>.<action>`, a child of the request span, attributed with `action.group`, `action.name` and `action.access`; its log lines carry the same annotations. The hook, decoding and encoding are outside it, in the request span.
 
 ## Failure modes
 
-- Route returns 404: the implementation was never passed to `Http.layer`, or the action has `http: false`, or the path lacks the group segment.
+- Route returns 404: the implementation was never passed to `Http.layer`, or its group is not bound by `make`, or the path lacks the group segment.
 - Type error listing `HttpRouter.Request.From<"Requires", CurrentActor>` as unsatisfied: a handler yields a request service and no middleware provides it. Wrap that `Http.layer` call with the middleware's `.layer`.
 - Two groups share a name: `make` throws. Rename one.
 - `Implementation of group "x" is not served by this adapter`: `Http.layer` received an implementation whose group was not passed to `ActionHttp.make`. Implement the exact shared group object bound by `make`, or add a genuinely new group to the binding. Matching names and schemas do not establish identity.
 - `Duplicate implementation group: <name>`: a single `Http.layer` call received more than one implementation of the same group. Pass one implementation per group.
-- Client method missing for an action: the action is `http: false`.
+- Client method missing for an action: its group is not bound by `make`.
 - Empty 400 on a valid-looking request: input did not decode. Set a `schemaError` policy on the group to get a typed body, and check `Content-Type: application/json`.
 - 415: wrong or missing content type.
 - `HttpClientError: Decode error (401 POST ...)` from a typed client: the surface answered with a status no endpoint declares. Add that error schema to `ActionHttp.make`'s `errors`.

package/docs/ActionHttpClient.md

@@ -7,17 +7,21 @@ page. It is Effect's native `HttpApiClient` over `fetch`, built once; each call
 
 Import `@gjermundgaraba/effect-actions/ActionHttpClient`.
 
-| API                       | Purpose                                                                       |
-| ------------------------- | ----------------------------------------------------------------------------- |
-| `promise(http, options?)` | `client.<group>.<action>(input)` for every HTTP-served 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.         |
-
-| Option    | Meaning                                                                                                                         |
-| --------- | ------------------------------------------------------------------------------------------------------------------------------- |
-| `baseUrl` | What routes are resolved against, such as `https://api.example.com`. Omitted: relative routes (the page's origin in a browser). |
-| `token`   | Sent as `Authorization: Bearer <token>` with every call.                                                                        |
-| `fetch`   | The transport. Defaults to the global `fetch`, looked up on each call.                                                          |
+| 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.
@@ -25,14 +29,16 @@ whose input may be empty (no `input`, or only optional fields) may be called wit
 ## Canonical
 
 ```ts
-import { HttpClientError } from "effect/unstable/http";
+import { HttpClient, HttpClientError, HttpClientRequest } from "effect/unstable/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",
-  token: "alice",
+  transformClient: HttpClient.mapRequest(HttpClientRequest.bearerToken("alice")),
 });
 
 export const userName = async (id: string): Promise<string> => {
@@ -52,8 +58,9 @@ export const userName = async (id: string): Promise<string> => {
 };
 ```
 
-Other headers, or reacting to a response every call may meet (a proxy's 401), go through
-`fetch`: `fetch: (input, init) => { const request = new Request(input, init); request.headers.set("x-agent", agent); return fetch(request); }`.
+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
 
@@ -61,7 +68,7 @@ Other headers, or reacting to a response every call may meet (a proxy's 401), go
 - 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, 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.
-- Only HTTP-served actions have methods. An action with `http: false` is absent, and so is a group without HTTP actions.
+- 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 }`.
 
@@ -70,4 +77,4 @@ Other headers, or reacting to a response every call may meet (a proxy's 401), go
 - Rejects with `HttpClientError` whose `reason._tag` is `StatusCodeError` 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 is `http: false`, or its group is not bound in this `Http`.
+- Property does not exist on the client: the action's group is not bound in this `Http`.

package/docs/ActionMcp.md

@@ -142,12 +142,12 @@ Layer.launch(layer).pipe(
 
 ## Rules
 
-- Both transports serve MCP 2026-07-28 and no other revision; there is no `protocols` option. Over HTTP the endpoint is stateless: no initialize handshake, no session, and every request stands alone. Effect owns version checks and rejects any other revision.
+- Both transports serve MCP 2026-07-28 and no other revision; there is no `protocols` option. Over HTTP the endpoint is stateless: no initialize handshake, no session, and every request stands alone. Effect owns version checks and rejects any other revision. Stdio has no sessions, so it could serve an older host, but it refuses one deliberately, for uniformity: a client that works over one transport works over the other.
 - `path` has no default. `layerHttp` uses the single-endpoint Streamable HTTP transport, never the two-endpoint HTTP+SSE form, whatever revision is negotiated.
 - Requests reaching the native MCP handler with an `Origin` header receive **403** unless that exact origin is listed in `allowedOrigins`. Requests without `Origin` pass this check. Authentication middleware wrapping the endpoint runs first and may reject the request before native Origin validation; the allowlist does not protect authentication from untrusted-origin requests.
 - `allowedOrigins` is an Origin allowlist, not CORS configuration. Cross-origin browser clients also need outer CORS middleware or a proxy to handle preflight and add response headers. Without it, an allowed-origin `OPTIONS` request receives **405** and even a successful `POST` has no `Access-Control-Allow-Origin`. Keep preflight outside authentication and apply CORS headers to refusals too.
 - An endpoint is one route. Middleware provided to `layerHttp` covers all of its tools. To serve tools under different middleware, mount them on different paths with separate `layerHttp` calls.
-- Only MCP-enabled actions become tools, under `mcp.name` with the resolved hints. A group with no tools is not built.
+- Only MCP-enabled actions become tools, under `mcp.name` with the resolved hints. A group with no tools is not built. The layer's types drop an action's requirements only when its type is certainly hidden (a literal `mcp: false`, see [Action.md](Action.md)); an `mcp` that may be `false` at runtime keeps them.
 - Every MCP-enabled action must have object-root input; the native server refuses anything else when the layer is built. Omit `input` for a tool with no arguments.
 - Success is `structuredContent: { value: <encoded success> }`. A declared error is an `isError` result whose text content is the error's JSON encoding, the same bytes HTTP sends as the body, and no `structuredContent`.
 - Invalid arguments and unencodable results are answered by the native `McpServer`: an `isError` result with a message for the model. Group `schemaError` policies do not apply.

package/docs/ActionToolkit.md

@@ -51,7 +51,7 @@ With a model: pass `binding.toolkit` as `toolkit` to `LanguageModel.generateText
 
 ## Rules
 
-- Selects MCP-enabled actions only, named by `mcp.name`, with resolved hints. Groups with no selected tools are not built. `make(apps, options?)` accepts a readonly implementation collection; options may be omitted.
+- Selects MCP-enabled actions only, named by `mcp.name`, with resolved hints. Groups with no selected tools are not built. The toolkit's type follows `ActionMcp`'s rule: only an action whose `mcp` type is exactly `false` has no tool; one whose `mcp` may be `false` at runtime is typed as a tool with its handler's requirements. `make(apps, options?)` accepts a readonly implementation collection; options may be omitted.
 - Successes are the action's native values. There is no `{ value }` wrapper. Declared failures are returned as native tool results (`failureMode: "return"`), not raised.
 - `tools.handle(name, encodedInput)` takes encoded arguments and returns an Effect producing a result stream. The handler starts while that stream is constructed, so request services must be provided around the entire `handle(...).pipe(Effect.flatMap(Stream.runCollect))`, not only around the stream.
 - `binding.layer` acquires each implementation once, in the layer's scope. Build-time requirements belong to the whole selected implementation.

package/docs/CONTEXT.md

@@ -5,7 +5,7 @@ use these words with these meanings.
 
 ## Terms
 
-- **Action**: one contract. A name, a description, an input schema, a success schema, declared error schemas, authorization metadata (`access`), and transport metadata (`http`, `mcp`). Holds no behavior. Made by `Action.make`.
+- **Action**: one contract. A name, a description, an input schema, a success schema, declared error schemas, authorization metadata (`access`), and MCP metadata (`mcp`). Holds no behavior. Made by `Action.make`.
 - **Access**: `"read"` or `"write"`, required on every action and kept as a literal. States what the action does to its resource. Authorization metadata read by a pre-handler hook, independent of the MCP `readOnly` hint, which defaults from it.
 - **Group**: a named, ordered set of actions plus group-level errors and an optional schema-error policy. Adapters serve groups, clients are organized by group, and the group name is the OpenAPI tag. Made by `ActionGroup.make`.
 - **Contract**: an action or a group. Pure data; safe to import anywhere, including browsers.
@@ -22,11 +22,10 @@ use these words with these meanings.
 - **Schema-error policy**: a group option answering Effect's `HttpApiSchemaError` with a declared policy error and its status: `invalid` when the request did not decode, `internal` when the handler's result did not encode. The library decides which applies. HTTP only.
 - **Policy error**: an error a schema-error policy may answer with. Part of the transport contract, never returnable by a handler.
 - **Surface error**: an error declared on an adapter binding rather than on an action. Produced by middleware around the surface or by its pre-handler hook, never by a handler; declared so typed callers decode it.
-- **Local-only action**: `http: false` and `mcp: false`. Reachable through `ActionCli` and listed in the catalog.
 - **Tool**: the MCP or Toolkit projection of an MCP-enabled action, named by `mcp.name` and carrying its hints.
 - **Endpoint**: one `ActionMcp.layerHttp` mount. One route, one middleware set, one tool registry.
 - **Document**: the OpenAPI output of `Http.api`, produced by Effect (`OpenApi.fromApi`) and served by `Http.openApi`.
-- **Promise client**: `ActionHttpClient.promise(Http)`, the native `HttpApiClient` as one Promise method per HTTP action, for code that does not run Effects. It rejects with what the native client fails with.
+- **Promise client**: `ActionHttpClient.promise(Http)`, the native `HttpApiClient` as one Promise method per action of the binding, for code that does not run Effects. It rejects with what the native client fails with.
 - **Catalog**: the offline JSON description of groups produced by `ActionCatalog.make`, with standalone JSON Schemas for encoded values. Descriptive only.
 - **Identity**: the per-request principal, provided by `Authentication.middleware` under an application-owned tag. Never provided at startup.
 

package/docs/guarantees.md

@@ -42,7 +42,7 @@ Defaults without a schema-error policy. HTTP is a native `HttpApi`; MCP is a nat
 
 - Group names are unique within one `ActionHttp.make`. Action names are unique within a group. MCP tool names are unique within a group and within each Toolkit or MCP projection that serves it.
 - Adapters validate only the namespace they serve. HTTP does not check tool names; MCP does not check route names.
-- Each adapter builds only what it serves. A group with no HTTP actions is not built by `Http.layer`; a group with no tools is not built by MCP or Toolkit.
+- Each adapter builds only what it serves. HTTP serves every action of a group it binds, so `Http.layer` builds every implementation it is given (except a group without actions); a group with no tools is not built by MCP or Toolkit.
 
 ## Observability
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gjermundgaraba/effect-actions",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "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": {