@gjermundgaraba/effect-actions 0.6.0 → 0.8.0

package/README.md

@@ -73,10 +73,10 @@ Code that does not run Effects, such as a browser page, gets the same calls as P
 ## Install
 
 ```sh
-pnpm add @gjermundgaraba/effect-actions effect@4.0.0-rc.117
+pnpm add @gjermundgaraba/effect-actions effect@4.0.0-rc.118
 ```
 
-Add `@effect/platform-node@4.0.0-rc.117` to serve from Node. Every module is a subpath import
+Add `@effect/platform-node@4.0.0-rc.118` to serve from Node. Every module is a subpath import
 (`.../Action`, `.../ActionHttp`, ...); there is no package root, so a contracts-only bundle
 never loads a server.
 
@@ -101,7 +101,7 @@ in `node_modules/@gjermundgaraba/effect-actions/docs`) gives the same content.
 
 ## Status
 
-The `effect` peer accepts any Effect 4.0 release candidate from `4.0.0-rc.116` on; the package
+The `effect` peer accepts any Effect 4.0 release candidate from `4.0.0-rc.118` on; the package
 is built and tested against the release candidate in its `devDependencies` (see [docs/setup.md](docs/setup.md)). Actions are unary JSON over HTTP and MCP: no streaming, uploads, prompts, or resources.
 Authentication and authorization belong to the application. See [docs/setup.md](docs/setup.md).
 

package/dist/Action.d.mts

@@ -21,16 +21,25 @@ export interface McpOptions {
   readonly idempotent?: boolean;
   /** `openWorldHint`; defaults to `true`. */
   readonly openWorld?: boolean;
+  /**
+   * A string field of the encoded success that MCP sends as a raw text block rather
+   * than as structured content, such as a document body. Other surfaces serve the
+   * whole success.
+   */
+  readonly text?: string;
 }
+/** The fields `mcp.text` may name: those an encoded success has as a string. */
+type TextFields<Encoded> = Encoded extends object ? { readonly [K in keyof Encoded]-?: Required<Encoded>[K] extends string ? K : never; }[keyof Encoded] & string : never;
 type ResolvedMcp<Name extends string, Mcp extends false | McpOptions | undefined> = Mcp extends false ? false : {
   readonly name: Mcp extends McpOptions ? "name" extends keyof Mcp ? Extract<Mcp["name"], string> extends never ? Name : Extract<Mcp["name"], string> | (undefined extends Mcp["name"] ? Name : never) : Name : Name;
   readonly readOnly: boolean;
   readonly destructive: boolean;
   readonly idempotent: boolean;
   readonly openWorld: boolean;
+  readonly text?: string;
 };
 /** 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 +52,44 @@ 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; } & {
+  readonly mcp?: false | (McpOptions & {
+    readonly text?: TextFields<O["success"]["Encoded"]>;
+  }) | undefined;
+}): 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

@@ -13,7 +13,8 @@ function make(name, options) {
 		readOnly,
 		destructive: options.mcp?.destructive ?? !readOnly,
 		idempotent: options.mcp?.idempotent ?? false,
-		openWorld: options.mcp?.openWorld ?? true
+		openWorld: options.mcp?.openWorld ?? true,
+		...options.mcp?.text === void 0 ? {} : { text: options.mcp.text }
 	};
 	if (mcp !== false && mcp.name.length > 128) throw new Error(`Invalid MCP name: ${mcp.name}`);
 	if (mcp !== false) assertName("MCP name", mcp.name);
@@ -24,7 +25,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

@@ -1,9 +1,12 @@
 import { assertDistinct, policyErrors } from "./internal/actions.mjs";
 import { JsonSchema, Schema } from "effect";
 //#region src/ActionCatalog.ts
-/** Describe the JSON wire form; decoding on the server remains authoritative. */
+/**
+* Describe the JSON wire form closed, as the OpenAPI document does; decoding on the
+* server remains authoritative.
+*/
 const describe = (codec) => {
-	const { schema, definitions } = Schema.toJsonSchemaDocument(codec);
+	const { schema, definitions } = Schema.toJsonSchemaDocument(codec, { onExcessProperty: "error" });
 	return {
 		$schema: JsonSchema.META_SCHEMA_URI_DRAFT_2020_12,
 		...schema,
@@ -13,23 +16,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/ActionCli.d.mts

@@ -3,7 +3,7 @@ import { Actions } from "./internal/actions.mjs";
 import { HandlerContext, Handlers, HandlersContext, Implementation } from "./internal/implementation.mjs";
 import { Options as Options$1 } from "./internal/cli.mjs";
 import { Effect, Scope } from "effect";
-import { Command } from "effect/unstable/cli";
+import { Command } from "effect/cli";
 //#region src/ActionCli.d.ts
 /**
  * The hook a local command runs before the selected handler. A CLI does not serialize

package/dist/ActionCli.mjs

@@ -2,7 +2,7 @@ import { selectNamed } from "./internal/actions.mjs";
 import { dispatch } from "./internal/implementation.mjs";
 import { command as command$1 } from "./internal/cli.mjs";
 import { Effect } from "effect";
-import { Command } from "effect/unstable/cli";
+import { Command } from "effect/cli";
 //#region src/ActionCli.ts
 /**
 * Acquire the implementation in a scope of its own, run one action through the hook

package/dist/ActionCliClient.d.mts

@@ -1,12 +1,11 @@
 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";
-import { HttpClient } from "effect/unstable/http";
-import { HttpApi, HttpApiClient, HttpApiEndpoint, HttpApiGroup } from "effect/unstable/httpapi";
-import { Command } from "effect/unstable/cli";
+import { HttpClient } from "effect/http";
+import { HttpApi, HttpApiClient, HttpApiEndpoint, HttpApiGroup } from "effect/http-api";
+import { Command } from "effect/cli";
 //#region src/ActionCliClient.d.ts
 /**
  * What the host configures on Effect's native client: `baseUrl`, `transformClient`,
@@ -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

@@ -1,9 +1,9 @@
 import { selectNamed } from "./internal/actions.mjs";
 import { command as command$1 } from "./internal/cli.mjs";
 import { Effect } from "effect";
-import { HttpClient } from "effect/unstable/http";
-import { HttpApiClient } from "effect/unstable/httpapi";
-import { Command } from "effect/unstable/cli";
+import { HttpClient } from "effect/http";
+import { HttpApiClient } from "effect/http-api";
+import { Command } from "effect/cli";
 //#region src/ActionCliClient.ts
 /**
 * The native endpoint builder needs string selectors for a runtime-selected route.
@@ -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;
 };
@@ -21,7 +16,6 @@ function make(options, ...declared) {
 		errors: [...action.errors, ...options.errors ?? []]
 	}));
 	assertDistinct("action", actions.map((action) => action.name));
-	assertDistinct("MCP tool", actions.flatMap((action) => action.mcp === false ? [] : [action.mcp.name]));
 	const group = {
 		name,
 		actions,

package/dist/ActionHttp.d.mts

@@ -2,8 +2,8 @@ import { Action_d_exports, Any, Codec } from "./Action.mjs";
 import { Actions, PolicyError } from "./internal/actions.mjs";
 import { AnyImplementation, BuildContext, BuildError, RequestContext } from "./internal/implementation.mjs";
 import { Effect, Layer, Schema } from "effect";
-import { Etag, HttpPlatform, HttpRouter } from "effect/unstable/http";
-import { HttpApi, HttpApiEndpoint, HttpApiGroup } from "effect/unstable/httpapi";
+import { Etag, HttpPlatform, HttpRouter } from "effect/http";
+import { HttpApi, HttpApiEndpoint, HttpApiGroup } from "effect/http-api";
 import { FileSystem } from "effect/FileSystem";
 import { Path } from "effect/Path";
 declare namespace ActionHttp_d_exports {
@@ -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

@@ -1,10 +1,9 @@
 import { answerSchemaError, assertDistinct, policyErrors, projectedErrors } from "./internal/actions.mjs";
 import { dispatch } from "./internal/implementation.mjs";
 import { Effect, Layer } from "effect";
-import { HttpRouter, HttpServerResponse } from "effect/unstable/http";
-import { HttpApi, HttpApiBuilder, HttpApiEndpoint, HttpApiGroup, HttpApiMiddleware, OpenApi } from "effect/unstable/httpapi";
+import { HttpRouter, HttpServerResponse } from "effect/http";
+import { HttpApi, HttpApiBuilder, HttpApiEndpoint, HttpApiGroup, HttpApiMiddleware, OpenApi } from "effect/http-api";
 //#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 {
@@ -34,7 +33,10 @@ function bind(options, group) {
 }
 function apiOf(groups) {
 	const [first, ...rest] = groups;
-	const empty = HttpApi.make("actions").annotate(HttpApi.ParseOptions, { errors: "all" });
+	const empty = HttpApi.make("actions").annotate(HttpApi.PayloadParseOptions, {
+		errors: "all",
+		onExcessProperty: "error"
+	});
 	return first === void 0 ? empty : empty.add(first, ...rest);
 }
 /**
@@ -49,7 +51,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,9 +1,9 @@
 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";
-import { McpSchema, McpServer } from "effect/unstable/ai";
+import { HttpRouter } from "effect/http";
+import { McpSchema, McpServer } from "effect/ai";
 import { Stdio } from "effect/Stdio";
 //#region src/ActionMcp.d.ts
 /**
@@ -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