@gjermundgaraba/effect-actions 0.16.0 → 0.18.0

package/README.md

@@ -72,7 +72,9 @@ implementation is also:
 ```ts
 const { toolkit, layer } = ActionToolkit.make(greeting); // native Effect AI Toolkit and its handler layer
 const cli = ActionCli.make(greeting, { name: "greetings" }); // greetings greet --name Ada
-const remote = ActionCli.remoteCommand(Http, Greet, { client: { baseUrl } }); // greet --name Ada, over HTTP
+const remote = ActionCli.remoteCommand(Http, Greet, {
+  client: ActionHttp.client(Http, { baseUrl }),
+}); // greet --name Ada, over HTTP
 const local = Action.client(greeting); // the HTTP client's methods, in process
 const rpc = ActionRpc.layer(ActionRpc.make([Greet]), greeting); // Effect RPC, on the protocol the host provides
 ```

package/dist/Action.d.mts

@@ -1,12 +1,10 @@
-import { Anyone } from "./contract/rules.mjs";
+import { Anyone } from "./contract/caller.mjs";
 import { BuiltIn, BuiltIns, Forbidden, InvalidInput, Issue, Refusal, Unauthenticated } from "./contract/errors.mjs";
 import { ActionOf, AnyImplementation, Authorize, BuildError, BuildServices, Holding, Implementation, Known, Member, Offered, OptionalUnless, Protected, RequestOf, SelectedOf, Served, Serving } from "./contract/implementation.mjs";
 import { Call } from "./contract/call.mjs";
 import { Image } from "./contract/media.mjs";
 import { Context, Effect, Layer, Schema, Scope } from "effect";
-declare namespace Action_d_exports {
-  export { Action, Any, AnyImplementation, Anyone, Authorize, BuildError, BuildServices, BuiltIn, Client, ClientOptions, Errors, Forbidden, Handler, Handlers, Image, Implementation, InvalidInput, Issue, Mcp, Options, Refusal, Unauthenticated, allowAll, byName, client, implement, layer, make };
-}
+//#region src/contract/Action.d.ts
 type Codec = Schema.Codec<unknown, unknown, never, never>;
 type Fields = {
   readonly [key: string]: Codec;
@@ -213,4 +211,4 @@ export interface ClientOptions<A extends Any> {
  */
 export declare function client<const Apps extends Served, const O extends ClientOptions<ActionOf<Member<Apps>>> = {}>(implementations: Apps, ...options: OptionalUnless<O, ClientOptions<ActionOf<Member<Apps>>> & O & NoInfer<Known<O, ClientOptions<Any>>>>): Effect.Effect<Client<Apps, Offered<O, ActionOf<Member<Apps>>>>, BuildError<Holding<Member<Apps>, SelectedOf<O, Apps>>, SelectedOf<O, Apps>>, BuildServices<Holding<Member<Apps>, SelectedOf<O, Apps>>, SelectedOf<O, Apps>> | Scope.Scope>;
 //#endregion
-export { Action_d_exports, type AnyImplementation, Anyone, type Authorize, type BuildError, type BuildServices, BuiltIn, Forbidden, Image, type Implementation, InvalidInput, type Issue, Refusal, Unauthenticated };
+export { type AnyImplementation, Anyone, type Authorize, type BuildError, type BuildServices, BuiltIn, Forbidden, Image, type Implementation, InvalidInput, type Issue, Refusal, Unauthenticated };

package/dist/Action.mjs

@@ -1,5 +1,7 @@
+import { Anyone } from "./contract/caller.mjs";
 import { BuiltIn, Forbidden, InvalidInput, Refusal, Unauthenticated } from "./contract/errors.mjs";
-import { Anyone, assertKnown, assertName, assertOnce, assertOwnTags, errorList, projectedErrors } from "./contract/rules.mjs";
+import { assertKnown, assertName, assertOnce } from "./contract/names.mjs";
+import { assertOwnTags, errorList, projectedErrors } from "./contract/declared.mjs";
 import { Implementation, builders, built, memoized, select, toList } from "./contract/implementation.mjs";
 import { inputOf } from "./contract/call.mjs";
 import { Image } from "./contract/media.mjs";

package/dist/ActionCli.d.mts

@@ -1,14 +1,13 @@
-import { Declaring } from "./contract/rules.mjs";
 import { BuiltIn } from "./contract/errors.mjs";
 import { ActionOf, BuildError, BuildServices, Holding, Known, Member, RequestOf, Selected, SelectedOf, Selection, Served } from "./contract/implementation.mjs";
-import { Action_d_exports, Any } from "./Action.mjs";
-import { VerifierError } from "./authentication/provider.mjs";
+import { Any } from "./Action.mjs";
+import { Declaring } from "./contract/declared.mjs";
 import { Options, UserError } from "./cli/commands.mjs";
-import { AnyHttp, Options as Options$2 } from "./http/client.mjs";
+import { AnyHttp, Client } from "./http/client.mjs";
 import "./ActionHttp.mjs";
-import { Effect, Schema } from "effect";
-import { HttpClient, HttpClientError } from "effect/http";
-import { Command } from "effect/cli";
+import { Effect } from "effect";
+import { HttpClient } from "effect/http";
+import { CliError, Command } from "effect/cli";
 //#region src/cli/ActionCli.d.ts
 interface AnyBinding extends Declaring {
   readonly actions: ReadonlyArray<Any>;
@@ -24,7 +23,7 @@ interface AnyBinding extends Declaring {
  * `Effect.tapError(() => Console.error(…))`: a `UserError` wrapped around the result would
  * replace its JSON.
  */
-export declare const toUserError: (calls: AnyBinding | ReadonlyArray<Any>) => <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, UserError<Exclude<E, import("effect/cli/CliError").CliError>> | Exclude<E, Exclude<E, import("effect/cli/CliError").CliError>>, R>;
+export declare const toUserError: (calls: AnyBinding | ReadonlyArray<Any>) => <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, UserError<Exclude<E, CliError.CliError>> | Exclude<E, Exclude<E, CliError.CliError>>, R>;
 /**
  * An aggregate command of the actions `A`: its name, the actions that are its subcommands,
  * and their options.
@@ -69,39 +68,28 @@ type Local<App, A extends Any> = Effect.Effect<A["success"]["Type"], A["error"][
  * as JSON when it is not a struct. The flag of an array of strings or numbers is repeated for each value, a boolean
  * field is a switch, `--no-<name>` sending `false` as a required one left out does, and a field's `description` is its flag's help. 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.
+ * `UserError`, or an Effect CLI error as it is, such as a builder's `CliError.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>>>;
+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, {}, Failing<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.
+ * derives it, that calls the action through `client`'s method and fails as the method does, or
+ * as the Effect building the client does. `client` is an Effect of the binding's client, such as
+ * `ActionHttp.client(Http, { baseUrl })`, run each time the command runs; omitted, it is
+ * `ActionHttp.client(binding)` on the host's `HttpClient`. 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. A URL or a
-   * token read from `Config` goes instead into the `HttpClient` provided on the command, with
-   * `Command.provideEffect(HttpClient.HttpClient, …)`: it is read when a command runs, so
-   * `--help` needs neither, and a command of your own in `subcommands` calls through it too.
-   * A required one that is not set fails that Effect with a `ConfigError`, which is no
-   * command's failure and prints as a crash line: map the read,
-   * `Effect.mapError((cause) => new CliError.UserError({ cause, userMessage: "TOKEN is not set" }))`.
-   */
-  readonly client?: Options$2;
+export declare function remoteCommand<const H extends AnyHttp, A extends H["actions"][number], const O = {}, C extends ClientOf<H> | undefined = undefined>(binding: H, action: A, options?: O & NoInfer<Options<A>> & NoInfer<Known<O, RemoteKeys<Options<Any>>>> & {
+  readonly client?: C;
+}): Command.Command<string, never, {}, Failing<CallFailure<H, C, A>>, CallServices<C, A>>;
+type ClientOf<H extends AnyHttp> = Effect.Effect<Client<H, unknown, unknown>, unknown, unknown>;
+type RemoteKeys<Keys> = Keys & {
+  readonly client?: unknown;
 };
-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>;
+type Failing<F> = UserError<Exclude<F, CliError.CliError>> | Extract<F, CliError.CliError>;
+type Called<M, A extends Any> = A extends unknown ? A["name"] extends keyof M ? M[A["name"]] extends ((...input: never) => infer Call) ? Call : never : never : never;
+type CallFailure<H extends AnyHttp, C, A extends Any> = C extends Effect.Effect<infer M, infer CE, unknown> ? CE | Effect.Error<Called<M, A>> : Effect.Error<Called<Client<H>, A>>;
+type CallServices<C, A extends Any> = C extends Effect.Effect<infer M, unknown, infer CR> ? CR | Effect.Services<Called<M, A>> : HttpClient.HttpClient;
 /**
  * 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
@@ -113,16 +101,17 @@ type HttpUserError<H extends AnyHttp, A extends Any> = UserError<A["error"][numb
  */
 export declare function make<const Apps extends Served, const O extends Selection<ActionOf<Member<Apps>>> = {}, const Own extends Subcommands = []>(implementations: Apps, options: O & NoInfer<Options$1<ActionOf<Member<Apps>>>> & NoInfer<KnownOptions<O, Options$1, ActionOf<Member<Apps>>>> & {
   readonly subcommands?: Own | undefined;
-}): Command.Command<string, {}, {}, UserError<Effect.Error<Local<Holding<Member<Apps>, SelectedOf<O, Apps>>, SelectedOf<O, Apps>>>> | Command.Error<OwnCommand<Own>>, Effect.Services<Local<Holding<Member<Apps>, SelectedOf<O, Apps>>, SelectedOf<O, Apps>>> | Command.Services<OwnCommand<Own>>>;
+}): Command.Command<string, {}, {}, Failing<Effect.Error<Local<Holding<Member<Apps>, SelectedOf<O, Apps>>, SelectedOf<O, Apps>>>> | Command.Error<OwnCommand<Own>>, Effect.Services<Local<Holding<Member<Apps>, SelectedOf<O, Apps>>, SelectedOf<O, Apps>>> | Command.Services<OwnCommand<Own>>>;
 /**
  * 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 derived
- * subcommand's client; `commands` gives one the options `command` takes; `subcommands` adds
- * commands of your own.
+ * `make` derives it, each calling its action through `client`'s method, as `remoteCommand`
+ * does. `commands` gives one the options `command` takes; `subcommands` adds commands of your
+ * own, which call through the same client by yielding the Effect given as `client`.
  */
-export declare function remote<const H extends AnyHttp, const O extends Selection<H["actions"][number]> = {}, const Own extends Subcommands = []>(binding: H, options: O & NoInfer<RemoteOptions<H["actions"][number]>> & NoInfer<KnownOptions<O, RemoteOptions<Any>, H["actions"][number]>> & {
+export declare function remote<const H extends AnyHttp, const O extends Selection<H["actions"][number]> = {}, const Own extends Subcommands = [], C extends ClientOf<H> | undefined = undefined>(binding: H, options: O & NoInfer<Options$1<H["actions"][number]>> & NoInfer<KnownOptions<O, RemoteKeys<Options$1<Any>>, H["actions"][number]>> & {
+  readonly client?: C;
   readonly subcommands?: Own | undefined;
-}): Command.Command<string, {}, {}, HttpUserError<H, Selected<O, H["actions"][number]>> | Command.Error<OwnCommand<Own>>, HttpClient.HttpClient | Command.Services<OwnCommand<Own>>>;
+}): Command.Command<string, {}, {}, Failing<CallFailure<H, C, Selected<O, H["actions"][number]>>> | Command.Error<OwnCommand<Own>>, CallServices<C, Selected<O, H["actions"][number]>> | Command.Services<OwnCommand<Own>>>;
 /**
  * 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

package/dist/ActionCli.mjs

@@ -1,4 +1,5 @@
-import { assertDistinct, assertKnown, bindingErrors, projectedErrors } from "./contract/rules.mjs";
+import { assertDistinct, assertKnown } from "./contract/names.mjs";
+import { bindingErrors, projectedErrors } from "./contract/declared.mjs";
 import { Implementation, acquire, assertHeld, select, toList } from "./contract/implementation.mjs";
 import { client } from "./ActionHttp.mjs";
 import { command as command$1, failingAsDerived } from "./cli/commands.mjs";
@@ -16,7 +17,7 @@ import { Command } from "effect/cli";
 * `Effect.tapError(() => Console.error(…))`: a `UserError` wrapped around the result would
 * replace its JSON.
 */
-const toUserError = (calls) => "actions" in calls ? failingAsDerived(calls.actions, (action) => bindingErrors(action, calls)) : failingAsDerived(calls, (action) => projectedErrors(action));
+const toUserError = (calls) => "actions" in calls ? failingAsDerived(calls.actions.flatMap((action) => bindingErrors(action, calls))) : failingAsDerived(calls.flatMap((action) => projectedErrors(action)));
 const runWithBuildOfItsOwn = (app, action, input) => {
 	const thisActionOnly = Implementation.share([action], app);
 	return Effect.flatMap(acquire([thisActionOnly]), (bound) => {
@@ -36,7 +37,7 @@ const inProcess = (apps, action, options) => {
 };
 const overHttp = (binding, action, options, client$1) => {
 	if (!binding.actions.includes(action)) throw new Error(`Action "${action.name}" is not in this HTTP binding`);
-	return command$1(action, (input) => Effect.flatMap(client(binding, client$1), (methods) => {
+	return command$1(action, (input) => Effect.flatMap(client$1 ?? client(binding), (methods) => {
 		const method = methods[action.name];
 		if (method === void 0) throw new Error(`No client method for ${action.name}`);
 		return method(input);
@@ -68,17 +69,12 @@ const checkedCommandsOf = (commands, actions) => {
 * as JSON when it is not a struct. The flag of an array of strings or numbers is repeated for each value, a boolean
 * field is a switch, `--no-<name>` sending `false` as a required one left out does, and a field's `description` is its flag's help. 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.
+* `UserError`, or an Effect CLI error as it is, such as a builder's `CliError.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);
@@ -98,12 +94,6 @@ function make(implementations, options) {
 	const served = select(apps, options.actions);
 	return aggregateCommand(options.name, served.flatMap((app) => app.actions), commands, options.subcommands ?? [], (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 derived
-* subcommand's client; `commands` gives one the options `command` takes; `subcommands` adds
-* commands of your own.
-*/
 function remote(binding, options) {
 	const listed = options.actions;
 	if (listed !== void 0) assertHeld("the binding does not hold it", listed, binding.actions);

package/dist/ActionHttp.d.mts

@@ -1,15 +1,16 @@
-import { Anyone, Certain, ErrorsOf } from "./contract/rules.mjs";
+import { Anyone } from "./contract/caller.mjs";
 import { BuiltIn, BuiltIns } from "./contract/errors.mjs";
 import { BuildError, Holding, Known, Member, MiddlewareOf, Protected, Selected, Served, Serving } from "./contract/implementation.mjs";
-import { Action_d_exports, Any, Errors } from "./Action.mjs";
+import { Any, Errors } from "./Action.mjs";
 import { Any as Any$1, DescriptorOf, Identity, Matching, PublicOnly, RemoteRequest, Required, ServedProvider, ServerBuildServices, VerifierError } from "./authentication/provider.mjs";
+import { Certain, ErrorsOf } from "./contract/declared.mjs";
 import { AnyHttp, Client, MethodError, Options } from "./http/client.mjs";
 import { Context, Effect, FileSystem, Layer, Path, Schema, Types } from "effect";
-import { Etag, HttpClient, HttpPlatform, HttpRouter } from "effect/http";
+import { Etag, HttpClient, HttpClientError, HttpPlatform, HttpRouter } from "effect/http";
 import { HttpApi, HttpApiEndpoint, HttpApiGroup, HttpApiMiddleware } from "effect/http-api";
 //#region src/http/ActionHttp.d.ts
 /** What `fetchClient` takes: `client`'s options, and the `fetch` its calls send with. */
-export interface FetchClientOptions extends Options {
+export interface FetchClientOptions<E = HttpClientError.HttpClientError, R = never> extends Options<E, R> {
   /**
    * What each call sends with. Omitted: the global `fetch`, looked up on every call, so one
    * installed after the client is built, such as a test's stub, is used.
@@ -115,18 +116,21 @@ export declare function layer<const H extends AnyHttp, const Apps extends Served
  * `InvalidInput`, `Unauthenticated` or `Forbidden`), a native `HttpClientError` when the
  * server could not be reached or answered with a status or body the contract does not
  * declare, or a `SchemaError` when the success does not decode. An input that does not encode
- * fails with `InvalidInput`, and nothing is sent.
+ * fails with `InvalidInput`, and nothing is sent. A call also fails with what the client
+ * `transformClient` returns fails with, as it is, and requires what that client requires.
  */
 export declare function client<const H extends AnyHttp>(binding: H, options?: Options): Effect.Effect<Client<H>, never, HttpClient.HttpClient>;
+export declare function client<const H extends AnyHttp, E, R>(binding: H, options: Options<E, R>): Effect.Effect<Client<H, E, R>, never, HttpClient.HttpClient>;
 /**
  * `client` built once over `fetch`, for code that holds a client outside an Effect, such as
- * a browser app: its methods are the same Effects and require nothing, so each call runs
- * alone, as `Effect.runPromise(api.greet({ name }))`. The options are `client`'s, and
- * `fetch`.
+ * a browser app: its methods are the same Effects, which require only what `transformClient`
+ * requires, so a call without one runs alone, as `Effect.runPromise(api.greet({ name }))`. The
+ * options are `client`'s, and `fetch`.
  *
  * Each call sends with `options.fetch`, or with the global `fetch` as it is when the call
  * runs.
  */
 export declare function fetchClient<const H extends AnyHttp>(binding: H, options?: FetchClientOptions): Client<H>;
+export declare function fetchClient<const H extends AnyHttp, E, R>(binding: H, options: FetchClientOptions<E, R>): Client<H, E, R>;
 //#endregion
 export { type AnyHttp as Any, type Client, type Options as ClientOptions, type MethodError, Options$1 as Options };

package/dist/ActionHttp.mjs

@@ -1,7 +1,9 @@
-import { Anyone, bindingErrors, bindingOf, declared, projectedErrors } from "./contract/rules.mjs";
+import { Anyone } from "./contract/caller.mjs";
+import { bindingErrors, bindingOf, projectedErrors } from "./contract/declared.mjs";
 import { acquire, provideHandlers, servingOf } from "./contract/implementation.mjs";
 import { providerOf } from "./authentication/provider.mjs";
 import { inputParseOptions } from "./contract/call.mjs";
+import { declared } from "./contract/status.mjs";
 import { methods } from "./http/client.mjs";
 import { SchemaErrors, schemaErrors } from "./http/schema-errors.mjs";
 import { Context, Effect, Layer, Scope } from "effect";

package/dist/ActionMcp.d.mts

@@ -1,5 +1,5 @@
 import { ActionOf, BuildError, BuildServices, Holding, Known, Member, Protected, SelectedOf, Selection, Served, ServedRequest } from "./contract/implementation.mjs";
-import { Action_d_exports, Any } from "./Action.mjs";
+import { Any } from "./Action.mjs";
 import { Any as Any$1, Matching, ProviderOf, RemoteRequest, Required, ServerBuildServices } from "./authentication/provider.mjs";
 import { Client, ClientOptions, McpCallError, Params, RequestOptions, client, request } from "./mcp/client.mjs";
 import { Cause, Effect, Layer, Stdio } from "effect";

package/dist/ActionMcp.mjs

@@ -1,4 +1,7 @@
-import { Anyone, assertAuthentication, assertOnce, hintsOf, projectedErrors } from "./contract/rules.mjs";
+import { Anyone, assertAuthentication } from "./contract/caller.mjs";
+import { assertOnce } from "./contract/names.mjs";
+import { projectedErrors } from "./contract/declared.mjs";
+import { hintsOf } from "./contract/hints.mjs";
 import { acquire, provideHandlers, select, toList } from "./contract/implementation.mjs";
 import { promote, providerOf } from "./authentication/provider.mjs";
 import { inputParseOptions } from "./contract/call.mjs";

package/dist/ActionRpc.d.mts

@@ -1,9 +1,10 @@
-import { Anyone, Certain, ErrorsOf } from "./contract/rules.mjs";
+import { Anyone } from "./contract/caller.mjs";
 import { BuiltIn, BuiltIns } from "./contract/errors.mjs";
 import { BuildError, Holding, Known, Member, MiddlewareOf, Protected, Selected, Served, Serving } from "./contract/implementation.mjs";
 import { Call } from "./contract/call.mjs";
-import { Action_d_exports, Any as Any$1, Errors } from "./Action.mjs";
+import { Any as Any$1, Errors } from "./Action.mjs";
 import { Any as Any$2, DescriptorOf, Identity, Matching, PublicOnly, RemoteRequest, Required, ServedProvider, ServerBuildServices, VerifierError } from "./authentication/provider.mjs";
+import { Certain, ErrorsOf } from "./contract/declared.mjs";
 import { Context, Effect, Layer, Schema, Scope, Types } from "effect";
 import { HttpRouter } from "effect/http";
 import { Rpc, RpcClient, RpcClientError, RpcGroup, RpcMiddleware, RpcServer } from "effect/rpc";
@@ -144,4 +145,5 @@ export type ClientOptions = Omit<NonNullable<Parameters<typeof RpcClient.make>[1
  * or with Effect's own `RpcClientError` when the server could not be reached.
  */
 export declare function client<const B extends Any>(binding: B, options?: ClientOptions): Effect.Effect<Client<B>, never, RpcClient.Protocol | Scope.Scope>;
-//#endregion
+//#endregion
+export {};

package/dist/ActionRpc.mjs

@@ -1,4 +1,5 @@
-import { Anyone, bindingErrors, bindingOf } from "./contract/rules.mjs";
+import { Anyone } from "./contract/caller.mjs";
+import { bindingErrors, bindingOf } from "./contract/declared.mjs";
 import { acquire, provideHandlers, servingOf } from "./contract/implementation.mjs";
 import { providerOf } from "./authentication/provider.mjs";
 import { checked, decodeInput } from "./contract/call.mjs";

package/dist/ActionToolkit.d.mts

@@ -1,6 +1,6 @@
 import { BuiltIns } from "./contract/errors.mjs";
 import { ActionOf, BuildError, BuildServices, Holding, Known, Member, Offered, OptionalUnless, RequestOf, SelectedOf, Served, Serving } from "./contract/implementation.mjs";
-import { Action_d_exports, Any } from "./Action.mjs";
+import { Any } from "./Action.mjs";
 import { Effect, Layer, Schema } from "effect";
 import { Prompt, Tool, Toolkit } from "effect/ai";
 //#region src/toolkit/ActionToolkit.d.ts
@@ -85,4 +85,5 @@ export interface Approval {
  * `examples/kitchen-sink/src/assistant/handlers.ts`.
  */
 export declare const openApprovals: ({ content: messages }: Prompt.Prompt) => ReadonlyArray<Approval>;
-//#endregion
+//#endregion
+export {};

package/dist/ActionToolkit.mjs

@@ -1,4 +1,6 @@
-import { assertOnce, hintsOf, projectedErrors } from "./contract/rules.mjs";
+import { assertOnce } from "./contract/names.mjs";
+import { projectedErrors } from "./contract/declared.mjs";
+import { hintsOf } from "./contract/hints.mjs";
 import { Implementation, acquire, provideHandlers, select, toList } from "./contract/implementation.mjs";
 import { Effect, Schema } from "effect";
 import { Tool, Toolkit } from "effect/ai";

package/dist/Authentication.d.mts

@@ -1,8 +1,8 @@
-import { ErrorsOf } from "./contract/rules.mjs";
 import { Refusal } from "./contract/errors.mjs";
 import { Known, OptionalUnless } from "./contract/implementation.mjs";
 import { Errors } from "./Action.mjs";
 import { Any, Descriptor, Provider, Security } from "./authentication/provider.mjs";
+import { ErrorsOf } from "./contract/declared.mjs";
 import { Array, Context, Effect, Layer, Option, Redacted, Scope } from "effect";
 import { HttpRouter, HttpServerResponse } from "effect/http";
 import { HttpApiSecurity } from "effect/http-api";

package/dist/Authentication.mjs

@@ -1,5 +1,5 @@
 import { Unauthenticated, scopeToken } from "./contract/errors.mjs";
-import { assertOwnTags, errorList } from "./contract/rules.mjs";
+import { assertOwnTags, errorList } from "./contract/declared.mjs";
 import { providerOf } from "./authentication/provider.mjs";
 import { answer, answerStepUp, bearer, challenge, declaredResponse, isRefusal, isStepUp, plain } from "./authentication/refusal.mjs";
 import { Context, Effect, Layer, Match, Option, Predicate, Redacted } from "effect";

package/dist/authentication/provider.d.mts

@@ -1,7 +1,7 @@
-import { Anyone } from "../contract/rules.mjs";
+import { Anyone } from "../contract/caller.mjs";
 import { Refusal } from "../contract/errors.mjs";
 import { BuildServices, Protected, ServedRequest, Serving } from "../contract/implementation.mjs";
-import { Action_d_exports, Any as Any$1, Errors } from "../Action.mjs";
+import { Any as Any$1, Errors } from "../Action.mjs";
 import { Context, Effect } from "effect";
 import { HttpRouter, HttpServerResponse } from "effect/http";
 import { HttpApiMiddleware, HttpApiSecurity } from "effect/http-api";

package/dist/authentication/refusal.mjs

@@ -1,5 +1,5 @@
 import { Forbidden, Refusal, Unauthenticated } from "../contract/errors.mjs";
-import { declared, httpApiStatusOf } from "../contract/rules.mjs";
+import { declared, httpApiStatusOf } from "../contract/status.mjs";
 import { Cause, Context, Effect, Exit, Option, Predicate, Ref, Schema } from "effect";
 import { HttpServerResponse } from "effect/http";
 //#region src/authentication/refusal.ts

package/dist/cli/commands.d.mts

@@ -1,6 +1,6 @@
 import "../contract/errors.mjs";
-import { Action_d_exports, Any } from "../Action.mjs";
-import { Effect, Runtime, Types } from "effect";
+import { Any } from "../Action.mjs";
+import { Effect, Option, Runtime, Types } from "effect";
 import { CliError, Command } from "effect/cli";
 //#region src/cli/commands.d.ts
 type Field<A extends Any> = A["input"]["Encoded"] extends (infer E) ? true extends Types.IsUnion<E> ? never : E extends ReadonlyArray<unknown> ? never : E extends object ? string extends keyof E ? never : Extract<keyof E, string> : never : never;
@@ -44,4 +44,5 @@ export declare class UserError<out E = unknown> extends CliError.UserError {
   get reason(): E;
   get [Runtime.errorExitCode](): number;
 }
-//#endregion
+//#endregion
+export {};

package/dist/cli/commands.mjs

@@ -1,5 +1,6 @@
+import { literalValues, members, unsuspended } from "../contract/ast.mjs";
 import { InvalidInput } from "../contract/errors.mjs";
-import { assertDistinct, literalValues, members, unsuspended } from "../contract/rules.mjs";
+import { assertDistinct } from "../contract/names.mjs";
 import { decodeInput } from "../contract/call.mjs";
 import { withStderrConsole } from "../stdio/console.mjs";
 import { Console, Effect, Option, Predicate, Record, Runtime, Schema, SchemaAST, Stdio, Stream } from "effect";
@@ -205,8 +206,8 @@ const userErrorOf = (errors) => {
 		userMessage
 	}))));
 };
-const failingAsDerived = (actions, errorsOf) => {
-	const failure = userErrorOf([...new Set(actions.flatMap(errorsOf))]);
+const failingAsDerived = (errors) => {
+	const failure = userErrorOf([...new Set(errors)]);
 	return (self) => Effect.catchIf(self, (error) => !CliError.isCliError(error), failure);
 };
 const unreadableStdinField = (field, message) => new InvalidInput({
@@ -273,7 +274,7 @@ const command = (action, execute, options, errors) => {
 	const name = options?.name ?? kebab(action.name);
 	const render = options?.render;
 	const { flags, positional, decode, stdinHelp } = inputConfig(action, options?.positional ?? [], options?.aliases ?? {}, options?.stdin);
-	const failure = userErrorOf(errors);
+	const failing = failingAsDerived(errors);
 	assertDistinct("flag", [
 		...Object.keys(flags).map((field) => [`--${kebab(field)}`, `field ${field}`]),
 		...render === void 0 ? [] : [["--json", "render's --json"]],
@@ -284,7 +285,7 @@ const command = (action, execute, options, errors) => {
 		...input,
 		...Object.fromEntries(positional.map(({ field }, index) => [field, values[index] ?? Option.none()]))
 	});
-	const run = (parsed, rendered) => decode(parsed).pipe(Effect.flatMap(execute), Effect.catch(failure), Effect.flatMap((value) => printedOutput(action, value, rendered)), withStderrConsole, Effect.flatMap(Option.match({
+	const run = (parsed, rendered) => decode(parsed).pipe(Effect.flatMap(execute), failing, Effect.flatMap((value) => printedOutput(action, value, rendered)), withStderrConsole, Effect.flatMap(Option.match({
 		onNone: () => Effect.void,
 		onSome: Console.log
 	})));

package/dist/contract/ast.mjs

@@ -0,0 +1,10 @@
+import { SchemaAST } from "effect";
+//#region src/contract/ast.ts
+const unsuspended = (ast) => SchemaAST.isSuspend(ast) ? unsuspended(ast.thunk()) : ast;
+const members = (ast) => {
+	const resolved = unsuspended(ast);
+	return SchemaAST.isUnion(resolved) ? resolved.types.flatMap(members) : [resolved];
+};
+const literalValues = (ast) => SchemaAST.isLiteral(ast) ? [ast.literal] : SchemaAST.isEnum(ast) ? ast.enums.map(([, value]) => value) : [void 0];
+//#endregion
+export { literalValues, members, unsuspended };

package/dist/contract/call.d.mts

@@ -1,6 +1,6 @@
 import "./errors.mjs";
 import "./implementation.mjs";
-import { Action_d_exports, Any } from "../Action.mjs";
+import { Any } from "../Action.mjs";
 import { Effect, Schema } from "effect";
 //#region src/contract/call.d.ts
 /**

package/dist/contract/caller.d.mts

@@ -0,0 +1,9 @@
+import "../Action.mjs";
+//#region src/contract/caller.d.ts
+/**
+ * The caller of a public action, `caller: Action.Anyone`: anyone, signed in or not, and no
+ * authorizer runs for it. Registered globally, so two copies of the package agree on it, as they
+ * agree on a name.
+ */
+export declare const Anyone: unique symbol;
+//#endregion

package/dist/contract/caller.mjs

@@ -0,0 +1,12 @@
+//#region src/contract/caller.ts
+/**
+* The caller of a public action, `caller: Action.Anyone`: anyone, signed in or not, and no
+* authorizer runs for it. Registered globally, so two copies of the package agree on it, as they
+* agree on a name.
+*/
+const Anyone = Symbol.for("@gjermundgaraba/effect-actions/Anyone");
+const assertAuthentication = (actions, authentication) => {
+	for (const action of actions) if (action.caller !== Anyone && (authentication === void 0 || action.caller.key !== authentication.identity.key)) throw new Error(`Protected action '${action.name}' requires its matching authentication descriptor`);
+};
+//#endregion
+export { Anyone, assertAuthentication };

package/dist/contract/{rules.d.mts → declared.d.mts}

@@ -1,6 +1,7 @@
-import { Action_d_exports, Errors } from "../Action.mjs";
-import { SchemaAST, Types } from "effect";
-//#region src/contract/rules.d.ts
+import "./caller.mjs";
+import { Errors } from "../Action.mjs";
+import { Types } from "effect";
+//#region src/contract/declared.d.ts
 type ListOf<G> = G extends Errors ? G : readonly [G];
 /**
  * The errors options `O` declare, as at run time: those `error` always gives, or, where it may
@@ -23,10 +24,5 @@ export interface Declaring {
     readonly error: Errors;
   } | undefined;
 }
-/**
- * The caller of a public action, `caller: Action.Anyone`: anyone, signed in or not, and no
- * authorizer runs for it. Registered globally, so two copies of the package agree on it, as they
- * agree on a name.
- */
-export declare const Anyone: unique symbol;
-//#endregion
+//#endregion
+export {};

package/dist/contract/declared.mjs

@@ -0,0 +1,42 @@
+import { literalValues, members } from "./ast.mjs";
+import { Anyone, assertAuthentication } from "./caller.mjs";
+import { builtIns } from "./errors.mjs";
+import { assertOnce } from "./names.mjs";
+import { Predicate, Schema, SchemaAST } from "effect";
+//#region src/contract/declared.ts
+const errorList = (error) => error === void 0 ? [] : Schema.isSchema(error) ? [error] : error;
+const projectedErrors = (action, surface = []) => [.../* @__PURE__ */ new Set([
+	...builtIns,
+	...action.error,
+	...surface
+])];
+/**
+* Every error a binding's call of `action` declares: the built-in ones, the action's, the
+* binding's and, where `action` is protected, its authentication's.
+*/
+const bindingErrors = (action, binding) => projectedErrors(action, action.caller === Anyone || binding.authentication === void 0 ? binding.error : [...binding.error, ...binding.authentication.error]);
+const encodedTags = (ast) => members(SchemaAST.toEncoded(ast)).flatMap((member) => {
+	const tag = SchemaAST.isObjects(member) ? member.propertySignatures.find((property) => property.name === "_tag")?.type : void 0;
+	return tag === void 0 ? [] : members(tag).flatMap(literalValues).filter(Predicate.isString);
+});
+const builtInTags = new Set(builtIns.flatMap((error) => encodedTags(error.ast)));
+const assertOwnTags = (what, errors) => {
+	const tag = errors.flatMap((error) => encodedTags(error.ast)).find((tag) => builtInTags.has(tag));
+	if (tag !== void 0) throw new Error(`${what}: error _tag "${tag}" is built in, and declared on every surface`);
+};
+/**
+* The checks `ActionHttp.make` and `ActionRpc.make` share: each action once, no built-in error in
+* `error`, and the descriptor every protected action names. Returns `error` as a list.
+*/
+const bindingOf = (what, actions, options) => {
+	assertOnce("action", actions);
+	const error = errorList(options.error);
+	assertOwnTags(what, error);
+	assertAuthentication(actions, options.authentication);
+	return {
+		error,
+		authentication: options.authentication
+	};
+};
+//#endregion
+export { assertOwnTags, bindingErrors, bindingOf, errorList, projectedErrors };

package/dist/contract/hints.mjs

@@ -0,0 +1,14 @@
+//#region src/contract/hints.ts
+/**
+* An action's MCP tool hints, MCP's defaults where its `mcp` leaves one out: a write destructive,
+* a read not, no tool idempotent and every tool open-world. A given value passes through, as MCP
+* calls `destructiveHint` and `idempotentHint` meaningless on a read-only tool.
+*/
+const hintsOf = ({ readOnly, mcp }) => ({
+	readOnlyHint: readOnly,
+	destructiveHint: mcp.destructiveHint ?? !readOnly,
+	idempotentHint: mcp.idempotentHint ?? false,
+	openWorldHint: mcp.openWorldHint ?? true
+});
+//#endregion
+export { hintsOf };

package/dist/contract/implementation.d.mts

@@ -1,6 +1,6 @@
-import { Anyone } from "./rules.mjs";
+import { Anyone } from "./caller.mjs";
 import { Refusal } from "./errors.mjs";
-import { Action_d_exports, Any } from "../Action.mjs";
+import { Any } from "../Action.mjs";
 import { Context, Effect, Layer, Scope } from "effect";
 //#region src/contract/implementation.d.ts
 /** Decoded values at the dispatch boundary every surface shares. */
@@ -192,4 +192,5 @@ export type BuildServices<App, Listed extends Any = OwnActions<App>> = App exten
   readonly "~buildServices": infer RX;
   readonly "~authorizeBuildServices": infer RAX;
 } ? RX | ([Protected<Serving<App, Listed>>] extends [never] ? never : RAX) : never;
-//#endregion
+//#endregion
+export {};