@gjermundgaraba/effect-actions 0.9.0 → 0.11.0

package/dist/Action.mjs

@@ -1,32 +1,134 @@
-import { assertName } from "./internal/actions.mjs";
-import { Schema } from "effect";
+import { BuiltIn, Forbidden, InvalidInput, Refusal, Unauthenticated } from "./internal/errors.mjs";
+import { Anyone, assertKnown, assertName, assertOnce, assertOwnTags, errorList, projectedErrors } from "./internal/actions.mjs";
+import { inputOf } from "./internal/call.mjs";
+import { Implementation, builders, built, memoized, select, toList } from "./internal/implementation.mjs";
+import { Image } from "./internal/media.mjs";
+import { Array as Array$1, Cause, Context, Effect, Predicate, Schema } from "effect";
 //#region src/Action.ts
-/** An empty object schema that also produces the object root MCP requires. */
+/**
+* An object without fields: an action without arguments, `{}` given or not. Effect's own
+* `Tool.EmptyParams`: strict, unlike `Schema.Struct({})`, which accepts any value but `null`,
+* and the object root MCP requires.
+*/
 const NoInput = Schema.Record(Schema.String, Schema.Never);
+/**
+* The schema an option stands for: a schema as given, `NoInput` for no fields, or the struct
+* of the fields, which may be keyed by symbols, as in a struct.
+*/
+const codecOf = (schema) => Schema.isSchema(schema) ? schema : Reflect.ownKeys(schema).length === 0 ? NoInput : Schema.Struct(schema);
 function make(name, options) {
 	assertName("action name", name);
-	const { access } = options;
-	if (access !== "read" && access !== "write") throw new Error(`Invalid access: ${String(access)}`);
-	const readOnly = options.mcp === false ? false : options.mcp?.readOnly ?? access === "read";
-	const mcp = options.mcp === false ? false : {
-		name: options.mcp?.name ?? name,
-		readOnly,
-		destructive: options.mcp?.destructive ?? !readOnly,
-		idempotent: options.mcp?.idempotent ?? false,
-		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);
-	return {
+	const { caller, readOnly } = options;
+	if (caller !== Anyone && !Context.isKey(caller)) throw new Error("Missing caller: declare Action.Anyone or an identity service key");
+	if (caller !== Anyone && Context.isReference(caller)) throw new Error("Invalid caller: an identity is a Context.Service, not a Context.Reference");
+	if (readOnly !== true && readOnly !== false) throw new Error(`Invalid readOnly: ${String(readOnly)}`);
+	const action = {
+		caller,
 		name,
 		description: options.description,
-		input: options.input ?? NoInput,
-		success: options.success,
-		errors: options.errors ?? [],
-		access,
-		mcp
+		input: codecOf(options.input ?? {}),
+		success: options.success === void 0 ? Schema.Void : codecOf(options.success),
+		error: errorList(options.error),
+		readOnly,
+		mcp: { ...options.mcp }
+	};
+	assertOwnTags(`Action "${action.name}"`, action.error);
+	return action;
+}
+function byName(actions) {
+	assertOnce("action", actions);
+	return Object.fromEntries(actions.map((action) => [action.name, action]));
+}
+/**
+* Every authenticated caller may call a protected action. The contract's identity
+* requirement is enforced independently, including when its handler reads no identity.
+*/
+const allowAll = () => Effect.void;
+/**
+* `authorize`, checked: the types require a function, and plain JavaScript can still pass
+* none, which must not serve every caller.
+*/
+const assertAuthorizer = (before) => {
+	if (!Predicate.isFunction(before)) throw new Error("Missing authorize: pass an authorization function, or Action.allowAll");
+	return before;
+};
+/** `authorize`, present wherever a protected action is implemented. */
+const assertAuthorization = (authorize) => {
+	if (authorize === void 0) throw new Error("Protected actions require authorize, or Action.allowAll");
+	return authorize;
+};
+/** No `authorize` where only public actions are implemented: it would never run. */
+const assertNoAuthorization = (authorize) => {
+	if (authorize !== void 0) throw new Error("A public-only target takes no authorize");
+	return allowAll;
+};
+/**
+* The layer building `authorize`: a plain function as it is, a built one once its Effect
+* runs, checked when the layer builds, as a builder's record is. `Effect.isEffect` tells them
+* apart, so one written with `Effect.fn` stays plain.
+*/
+const authorizerOf = (before) => memoized(Effect.isEffect(before) ? Effect.map(before, assertAuthorizer) : Effect.succeed(assertAuthorizer(before)));
+function implement(actions, handlers, options) {
+	const listed = Array$1.ensure(actions);
+	const names = listed.map((action) => action.name);
+	assertOnce("action", listed);
+	const authorizer = authorizerOf(listed.some((action) => action.caller !== Anyone) ? assertAuthorization(options?.authorize) : assertNoAuthorization(options?.authorize));
+	const record = (built) => {
+		const keyed = Predicate.isFunction(built) ? Object.fromEntries(Array.isArray(actions) ? [] : listed.map(({ name }) => [name, built])) : built;
+		assertKnown("handlers", Object.keys(keyed), names);
+		const bound = listed.flatMap((action) => {
+			const handle = Object.hasOwn(keyed, action.name) ? keyed[action.name] : void 0;
+			return Predicate.isFunction(handle) ? [[action, handle]] : [];
+		});
+		const missing = names.filter((name) => !bound.some(([action]) => action.name === name));
+		if (missing.length > 0) throw new Error(`Missing handlers: ${missing.join(", ")}`);
+		return bound;
 	};
+	const recorded = Effect.isEffect(handlers) ? Effect.map(handlers, record) : Effect.succeed(record(handlers));
+	return new Implementation(listed, memoized(recorded), authorizer);
+}
+function layer(implementations) {
+	return builders(toList(implementations));
+}
+/**
+* A value through `schema`'s JSON codec, as a wire carries it: encoded to JSON text, then
+* decoded, so what comes out is what a remote call's other side decodes, `-0` as `0`. Every
+* issue is reported.
+*/
+const wire = (schema) => {
+	const codec = Schema.fromJsonString(Schema.toCodecJson(schema));
+	const encode = Schema.encodeUnknownEffect(codec, { errors: "all" });
+	const decode = Schema.decodeUnknownEffect(codec, { errors: "all" });
+	return (value) => Effect.flatMap(encode(value), (encoded) => decode(encoded));
+};
+/**
+* `cause` with each failure passed through `failure` where it stands, so it keeps its
+* annotations, the span it failed in among them; failed anew, it would lose them. One that
+* passes keeps the stack of where it was made, where the decoded error's would be the codec's.
+* One that does not, such as an error the action does not declare, is a defect: its
+* `SchemaError`, then the failure itself.
+*/
+const mapFailures = (cause, failure) => Effect.map(Effect.forEach(cause.reasons, (reason) => Cause.isFailReason(reason) ? Effect.match(failure(reason.error), {
+	onFailure: (refused) => Cause.combine(Cause.die(refused), Cause.die(reason.error)),
+	onSuccess: (decoded) => Cause.fail(Predicate.isError(reason.error) && Predicate.isError(decoded) ? Object.assign(decoded, { stack: reason.error.stack }) : decoded)
+}).pipe(Effect.map((mapped) => Cause.annotate(mapped, Cause.reasonAnnotations(reason)))) : Effect.succeed(Cause.fromReasons([reason]))), (causes) => Cause.fromReasons(causes.flatMap(({ reasons }) => reasons)));
+/**
+* `action`'s method, running `run`, its handler behind authorization, as a remote
+* call runs: input that does not pass through its codec is `InvalidInput`, and nothing else
+* runs; a success or a failure that does not is a defect, as it is an empty 500 over HTTP,
+* since the handler broke its contract. A failure passes through the codec of
+* every error the action declares, the built-in ones included.
+*/
+const methodOf = (action, run) => {
+	const input = wire(action.input);
+	const success = wire(action.success);
+	const failure = wire(Schema.Union(projectedErrors(action)));
+	return (...args) => inputOf(action, args).pipe(Effect.flatMap(input), Effect.mapError(InvalidInput.fromSchemaError), Effect.flatMap((value) => Effect.catchCause(run(value), (cause) => Effect.flatMap(mapFailures(cause, failure), Effect.failCause))), Effect.flatMap((value) => Effect.orDie(success(value))));
+};
+function client(served, options) {
+	const apps = select(toList(served), options?.actions);
+	assertOnce("action", apps.flatMap((app) => app.actions));
+	return Effect.map(built(apps), (bound) => Object.fromEntries(bound.map(([action, run]) => [action.name, methodOf(action, run)])));
 }
 //#endregion
-export { make };
+export { Anyone, BuiltIn, Forbidden, Image, InvalidInput, Refusal, Unauthenticated, allowAll, byName, client, implement, layer, make };

package/dist/ActionCli.d.mts

@@ -1,36 +1,107 @@
-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 as Options$1 } from "./internal/cli.mjs";
-import { Effect, Scope } from "effect";
+import { BuiltIn } from "./internal/errors.mjs";
+import { ActionOf, BuildError, BuildServices, Holding, Known, Member, RequestOf, Selected, SelectedOf, Selection, Served } from "./internal/implementation.mjs";
+import { Action_d_exports, Any } from "./Action.mjs";
+import { VerifierError } from "./internal/authentication.mjs";
+import { Options, UserError } from "./internal/cli.mjs";
+import { AnyHttp, Options as Options$2 } from "./internal/client.mjs";
+import { Effect, Schema } from "effect";
+import { HttpClient, HttpClientError } from "effect/http";
 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
- * failures, so its refusal is a typed failure of the command effect rather than a
- * declared surface error; the native parser has already decoded the input.
+ * An aggregate command of the actions `A`: its name, the actions that are its subcommands,
+ * and their options.
  */
-interface BeforeOptions<E, R> {
-  readonly before?: (action: Any) => Effect.Effect<void, E, R>;
+interface Options$1<A extends Any = Any> {
+  /** The aggregate command's name. */
+  readonly name: string;
+  /**
+   * The actions that are subcommands, among the binding's or the implementations' actions:
+   * `[GetUser, RenameUser]`. Defaults to every action of them.
+   */
+  readonly actions?: ReadonlyArray<A> | undefined;
+  /**
+   * The options of each subcommand, keyed by its action's name, as `command` takes them:
+   * `{ readFile: { positional: ["path"], render } }`.
+   */
+  readonly commands?: { readonly [K in A as K["name"]]?: Options<K>; };
 }
-/** Parsing, rendering and the pre-handler hook of one local command. */
-export type Options<Output, E = never, R = never, Parameters extends Command.Command.Config = never> = Options$1<Output, Parameters> & BeforeOptions<E, R>;
-/** Configuration for an aggregate group command. */
-export interface GroupOptions<E = never, R = never> extends BeforeOptions<E, R> {
-  /** 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, EB = never, RB = never, Parameters extends Command.Command.Config = never>(app: Implementation<G, H, EX, RX>, name: Name, options?: Options<Selected<G, Name>["success"]["Type"], EB, RB, Parameters>) => Command.Command<string, never, {}, EB | EX | import("effect/Schema").SchemaError | Extract<G["actions"][number], {
-  readonly name: Name;
-}>["errors"][number]["Type"], Exclude<RB, Scope.Scope> | 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, EB = never, RB = never>(app: Implementation<G, H, EX, RX>, options?: GroupOptions<EB, RB>) => Command.Command<string, {}, {}, EB | EX | import("effect/Schema").SchemaError | G["actions"][number]["errors"][number]["Type"], Exclude<Exclude<RB, Scope.Scope>, Command.CommandContext<string>> | Exclude<Exclude<RX, Scope.Scope>, Command.CommandContext<string>> | Exclude<Exclude<HandlersContext<H>, Scope.Scope>, Command.CommandContext<string>>>;
-//#endregion
+/** The `commands` any member of `O` may give. */
+type CommandsOf<O> = O extends unknown ? "commands" extends keyof O ? NonNullable<O["commands" & keyof O]> : never : never;
+/** The keys of any member of `C`. */
+type KeysOf<C> = C extends unknown ? keyof C : never;
+/** The options any member of `C` gives command `K`. */
+type CommandOf<C, K> = C extends unknown ? (K extends keyof C ? C[K] : never) : never;
+/**
+ * No option, no command beyond the actions `A` of the target, and no command's option, beyond
+ * `Keys`'s, in any member of `O`.
+ */
+type KnownOptions<O, Keys, A extends Any> = Known<O, Keys> & ([CommandsOf<O>] extends [never] ? unknown : {
+  readonly commands?: Known<CommandsOf<O>, { readonly [K in A["name"]]: Options<A>; }> & { readonly [K in KeysOf<CommandsOf<O>>]?: Known<CommandOf<CommandsOf<O>, K>, Options<Any>>; };
+});
+/** The implementation of `A` among `App`. */
+type Owning<App, A extends Any> = App extends unknown ? A extends ActionOf<App> ? App : never : never;
+/**
+ * What one local command of `A` runs: its implementation's builder and authorization, then
+ * its handler. Authorization may refuse and any handler fail with a built-in error, so
+ * every one fails with `Action.BuiltIn` too.
+ */
+type Local<App, A extends Any> = Effect.Effect<A["success"]["Type"], A["error"][number]["Type"] | BuildError<App, A> | BuiltIn, RequestOf<App, A> | BuildServices<App, A>>;
+/**
+ * Project one implemented action into a native Effect CLI command that runs its handler in
+ * process, behind its implementation's authorization. It is named after the action in kebab
+ * case with one flag per field of its input (`--user-id`), or `--input` taking the whole input
+ * as JSON when it is not a struct. It needs what the authorization, its handler and its builder
+ * need; the host provides the identity. It prints the result on stdout; a failure is a
+ * `UserError`, which `Command.run` prints on stderr. `remoteCommand` calls a server instead.
+ */
+export declare function command<const Apps extends Served, A extends ActionOf<Member<Apps>>, const O = {}>(implementations: Apps, action: A, options?: O & NoInfer<Options<A>> & NoInfer<Known<O, Options<Any>>>): Command.Command<string, never, {}, UserError<Effect.Error<Local<Owning<Member<Apps>, A>, A>>>, Effect.Services<Local<Owning<Member<Apps>, A>, A>>>;
+/**
+ * Project one action of an HTTP binding into a native Effect CLI command, derived as `command`
+ * derives it, that calls the action over HTTP through its `ActionHttp.client` method, made with
+ * the `client` options on the host's `HttpClient`, and fails as the method does. It runs
+ * nothing locally.
+ */
+export declare function remoteCommand<const H extends AnyHttp, A extends H["actions"][number], const O = {}>(binding: H, action: A, options?: O & NoInfer<RemoteCommandOptions<A>> & NoInfer<Known<O, RemoteCommandOptions<Any>>>): Command.Command<string, never, {}, HttpUserError<H, A>, HttpClient.HttpClient>;
+/** A remote command's options, its action `A`. */
+export type RemoteCommandOptions<A extends Any = Any> = Options<A> & {
+  /**
+   * Its client's options, as `ActionHttp.client` takes them: `baseUrl`, and
+   * `transformClient` for credentials. They reach this command's requests alone.
+   */
+  readonly client?: Options$2;
+};
+/** A remote aggregate command's options, its actions `A`. */
+export type RemoteOptions<A extends Any = Any> = Options$1<A> & {
+  /**
+   * Every subcommand's client options, as `ActionHttp.client` takes them: `baseUrl`, and
+   * `transformClient` for credentials. They reach this aggregate's requests alone.
+   */
+  readonly client?: Options$2;
+};
+/** What an aggregate command over binding `H` fails with, running its actions `A`. */
+type HttpUserError<H extends AnyHttp, A extends Any> = UserError<A["error"][number]["Type"] | H["error"][number]["Type"] | VerifierError<A, H["authentication"]>["Type"] | BuiltIn | HttpClientError.HttpClientError | Schema.SchemaError>;
+/**
+ * Project every implemented action as a subcommand of one aggregate command, each named after
+ * its action in kebab case and run in process. `commands` gives a subcommand the options
+ * `command` takes, by action name. `remote` calls a server instead.
+ */
+export declare function make<const Apps extends Served, const O extends Selection<ActionOf<Member<Apps>>> = {}>(implementations: Apps, options: O & NoInfer<Options$1<ActionOf<Member<Apps>>>> & NoInfer<KnownOptions<O, Options$1, ActionOf<Member<Apps>>>>): Command.Command<string, {}, {}, UserError<Effect.Error<Local<Holding<Member<Apps>, SelectedOf<O, Apps>>, SelectedOf<O, Apps>>>>, Effect.Services<Local<Holding<Member<Apps>, SelectedOf<O, Apps>>, SelectedOf<O, Apps>>>>;
+/**
+ * Project every action of an HTTP binding as a subcommand of one aggregate command, derived as
+ * `make` derives it, each calling its action over HTTP. `client` configures every
+ * subcommand's client; `commands` gives a subcommand the options `command` takes.
+ */
+export declare function remote<const H extends AnyHttp, const O extends Selection<H["actions"][number]> = {}>(binding: H, options: O & NoInfer<RemoteOptions<H["actions"][number]>> & NoInfer<KnownOptions<O, RemoteOptions<Any>, H["actions"][number]>>): Command.Command<string, {}, {}, HttpUserError<H, Selected<O, H["actions"][number]>>, HttpClient.HttpClient>;
+/**
+ * A program whose stdout carries only its results, such as a CLI feeding scripts or an MCP
+ * subprocess, applied last, before `NodeRuntime.runMain`: the default logger of every layer
+ * provided within writes to stderr, and a failure `runMain` would report, such as a defect or
+ * a failure of a layer the host provides, is reported on stderr instead, once. A command's
+ * own failure, which `Command.run` has printed, is not reported again. The exit code is the
+ * one `runMain` gives: the failure's `Runtime.errorExitCode`, 1 by default, or 130 for an
+ * interruption.
+ */
+export declare const logToStderr: <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, never, R>;
+//#endregion
+export { type Options as CommandOptions, Options$1 as Options, type UserError };

package/dist/ActionCli.mjs

@@ -1,26 +1,124 @@
-import { selectNamed } from "./internal/actions.mjs";
-import { dispatch } from "./internal/implementation.mjs";
+import { assertDistinct, assertKnown } from "./internal/actions.mjs";
+import { Implementation, acquire, assertHeld, select, toList } from "./internal/implementation.mjs";
+import { assertInBinding, methods } from "./internal/client.mjs";
 import { command as command$1 } from "./internal/cli.mjs";
-import { Effect } from "effect";
+import { Cause, Effect, Logger, Runtime } from "effect";
 import { Command } from "effect/cli";
 //#region src/ActionCli.ts
 /**
-* Acquire the implementation in a scope of its own, run one action through the hook
-* and its handler, and release it: every local command, selected or grouped.
+* Build the implementation's handlers for this call alone, run one action through its
+* authorization and handler, and release them: every local command, selected or aggregated.
+* The call's own scope, which every call has, closes first, so its finalizers run while the
+* builder's resources are still open; a local build never reuses one the host already made.
 */
-const local = (app, action, before, input) => Effect.scoped(Effect.flatMap(app.build, (handlers) => dispatch(app.group, action, handlers, before)(input)));
+const local = (app, action, input) => {
+	const own = Implementation.share([action], app);
+	return Effect.flatMap(acquire([own]), (bound) => {
+		const [, run] = bound.find(([candidate]) => candidate === action) ?? [];
+		return run === void 0 ? Effect.die(/* @__PURE__ */ new Error(`No handler for ${action.name}`)) : run(input);
+	}).pipe(Effect.provide(Implementation.layerOf(own), { local: true }));
+};
 /**
-* Project one explicitly selected local action into a native Effect CLI command.
-* The action name resolves against the bound group; no HTTP fallback exists.
+* The one implementation of `action` among `apps`. One implemented twice is refused rather
+* than the first run; other actions' names are not this command's to check.
 */
-const command = (app, name, options) => {
-	const action = selectNamed(app.group.actions, name, `action "${app.group.name}.${name}"`);
-	return command$1(action, (input) => local(app, action, options?.before, input), options);
+const implementationOf = (apps, action) => {
+	const [app, ...others] = apps.filter((candidate) => candidate.actions.includes(action));
+	if (app === void 0) throw new Error(`Action "${action.name}" has no implementation here`);
+	if (others.length > 0) throw new Error(`Action "${action.name}" is implemented twice here`);
+	return app;
 };
-/** 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) => local(app, action, options?.before, input)));
-	return Command.make(options?.name ?? app.group.name).pipe(Command.withSubcommands(commands));
+/** One command running `action` in process, by its one implementation among `apps`. */
+const inProcess = (apps, action, options) => {
+	const app = implementationOf(apps, action);
+	return command$1(action, (input) => local(app, action, input), options);
 };
+/**
+* One command calling `action` through the binding's client, made with `client` on the
+* host's `HttpClient`, whose failures include the binding's errors.
+*/
+const overHttp = (binding, action, options, client) => {
+	assertInBinding(binding.actions, action);
+	return command$1(action, (input) => Effect.flatMap(methods(binding, client), (methodOf) => methodOf(action)(input)), options, binding.error);
+};
+/**
+* One aggregate command named `name`, a subcommand per action of `actions`, each made by
+* `project` with its options in `commands`: a local aggregate's and a remote one's.
+*/
+const aggregate = (name, actions, commands, project) => {
+	const subcommands = actions.map((action) => ({
+		action,
+		command: project(action, Object.hasOwn(commands, action.name) ? commands[action.name] : void 0)
+	}));
+	assertDistinct("command", subcommands, ({ command }) => command.name, ({ action }) => `action ${action.name}`);
+	return Command.make(name).pipe(Command.withSubcommands(subcommands.map(({ command }) => command)));
+};
+/** A command of any action of the target, so one record serves several selections. */
+const commandsOf = (commands, actions) => {
+	const given = commands ?? {};
+	assertKnown("commands", Object.keys(given), actions.map((action) => action.name));
+	return given;
+};
+/**
+* Project one implemented action into a native Effect CLI command that runs its handler in
+* process, behind its implementation's authorization. It is named after the action in kebab
+* case with one flag per field of its input (`--user-id`), or `--input` taking the whole input
+* as JSON when it is not a struct. It needs what the authorization, its handler and its builder
+* need; the host provides the identity. It prints the result on stdout; a failure is a
+* `UserError`, which `Command.run` prints on stderr. `remoteCommand` calls a server instead.
+*/
+function command(implementations, action, options) {
+	return inProcess(toList(implementations), action, options);
+}
+/**
+* Project one action of an HTTP binding into a native Effect CLI command, derived as `command`
+* derives it, that calls the action over HTTP through its `ActionHttp.client` method, made with
+* the `client` options on the host's `HttpClient`, and fails as the method does. It runs
+* nothing locally.
+*/
+function remoteCommand(binding, action, options) {
+	const { client, ...syntax } = options ?? {};
+	return overHttp(binding, action, options === void 0 ? void 0 : syntax, client);
+}
+/**
+* Project every implemented action as a subcommand of one aggregate command, each named after
+* its action in kebab case and run in process. `commands` gives a subcommand the options
+* `command` takes, by action name. `remote` calls a server instead.
+*/
+function make(implementations, options) {
+	const apps = toList(implementations);
+	const commands = commandsOf(options.commands, apps.flatMap((app) => app.actions));
+	const served = select(apps, options.actions);
+	return aggregate(options.name, served.flatMap((app) => app.actions), commands, (action, syntax) => inProcess(served, action, syntax));
+}
+/**
+* Project every action of an HTTP binding as a subcommand of one aggregate command, derived as
+* `make` derives it, each calling its action over HTTP. `client` configures every
+* subcommand's client; `commands` gives a subcommand the options `command` takes.
+*/
+function remote(binding, options) {
+	const listed = options.actions;
+	if (listed !== void 0) assertHeld("the binding does not hold it", listed, binding.actions);
+	const commands = commandsOf(options.commands, binding.actions);
+	return aggregate(options.name, binding.actions.filter((action) => listed?.includes(action) ?? true), commands, (action, syntax) => overHttp(binding, action, syntax, options.client));
+}
+/**
+* A program whose stdout carries only its results, such as a CLI feeding scripts or an MCP
+* subprocess, applied last, before `NodeRuntime.runMain`: the default logger of every layer
+* provided within writes to stderr, and a failure `runMain` would report, such as a defect or
+* a failure of a layer the host provides, is reported on stderr instead, once. A command's
+* own failure, which `Command.run` has printed, is not reported again. The exit code is the
+* one `runMain` gives: the failure's `Runtime.errorExitCode`, 1 by default, or 130 for an
+* interruption.
+*/
+const logToStderr = (self) => self.pipe(Effect.catchCause((cause) => {
+	if (Cause.hasInterruptsOnly(cause)) return Effect.interrupt;
+	const squashed = Cause.squash(cause);
+	const reported = Object.assign(new Error("Reported on stderr", { cause }), {
+		[Runtime.errorReported]: false,
+		[Runtime.errorExitCode]: Runtime.getErrorExitCode(squashed)
+	});
+	return Effect.andThen(Runtime.getErrorReported(squashed) ? Effect.logError(cause) : Effect.void, Effect.die(reported));
+}), Effect.provideService(Logger.LogToStderr, true));
 //#endregion
-export { command, group };
+export { command, logToStderr, make, remote, remoteCommand };