@gjermundgaraba/effect-actions 0.11.0 → 0.13.0

package/dist/{internal → contract}/implementation.mjs

@@ -1,13 +1,8 @@
 import { Unauthenticated } from "./errors.mjs";
-import { Anyone } from "./actions.mjs";
+import { Anyone, assertOnce } from "./rules.mjs";
 import { Array, Context, Effect, Layer, Option } from "effect";
-//#region src/internal/implementation.ts
-/**
-* A random key segment, unique to its caller even across installed copies of this module,
-* where a counter of each copy would repeat another's.
-*/
+//#region src/contract/implementation.ts
 const uniqueKey = () => Math.random().toString(36).slice(2);
-/** What `build` makes, as a layer of its own. */
 const memoized = (build) => {
 	const key = Context.Service(`effect-actions/Implementation/${uniqueKey()}`);
 	return {
@@ -76,12 +71,7 @@ var Implementation = class Implementation {
 		return app;
 	}
 };
-/** A surface's implementations as a list. */
 const toList = (served) => Array.ensure(served);
-/**
-* Refuse an action of `listed` that `held` lacks, by identity, as a stale list, marking one
-* of a held name as another contract's.
-*/
 const assertHeld = (why, listed, held) => {
 	const missing = listed.filter((action) => !held.includes(action));
 	if (missing.length > 0) {
@@ -89,12 +79,6 @@ const assertHeld = (why, listed, held) => {
 		throw new Error(`Listed in actions, but ${why}: ${missing.map(({ name }) => names.has(name) ? `${name} (another contract)` : name).join(", ")}`);
 	}
 };
-/**
-* Each of `apps` narrowed to the actions `listed` holds, matched by identity, behind its own
-* authorization and sharing its builder; one holding none of them is
-* left out, and not built. All of `apps` as they are when nothing is listed. A listed action
-* none of them holds is refused, as a stale list or another contract of its name.
-*/
 const select = (apps, listed) => {
 	if (listed === void 0) return apps;
 	assertHeld("no implementation holds it", listed, apps.flatMap((app) => app.actions));
@@ -104,32 +88,24 @@ const select = (apps, listed) => {
 		return own.length === app.actions.length ? [app] : [Implementation.share(own, app)];
 	});
 };
-/**
-* Provide `layer` the handlers of `apps`. Each implementation's layer is memoized, so its
-* builder runs once per layer graph however many surfaces serve it.
-*/
+const servedBy = (what, bound, apps, listed) => {
+	if (listed !== void 0) assertHeld("the binding does not hold it", listed, bound);
+	const held = apps.flatMap((app) => app.actions);
+	const served = select(apps, listed ?? bound.filter((action) => held.includes(action)));
+	const actions = served.flatMap((app) => app.actions);
+	if (actions.length === 0 && listed === void 0 && apps.length > 0) {
+		const names = new Set(bound.map(({ name }) => name));
+		throw new Error(`No action of these implementations is in this ${what}: ${held.map(({ name }) => names.has(name) ? `${name} (another contract)` : name).join(", ") || "none"}`);
+	}
+	assertOnce("served action", actions);
+	return served;
+};
 const provideHandlers = (apps) => (layer) => {
 	const [first, ...rest] = apps.map((app) => Implementation.layerOf(app));
 	return first === void 0 ? layer : Layer.provide(layer, Layer.mergeAll(first, ...rest));
 };
-/**
-* The builders of `apps` as one layer providing nothing: built above the surfaces, it runs
-* each builder once for all of them, since every surface builds the same memoized layers.
-*/
 const builders = (apps) => Layer.empty.pipe(provideHandlers(apps));
-/**
-* Every action `apps` serve with its handler, behind its authorizer, as `provideHandlers` built
-* them.
-*/
 const acquire = (apps) => Effect.map(Effect.forEach(apps, (app) => Implementation.boundOf(app)), (bound) => bound.flat());
-/**
-* Every action `apps` serve with its handler, behind its authorizer, their builders built as layers
-* of the graph being built around the caller, into its memo map, as `HttpRouter` builds a
-* middleware's dependencies: a builder acquiring them shares each builder's one run with the
-* surfaces of its graph, whichever builds first. Outside any graph, a program under
-* `Effect.provide` shares that layer's, and one under none builds into a map of its own. The
-* caller's scope holds them; a surface serving them too keeps them until it is released.
-*/
 const built = (apps) => {
 	const [first, ...rest] = apps.map((app) => Implementation.layerOf(app));
 	return Effect.gen(function* () {
@@ -141,27 +117,20 @@ const built = (apps) => {
 		return yield* Effect.provideContext(acquire(apps), context);
 	});
 };
-/**
-* One action's handler behind its admission: a protected action's identity, then its
-* `authorize`. These run outside the action's span, so what they fail with is attributed to
-* the surface rather than to a handler that never ran. Each call has a scope of its own, on
-* every surface: what `authorize` and the handler acquire is released when the call ends, the
-* handler's first, so no call needs a `Scope` of its caller.
-*/
 const dispatch = (action, handle, before) => {
-	const attributes = {
+	const actionAttributes = {
 		"action.name": action.name,
 		"action.read_only": action.readOnly
 	};
 	const authentication = action.caller === Anyone ? Effect.void : Effect.flatMap(Effect.serviceOption(action.caller), (actor) => Option.isSome(actor) ? Effect.void : Effect.fail(new Unauthenticated()));
 	const authorization = action.caller === Anyone ? Effect.void : Effect.suspend(() => before(action));
 	return (input) => {
-		const handled = Effect.withSpan(Effect.annotateLogs(Effect.suspend(() => handle(input)), attributes), action.name, {
+		const handled = Effect.withSpan(Effect.annotateLogs(Effect.suspend(() => handle(input)), actionAttributes), action.name, {
 			captureStackTrace: false,
-			attributes
+			attributes: actionAttributes
 		});
 		return Effect.scoped(authentication.pipe(Effect.andThen(authorization), Effect.andThen(handled)));
 	};
 };
 //#endregion
-export { Implementation, acquire, assertHeld, builders, built, memoized, provideHandlers, select, toList, uniqueKey };
+export { Implementation, acquire, assertHeld, builders, built, memoized, provideHandlers, select, servedBy, toList };

package/dist/contract/media.d.mts

@@ -0,0 +1,13 @@
+import { Schema, SchemaAST } from "effect";
+//#region src/contract/media.d.ts
+/**
+ * An image, a media field of a success: `{ data: Uint8Array, mimeType: string }`, `mimeType` such
+ * as `image/png`. A top-level field of a struct success, optional or an array, or the whole
+ * success, one or an array: an MCP tool lifts it into an image block of its own, and every other
+ * surface sends it as JSON, the bytes in base64. `ActionMcp` refuses it anywhere else.
+ */
+export declare const Image: Schema.Struct<{
+  readonly data: Schema.Uint8Array;
+  readonly mimeType: Schema.String;
+}>;
+//#endregion

package/dist/contract/media.mjs

@@ -0,0 +1,18 @@
+import { Schema } from "effect";
+//#region src/contract/media.ts
+const mediaKindAnnotation = "effect-actions/media";
+const Media = Schema.Struct({
+	data: Schema.Uint8Array,
+	mimeType: Schema.String
+});
+/**
+* An image, a media field of a success: `{ data: Uint8Array, mimeType: string }`, `mimeType` such
+* as `image/png`. A top-level field of a struct success, optional or an array, or the whole
+* success, one or an array: an MCP tool lifts it into an image block of its own, and every other
+* surface sends it as JSON, the bytes in base64. `ActionMcp` refuses it anywhere else.
+*/
+const Image = Media.annotate({ [mediaKindAnnotation]: "image" });
+const isMarked = (ast) => ast.annotations?.[mediaKindAnnotation] === "image";
+const kindOf = (ast) => isMarked(ast) && ast.encoding === void 0 ? "image" : void 0;
+//#endregion
+export { Image, Media, isMarked, kindOf };

package/dist/contract/rules.d.mts

@@ -0,0 +1,25 @@
+import { Action_d_exports, Errors } from "../Action.mjs";
+import { SchemaAST, Types } from "effect";
+//#region src/contract/rules.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
+ * be absent, those it gives or none, so clients decode each that may arrive.
+ */
+export type ErrorsOf<O> = O extends unknown ? "error" extends keyof O ? O extends {
+  readonly error: infer G extends Errors | Errors[number];
+} ? ListOf<G> : ListOf<Extract<O["error" & keyof O], Errors | Errors[number]>> | [] : [] : never;
+type Single<T> = true extends Types.IsUnion<T> ? never : T;
+/**
+ * The errors a binding of errors `E` surely declares: each slot of one error in a list of
+ * fixed length, never one of an array of unknown length, which may be empty, nor of a list
+ * `E` may be one of several.
+ */
+export type Certain<E extends Errors> = true extends Types.IsUnion<E> ? never : number extends E["length"] ? never : { readonly [K in keyof E]: Single<E[K]>; }[number];
+/**
+ * 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/{internal/actions.mjs → contract/rules.mjs}

@@ -1,37 +1,22 @@
 import { builtIns, statuses } from "./errors.mjs";
 import { Predicate, Schema, SchemaAST } from "effect";
-//#region src/internal/actions.ts
-/**
-* The list an `error` option stands for: one schema, a list as given, or none, as
-* `HttpApiEndpoint` takes it.
-*/
+//#region src/contract/rules.ts
 const errorList = (error) => error === void 0 ? [] : Schema.isSchema(error) ? [error] : error;
-/**
-* What a projection of an action declares: the built-in errors, the action's own, and any
-* its surface adds, such as a binding's. The built-ins come first, since a failure encodes
-* and decodes with the first schema that accepts it, and they are classes, which accept
-* only their own instances: a loose schema of the action's never captures one. A schema
-* listed twice is not repeated.
-*/
 const projectedErrors = (action, surface = []) => [.../* @__PURE__ */ new Set([
 	...builtIns,
 	...action.error,
 	...surface
 ])];
 /**
-* The caller of a public action: anyone, signed in or not. Registered globally, so two copies
-* of the package agree on it, as they agree on a name.
+* 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 validName = /^[A-Za-z0-9_-]{1,128}$/;
-/** Names become path segments, OpenAPI identifiers and client method keys. */
 const assertName = (what, name) => {
 	if (!validName.test(name) || name === "then") throw new Error(`Invalid ${what}: ${name}`);
 };
-/**
-* Names are checked by whoever owns them: an implementation, a binding, a CLI, or the MCP
-* tools. `claimantOf` says who claims a name, so a clash between two claimants names both.
-*/
 const assertDistinct = (what, items, nameOf, claimantOf = nameOf) => {
 	const seen = /* @__PURE__ */ new Map();
 	for (const item of items) {
@@ -45,44 +30,23 @@ const assertDistinct = (what, items, nameOf, claimantOf = nameOf) => {
 		seen.set(name, claimant);
 	}
 };
-/** Refuse an action name `actions` hold twice. */
 const assertOnce = (what, actions) => assertDistinct(what, actions, (action) => action.name);
-/**
-* Refuse a key of options keyed by action name, such as handlers, tools or commands, that no
-* action of `names` has, so a stale option cannot outlive its action.
-*/
 const assertKnown = (what, keys, names) => {
 	const unknown = keys.filter((key) => !names.includes(key));
 	if (unknown.length > 0) throw new Error(`Unknown ${what}: ${unknown.join(", ")}`);
 };
-/** `ast` with any suspension at its top resolved, as a recursive schema's is. */
 const unsuspended = (ast) => SchemaAST.isSuspend(ast) ? unsuspended(ast.thunk()) : ast;
-/** The members of a union, nested and suspended ones included, or the one type otherwise. */
 const members = (ast) => {
 	const resolved = unsuspended(ast);
 	return SchemaAST.isUnion(resolved) ? resolved.types.flatMap(members) : [resolved];
 };
-/**
-* The values a literal or an enum accepts, or `undefined` for any other type, which has no
-* fixed set.
-*/
 const literalValues = (ast) => SchemaAST.isLiteral(ast) ? [ast.literal] : SchemaAST.isEnum(ast) ? ast.enums.map(([, value]) => value) : [void 0];
-/**
-* The `_tag`s a schema's encoding carries: each member's of a union, every value of a union of
-* literals or of an enum, and a suspended schema's, as a recursive error is written.
-*/
-const tagsOf = (ast) => members(SchemaAST.toEncoded(ast)).flatMap((member) => {
+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);
 });
-/**
-* Refuse an error that encodes with a built-in error's `_tag`, the built-in itself included:
-* every endpoint and tool declares the built-in errors already, a client decoding the answer
-* could not tell a look-alike from them, and a look-alike of a refusal would step up. Checked
-* where the action or the binding is made, so every surface and client of it may rely on it.
-*/
 const assertOwnTags = (what, errors) => {
-	const tag = errors.flatMap((error) => tagsOf(error.ast)).find((tag) => Object.hasOwn(statuses, tag));
+	const tag = errors.flatMap((error) => encodedTags(error.ast)).find((tag) => Object.hasOwn(statuses, tag));
 	if (tag !== void 0) throw new Error(`${what}: error _tag "${tag}" is built in, and declared on every surface`);
 };
 //#endregion

package/dist/{internal → http}/client.d.mts

@@ -1,19 +1,17 @@
-import { BuiltIns } from "./errors.mjs";
-import "./implementation.mjs";
-import { Call } from "./call.mjs";
+import { BuiltIns } from "../contract/errors.mjs";
+import { Call } from "../contract/call.mjs";
 import { Action_d_exports, Any, Errors } from "../Action.mjs";
-import { Any as Any$1, VerifierError } from "./authentication.mjs";
+import { Any as Any$1, VerifierError } from "../authentication/provider.mjs";
 import { Effect, Schema } from "effect";
 import { HttpClient, HttpClientError } from "effect/http";
 import { HttpApi, HttpApiClient } from "effect/http-api";
-//#region src/internal/client.d.ts
+//#region src/http/client.d.ts
 /**
  * The native `HttpApiClient.make` options except `transformResponse`: `baseUrl` and
  * `transformClient`. `transformResponse` may change a call's success, failure or
  * services, which the method types cannot follow.
  */
 export type Options = Omit<NonNullable<Parameters<typeof HttpApiClient.make>[1]>, "transformResponse">;
-/** An error schema the binding declares on every endpoint. */
 type BindingError = Errors[number];
 /**
  * What one call of `A` fails with: a declared error value (the action's own, one `E` of the
@@ -22,11 +20,11 @@ type BindingError = Errors[number];
  * the success does not decode. Input that does not encode is `InvalidInput`, and nothing is sent.
  */
 export type MethodError<A extends Any, E extends BindingError = never> = A["error"][number]["Type"] | E["Type"] | BuiltIns["Type"] | HttpClientError.HttpClientError | Schema.SchemaError;
-/** One action as an Effect of its decoded success, failing with `MethodError`. */
 type Method<A extends Any, E extends BindingError> = Call<A, Effect.Effect<A["success"]["Type"], MethodError<A, E>>>;
 /**
- * Any HTTP binding. The API is a native constraint here because native groups are
- * invariant in their endpoints; `actions` carries the types.
+ * Any HTTP binding, with its actions erased: what `layer` and `client` read. The API is a native
+ * constraint here because native groups are invariant in their endpoints; `actions` carries the
+ * types.
  */
 export interface AnyHttp {
   readonly authentication?: Any$1 | undefined;

package/dist/http/client.mjs

@@ -0,0 +1,17 @@
+import { checked } from "../contract/call.mjs";
+import { Effect } from "effect";
+import { HttpApiClient } from "effect/http-api";
+//#region src/http/client.ts
+const assertInBinding = (actions, action) => {
+	if (!actions.includes(action)) throw new Error(`Action "${action.name}" is not in this HTTP binding`);
+};
+const methods = (http, options = {}) => Effect.map(HttpApiClient.make(http.api, options), (client) => {
+	const native = client;
+	return (action) => {
+		const method = native[action.name];
+		if (method === void 0) throw new Error(`No client method for ${action.name}`);
+		return checked(action, (payload) => method({ payload }));
+	};
+});
+//#endregion
+export { assertInBinding, methods };

package/dist/http/declared.mjs

@@ -0,0 +1,20 @@
+import { unsuspended } from "../contract/rules.mjs";
+import { Schema, SchemaAST } from "effect";
+import { HttpServerResponse } from "effect/http";
+import { HttpApiSchema } from "effect/http-api";
+//#region src/http/declared.ts
+const httpApiStatusOf = SchemaAST.resolveAt("httpApiStatus");
+const statusThroughSuspensions = (ast) => httpApiStatusOf(ast) ?? (SchemaAST.isSuspend(ast) ? statusThroughSuspensions(ast.thunk()) : void 0);
+const declared = (error) => {
+	const status = statusThroughSuspensions(error.ast);
+	if (status !== void 0) return [httpApiStatusOf(error.ast) === void 0 ? HttpApiSchema.status(status)(error) : error];
+	const resolved = unsuspended(error.ast);
+	if (SchemaAST.isUnion(resolved) && resolved.checks === void 0 && resolved.encoding === void 0) return resolved.types.flatMap((member) => declared(Schema.make(member)));
+	return [HttpApiSchema.status(422)(error)];
+};
+const declaredResponse = (errors, error) => {
+	const schema = errors.flatMap(declared).find((each) => Schema.is(each)(error));
+	return schema === void 0 ? void 0 : HttpServerResponse.jsonUnsafe(Schema.encodeUnknownSync(Schema.toCodecJson(schema))(error), { status: httpApiStatusOf(schema.ast) ?? 422 });
+};
+//#endregion
+export { declared, declaredResponse };

package/dist/http/schema-errors.mjs

@@ -0,0 +1,9 @@
+import { InvalidInput } from "../contract/errors.mjs";
+import { Effect } from "effect";
+import { HttpApiMiddleware } from "effect/http-api";
+//#region src/http/schema-errors.ts
+const responseEncodingKinds = /* @__PURE__ */ new Set(["Body", "ResponseHeaders"]);
+var SchemaErrors = class extends HttpApiMiddleware.Service()("effect-actions/http/SchemaErrors", { error: [InvalidInput] }) {};
+const schemaErrors = () => HttpApiMiddleware.layerSchemaErrorTransform(SchemaErrors, (failure) => Effect.fail(responseEncodingKinds.has(failure.kind) ? failure : InvalidInput.fromSchemaError(failure.cause)));
+//#endregion
+export { SchemaErrors, schemaErrors };

package/dist/mcp/protocol.d.mts

@@ -0,0 +1,18 @@
+import "../contract/implementation.mjs";
+import "../contract/media.mjs";
+import "../Action.mjs";
+import { Schema } from "effect";
+import { McpProtocol } from "effect/ai";
+//#region src/mcp/protocol.d.ts
+/**
+ * An MCP request's parameters, as `Testing.mcpRequest` takes them: JSON, with any `_meta`, leaving
+ * out an `undefined` one, as a caller may. A helper passing on whole params types them as this,
+ * and a tool's `arguments` as `Schema.Json`, never `unknown`.
+ */
+export interface Params {
+  readonly _meta?: {
+    readonly [key: string]: Schema.Json;
+  };
+  readonly [key: string]: Schema.Json | undefined;
+}
+//#endregion

package/dist/{internal/mcp.mjs → mcp/protocol.mjs}

@@ -1,19 +1,16 @@
-import { Media, isMarked, kindOf } from "./media.mjs";
+import { unsuspended } from "../contract/rules.mjs";
+import { Media, isMarked, kindOf } from "../contract/media.mjs";
 import { Predicate, Schema, SchemaAST } from "effect";
 import { McpProtocol } from "effect/ai";
-//#region src/internal/mcp.ts
-/**
-* The one protocol revision served over HTTP. 2026-07-28 is stateless: every request
-* stands alone. The stateful revisions keep a session per `initialize`, which the native
-* HTTP runtime never expires and which no identity owns. A mixed endpoint's gate relies on it
-* too: it decides from the routing headers, which the native runtime checks against the body
-* of a stateless request alone, so serving a stateful revision over HTTP would open the gate.
-*/
+//#region src/mcp/protocol.ts
 const httpProtocol = McpProtocol.v2026_07_28;
-/** Where `ActionMcp.layerHttp` serves, and `Testing.mcpClient` calls, by default. */
+const protocols = [
+	McpProtocol.v2026_07_28,
+	McpProtocol.v2025_11_25,
+	McpProtocol.v2025_06_18
+];
 const defaultPath = "/mcp";
-/** The parameter a method's `mcp-name` header repeats, as the native runtime routes it. */
-const routed = (method, params) => method === "resources/read" ? params.uri : params.name;
+const mcpNameHeaderOf = (method, params) => method === "resources/read" ? params.uri : params.name;
 /**
 * One stateless MCP request of `method` with `params`, as `ActionMcp.layerHttp` serves it:
 * the headers routing it, which repeat what its body says, and its JSON-RPC body. The client
@@ -22,7 +19,7 @@ const routed = (method, params) => method === "resources/read" ? params.uri : pa
 */
 const statelessRequest = (method, params) => {
 	const { protocolVersion } = httpProtocol;
-	const name = routed(method, params);
+	const name = mcpNameHeaderOf(method, params);
 	return {
 		headers: {
 			accept: "application/json, text/event-stream",
@@ -49,60 +46,41 @@ const statelessRequest = (method, params) => {
 		}
 	};
 };
-/** The `_meta` key of a lifted block naming its field. */
 const fieldKey = "effect-actions/field";
 const isMedia = Schema.is(Media);
 const isMediaArray = Schema.is(Schema.Array(Media));
-/** The schema `ast` stands for, a `Schema.suspend` resolved, which only delays its definition. */
-const resolved = (ast) => SchemaAST.isSuspend(ast) ? resolved(ast.thunk()) : ast;
-/** The kind `ast` is, suspended or not. */
-const kindIn = (ast) => kindOf(resolved(ast));
-/**
-* The media `ast` is, one value or an array of them, as a whole success may be: an array without
-* an encoding of its own whose every element is media of one kind, such as `Schema.Array` or
-* `Schema.NonEmptyArray` of it.
-*/
-const wholeOf = (suspended) => {
-	const ast = resolved(suspended);
+const kindOfUnsuspended = (ast) => kindOf(unsuspended(ast));
+const wholeSuccessMediaOf = (suspended) => {
+	const ast = unsuspended(suspended);
 	const one = kindOf(ast);
 	if (one !== void 0) return {
 		kind: one,
 		many: false
 	};
 	if (!SchemaAST.isArrays(ast) || ast.encoding !== void 0) return void 0;
-	const [kind, ...others] = new Set([...ast.elements, ...ast.rest].map(kindIn));
+	const [kind, ...others] = new Set([...ast.elements, ...ast.rest].map(kindOfUnsuspended));
 	return kind === void 0 || others.length > 0 ? void 0 : {
 		kind,
 		many: true
 	};
 };
-/**
-* The media a field's `ast` is: one value, which `Schema.optional` or `Schema.optionalKey` may
-* make absent, or an array, which they may not, as no block would tell an absent one from an
-* empty one.
-*/
-const fieldOf = (field) => {
+const mediaFieldOf = (field) => {
 	const optional = field.context?.isOptional === true;
-	const ast = resolved(field);
+	const ast = unsuspended(field);
 	if (optional && SchemaAST.isUnion(ast) && ast.types.length === 2) {
-		const [value, ...more] = ast.types.filter((member) => !SchemaAST.isUndefined(member));
-		const kind = value === void 0 || more.length > 0 ? void 0 : kindIn(value);
+		const [definedMember, ...otherDefinedMembers] = ast.types.filter((member) => !SchemaAST.isUndefined(member));
+		const kind = definedMember === void 0 || otherDefinedMembers.length > 0 ? void 0 : kindOfUnsuspended(definedMember);
 		return kind === void 0 ? void 0 : {
 			kind,
 			many: false
 		};
 	}
-	const whole = wholeOf(ast);
+	const whole = wholeSuccessMediaOf(ast);
 	return whole === void 0 || optional && whole.many ? void 0 : whole;
 };
-/**
-* How an MCP tool sends `success`: it lifts the success itself, one value or an array, or the
-* top-level media fields of a struct without an encoding of its own, keyed by strings, and
-* sends the rest of the struct, if any is left.
-*/
 const liftOf = (success) => {
-	const ast = resolved(success.ast);
-	const whole = wholeOf(ast);
+	const ast = unsuspended(success.ast);
+	const whole = wholeSuccessMediaOf(ast);
 	if (whole !== void 0) return {
 		fields: [{
 			name: void 0,
@@ -115,7 +93,7 @@ const liftOf = (success) => {
 		rest: success
 	};
 	const fields = ast.propertySignatures.flatMap(({ name, type }) => {
-		const field = fieldOf(type);
+		const field = mediaFieldOf(type);
 		return field === void 0 ? [] : [{
 			name: String(name),
 			...field
@@ -127,14 +105,13 @@ const liftOf = (success) => {
 	};
 	const names = new Set(fields.map(({ name }) => name));
 	const rest = ast.propertySignatures.filter(({ name }) => !names.has(name));
-	const { identifier: _identifier, ...annotations } = ast.annotations ?? {};
+	const { identifier: _identifierOfWholeSuccess, ...annotationsOfRest } = ast.annotations ?? {};
 	return {
 		fields,
-		rest: rest.length === 0 && ast.indexSignatures.length === 0 ? void 0 : Schema.make(new SchemaAST.Objects(rest, ast.indexSignatures, annotations))
+		rest: rest.length === 0 && ast.indexSignatures.length === 0 ? void 0 : Schema.make(new SchemaAST.Objects(rest, ast.indexSignatures, annotationsOfRest))
 	};
 };
-/** The schemas `ast` is made of, its encoded side included. */
-const partsOf = (ast) => [
+const partsAndEncodedSideOf = (ast) => [
 	...SchemaAST.isDeclaration(ast) ? ast.typeParameters : [],
 	...SchemaAST.isArrays(ast) ? [...ast.elements, ...ast.rest] : [],
 	...SchemaAST.isObjects(ast) ? [...ast.propertySignatures, ...ast.indexSignatures].map(({ type }) => type) : [],
@@ -142,34 +119,24 @@ const partsOf = (ast) => [
 	...SchemaAST.isSuspend(ast) ? [ast.thunk()] : [],
 	...(ast.encoding ?? []).map(({ to }) => to)
 ];
-/** Whether `ast` holds media anywhere, each schema visited once, so a recursive one ends. */
-const holdsMedia = (ast) => {
+const holdsMediaAnywhere = (ast) => {
 	const seen = /* @__PURE__ */ new Set();
 	const pending = [ast];
 	for (let next = pending.pop(); next !== void 0; next = pending.pop()) {
 		if (seen.has(next)) continue;
 		seen.add(next);
 		if (isMarked(next)) return true;
-		pending.push(...partsOf(next));
+		pending.push(...partsAndEncodedSideOf(next));
 	}
 	return false;
 };
-/**
-* Whether `action`, whose success an MCP tool lifts as `lift` says, holds media where no tool
-* lifts it: in its input, in a declared error, or in the rest of its success, such as nested in
-* a field or in a union.
-*/
 const isMisplaced = (action, { rest }) => {
 	return [
 		action.input,
 		...action.error,
 		...rest === void 0 ? [] : [rest]
-	].some(({ ast }) => holdsMedia(ast));
+	].some(({ ast }) => holdsMediaAnywhere(ast));
 };
-/**
-* The media `lift` finds in `success`, a decoded value its schema has validated: the whole
-* success's, or each field's, in field order, an array's in its order, none for an absent field.
-*/
 const liftedFrom = (lift, success) => lift.fields.flatMap(({ name, kind, many }) => {
 	const value = name === void 0 ? success : Predicate.hasProperty(success, name) ? success[name] : void 0;
 	return (many ? isMediaArray(value) ? value : [] : isMedia(value) ? [value] : []).map((media) => ({
@@ -179,4 +146,4 @@ const liftedFrom = (lift, success) => lift.fields.flatMap(({ name, kind, many })
 	}));
 });
 //#endregion
-export { defaultPath, fieldKey, httpProtocol, isMisplaced, liftOf, liftedFrom, statelessRequest };
+export { defaultPath, fieldKey, httpProtocol, isMisplaced, liftOf, liftedFrom, protocols, statelessRequest };

package/dist/stdio/console.mjs

@@ -0,0 +1,64 @@
+import { Clock, Console, Effect, Function, Predicate } from "effect";
+//#region src/stdio/console.ts
+const stderrConsole = (console, clock) => {
+	const counts = /* @__PURE__ */ new Map();
+	const timers = /* @__PURE__ */ new Map();
+	const write = (...args) => console.error(...args);
+	const elapsed = (label, data) => {
+		const start = timers.get(label);
+		if (start !== void 0) {
+			const millis = Number(clock.monotonicTimeNanosUnsafe() - start) / 1e6;
+			write("%s: %sms", label, Number(millis.toFixed(3)), ...data);
+		}
+	};
+	const writeLabelKeepingFormat = (label, args) => {
+		const [formatOrFirst, ...rest] = args;
+		write(...Predicate.isString(formatOrFirst) ? [`${label}: ${formatOrFirst}`, ...rest] : [label, ...args]);
+	};
+	const group = (...labelOrUndefined) => {
+		if (labelOrUndefined.some((part) => part !== void 0)) write(...labelOrUndefined);
+	};
+	return {
+		assert: (condition, ...args) => {
+			if (!condition) writeLabelKeepingFormat("Assertion failed", args);
+		},
+		clear: Function.constVoid,
+		count: (label = "default") => {
+			const count = (counts.get(label) ?? 0) + 1;
+			counts.set(label, count);
+			write("%s: %d", label, count);
+		},
+		countReset: (label = "default") => {
+			counts.delete(label);
+		},
+		debug: write,
+		dir: (item) => write("%O", item),
+		dirxml: write,
+		error: write,
+		group,
+		groupCollapsed: group,
+		groupEnd: Function.constVoid,
+		info: write,
+		log: write,
+		table: (data) => write(data),
+		time: (label = "default") => {
+			if (!timers.has(label)) timers.set(label, clock.monotonicTimeNanosUnsafe());
+		},
+		timeEnd: (label = "default") => {
+			elapsed(label, []);
+			timers.delete(label);
+		},
+		timeLog: (label = "default", ...data) => elapsed(label, data),
+		trace: (...args) => {
+			const { stack = "" } = /* @__PURE__ */ new Error();
+			const [_header, _traceFrame, ...callerFrames] = stack.split("\n");
+			const callerStack = callerFrames.join("\n");
+			writeLabelKeepingFormat("Trace", args);
+			if (callerStack !== "") write(callerStack);
+		},
+		warn: write
+	};
+};
+const withStderrConsole = (effect) => Effect.provideServiceEffect(effect, Console.Console, Effect.zipWith(Effect.service(Console.Console), Effect.service(Clock.Clock), stderrConsole));
+//#endregion
+export { withStderrConsole };

package/dist/{internal → testing}/memory.d.mts

@@ -1,6 +1,6 @@
 import { Layer } from "effect";
 import { HttpClient, HttpRouter, HttpServer } from "effect/http";
-//#region src/internal/memory.d.ts
+//#region src/testing/memory.d.ts
 /** What in-memory routes may leave to the host: the router, the platform, nothing per request. */
 export type Served = HttpRouter.HttpRouter | HttpRouter.Request<"Requires", never> | HttpRouter.Request<"GlobalRequires", never> | HttpRouter.Request<"Error", any> | HttpRouter.Request<"GlobalError", any> | Layer.Success<typeof HttpServer.layerServices>;
 //#endregion