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

package/dist/ActionCli.d.mts

@@ -0,0 +1,27 @@
+import { Action_d_exports, Any, Handler } from "./Action.mjs";
+import { Actions } from "./internal/actions.mjs";
+import { HandlerContext, Handlers, HandlersContext, Implementation } from "./internal/implementation.mjs";
+import { Options } from "./internal/cli.mjs";
+import { Scope } from "effect";
+import { Command } from "effect/unstable/cli";
+//#region src/ActionCli.d.ts
+/** Configuration for an aggregate group command. */
+export interface GroupOptions {
+  /** Override the group command name. */
+  readonly name?: string;
+}
+type Selected<G extends Actions, Name extends G["actions"][number]["name"]> = Extract<G["actions"][number], {
+  readonly name: Name;
+}>;
+type BoundHandler<Name extends string, A extends Any, R> = Readonly<Record<Name, Handler<A, R>>>;
+/**
+ * Project one explicitly selected local action into a native Effect CLI command.
+ * The action name resolves against the bound group; no HTTP fallback exists.
+ */
+export declare const command: <G extends Actions, Name extends G["actions"][number]["name"], H extends BoundHandler<Name, Selected<G, Name>, HandlerContext<H, Name>>, EX, RX, Parameters extends Command.Command.Config = never>(app: Implementation<G, H, EX, RX>, name: Name, options?: Options<Selected<G, Name>["success"]["Type"], Parameters>) => Command.Command<string, never, {}, EX | import("effect/Schema").SchemaError | Extract<G["actions"][number], {
+  readonly name: Name;
+}>["errors"][number]["Type"], Exclude<RX, Scope.Scope> | Exclude<HandlerContext<H, Name>, Scope.Scope>>;
+/** Project every local action below its group namespace with default CLI options. */
+export declare const group: <G extends Actions, H extends Handlers<HandlersContext<H>>, EX, RX>(app: Implementation<G, H, EX, RX>, options?: GroupOptions) => Command.Command<string, {}, {}, EX | import("effect/Schema").SchemaError | G["actions"][number]["errors"][number]["Type"], Exclude<Exclude<RX, Scope.Scope>, Command.CommandContext<string>> | Exclude<Exclude<HandlersContext<H>, Scope.Scope>, Command.CommandContext<string>>>;
+//#endregion
+export type { Options };

package/dist/ActionCli.mjs

@@ -0,0 +1,26 @@
+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";
+//#region src/ActionCli.ts
+const select = (group, name) => {
+	const action = group.actions.find((candidate) => candidate.name === name);
+	if (action === void 0) throw new Error(`Unknown action "${group.name}.${name}"`);
+	return action;
+};
+const local = (app, action, input) => Effect.scoped(Effect.flatMap(app.build, (handlers) => dispatch(app.group, action, handlers)(input)));
+/**
+* Project one explicitly selected local action into a native Effect CLI command.
+* The action name resolves against the bound group; no HTTP fallback exists.
+*/
+const command = (app, name, options) => {
+	const action = select(app.group, name);
+	return command$1(action, (input) => local(app, action, input), options);
+};
+/** Project every local action below its group namespace with default CLI options. */
+const group = (app, options) => {
+	const commands = app.group.actions.map((action) => command$1(action, (input) => Effect.scoped(Effect.flatMap(app.build, (handlers) => dispatch(app.group, action, handlers)(input)))));
+	return Command.make(options?.name ?? app.group.name).pipe(Command.withSubcommands(commands));
+};
+//#endregion
+export { command, group };

package/dist/ActionCliClient.d.mts

@@ -0,0 +1,45 @@
+import { Actions } from "./internal/actions.mjs";
+import { Options as Options$1 } from "./internal/cli.mjs";
+import { ActionHttp_d_exports, Api, Http } from "./ActionHttp.mjs";
+import { Effect } from "effect";
+import { HttpApi, HttpApiClient, HttpApiEndpoint, HttpApiGroup } from "effect/unstable/httpapi";
+import { Command } from "effect/unstable/cli";
+import { HttpClient } from "effect/unstable/http";
+//#region src/ActionCliClient.d.ts
+/** Parsing, rendering and native HTTP-endpoint configuration for one remote action. */
+export type Options<Output, ParsedParameters extends Command.Command.Config = never> = Options$1<Output, ParsedParameters> & {
+  /** Passed directly to Effect's native `HttpApiClient.endpoint`. */
+  readonly connection?: NonNullable<globalThis.Parameters<typeof HttpApiClient.make>[1]>;
+};
+/** Configuration for a remote aggregate group command. */
+export interface GroupOptions {
+  /** Override the group command name. */
+  readonly name?: string;
+  /** Shared native HTTP-endpoint configuration for every remote action. */
+  readonly connection?: NonNullable<globalThis.Parameters<typeof HttpApiClient.make>[1]>;
+}
+type Group<Groups extends ReadonlyArray<Actions>, Name extends Groups[number]["name"]> = Extract<Groups[number], {
+  readonly name: Name;
+}>;
+type Selected<G extends Actions, Name extends G["actions"][number]["name"]> = Extract<G["actions"][number], {
+  readonly name: Name;
+}>;
+type HttpNames<G extends Actions> = Extract<G["actions"][number], {
+  readonly http: true;
+}>["name"];
+type ApiGroups<Groups extends ReadonlyArray<Actions>> = Api<Groups[number]> extends HttpApi.HttpApi<"actions", infer ApiGroups> ? ApiGroups : never;
+type Endpoint<Groups extends ReadonlyArray<Actions>, GroupName extends Groups[number]["name"], ActionName extends HttpNames<Group<Groups, GroupName>>> = Extract<HttpApiGroup.EndpointsWithIdentifier<ApiGroups<Groups>, Extract<GroupName, HttpApiGroup.Identifier<ApiGroups<Groups>>>>, {
+  readonly identifier: ActionName;
+}>;
+type NativeMethod<Groups extends ReadonlyArray<Actions>, GroupName extends Groups[number]["name"], ActionName extends HttpNames<Group<Groups, GroupName>>> = HttpApiClient.Client.Method<Extract<Endpoint<Groups, GroupName, ActionName>, HttpApiEndpoint.ConstraintRequest>, never, never>;
+type RemoteCommand<Groups extends ReadonlyArray<Actions>, GroupName extends Groups[number]["name"], ActionName extends HttpNames<Group<Groups, GroupName>>> = Command.Command<string, never, {}, Effect.Error<ReturnType<NativeMethod<Groups, GroupName, ActionName>>>, HttpClient.HttpClient | Effect.Services<ReturnType<NativeMethod<Groups, GroupName, ActionName>>>>;
+type RemoteGroupCommand<Groups extends ReadonlyArray<Actions>, GroupName extends Groups[number]["name"]> = Command.Command<string, {}, {}, Effect.Error<ReturnType<NativeMethod<Groups, GroupName, HttpNames<Group<Groups, GroupName>>>>>, HttpClient.HttpClient | Effect.Services<ReturnType<NativeMethod<Groups, GroupName, HttpNames<Group<Groups, GroupName>>>>>>;
+/**
+ * Project one HTTP action retained by 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 GroupName extends Groups[number]["name"], const ActionName extends HttpNames<Group<Groups, GroupName>>, ParsedParameters extends Command.Command.Config = never>(http: Http<Groups>, groupName: GroupName, actionName: ActionName, options?: Options<Selected<Group<Groups, GroupName>, ActionName>["success"]["Type"], ParsedParameters>) => RemoteCommand<Groups, GroupName, ActionName>;
+/** Project all HTTP-enabled actions retained by one group below its group namespace. */
+export declare const group: <const Groups extends ReadonlyArray<Actions>, const GroupName extends Groups[number]["name"]>(http: Http<Groups>, groupName: GroupName, options?: GroupOptions) => RemoteGroupCommand<Groups, GroupName>;
+//#endregion

package/dist/ActionCliClient.mjs

@@ -0,0 +1,52 @@
+import { command as command$1 } from "./internal/cli.mjs";
+import { Effect } from "effect";
+import { HttpApiClient } from "effect/unstable/httpapi";
+import { Command } from "effect/unstable/cli";
+import { HttpClient } from "effect/unstable/http";
+//#region src/ActionCliClient.ts
+/**
+* The native endpoint builder needs string selectors for a runtime-selected route.
+* `http.groups` is checked before this widening, and `NativeMethod` restores the
+* corresponding precise endpoint type at that one dynamic client boundary.
+*/
+const erasedApi = (api) => {
+	return api;
+};
+const selectGroup = (groups, name) => {
+	const group = groups.find((candidate) => candidate.name === name);
+	if (group === void 0) throw new Error(`Unknown HTTP group "${name}"`);
+	return group;
+};
+const selectAction = (group, name) => {
+	const action = group.actions.find((candidate) => candidate.name === name);
+	if (action === void 0 || !action.http) throw new Error(`Unknown HTTP action "${group.name}.${name}"`);
+	return action;
+};
+/**
+* Project one HTTP action retained by 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 = selectGroup(http.groups, groupName);
+	const action = selectAction(group, actionName);
+	return command$1(action, (input) => Effect.flatMap(HttpClient.HttpClient, (httpClient) => {
+		const endpoint = HttpApiClient.endpoint(erasedApi(http.api), {
+			group: groupName,
+			endpoint: actionName,
+			httpClient,
+			...options?.connection
+		});
+		return Effect.flatMap(endpoint, (method) => {
+			return method({ payload: input });
+		});
+	}), options);
+};
+/** Project all HTTP-enabled actions retained by one group below its group namespace. */
+const group = (http, groupName, options) => {
+	const actions = selectGroup(http.groups, 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 })] : []);
+	return Command.make(options?.name ?? actions.name).pipe(Command.withSubcommands(commands));
+};
+//#endregion
+export { command, group };

package/dist/ActionGroup.d.mts

@@ -1,21 +1,30 @@
-import { Any, Handler, t as Action_d_exports } from "./Action.mjs";
-import { t as Implementation } from "./implementation-D75QAcD3.mjs";
+import { Action, Action_d_exports, Any as Any$1, Codec, Handler } from "./Action.mjs";
+import { Actions, SchemaErrorPolicy } from "./internal/actions.mjs";
+import { Implementation } from "./internal/implementation.mjs";
 import { Effect, Scope } from "effect";
 declare namespace ActionGroup_d_exports {
-  export { Group, Implementation, make };
+  export { Any, Group, Implementation, Options, SchemaErrorPolicy, make };
 }
-type HandlersFrom<Actions extends ReadonlyArray<Any>> = { readonly [A in Actions[number] as A["name"]]: Handler<A, any>; };
-type HandlersContext<H> = { [K in keyof H]: H[K] extends ((input: never) => Effect.Effect<infer _A, infer _E, infer R>) ? R : never; }[keyof H];
-export interface Group<Actions extends ReadonlyArray<Any>> {
-  readonly actions: Actions;
-  /**
-   * Bind every handler at once. Pass an Effect to resolve build-time services
-   * once (`const users = yield* Users`); services yielded inside a handler are
-   * request-scoped instead. Scoped acquisition lasts for the adapter runtime.
-   */
-  readonly implement: <H extends HandlersFrom<Actions>, EX = never, RX = never>(build: H | Effect.Effect<H, EX, RX>) => Implementation<Actions, HandlersContext<H>, EX, Exclude<RX, Scope.Scope>>;
+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 Http, infer Mcp> ? Action<Name, Input, Output, readonly [...Own, ...Errors], Http, Mcp> : never; };
+/** What `make` needs to define a group. */
+export interface Options<Name extends string, Errors extends ReadonlyArray<Codec>, PolicyErrors extends ReadonlyArray<Codec>> {
+  /** The `HttpApiGroup` identifier, and so the OpenAPI tag and operation-ID prefix. */
+  readonly name: Name;
+  /** Failures every action of the group may have, added to each action's own. */
+  readonly errors?: Errors;
+  /** How HTTP answers failed decoding or encoding of these actions; MCP keeps its native answers. */
+  readonly schemaError?: SchemaErrorPolicy<PolicyErrors>;
 }
-/** Duplicate action and MCP names fail at definition time. */
-export declare const make: <const Actions extends ReadonlyArray<Any>>(...actions: Actions) => Group<Actions>;
+/** A named set of action contracts: what adapters serve and what `implement` binds. */
+export interface Group<Name extends string, Actions$1 extends ReadonlyArray<Any$1>, PolicyErrors extends ReadonlyArray<Codec> = ReadonlyArray<Codec>> extends Actions<Name, Actions$1, PolicyErrors> {
+  /** Bind every handler at once, resolving build-time services once per adapter layer. */
+  readonly implement: <H extends HandlersFrom<Actions$1>, EX = never, RX = never>(build: H | Effect.Effect<H, EX, RX>) => Implementation<Group<Name, Actions$1, PolicyErrors>, H, NoInfer<EX>, NoInfer<Exclude<RX, Scope.Scope>>>;
+}
+/** Any group, with its actions erased. */
+export type Any = Group<string, ReadonlyArray<Any$1>>;
+/** Define a group. Invalid or duplicate action and MCP names fail here, at definition time. */
+export declare function make<const Name extends string, const Actions extends ReadonlyArray<Any$1>, const Errors extends ReadonlyArray<Codec> = [], const PolicyErrors extends ReadonlyArray<Codec> = []>(options: Options<Name, Errors, PolicyErrors>, ...actions: Actions): Group<Name, WithErrors<Actions, Errors>, PolicyErrors>;
 //#endregion
-export { type Implementation, ActionGroup_d_exports as t };
+export { ActionGroup_d_exports, type Implementation, type SchemaErrorPolicy };

package/dist/ActionGroup.mjs

@@ -1,27 +1,26 @@
-import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
-import { t as Implementation } from "./implementation-BkLqMWtv.mjs";
+import { assertDistinct, assertName } from "./internal/actions.mjs";
+import { Implementation } from "./internal/implementation.mjs";
 import { Effect } from "effect";
 //#region src/ActionGroup.ts
-var ActionGroup_exports = /* @__PURE__ */ __exportAll({ make: () => make });
-/** Duplicate action and MCP names fail at definition time. */
-const make = (...actions) => {
-	const names = /* @__PURE__ */ new Set();
-	const toolNames = /* @__PURE__ */ new Set();
-	for (const action of actions) {
-		if (names.has(action.name)) throw new Error(`Duplicate action: ${action.name}`);
-		names.add(action.name);
-		if (action.mcp !== false) {
-			if (toolNames.has(action.mcp.name)) throw new Error(`Duplicate MCP tool: ${action.mcp.name}`);
-			toolNames.add(action.mcp.name);
-		}
-	}
-	return {
+function make(options, ...declared) {
+	const { name } = options;
+	assertName("action group name", name);
+	const actions = declared.map((action) => ({
+		...action,
+		errors: [...action.errors, ...options.errors ?? []]
+	}));
+	assertDistinct("action", actions.map((action) => action.name));
+	assertDistinct("MCP tool", actions.flatMap((action) => action.mcp === false ? [] : [action.mcp.name]));
+	const group = {
+		name,
 		actions,
+		schemaError: options.schemaError,
 		implement: (build) => {
 			const built = Effect.isEffect(build) ? build : Effect.succeed(build);
-			return Implementation.make(actions, built);
+			return Implementation.make(group, built);
 		}
 	};
-};
+	return group;
+}
 //#endregion
-export { make, ActionGroup_exports as t };
+export { make };

package/dist/ActionHttp.d.mts

@@ -0,0 +1,39 @@
+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 { Layer, Schema } from "effect";
+import { HttpApi, HttpApiEndpoint, HttpApiGroup } from "effect/unstable/httpapi";
+import { Etag, HttpPlatform, HttpRouter } from "effect/unstable/http";
+import { FileSystem } from "effect/FileSystem";
+import { Path } from "effect/Path";
+declare namespace ActionHttp_d_exports {
+  export { Api, Http, Options, make };
+}
+/** Contract-level configuration: servers and clients must agree on it. */
+export interface Options {
+  readonly apiPath: `/${string}`;
+}
+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 ApiGroup<G extends Actions> = G extends Actions ? [Endpoint<G["actions"][number], never>] extends [never] ? never : HttpApiGroup.HttpApiGroup<G["name"], Endpoint<G["actions"][number], PolicyError<G>>> : never;
+/** The native `HttpApi` of every HTTP-enabled action of `G`, one group per action group. */
+export type Api<G extends Actions> = HttpApi.HttpApi<"actions", ApiGroup<G>>;
+/** A namespaced HTTP binding. */
+export interface Http<Groups extends ReadonlyArray<Actions>> {
+  /** The exact contracts bound to this HTTP adapter, in declaration order. */
+  readonly groups: Groups;
+  readonly api: Api<Groups[number]>;
+  /**
+   * Serve any number of implementations in one layer. Build failures, build
+   * services and request services are unions over precisely those apps.
+   */
+  readonly layer: <const Apps extends ReadonlyArray<AnyImplementation<Groups[number]>>>(...apps: Apps) => Layer.Layer<never, BuildError<Apps[number]>, BuildContext<Apps[number]> | HttpRouter.HttpRouter | HttpRouter.Request.From<"Requires", RequestContext<Apps[number]>> | Etag.Generator | FileSystem | HttpPlatform.HttpPlatform | Path>;
+}
+/**
+ * Bind the contract-level configuration once. Every route is `POST
+ * <apiPath>/<group>/<action>`, so action names may repeat across groups.
+ */
+export declare function make<const G extends ReadonlyArray<Actions>>(options: Options, ...groups: G): Http<G>;
+//#endregion
+export { ActionHttp_d_exports };

package/dist/ActionHttp.mjs

@@ -0,0 +1,67 @@
+import { assertDistinct } from "./internal/actions.mjs";
+import { dispatch } from "./internal/implementation.mjs";
+import { Effect, Layer } from "effect";
+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 = (apiPath, group, action) => HttpApiEndpoint.post(action.name, `${apiPath}/${group.name}/${action.name}`, {
+	payload: action.input,
+	success: action.success,
+	error: [...action.errors, ...group.schemaError?.errors ?? []]
+}).annotate(OpenApi.Description, action.description);
+function erasedApi(groups, options) {
+	const [first, ...rest] = groups.flatMap((group) => {
+		const [first, ...rest] = httpActions(group).map((action) => endpoint(options.apiPath, group, action));
+		return first === void 0 ? [] : [HttpApiGroup.make(group.name).add(first, ...rest)];
+	});
+	const empty = HttpApi.make("actions");
+	return first === void 0 ? empty : empty.add(first, ...rest);
+}
+const schemaErrorMiddleware = (policy) => {
+	class SchemaErrors extends HttpApiMiddleware.Service()("effect-actions/http/SchemaErrors", { error: policy.errors }) {}
+	return {
+		SchemaErrors,
+		layer: HttpApiMiddleware.layerSchemaErrorTransform(SchemaErrors, (failure) => Effect.fail(policy.map(failure)))
+	};
+};
+/**
+* `HttpApiBuilder.handleAll` registers a dynamically assembled record. The
+* action selected by the native router determines the input before `dispatch`
+* calls its handler, so this is the one adapter boundary where exact handlers
+* are viewed as an erased record. `HandlersContext` remains on the dispatch
+* effect and is restored by `Http.layer`'s public signature.
+*/
+const erasedHandlers = (handlers) => {
+	return handlers;
+};
+/** Build routes for one group. Handler erasure is limited to native dynamic endpoint registration. */
+const groupLayer = (options, app) => {
+	const actions = httpActions(app.group);
+	if (actions.length === 0) return Layer.empty;
+	const api = erasedApi([app.group], options);
+	const entries = (record) => Object.fromEntries(actions.map((action) => [action.name, (request) => dispatch(app.group, action, record)(request.payload)]));
+	const handlers = (record) => HttpApiBuilder.group(api, app.group.name, (builder) => builder.handleAll(entries(record)));
+	if (app.group.schemaError === void 0) return Layer.unwrap(Effect.map(app.build, (record) => HttpApiBuilder.layer(api).pipe(Layer.provide(handlers(erasedHandlers(record))))));
+	const schemaErrors = schemaErrorMiddleware(app.group.schemaError);
+	const policyApi = api.middleware(schemaErrors.SchemaErrors);
+	const policyHandlers = (record) => HttpApiBuilder.group(policyApi, app.group.name, (builder) => {
+		const dynamicEntries = entries(record);
+		return builder.handleAll(dynamicEntries);
+	});
+	return Layer.unwrap(Effect.map(app.build, (record) => HttpApiBuilder.layer(policyApi).pipe(Layer.provide(policyHandlers(erasedHandlers(record))), Layer.provide(schemaErrors.layer))));
+};
+function make(options, ...groups) {
+	assertDistinct("action group", groups.map((group) => group.name));
+	const layer = (...apps) => {
+		assertDistinct("implementation group", apps.map((app) => app.group.name));
+		for (const app of apps) if (!groups.includes(app.group)) throw new Error(`Implementation of group "${app.group.name}" is not served by this adapter`);
+		return apps.map((app) => groupLayer(options, app)).reduce((all, app) => Layer.merge(all, app), Layer.empty);
+	};
+	return {
+		groups,
+		api: erasedApi(groups, options),
+		layer
+	};
+}
+//#endregion
+export { make };

package/dist/ActionMcp.d.mts

@@ -0,0 +1,41 @@
+import { AnyImplementation, BuildContext, BuildError, RequestContext } from "./internal/implementation.mjs";
+import { Cause, Layer } from "effect";
+import { McpServer } from "effect/unstable/ai";
+import { HttpRouter } from "effect/unstable/http";
+import { Stdio } from "effect/Stdio";
+//#region src/ActionMcp.d.ts
+/** One Streamable HTTP MCP endpoint; its fields become the native server info. */
+export interface Options {
+  readonly name: string;
+  readonly version: string;
+  /** Native protocol adapters to serve; negotiation and sessions are owned by Effect. */
+  readonly protocols: Parameters<typeof McpServer.layerHttp>[0]["protocols"];
+  /** Route of the Streamable HTTP endpoint; no default. */
+  readonly path: HttpRouter.PathInput;
+  /** Browser origins accepted by the native server; passed through to `McpServer.layerHttp`. */
+  readonly allowedOrigins?: ReadonlyArray<string>;
+  readonly instructions?: string;
+}
+/** Server information for an MCP subprocess connected through standard I/O. */
+export interface StdioOptions {
+  readonly name: string;
+  readonly version: string;
+  /** Native protocol adapters to serve; negotiation is owned by Effect. */
+  readonly protocols: Parameters<typeof McpServer.layerStdio>[0]["protocols"];
+  readonly instructions?: string;
+}
+/**
+ * Serve MCP tools over one Streamable HTTP endpoint.
+ *
+ * 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>>(options: Options, ...apps: Apps): Layer.Layer<never, BuildError<Apps[number]> | Cause.IllegalArgumentError, BuildContext<Apps[number]> | HttpRouter.HttpRouter | HttpRouter.Request.From<"Requires", RequestContext<Apps[number]>>>;
+/**
+ * Serve MCP tools through newline-delimited JSON-RPC on standard I/O.
+ *
+ * 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>>(options: StdioOptions, ...apps: Apps): Layer.Layer<never, BuildError<Apps[number]> | Cause.IllegalArgumentError, BuildContext<Apps[number]> | Stdio | RequestContext<Apps[number]>>;
+//#endregion

package/dist/ActionMcp.mjs

@@ -0,0 +1,25 @@
+import "./internal/implementation.mjs";
+import { bindTools } from "./internal/tools.mjs";
+import { Layer } from "effect";
+import { McpServer } from "effect/unstable/ai";
+//#region src/ActionMcp.ts
+const registration = (apps) => {
+	const binding = bindTools(apps, "mcp");
+	return Layer.effectDiscard(McpServer.registerToolkit(binding.toolkit)).pipe(Layer.provide(binding.layer));
+};
+const server = (apps, transport) => registration(apps).pipe(Layer.provide(transport), Layer.fresh);
+function layerHttp(options, ...apps) {
+	return server(apps, McpServer.layerHttp({
+		name: options.name,
+		version: options.version,
+		instructions: options.instructions,
+		path: options.path,
+		protocols: options.protocols,
+		allowedOrigins: options.allowedOrigins
+	}));
+}
+function layerStdio(options, ...apps) {
+	return server(apps, McpServer.layerStdio(options));
+}
+//#endregion
+export { layerHttp, layerStdio };

package/dist/ActionToolkit.d.mts

@@ -0,0 +1,37 @@
+import { Action_d_exports, Any } from "./Action.mjs";
+import { AnyImplementation, BuildContext, BuildError, HandlerContext, Implementation } from "./internal/implementation.mjs";
+import { Layer, Schema } from "effect";
+import { Tool, Toolkit } from "effect/unstable/ai";
+//#region src/ActionToolkit.d.ts
+/** A native tool corresponding to an MCP-enabled action. */
+type NativeTool<A extends Any, R> = A extends {
+  readonly mcp: {
+    readonly name: infer Name extends string;
+  };
+} ? Tool.Tool<Name, {
+  readonly parameters: A["input"];
+  readonly success: A["success"];
+  readonly failure: Schema.Union<A["errors"]>;
+  readonly failureMode: "return";
+}, R> : never;
+type HandlersOf<App extends AnyImplementation> = App extends Implementation<any, infer H, any, any> ? H : never;
+type ToolForAction<App extends AnyImplementation, A extends Any> = A extends {
+  readonly mcp: object;
+} ? NativeTool<A, HandlerContext<HandlersOf<App>, Extract<A["name"], keyof HandlersOf<App>>>> : never;
+type ToolsFor<App extends AnyImplementation> = App extends AnyImplementation ? ToolForAction<App, App["group"]["actions"][number]> : never;
+type ToolkitTools<Apps extends ReadonlyArray<AnyImplementation>> = { readonly [T in ToolsFor<Apps[number]> as T["name"]]: T; };
+/** Native tools and the layer that binds their action implementations. */
+export interface Binding<Tools extends Record<string, Tool.Any>, E = never, R = never> {
+  readonly toolkit: Toolkit.Toolkit<Tools>;
+  /** Acquires handlers once in the layer scope; handler requirements remain at invocation. */
+  readonly layer: Layer.Layer<Tool.HandlersFor<Tools>, E, R>;
+}
+/**
+ * Project implementations into Effect's native AI toolkit.
+ *
+ * Unlike MCP, calls return the action's native success/failure values directly.
+ * 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>>(...apps: Apps): Binding<ToolkitTools<Apps>, BuildError<Apps[number]>, BuildContext<Apps[number]>>;
+//#endregion

package/dist/ActionToolkit.mjs

@@ -0,0 +1,10 @@
+import "./internal/implementation.mjs";
+import { bindTools } from "./internal/tools.mjs";
+import "effect";
+import "effect/unstable/ai";
+//#region src/ActionToolkit.ts
+function make(...apps) {
+	return bindTools(apps, "native");
+}
+//#endregion
+export { make };

package/dist/Authentication.d.mts

@@ -0,0 +1,46 @@
+import { Context, Effect } from "effect";
+import { HttpRouter, HttpServerResponse } from "effect/unstable/http";
+import { NonEmptyReadonlyArray } from "effect/Array";
+//#region src/Authentication.d.ts
+/**
+ * Authenticate each request and provide its identity to the downstream handler.
+ * `authenticate` fails with the response to send instead, so the host owns its
+ * status, body and challenge headers. Dependencies remain native router request
+ * requirements. Acquired resources live until the request scope closes, including
+ * while the handler is running. Every response is marked `Cache-Control: no-store`,
+ * including private failures serialized by enclosing middleware.
+ */
+export declare const middleware: <I, A, R>(service: Context.Key<I, A>, authenticate: Effect.Effect<NoInfer<A>, HttpServerResponse.HttpServerResponse, R>) => HttpRouter.Middleware<{
+  provides: I;
+  handles: never;
+  error: never;
+  requires: Exclude<R, HttpRouter.Provided> | Exclude<Exclude<import("effect/Types").NoInfer<I>, I>, HttpRouter.Provided>;
+  layerError: never;
+  layerRequires: never;
+}>;
+/** RFC 9728 metadata to publish; the host is responsible for these being valid OAuth URLs. */
+export interface ProtectedResourceOptions {
+  /** Exact OAuth resource identifier; its path and query select the discovery path. */
+  readonly resource: string;
+  readonly authorizationServers: NonEmptyReadonlyArray<string>;
+  readonly scopesSupported?: ReadonlyArray<string>;
+  readonly resourceName?: string;
+}
+/** Parameters of one `WWW-Authenticate: Bearer` challenge, RFC 6750 §3. */
+export interface BearerChallengeOptions {
+  readonly error?: "invalid_token" | "insufficient_scope";
+  readonly errorDescription?: string;
+  /** Space-separated scopes needed for this request, not all supported scopes. */
+  readonly scope?: string;
+}
+/**
+ * Publish RFC 9728 discovery independently from the authenticated routes.
+ * This supplies metadata and challenges; the host still verifies access tokens.
+ */
+export declare const protectedResource: (options: ProtectedResourceOptions) => {
+  layer: import("effect/Layer").Layer<never, never, HttpRouter.HttpRouter>;
+  metadataUrl: string;
+  /** The `WWW-Authenticate` value; parameter values are quoted and escaped. */
+  challenge: (challenge?: BearerChallengeOptions) => string;
+};
+//#endregion

package/dist/Authentication.mjs

@@ -0,0 +1,55 @@
+import { Effect } from "effect";
+import { HttpEffect, HttpRouter, HttpServerRequest, HttpServerResponse } from "effect/unstable/http";
+//#region src/Authentication.ts
+/**
+* Authenticate each request and provide its identity to the downstream handler.
+* `authenticate` fails with the response to send instead, so the host owns its
+* status, body and challenge headers. Dependencies remain native router request
+* requirements. Acquired resources live until the request scope closes, including
+* while the handler is running. Every response is marked `Cache-Control: no-store`,
+* including private failures serialized by enclosing middleware.
+*/
+const middleware = (service, authenticate) => HttpRouter.middleware()((httpEffect) => authenticate.pipe(Effect.matchEffect({
+	onFailure: Effect.succeed,
+	onSuccess: (identity) => Effect.provideService(httpEffect, service, identity)
+}), HttpEffect.withPreResponseHandler((_request, response) => Effect.succeed(HttpServerResponse.setHeader(response, "cache-control", "no-store")))));
+const quoted = (value) => `"${value.replace(/["\\]/g, "\\$&")}"`;
+/**
+* Publish RFC 9728 discovery independently from the authenticated routes.
+* This supplies metadata and challenges; the host still verifies access tokens.
+*/
+const protectedResource = (options) => {
+	const resource = new URL(options.resource);
+	const path = `/.well-known/oauth-protected-resource${resource.pathname === "/" ? "" : resource.pathname}`;
+	const discoveryUrl = new URL(resource);
+	discoveryUrl.pathname = path;
+	const metadataUrl = discoveryUrl.href;
+	const target = metadataUrl.slice(discoveryUrl.origin.length);
+	const response = HttpServerResponse.jsonUnsafe({
+		resource: options.resource,
+		authorization_servers: options.authorizationServers,
+		bearer_methods_supported: ["header"],
+		scopes_supported: options.scopesSupported,
+		resource_name: options.resourceName
+	});
+	return {
+		layer: HttpRouter.middleware((next) => Effect.gen(function* () {
+			const request = yield* HttpServerRequest.HttpServerRequest;
+			const url = new URL(request.url, resource.origin);
+			if ((request.method === "GET" || request.method === "HEAD") && url.href.slice(url.origin.length) === target) return response;
+			return yield* next;
+		}), { global: true }),
+		metadataUrl,
+		/** The `WWW-Authenticate` value; parameter values are quoted and escaped. */
+		challenge: (challenge = {}) => {
+			return `Bearer ${[
+				["resource_metadata", metadataUrl],
+				["error", challenge.error],
+				["error_description", challenge.errorDescription],
+				["scope", challenge.scope]
+			].flatMap(([name, value]) => value === void 0 ? [] : [`${name}=${quoted(value)}`]).join(", ")}`;
+		}
+	};
+};
+//#endregion
+export { middleware, protectedResource };

package/dist/Testing.d.mts

@@ -0,0 +1,36 @@
+import { Effect } from "effect";
+import { HttpApi, HttpApiClient, 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>;
+/**
+ * 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, {
+  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>>;
+/** A stateless 2026-07-28 request. */
+export interface McpRequestOptions {
+  readonly url: string | URL;
+  readonly method: string;
+  readonly params?: McpRequestParams;
+  readonly headers?: ConstructorParameters<typeof Headers>[0];
+}
+/**
+ * What `JSON.stringify` accepts, not only valid JSON: `undefined` fields are
+ * dropped, and tests send malformed arguments on purpose.
+ */
+export type McpRequestValue = string | number | boolean | null | undefined | ReadonlyArray<McpRequestValue> | {
+  readonly [key: string]: McpRequestValue;
+};
+/** JSON-RPC `params`; `_meta` is merged shallowly over the defaults `mcpRequest` supplies. */
+export interface McpRequestParams {
+  readonly _meta?: {
+    readonly [key: string]: McpRequestValue;
+  };
+  readonly [key: string]: McpRequestValue;
+}
+/** Build one stateless 2026-07-28 JSON-RPC request, with client metadata defaulted. */
+export declare const mcpRequest: ({ url, method, params, headers: init }: McpRequestOptions) => Request;
+//#endregion