@gjermundgaraba/effect-actions 0.1.0-rc.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Gjermund Garaba
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,170 @@
+# @gjermundgaraba/effect-actions
+
+Define an Effect action once, implement it once, expose it over **HTTP and MCP**.
+
+**Experimental release candidate.** The repository currently uses Effect snapshot
+[`4e4a3a6`](https://pkg.pr.new/Effect-TS/effect/effect@4e4a3a6). The MCP adapter
+requires APIs missing from published `4.0.0-rc.115`, despite that being the current
+peer declaration. Until these versions are aligned, use the pinned snapshot;
+the declared peer version alone is not sufficient.
+
+## Quickstart
+
+```ts
+import { Effect, Layer, Schema } from "effect";
+import { Action, ActionGroup, ActionHttp, ActionMcp } from "@gjermundgaraba/effect-actions";
+
+const Greet = Action.make("greet", {
+  description: "Greet someone by name.",
+  input: Schema.Struct({ name: Schema.String }),
+  success: Schema.String,
+  mcp: { readOnly: true },
+});
+
+export const Actions = ActionGroup.make(Greet);
+const app = Actions.implement({
+  greet: ({ name }) => Effect.succeed(`Hello, ${name}!`),
+});
+
+export const routes = Layer.mergeAll(
+  ActionHttp.layer(app, {
+    apiPath: "/api/actions",
+    openapiPath: "/openapi.json",
+  }),
+  ActionMcp.layer(app, { name: "greetings", version: "1.0.0", path: "/mcp" }),
+);
+```
+
+Serve `routes` with Effect's `HttpRouter`. This creates `POST /api/actions/greet`,
+`GET /openapi.json`, and an MCP endpoint at `/mcp`. The HTTP response is
+`"Hello, Ada!"`; MCP returns `structuredContent: { value: "Hello, Ada!" }`.
+See [examples/server.ts](examples/server.ts) for Node server wiring and the
+[authenticated demo](examples/README.md) for a runnable application.
+
+### Contracts
+
+- `input` defaults to `Action.NoInput` for actions without arguments.
+- `error` is a list of failure schemas, defaulting to none. Each schema retains
+  its own `httpApiStatus` annotation.
+- Actions default to both transports; use `http: false` or `mcp: false` to opt out.
+- MCP input must have an object-root JSON Schema; declared errors must encode to
+  objects. The MCP adapter checks this at Layer construction. HTTP allows scalars.
+- `mcp.name` overrides the tool name. `destructive` defaults to `!readOnly`.
+- Schemas must be service-free. Handlers may require services.
+
+## HTTP client
+
+Save the quickstart above as `quickstart.ts`. Once its routes are served:
+
+```ts
+import { Effect } from "effect";
+import { FetchHttpClient } from "effect/unstable/http";
+import { ActionHttp } from "@gjermundgaraba/effect-actions";
+import { Actions } from "./quickstart.js";
+
+export const greeting = Effect.gen(function* () {
+  const client = yield* ActionHttp.client(Actions, {
+    apiPath: "/api/actions",
+    baseUrl: "http://127.0.0.1:3000",
+  });
+  return yield* client.greet({ name: "Ada" });
+}).pipe(Effect.provide(FetchHttpClient.layer));
+```
+
+Run `greeting` with `Effect.runPromise`. Methods take decoded inputs and return
+decoded results; MCP-only actions are excluded. Authentication
+headers can be added with `transformClient`. See [client details](docs/behavior.md#http-client-details)
+for error types, optional inputs, and native grouped clients.
+
+## Adapter options
+
+| API                          | Options                                                                                 |
+| ---------------------------- | --------------------------------------------------------------------------------------- |
+| `ActionHttp.layer`           | `apiPath`, `openapiPath`, `schemaError`                                                 |
+| `ActionHttp.api` / `openapi` | `apiPath`, `schemaError`                                                                |
+| `ActionHttp.client`          | `apiPath`, `schemaError`, `baseUrl`, `transformClient`, `transformResponse`             |
+| `ActionMcp.layer`            | `name`, `version`, `path`, `protocols`, `allowedOrigins`, `instructions`, `schemaError` |
+
+`apiPath`, `openapiPath` (on `layer` / `configure`), and MCP `path` are required —
+the library has no defaults. `ActionHttp.configure(options)` binds HTTP configuration
+for its `layer`, `api`, `openapi`, and `client` methods. Configured clients accept
+only connection options. Set `openapiPath: false` when the host serves a combined
+document.
+
+See [adapter behavior](docs/behavior.md) for shared schema-error policies,
+dependency lifetimes, wire formats, and MCP protocol support.
+
+## Scope
+
+HTTP means JSON POST endpoints, not Effect's RPC wire protocol. Both adapters use
+Effect's servers; there is no MCP SDK runtime dependency. Actions are unary:
+no streaming, uploads, prompts, resources, or retries.
+
+Authentication and authorization belong to the application. Tool discovery is
+not filtered by actor. The example's bearer tokens are **demo-only**; production
+needs real token validation, MCP authorization discovery, request limits, and
+error reporting.
+
+## Development and packaging
+
+Requires a supported Node.js version (24 LTS recommended) and [Vite+](https://viteplus.dev).
+
+```sh
+vp install
+vp check
+vp test
+vp run test:package
+vp run example
+```
+
+`vp run dev` watches the library build. `vp check` also verifies the compile-time
+assertions in `tests/types.ts`. Tests cover both transports, official MCP clients,
+context isolation, schema-error policies, and cancellation.
+
+`vp run build` emits ESM and declarations into `dist/`. Public entry points are the
+package root, `/Action`, `/ActionGroup`, `/http`, `/mcp`, `/authentication`, `/testing`, and `/testing/client`.
+`vp run test:package` builds and checks a tarball in an isolated consumer using the pinned
+Effect snapshot; it does not establish compatibility with the published peer.
+
+## Authentication and OAuth discovery
+
+`Authentication.middleware(CurrentActor, { authenticate, errors, headers })` provides
+an application-defined context service for each request. `authenticate` is an Effect;
+`errors` lists its error schemas in precedence order. The first matching schema owns
+both serialization and `httpApiStatus` (500 when unannotated). If its encoder fails,
+the request fails as a server error; another schema is not tried. `headers(error)`
+can add a Bearer challenge.
+Responses use `Cache-Control: no-store`, including failures handled by enclosing middleware. Provide the returned middleware's `.layer` to
+HTTP and MCP route layers. See [examples/app.ts](examples/app.ts).
+
+Authentication dependencies are request requirements, as with native `HttpRouter.middleware`.
+Use `.combine(...)` with middleware that provides them. Acquired resources stay alive
+until the request scope closes. Downstream action errors are handled by their transport,
+not serialized as authentication failures.
+
+`ActionMcp.protectedResource({ resource, authorizationServers, scopesSupported })`
+returns `{ layer, metadataUrl, challenge }`. Mount its public `layer` separately from
+protected routes. It publishes [RFC 9728 metadata](https://www.rfc-editor.org/rfc/rfc9728.html)
+at `/.well-known/oauth-protected-resource` followed by the resource path and query. Discovery
+matches that literal path and query for GET and HEAD; other requests reach the host router.
+Caching policy belongs to the host. `challenge()`
+returns the `WWW-Authenticate` value; pass `{ error: "invalid_token" }` or
+`{ error: "insufficient_scope", scope: "admin" }` where appropriate. Supported scopes
+are advertised in metadata; the challenge names only scopes needed for that request.
+The helper supports HTTPS URLs and loopback HTTP for development, with no credentials
+or fragment. Resource identifiers may include a query; authorization-server issuers may not.
+Your application owns login, consent, and token verification.
+
+## MCP testing
+
+Import `mcpRequest` from `@gjermundgaraba/effect-actions/testing`; it requires no MCP client dependency.
+Import `withMcpClient` from `@gjermundgaraba/effect-actions/testing/client` and install
+its optional peer `@modelcontextprotocol/client@^2.0.0`. Only the client entry point loads this peer.
+
+- `mcpRequest(method, params?, { url, headers? })` builds a stateless 2026-07-28 request.
+  `url` is required. Caller `params._meta` fields override the default client capabilities
+  and information; application metadata is preserved. The protocol version stays pinned to
+  2026-07-28 in both the request header and metadata. Metadata is merged shallowly.
+- `withMcpClient(fetch, async client => ..., { path, mode?, baseUrl?, headers? })`
+  connects the official client and closes it in a `finally` block. `path` is required.
+  `mode` defaults to `"modern"` (2026-07-28); use `"legacy"` to exercise session negotiation.

package/dist/Action.d.mts

@@ -0,0 +1,54 @@
+import { Effect, Schema } from "effect";
+declare namespace Action_d_exports {
+  export { Action, Any, Codec, Handler, McpOptions, NoInput, Options, SchemaErrorPolicy, SchemaFailure, make };
+}
+export type Codec = Schema.Codec<unknown, unknown, never, never>;
+/** Failed request decoding or successful-result encoding, independent of transport terminology. */
+export interface SchemaFailure {
+  readonly phase: "input" | "output";
+  /** May contain sensitive values. Do not reflect it in public error messages. */
+  readonly cause: Schema.SchemaError;
+}
+/** Pure application-owned mapping, shared by the HTTP and MCP adapters. */
+export interface SchemaErrorPolicy<Errors extends ReadonlyArray<Codec>> {
+  readonly errors: Errors;
+  readonly map: (failure: SchemaFailure) => NoInfer<Errors[number]["Type"]>;
+}
+export interface McpOptions {
+  readonly name?: string;
+  readonly readOnly?: boolean;
+  /** Defaults to `!readOnly`; the MCP spec only defines it for non-read-only tools. */
+  readonly destructive?: boolean;
+}
+export interface Options<Input extends Codec, Output extends Codec, Errors extends ReadonlyArray<Codec>, Http extends boolean = boolean> {
+  readonly description: string;
+  /** Defaults to `NoInput`. */
+  readonly input?: Input;
+  readonly success: Output;
+  /** One schema per declared failure; each keeps its own HTTP status annotation. Defaults to none. */
+  readonly error?: Errors;
+  readonly http?: Http;
+  readonly mcp?: false | McpOptions;
+}
+/** A pure contract: schemas and transport metadata. Implementations are bound by `ActionGroup.implement`. */
+export interface Action<Name extends string, Input extends Codec, Output extends Codec, Errors extends ReadonlyArray<Codec>, Http extends boolean = boolean> {
+  readonly name: Name;
+  readonly description: string;
+  readonly input: Input;
+  readonly success: Output;
+  readonly errors: Errors;
+  readonly http: Http;
+  readonly mcp: false | {
+    readonly name: string;
+    readonly readOnly: boolean;
+    readonly destructive: boolean;
+  };
+}
+export type Any = Action<string, Codec, Codec, ReadonlyArray<Codec>>;
+/** Receives decoded input; may fail only with the declared errors. */
+export type Handler<A extends Any, R = never> = (input: A["input"]["Type"]) => Effect.Effect<A["success"]["Type"], A["errors"][number]["Type"], R>;
+/** An empty object schema that also produces the object root MCP requires. */
+export declare const NoInput: Schema.$Record<Schema.String, Schema.Never>;
+export declare function make<const Name extends string, Input extends Codec = typeof NoInput, Output extends Codec = never, const Errors extends ReadonlyArray<Codec> = [], const Http extends boolean = true>(name: Name, options: Options<Input, Output, Errors, Http>): Action<Name, Input, Output, Errors, Http>;
+//#endregion
+export { Action_d_exports as t };

package/dist/Action.mjs

@@ -0,0 +1,30 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+import { Schema } from "effect";
+//#region src/Action.ts
+var Action_exports = /* @__PURE__ */ __exportAll({
+	NoInput: () => NoInput,
+	make: () => make
+});
+/** An empty object schema that also produces the object root MCP requires. */
+const NoInput = Schema.Record(Schema.String, Schema.Never);
+function make(name, options) {
+	if (!/^[A-Za-z][A-Za-z0-9_-]*$/.test(name)) throw new Error(`Invalid action name: ${name}`);
+	const readOnly = options.mcp === false ? false : options.mcp?.readOnly ?? false;
+	const mcp = options.mcp === false ? false : {
+		name: options.mcp?.name ?? name,
+		readOnly,
+		destructive: options.mcp?.destructive ?? !readOnly
+	};
+	if (mcp !== false && !/^[A-Za-z0-9_-]{1,128}$/.test(mcp.name)) throw new Error(`Invalid MCP name: ${mcp.name}`);
+	return {
+		name,
+		description: options.description,
+		input: options.input ?? NoInput,
+		success: options.success,
+		errors: options.error ?? [],
+		http: options.http !== false,
+		mcp
+	};
+}
+//#endregion
+export { NoInput, make, Action_exports as t };

package/dist/ActionGroup.d.mts

@@ -0,0 +1,21 @@
+import { Any, Handler, t as Action_d_exports } from "./Action.mjs";
+import { t as Implementation } from "./implementation-D75QAcD3.mjs";
+import { Effect, Scope } from "effect";
+declare namespace ActionGroup_d_exports {
+  export { Group, Implementation, make };
+}
+type HandlersFrom<Actions extends ReadonlyArray<Any>> = { readonly [A in Actions[number] as A["name"]]: Handler<A, any>; };
+type HandlersContext<H> = { [K in keyof H]: H[K] extends ((input: never) => Effect.Effect<infer _A, infer _E, infer R>) ? R : never; }[keyof H];
+export interface Group<Actions extends ReadonlyArray<Any>> {
+  readonly actions: Actions;
+  /**
+   * Bind every handler at once. Pass an Effect to resolve build-time services
+   * once (`const users = yield* Users`); services yielded inside a handler are
+   * request-scoped instead. Scoped acquisition lasts for the adapter runtime.
+   */
+  readonly implement: <H extends HandlersFrom<Actions>, EX = never, RX = never>(build: H | Effect.Effect<H, EX, RX>) => Implementation<Actions, HandlersContext<H>, EX, Exclude<RX, Scope.Scope>>;
+}
+/** Duplicate action and MCP names fail at definition time. */
+export declare const make: <const Actions extends ReadonlyArray<Any>>(...actions: Actions) => Group<Actions>;
+//#endregion
+export { type Implementation, ActionGroup_d_exports as t };

package/dist/ActionGroup.mjs

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

package/dist/authentication.d.mts

@@ -0,0 +1,27 @@
+import { Codec, t as Action_d_exports } from "./Action.mjs";
+import { Context, Effect } from "effect";
+import { Headers, HttpRouter } from "effect/unstable/http";
+declare namespace Authentication_d_exports {
+  export { Options, middleware };
+}
+export interface Options<A, Errors extends ReadonlyArray<Codec>, R> {
+  readonly authenticate: Effect.Effect<A, Errors[number]["Type"], R>;
+  readonly errors: Errors;
+  readonly headers?: (error: Errors[number]["Type"]) => Headers.Input;
+}
+/**
+ * Authenticate each request and provide its identity to the downstream handler.
+ * Only authentication failures are encoded, using each schema's httpApiStatus.
+ * Dependencies remain native router request requirements. Acquired resources live
+ * until the request scope closes, including while the handler is running.
+ */
+export declare const middleware: <I, A, const Errors extends ReadonlyArray<Codec>, R>(service: Context.Key<I, A>, options: Options<NoInfer<A>, Errors, R>) => HttpRouter.Middleware<{
+  provides: I;
+  handles: never;
+  error: never;
+  requires: Exclude<R, HttpRouter.Provided> | Exclude<Exclude<import("effect/Types").NoInfer<I>, I>, HttpRouter.Provided>;
+  layerError: never;
+  layerRequires: never;
+}>;
+//#endregion
+export { Authentication_d_exports as t };

package/dist/authentication.mjs

@@ -0,0 +1,31 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+import { Effect, Schema, SchemaAST } from "effect";
+import { HttpEffect, HttpRouter, HttpServerResponse } from "effect/unstable/http";
+//#region src/Authentication.ts
+var Authentication_exports = /* @__PURE__ */ __exportAll({ middleware: () => middleware });
+/**
+* Authenticate each request and provide its identity to the downstream handler.
+* Only authentication failures are encoded, using each schema's httpApiStatus.
+* Dependencies remain native router request requirements. Acquired resources live
+* until the request scope closes, including while the handler is running.
+*/
+const middleware = (service, options) => {
+	const errors = options.errors.map((schema) => ({
+		matches: Schema.is(schema),
+		encode: HttpServerResponse.schemaJson(schema),
+		status: SchemaAST.resolveAt("httpApiStatus")(schema.ast) ?? 500
+	}));
+	return HttpRouter.middleware()((httpEffect) => options.authenticate.pipe(Effect.matchEffect({
+		onFailure: (error) => {
+			const selected = errors.find((candidate) => candidate.matches(error));
+			if (selected === void 0) return Effect.die(/* @__PURE__ */ new Error("Undeclared authentication error"));
+			return selected.encode(error, {
+				status: selected.status,
+				...options.headers === void 0 ? {} : { headers: options.headers(error) }
+			}).pipe(Effect.orDie);
+		},
+		onSuccess: (identity) => Effect.provideService(httpEffect, service, identity)
+	}), HttpEffect.withPreResponseHandler((_request, response) => Effect.succeed(HttpServerResponse.setHeader(response, "cache-control", "no-store")))));
+};
+//#endregion
+export { middleware, Authentication_exports as t };

package/dist/http.d.mts

@@ -0,0 +1,53 @@
+import { Any, Codec, SchemaErrorPolicy, t as Action_d_exports } from "./Action.mjs";
+import { t as Implementation } from "./implementation-D75QAcD3.mjs";
+import { Effect, Layer, Schema } from "effect";
+import { HttpApi, HttpApiClient, HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/unstable/httpapi";
+import { Etag, HttpClient, HttpPlatform, HttpRouter } from "effect/unstable/http";
+import { FileSystem } from "effect/FileSystem";
+import { Path } from "effect/Path";
+declare namespace ActionHttp_d_exports {
+  export { Actions, Client, ClientOptions, LayerOptions, Options, api, client, configure, layer, openapi };
+}
+export interface Options<Errors extends ReadonlyArray<Codec> = []> {
+  readonly apiPath: `/${string}`;
+  readonly schemaError?: SchemaErrorPolicy<Errors>;
+}
+/** Layer/configure options: mount path plus OpenAPI document route. */
+export interface LayerOptions<Errors extends ReadonlyArray<Codec> = []> extends Options<Errors> {
+  /** Set false when the host serves a combined document for multiple groups. */
+  readonly openapiPath: `/${string}` | false;
+}
+/** A group or its implementation. */
+export interface Actions<A extends ReadonlyArray<Any> = ReadonlyArray<Any>> {
+  readonly actions: A;
+}
+/** Distribute over the tuple so each name retains its own codecs. */
+type Endpoint<A extends Any, E extends Codec> = A extends {
+  readonly http: false;
+} ? never : A extends Any ? HttpApiEndpoint.HttpApiEndpoint<A["name"], "POST", `/${string}`, never, never, Schema.toCodecJson<A["input"]>, never, Schema.toCodecJson<A["success"]>, Schema.toCodecJson<A["errors"][number] | E>> : never;
+/** The native `HttpApi` for every HTTP-enabled action: `POST <apiPath>/<name>`. */
+export declare function api<A extends ReadonlyArray<Any>, Errors extends ReadonlyArray<Codec> = []>(group: Actions<A>, options: Options<Errors>): HttpApi.HttpApi<"actions", HttpApiGroup.HttpApiGroup<"actions", Endpoint<A[number], Errors[number]>>>;
+/** The OpenAPI 3.1 document Effect derives from `api`. */
+export declare const openapi: <Errors extends ReadonlyArray<Codec> = []>(group: Actions, options: Options<Errors>) => OpenApi.OpenAPISpec;
+/**
+ * Register the endpoints and optional OpenAPI document route on the router.
+ * Handler requirements are request-level requirements, exactly as native
+ * `HttpApiBuilder` handlers' are. Groups with no HTTP action register nothing.
+ */
+export declare const layer: <Actions extends ReadonlyArray<Any>, R, EX, RX, Errors extends ReadonlyArray<Codec> = []>(app: Implementation<Actions, R, EX, RX>, options: LayerOptions<Errors>) => Layer.Layer<never, EX, RX | HttpRouter.HttpRouter | HttpRouter.Request.From<"Requires", R> | Etag.Generator | FileSystem | HttpPlatform.HttpPlatform | Path>;
+type NativeClientOptions = NonNullable<Parameters<typeof HttpApiClient.make>[1]>;
+/** Connection options plus the transport configuration used by HTTP clients. */
+export type ClientOptions<Errors extends ReadonlyArray<Codec> = []> = NativeClientOptions & Options<Errors>;
+/** Direct decoded-input methods, excluding MCP-only actions. */
+export type Client<A extends ReadonlyArray<Any>, E extends Codec = never> = { readonly [Item in A[number] as Item["http"] extends false ? never : Item["name"]]: (...args: {} extends Item["input"]["Type"] ? [input?: Item["input"]["Type"]] : [input: Item["input"]["Type"]]) => HttpApiClient.Client.MethodReturn<Endpoint<Item, E>, never, never, "decoded-only">; };
+/** Bind transport configuration once for contracts, routes, documents and clients. */
+export declare const configure: <Errors extends ReadonlyArray<Codec> = []>(options: LayerOptions<Errors>) => {
+  api: <A extends ReadonlyArray<Any>>(group: Actions<A>) => HttpApi.HttpApi<"actions", HttpApiGroup.HttpApiGroup<"actions", Endpoint<A[number], Errors[number]>, false>>;
+  openapi: (group: Actions) => OpenApi.OpenAPISpec;
+  layer: <A extends ReadonlyArray<Any>, R, EX, RX>(app: Implementation<A, R, EX, RX>) => Layer.Layer<never, EX, RX | FileSystem | Etag.Generator | HttpPlatform.HttpPlatform | HttpRouter.HttpRouter | Path | HttpRouter.Request.From<"Requires", R>>;
+  client: <A extends ReadonlyArray<Any>>(group: Actions<A>, { baseUrl, transformClient, transformResponse }?: NativeClientOptions) => Effect.Effect<Client<A, Errors[number]>, never, HttpClient.HttpClient>;
+};
+/** Direct action methods backed by the native HTTP client and its codecs. */
+export declare function client<A extends ReadonlyArray<Any>, Errors extends ReadonlyArray<Codec> = []>(group: Actions<A>, options: ClientOptions<Errors>): Effect.Effect<Client<A, Errors[number]>, never, HttpClient.HttpClient>;
+//#endregion
+export { ActionHttp_d_exports as t };

package/dist/http.mjs

@@ -0,0 +1,74 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+import { n as handlerFor, t as Implementation } from "./implementation-BkLqMWtv.mjs";
+import { Context, Effect, Layer, Schema } from "effect";
+import { HttpApi, HttpApiBuilder, HttpApiClient, HttpApiEndpoint, HttpApiGroup, HttpApiMiddleware, OpenApi } from "effect/unstable/httpapi";
+//#region src/ActionHttp.ts
+var ActionHttp_exports = /* @__PURE__ */ __exportAll({
+	api: () => api,
+	client: () => client,
+	configure: () => configure,
+	layer: () => layer,
+	openapi: () => openapi
+});
+const endpoint = (apiPath, action, errors) => HttpApiEndpoint.post(action.name, `${apiPath}/${action.name}`, {
+	payload: action.input,
+	success: action.success,
+	error: [...action.errors, ...errors]
+}).annotate(OpenApi.Description, action.description);
+function api(group, options) {
+	const [first, ...rest] = group.actions.filter((action) => action.http).map((action) => endpoint(options.apiPath, action, options.schemaError?.errors ?? []));
+	if (first === void 0) throw new Error("No HTTP-enabled actions");
+	return HttpApi.make("actions").add(HttpApiGroup.make("actions").add(first, ...rest));
+}
+/** The OpenAPI 3.1 document Effect derives from `api`. */
+const openapi = (group, options) => OpenApi.fromApi(api(group, options));
+/**
+* Register the endpoints and optional OpenAPI document route on the router.
+* Handler requirements are request-level requirements, exactly as native
+* `HttpApiBuilder` handlers' are. Groups with no HTTP action register nothing.
+*/
+const layer = (app, options) => {
+	const exposed = app.actions.filter((action) => action.http);
+	if (exposed.length === 0) return Layer.empty;
+	const policy = options.schemaError;
+	class SchemaErrors extends HttpApiMiddleware.Service()("effect-actions/http/SchemaErrors", { error: policy?.errors ?? [] }) {}
+	const schemaErrors = HttpApiMiddleware.layerSchemaErrorTransform(SchemaErrors, (failure) => Effect.fail(policy === void 0 ? failure : policy.map({
+		phase: failure.kind === "Body" || failure.kind === "ResponseHeaders" ? "output" : "input",
+		cause: failure.cause
+	})));
+	const httpApi = api(app, options).middleware(SchemaErrors);
+	return Implementation.register(app, (table) => {
+		const group = HttpApiBuilder.group(httpApi, "actions", (handlers) => handlers.handleAll(Object.fromEntries(exposed.map((action) => {
+			const handle = handlerFor(table, action);
+			return [action.name, (request) => handle(request.payload)];
+		}))));
+		const isolated = Layer.fromBuildMemo((memoMap, scope) => Layer.buildWithMemoMap(group.pipe(Layer.provide(schemaErrors)), memoMap, scope).pipe(Effect.setContext(Context.empty())));
+		return HttpApiBuilder.layer(httpApi, { openapiPath: options.openapiPath === false ? void 0 : options.openapiPath }).pipe(Layer.provide(isolated));
+	});
+};
+/** Bind transport configuration once for contracts, routes, documents and clients. */
+const configure = (options) => ({
+	api: (group) => api(group, options),
+	openapi: (group) => openapi(group, options),
+	layer: (app) => layer(app, options),
+	client: (group, { baseUrl, transformClient, transformResponse } = {}) => client(group, {
+		...options,
+		baseUrl,
+		transformClient,
+		transformResponse
+	})
+});
+function client(group, options) {
+	return Effect.map(HttpApiClient.make(api(group, options), options), (native) => {
+		const acceptsUndefined = new Set(group.actions.filter((action) => Schema.is(action.input)(void 0)).map((action) => action.name));
+		return Object.fromEntries(Object.entries(native.actions).map(([name, method]) => {
+			if (name === "then") throw new Error("Action \"then\" requires the native grouped HttpApiClient");
+			return [name, (input) => method({
+				payload: input === void 0 && !acceptsUndefined.has(name) ? {} : input,
+				responseMode: "decoded-only"
+			})];
+		}));
+	});
+}
+//#endregion
+export { api, client, configure, layer, openapi, ActionHttp_exports as t };

package/dist/implementation-BkLqMWtv.mjs

@@ -0,0 +1,32 @@
+import { Context, Effect, Layer } from "effect";
+//#region src/internal/implementation.ts
+const handlerFor = (table, action) => {
+	const handle = table[action.name];
+	if (handle === void 0) throw new Error(`Missing handler: ${action.name}`);
+	return handle;
+};
+let implementations = 0;
+/**
+* Opaque implementation value; only its type is public. `R` is required per
+* request, `EX`/`RX` describe handler acquisition at Layer build. Layer
+* memoization lets both adapters share one handler build per runtime.
+*/
+var Implementation = class Implementation {
+	actions;
+	#handlers;
+	#layer;
+	constructor(actions, handlers, layer) {
+		this.actions = actions;
+		this.#handlers = handlers;
+		this.#layer = layer;
+	}
+	static make(actions, build) {
+		const handlers = Context.Service(`effect-actions/Handlers#${++implementations}`);
+		return new Implementation(actions, handlers, Layer.effect(handlers, build));
+	}
+	static register(app, make) {
+		return Layer.unwrap(Effect.map(app.#handlers, make)).pipe(Layer.provide(app.#layer));
+	}
+};
+//#endregion
+export { handlerFor as n, Implementation as t };

package/dist/implementation-D75QAcD3.d.mts

@@ -0,0 +1,21 @@
+import { Any, t as Action_d_exports } from "./Action.mjs";
+import { Effect, Layer, Scope } from "effect";
+//#region src/internal/implementation.d.ts
+type Erased<R> = {
+  handle(input: unknown): Effect.Effect<unknown, unknown, R>;
+}["handle"];
+type Handlers<R> = Readonly<Record<string, Erased<R>>>;
+/**
+ * Opaque implementation value; only its type is public. `R` is required per
+ * request, `EX`/`RX` describe handler acquisition at Layer build. Layer
+ * memoization lets both adapters share one handler build per runtime.
+ */
+declare class Implementation<Actions extends ReadonlyArray<Any>, R, EX, RX> {
+  #private;
+  readonly actions: Actions;
+  private constructor();
+  static make<Actions extends ReadonlyArray<Any>, R, EX, RX>(actions: Actions, build: Effect.Effect<Handlers<R>, EX, RX>): Implementation<Actions, R, EX, Exclude<RX, Scope.Scope>>;
+  static register<Actions extends ReadonlyArray<Any>, R, EX, RX, Out, E, In>(app: Implementation<Actions, R, EX, RX>, make: (handlers: Handlers<R>) => Layer.Layer<Out, E, In>): Layer.Layer<Out, E | EX, In | RX>;
+}
+//#endregion
+export { Implementation as t };

package/dist/index.d.mts

@@ -0,0 +1,6 @@
+import { t as Action_d_exports } from "./Action.mjs";
+import { t as ActionGroup_d_exports } from "./ActionGroup.mjs";
+import { t as ActionHttp_d_exports } from "./http.mjs";
+import { t as ActionMcp_d_exports } from "./mcp.mjs";
+import { t as Authentication_d_exports } from "./authentication.mjs";
+export { Action_d_exports as Action, ActionGroup_d_exports as ActionGroup, ActionHttp_d_exports as ActionHttp, ActionMcp_d_exports as ActionMcp, Authentication_d_exports as Authentication };

package/dist/index.mjs

@@ -0,0 +1,6 @@
+import { t as Action_exports } from "./Action.mjs";
+import { t as ActionGroup_exports } from "./ActionGroup.mjs";
+import { t as ActionHttp_exports } from "./http.mjs";
+import { t as ActionMcp_exports } from "./mcp.mjs";
+import { t as Authentication_exports } from "./authentication.mjs";
+export { Action_exports as Action, ActionGroup_exports as ActionGroup, ActionHttp_exports as ActionHttp, ActionMcp_exports as ActionMcp, Authentication_exports as Authentication };

package/dist/mcp.d.mts

@@ -0,0 +1,46 @@
+import { Any, Codec, SchemaErrorPolicy, t as Action_d_exports } from "./Action.mjs";
+import { t as Implementation } from "./implementation-D75QAcD3.mjs";
+import { Cause, Layer } from "effect";
+import { McpProtocol } from "effect/unstable/ai";
+import { HttpRouter } from "effect/unstable/http";
+import { NonEmptyReadonlyArray } from "effect/Array";
+declare namespace ActionMcp_d_exports {
+  export { BearerChallengeOptions, Options, ProtectedResourceOptions, layer, protectedResource, protocols };
+}
+export interface Options<Errors extends ReadonlyArray<Codec> = []> {
+  readonly schemaError?: SchemaErrorPolicy<Errors>;
+  readonly name: string;
+  readonly version: string;
+  readonly path: HttpRouter.PathInput;
+  readonly protocols?: NonEmptyReadonlyArray<McpProtocol.ProtocolAdapter>;
+  readonly allowedOrigins?: ReadonlyArray<string>;
+  readonly instructions?: string;
+}
+/** Protocol revisions served over Streamable HTTP; 2026-07-28 is stateless. */
+export declare const protocols: NonEmptyReadonlyArray<McpProtocol.ProtocolAdapter>;
+/** A Streamable HTTP MCP endpoint serving the group's MCP-enabled actions. */
+export declare const layer: <Actions extends ReadonlyArray<Any>, R, EX, RX, Errors extends ReadonlyArray<Codec> = []>(app: Implementation<Actions, R, EX, RX>, options: Options<Errors>) => Layer.Layer<never, EX | Cause.IllegalArgumentError, RX | HttpRouter.HttpRouter | HttpRouter.Request.From<"Requires", R>>;
+export interface ProtectedResourceOptions {
+  /** Exact OAuth resource identifier. HTTPS, or HTTP on loopback for development. */
+  readonly resource: string;
+  readonly authorizationServers: NonEmptyReadonlyArray<string>;
+  readonly scopesSupported?: ReadonlyArray<string>;
+  readonly resourceName?: string;
+}
+export interface BearerChallengeOptions {
+  readonly error?: "invalid_token" | "insufficient_scope";
+  readonly errorDescription?: string;
+  /** Space-separated scopes needed for this request, not all supported scopes. */
+  readonly scope?: string;
+}
+/**
+ * Publish RFC 9728 discovery independently from the authenticated MCP route.
+ * This supplies metadata and challenges; the host still verifies access tokens.
+ */
+export declare const protectedResource: (options: ProtectedResourceOptions) => {
+  layer: Layer.Layer<never, never, HttpRouter.HttpRouter>;
+  metadataUrl: string;
+  challenge: (challenge?: BearerChallengeOptions) => string;
+};
+//#endregion
+export { ActionMcp_d_exports as t };

package/dist/mcp.mjs

@@ -0,0 +1,189 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+import { n as handlerFor, t as Implementation } from "./implementation-BkLqMWtv.mjs";
+import { Context, Effect, JsonPointer, Layer, Schema } from "effect";
+import { McpProtocol, McpSchema, McpServer, Tool } from "effect/unstable/ai";
+import { HttpRouter, HttpServerRequest, HttpServerResponse } from "effect/unstable/http";
+//#region src/ActionMcp.ts
+var ActionMcp_exports = /* @__PURE__ */ __exportAll({
+	layer: () => layer,
+	protectedResource: () => protectedResource,
+	protocols: () => protocols
+});
+/** Protocol revisions served over Streamable HTTP; 2026-07-28 is stateless. */
+const protocols = [
+	McpProtocol.v2026_07_28,
+	McpProtocol.v2025_11_25,
+	McpProtocol.v2025_06_18,
+	McpProtocol.v2025_03_26,
+	McpProtocol.v2024_11_05
+];
+const toolResult = (structuredContent, isError) => new McpSchema.CallToolResult({
+	isError,
+	structuredContent,
+	content: [{
+		type: "text",
+		text: JSON.stringify(structuredContent)
+	}]
+});
+const resolveReference = (name, what, schema, definitions) => {
+	if (typeof schema.$ref !== "string") return schema;
+	const reference = schema.$ref;
+	const path = JsonPointer.parseUriFragment(reference);
+	const key = path?.[1];
+	if (path?.length !== 2 || path[0] !== "$defs" || key === void 0) throw new Error(`${name}: unsupported MCP ${what} reference ${reference}`);
+	const definition = Object.hasOwn(definitions, key) ? definitions[key] : void 0;
+	if (definition === void 0) throw new Error(`${name}: missing MCP ${what} reference ${reference}`);
+	return definition;
+};
+/** MCP `inputSchema` requires a literal object root. */
+const inputJsonSchema = (action) => {
+	const { schema, definitions } = Schema.toJsonSchemaDocument(action.input);
+	const root = resolveReference(action.name, "input", schema, definitions);
+	if (root.type !== "object") throw new Error(`${action.name}: MCP input must have an object root; use Action.NoInput for no arguments`);
+	return Object.keys(definitions).length === 0 ? root : {
+		...root,
+		$defs: definitions
+	};
+};
+/** Declared errors are published as-is in `structuredContent`, so each must encode to an object. */
+const assertObjectError = (owner, error) => {
+	const { schema, definitions } = Schema.toJsonSchemaDocument(error);
+	const visited = /* @__PURE__ */ new Set();
+	const encodesObject = (candidate) => {
+		const root = resolveReference(owner, "error", candidate, definitions);
+		if (root.type === "object" || visited.has(root)) return true;
+		visited.add(root);
+		const members = root.anyOf ?? root.oneOf;
+		return Array.isArray(members) && members.length > 0 && members.every(encodesObject);
+	};
+	if (!encodesObject(schema)) throw new Error(`${owner}: MCP error must have an object root`);
+};
+const registerTool = (action, table, policy) => Effect.gen(function* () {
+	if (action.mcp === false) return;
+	const server = yield* McpServer.McpServer;
+	const inputSchema = yield* Schema.decodeUnknownEffect(McpSchema.ToolJson)(inputJsonSchema(action)).pipe(Effect.orDie);
+	const errors = [...action.errors, ...policy?.errors ?? []];
+	for (const error of action.errors) assertObjectError(action.name, error);
+	const input = Schema.toCodecJson(action.input);
+	const success = Schema.toCodecJson(action.success);
+	const failure = Schema.toCodecJson(Schema.Union(errors));
+	const handle = handlerFor(table, action);
+	const failureResult = (error) => Schema.encodeUnknownEffect(failure)(error).pipe(Effect.orDie, Effect.map((json) => toolResult(json, true)));
+	const schemaFailure = (phase, cause) => {
+		if (policy !== void 0) return failureResult(policy.map({
+			phase,
+			cause
+		}));
+		if (phase === "input") return Effect.fail(new McpSchema.InvalidParams({ message: cause.message }));
+		return Effect.die(cause);
+	};
+	const successResult = (value) => Schema.encodeUnknownEffect(success)(value).pipe(Effect.matchEffect({
+		onFailure: (cause) => schemaFailure("output", cause),
+		onSuccess: (json) => Effect.succeed(toolResult({ value: json }, false))
+	}));
+	yield* server.addTool({
+		tool: new McpSchema.Tool({
+			name: action.mcp.name,
+			description: action.description,
+			inputSchema,
+			outputSchema: Tool.getJsonSchemaFromSchema(Schema.Struct({ value: action.success })),
+			annotations: {
+				readOnlyHint: action.mcp.readOnly,
+				destructiveHint: action.mcp.destructive
+			}
+		}),
+		annotations: Context.empty(),
+		handle: (payload) => Schema.decodeUnknownEffect(input)(payload).pipe(Effect.matchEffect({
+			onFailure: (cause) => schemaFailure("input", cause),
+			onSuccess: (decoded) => handle(decoded).pipe(Effect.matchEffect({
+				onSuccess: successResult,
+				onFailure: failureResult
+			}))
+		}))
+	});
+});
+const registrationRouter = (router, context) => HttpRouter.HttpRouter.of({
+	...router,
+	add: (method, path, handler, options) => router.add(method, path, handler, options).pipe(Effect.provideContext(context)),
+	addAll: (routes) => router.addAll(routes).pipe(Effect.provideContext(context)),
+	prefixed: (prefix) => registrationRouter(router.prefixed(prefix), context)
+});
+/** A Streamable HTTP MCP endpoint serving the group's MCP-enabled actions. */
+const layer = (app, options) => Implementation.register(app, (table) => {
+	const native = Layer.effectDiscard(Effect.gen(function* () {
+		if (app.actions.some((action) => action.mcp !== false)) for (const error of options.schemaError?.errors ?? []) assertObjectError("Schema-error policy", error);
+		yield* Effect.forEach(app.actions, (action) => registerTool(action, table, options.schemaError), { discard: true });
+	})).pipe(Layer.provide(McpServer.layerHttp({
+		name: options.name,
+		version: options.version,
+		instructions: options.instructions,
+		path: options.path,
+		protocols: options.protocols ?? protocols,
+		allowedOrigins: options.allowedOrigins
+	})), Layer.fresh);
+	return Layer.fromBuildMemo((memoMap, scope) => Effect.gen(function* () {
+		const router = registrationRouter(yield* HttpRouter.HttpRouter, yield* Effect.context());
+		return yield* Layer.buildWithMemoMap(native, memoMap, scope).pipe(Effect.setContext(Context.make(HttpRouter.HttpRouter, router)));
+	}));
+});
+const oauthUrl = (value) => {
+	const url = new URL(value);
+	const loopback = [
+		"localhost",
+		"127.0.0.1",
+		"[::1]"
+	].includes(url.hostname);
+	if (url.protocol !== "https:" && !(url.protocol === "http:" && loopback) || url.username !== "" || url.password !== "" || value.includes("#")) throw new Error("OAuth URLs must use HTTPS (or loopback HTTP) without credentials or fragment");
+	return url;
+};
+const scopeToken = /^[\x21\x23-\x5B\x5D-\x7E]+$/;
+/**
+* Publish RFC 9728 discovery independently from the authenticated MCP route.
+* This supplies metadata and challenges; the host still verifies access tokens.
+*/
+const protectedResource = (options) => {
+	const resource = oauthUrl(options.resource);
+	if (options.authorizationServers.length === 0) throw new Error("An authorization server is required");
+	for (const issuer of options.authorizationServers) {
+		oauthUrl(issuer);
+		if (issuer.includes("?")) throw new Error("Authorization server issuers must not contain a query");
+	}
+	for (const scope of options.scopesSupported ?? []) if (!scopeToken.test(scope)) throw new Error("Invalid OAuth scope token");
+	const path = `/.well-known/oauth-protected-resource${resource.pathname === "/" ? "" : resource.pathname}`;
+	const discoveryUrl = new URL(resource);
+	discoveryUrl.pathname = path;
+	const metadataUrl = discoveryUrl.href;
+	const target = metadataUrl.slice(discoveryUrl.origin.length);
+	const metadata = {
+		resource: options.resource,
+		authorization_servers: options.authorizationServers,
+		bearer_methods_supported: ["header"],
+		...options.scopesSupported?.length ? { scopes_supported: options.scopesSupported } : {},
+		...options.resourceName === void 0 ? {} : { resource_name: options.resourceName }
+	};
+	const response = HttpServerResponse.jsonUnsafe(metadata);
+	return {
+		layer: HttpRouter.middleware((next) => Effect.gen(function* () {
+			const request = yield* HttpServerRequest.HttpServerRequest;
+			const url = new URL(request.url, resource.origin);
+			if ((request.method === "GET" || request.method === "HEAD") && url.href.slice(url.origin.length) === target) return response;
+			return yield* next;
+		}), { global: true }),
+		metadataUrl,
+		challenge: (challenge = {}) => {
+			const parameters = [`resource_metadata="${metadataUrl.replace(/["\\]/g, "\\$&")}"`];
+			if (challenge.error !== void 0) parameters.push(`error="${challenge.error}"`);
+			if (challenge.errorDescription !== void 0) {
+				if (!/^[\x20-\x21\x23-\x5B\x5D-\x7E]*$/.test(challenge.errorDescription)) throw new Error("Invalid OAuth error description");
+				parameters.push(`error_description="${challenge.errorDescription}"`);
+			}
+			if (challenge.scope !== void 0) {
+				if (!challenge.scope.split(" ").every((scope) => scopeToken.test(scope))) throw new Error("Invalid OAuth challenge scope");
+				parameters.push(`scope="${challenge.scope}"`);
+			}
+			return `Bearer ${parameters.join(", ")}`;
+		}
+	};
+};
+//#endregion
+export { layer, protectedResource, protocols, ActionMcp_exports as t };

package/dist/rolldown-runtime-D7D4PA-g.mjs

@@ -0,0 +1,13 @@
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+export { __exportAll as t };

package/dist/testing/client.d.mts

@@ -0,0 +1,11 @@
+import { Client } from "@modelcontextprotocol/client";
+//#region src/TestingClient.d.ts
+export interface McpClientOptions {
+  readonly path: string;
+  readonly mode?: "legacy" | "modern";
+  readonly baseUrl?: string | URL;
+  readonly headers?: ConstructorParameters<typeof Headers>[0];
+}
+/** Connect an official client and always close its transport after the callback. */
+export declare const withMcpClient: <A>(fetch: (request: Request) => Promise<Response>, run: (client: Client) => Promise<A>, { mode, path, baseUrl, headers }: McpClientOptions) => Promise<A>;
+//#endregion

package/dist/testing/client.mjs

@@ -0,0 +1,20 @@
+import { Client, StreamableHTTPClientTransport } from "@modelcontextprotocol/client";
+//#region src/TestingClient.ts
+/** Connect an official client and always close its transport after the callback. */
+const withMcpClient = async (fetch, run, { mode = "modern", path, baseUrl = "http://localhost", headers }) => {
+	const client = new Client({
+		name: "test",
+		version: "0"
+	}, { versionNegotiation: { mode: mode === "modern" ? { pin: "2026-07-28" } : "legacy" } });
+	try {
+		await client.connect(new StreamableHTTPClientTransport(new URL(path, baseUrl), {
+			...headers === void 0 ? {} : { requestInit: { headers } },
+			fetch: (input, init) => fetch(new Request(input, init))
+		}));
+		return await run(client);
+	} finally {
+		await client.close();
+	}
+};
+//#endregion
+export { withMcpClient };

package/dist/testing.d.mts

@@ -0,0 +1,10 @@
+//#region src/Testing.d.ts
+/** A stateless 2026-07-28 request. */
+export interface McpRequestOptions {
+  readonly url: string | URL;
+  readonly headers?: ConstructorParameters<typeof Headers>[0];
+}
+export declare const mcpRequest: (method: string, params: (Record<string, unknown> & {
+  readonly _meta?: Record<string, unknown>;
+}) | undefined, options: McpRequestOptions) => Request;
+//#endregion

package/dist/testing.mjs

@@ -0,0 +1,34 @@
+//#region src/Testing.ts
+const mcpRequest = (method, params = {}, options) => {
+	const headers = new Headers(options.headers);
+	for (const [name, value] of Object.entries({
+		"content-type": "application/json",
+		accept: "application/json, text/event-stream",
+		"mcp-protocol-version": "2026-07-28",
+		"mcp-method": method,
+		...typeof params.name === "string" ? { "mcp-name": params.name } : {}
+	})) headers.set(name, value);
+	return new Request(options.url, {
+		method: "POST",
+		headers,
+		body: JSON.stringify({
+			jsonrpc: "2.0",
+			id: 1,
+			method,
+			params: {
+				...params,
+				_meta: {
+					"io.modelcontextprotocol/clientCapabilities": {},
+					"io.modelcontextprotocol/clientInfo": {
+						name: "test",
+						version: "0"
+					},
+					...params._meta,
+					"io.modelcontextprotocol/protocolVersion": "2026-07-28"
+				}
+			}
+		})
+	});
+};
+//#endregion
+export { mcpRequest };

package/package.json

@@ -0,0 +1,69 @@
+{
+  "name": "@gjermundgaraba/effect-actions",
+  "version": "0.1.0-rc.0",
+  "description": "Define Effect action contracts once and expose them over HTTP and MCP.",
+  "homepage": "https://github.com/gjermundgaraba/effect-actions#readme",
+  "bugs": {
+    "url": "https://github.com/gjermundgaraba/effect-actions/issues"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/gjermundgaraba/effect-actions.git"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "exports": {
+    ".": "./dist/index.mjs",
+    "./Action": "./dist/Action.mjs",
+    "./ActionGroup": "./dist/ActionGroup.mjs",
+    "./authentication": "./dist/authentication.mjs",
+    "./http": "./dist/http.mjs",
+    "./mcp": "./dist/mcp.mjs",
+    "./testing": "./dist/testing.mjs",
+    "./testing/client": "./dist/testing/client.mjs",
+    "./package.json": "./package.json"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "@effect/platform-node": "https://pkg.pr.new/Effect-TS/effect/@effect/platform-node@4e4a3a6",
+    "@modelcontextprotocol/client": "2.0.0",
+    "@types/node": "26.5.1",
+    "effect": "https://pkg.pr.new/Effect-TS/effect/effect@4e4a3a6",
+    "tsx": "4.23.13",
+    "typescript": "7.0.2",
+    "vite": "npm:@voidzero-dev/vite-plus-core@0.3.2",
+    "vite-plus": "0.3.2"
+  },
+  "peerDependencies": {
+    "@modelcontextprotocol/client": "^2.0.0",
+    "effect": "4.0.0-rc.115"
+  },
+  "peerDependenciesMeta": {
+    "@modelcontextprotocol/client": {
+      "optional": true
+    }
+  },
+  "devEngines": {
+    "packageManager": {
+      "name": "pnpm",
+      "version": "12.4.1",
+      "onFail": "download"
+    }
+  },
+  "engines": {
+    "node": "^22.12.0 || ^24.0.0 || >=26.0.0"
+  },
+  "scripts": {
+    "build": "vp pack",
+    "dev": "vp pack --watch",
+    "test": "vp test",
+    "check": "vp check",
+    "example": "node --import tsx examples/server.ts",
+    "test:package": "vp run build && node scripts/test-package.mjs"
+  }
+}