@effect-uai/mcp 0.12.1

package/dist/internal/schema.mjs

@@ -0,0 +1,168 @@
+import { Option, Schema } from "effect";
+//#region src/internal/schema.ts
+/**
+* Self-contained MCP wire schemas, both protocol eras. The single source of
+* truth for the wire format; nothing MCP-shaped is imported from effect.
+* Decodes are deliberately loose (unknown extra fields pass through) so
+* spec-compliant servers with richer payloads never fail the client.
+*/
+/** Every protocol version this client can speak. */
+const ProtocolVersion = Schema.Literals([
+	"2026-07-28",
+	"2025-11-25",
+	"2025-06-18"
+]);
+/** Newest version we speak: the stateless protocol, and what the probe tries first. */
+const LATEST_VERSION = "2026-07-28";
+/** The legacy handshake era we negotiate; 2025-11-25 is wire-compatible. */
+const LEGACY_VERSION = "2025-06-18";
+const isProtocolVersion = Schema.is(ProtocolVersion);
+/** Narrow a server-offered version string to one we support. */
+const asProtocolVersion = (raw) => isProtocolVersion(raw) ? Option.some(raw) : Option.none();
+/**
+* The JSON-RPC methods this client issues. Not to be confused with an HTTP
+* method: on Streamable HTTP every one of these travels as a POST, and the
+* name is mirrored into the `Mcp-Method` header.
+*/
+const McpMethod = Schema.Literals([
+	"server/discover",
+	"initialize",
+	"tools/list",
+	"tools/call"
+]);
+/** Modern `_meta` keys (SEP-2575): every request self-describes its protocol. */
+const META_PROTOCOL_VERSION = "io.modelcontextprotocol/protocolVersion";
+const META_CLIENT_INFO = "io.modelcontextprotocol/clientInfo";
+const META_CLIENT_CAPABILITIES = "io.modelcontextprotocol/clientCapabilities";
+/** Servers identify themselves in each *result's* `_meta`, not at the top level. */
+const META_SERVER_INFO = "io.modelcontextprotocol/serverInfo";
+const CLIENT_INFO = {
+	name: "@effect-uai/mcp",
+	version: "0.12.1"
+};
+/** Modern JSON-RPC error codes. */
+const CODE_HEADER_MISMATCH = -32020;
+const CODE_MISSING_CLIENT_CAPABILITY = -32021;
+const CODE_UNSUPPORTED_PROTOCOL_VERSION = -32022;
+const CODE_METHOD_NOT_FOUND = -32601;
+/**
+* A reply carrying one of these proves the server speaks a modern version, so
+* era detection corrects and retries instead of falling back to `initialize`.
+*/
+const MODERN_ERROR_CODES = /* @__PURE__ */ new Set([
+	CODE_HEADER_MISMATCH,
+	CODE_MISSING_CLIENT_CAPABILITY,
+	CODE_UNSUPPORTED_PROTOCOL_VERSION
+]);
+const JsonRpcId = Schema.Union([Schema.Number, Schema.String]);
+const JsonRpcErrorObject = Schema.Struct({
+	code: Schema.Number,
+	message: Schema.optional(Schema.String),
+	data: Schema.optional(Schema.Unknown)
+});
+/**
+* Any inbound frame: a reply (`id` + `result`/`error`), a server-initiated
+* request (`method` + `id`), or a notification (`method`, no `id`). One
+* loose struct so the reader can classify without a union decode.
+*/
+const InboundMessage = Schema.Struct({
+	id: Schema.optional(Schema.NullOr(JsonRpcId)),
+	result: Schema.optional(Schema.Unknown),
+	error: Schema.optional(JsonRpcErrorObject),
+	method: Schema.optional(Schema.String),
+	params: Schema.optional(Schema.Unknown)
+});
+const decodeInboundMessage = Schema.decodeUnknownEffect(InboundMessage);
+const requestFrame = (id, method, params) => JSON.stringify({
+	jsonrpc: "2.0",
+	id,
+	method,
+	params: params ?? {}
+});
+const notificationFrame = (method, params) => JSON.stringify(params === void 0 ? {
+	jsonrpc: "2.0",
+	method
+} : {
+	jsonrpc: "2.0",
+	method,
+	params
+});
+const resultFrame = (id, result) => JSON.stringify({
+	jsonrpc: "2.0",
+	id,
+	result
+});
+const errorFrame = (id, code, message) => JSON.stringify({
+	jsonrpc: "2.0",
+	id,
+	error: {
+		code,
+		message
+	}
+});
+const ToolInfo = Schema.Struct({
+	name: Schema.String,
+	description: Schema.optional(Schema.String),
+	inputSchema: Schema.Record(Schema.String, Schema.Unknown)
+});
+/**
+* Modern list results may carry cache metadata (`ttlMs` / `cacheScope`);
+* v1 reads but does not act on them (input for a later refresh feature).
+*/
+const ListToolsResult = Schema.Struct({
+	tools: Schema.Array(ToolInfo),
+	nextCursor: Schema.optional(Schema.String),
+	ttlMs: Schema.optional(Schema.Number),
+	cacheScope: Schema.optional(Schema.String)
+});
+const decodeListToolsResult = Schema.decodeUnknownEffect(ListToolsResult);
+const TextContent = Schema.Struct({
+	type: Schema.Literal("text"),
+	text: Schema.String
+});
+/** Non-text blocks (image / audio / resource) are placeholder-summarized in v1. */
+const OtherContent = Schema.Struct({ type: Schema.String });
+const ContentBlock = Schema.Union([TextContent, OtherContent]);
+const isTextContent = Schema.is(TextContent);
+const CallToolResult = Schema.Struct({
+	content: Schema.optionalKey(Schema.Array(ContentBlock)),
+	isError: Schema.optional(Schema.Boolean),
+	structuredContent: Schema.optional(Schema.Unknown),
+	resultType: Schema.optional(Schema.String)
+});
+const decodeCallToolResult = Schema.decodeUnknownEffect(CallToolResult);
+const ServerInfo = Schema.Struct({
+	name: Schema.String,
+	version: Schema.optional(Schema.String),
+	title: Schema.optional(Schema.String)
+});
+/** The subset of a result's `_meta` we read. */
+const ResultMeta = Schema.Struct({ [META_SERVER_INFO]: Schema.optional(ServerInfo) });
+const DiscoverResult = Schema.Struct({
+	supportedVersions: Schema.Array(Schema.String),
+	capabilities: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
+	_meta: Schema.optional(ResultMeta),
+	serverInfo: Schema.optional(ServerInfo),
+	instructions: Schema.optional(Schema.String)
+});
+const decodeDiscoverResult = Schema.decodeUnknownEffect(DiscoverResult);
+/**
+* `data` of a `-32022` UnsupportedProtocolVersionError reply. Decoded, not
+* hand-parsed: the shape is server-controlled and may carry extra fields.
+*/
+const UnsupportedVersionData = Schema.Struct({
+	supported: Schema.optional(Schema.Array(Schema.String)),
+	requested: Schema.optional(Schema.NullOr(Schema.String))
+});
+const decodeUnsupportedVersionData = Schema.decodeUnknownOption(UnsupportedVersionData);
+const InitializeResult = Schema.Struct({
+	protocolVersion: Schema.String,
+	capabilities: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
+	serverInfo: Schema.optional(ServerInfo),
+	instructions: Schema.optional(Schema.String)
+});
+const decodeInitializeResult = Schema.decodeUnknownEffect(InitializeResult);
+//#endregion
+export { CLIENT_INFO, CODE_HEADER_MISMATCH, CODE_METHOD_NOT_FOUND, CODE_MISSING_CLIENT_CAPABILITY, CODE_UNSUPPORTED_PROTOCOL_VERSION, CallToolResult, ContentBlock, DiscoverResult, InboundMessage, InitializeResult, JsonRpcErrorObject, JsonRpcId, LATEST_VERSION, LEGACY_VERSION, ListToolsResult, META_CLIENT_CAPABILITIES, META_CLIENT_INFO, META_PROTOCOL_VERSION, META_SERVER_INFO, MODERN_ERROR_CODES, McpMethod, OtherContent, ProtocolVersion, ResultMeta, ServerInfo, TextContent, ToolInfo, UnsupportedVersionData, asProtocolVersion, decodeCallToolResult, decodeDiscoverResult, decodeInboundMessage, decodeInitializeResult, decodeListToolsResult, decodeUnsupportedVersionData, errorFrame, isTextContent, notificationFrame, requestFrame, resultFrame };
+
+//# sourceMappingURL=schema.mjs.map

package/dist/internal/schema.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.mjs","names":[],"sources":["../../src/internal/schema.ts"],"sourcesContent":["/**\n * Self-contained MCP wire schemas, both protocol eras. The single source of\n * truth for the wire format; nothing MCP-shaped is imported from effect.\n * Decodes are deliberately loose (unknown extra fields pass through) so\n * spec-compliant servers with richer payloads never fail the client.\n */\nimport { Option, Schema } from \"effect\"\n\n// ---------------------------------------------------------------------------\n// Protocol versions\n// ---------------------------------------------------------------------------\n\n/** Every protocol version this client can speak. */\nexport const ProtocolVersion = Schema.Literals([\"2026-07-28\", \"2025-11-25\", \"2025-06-18\"])\nexport type ProtocolVersion = typeof ProtocolVersion.Type\n\n/** Newest version we speak: the stateless protocol, and what the probe tries first. */\nexport const LATEST_VERSION = \"2026-07-28\" satisfies ProtocolVersion\n\n/** The legacy handshake era we negotiate; 2025-11-25 is wire-compatible. */\nexport const LEGACY_VERSION = \"2025-06-18\" satisfies ProtocolVersion\n\nconst isProtocolVersion = Schema.is(ProtocolVersion)\n\n/** Narrow a server-offered version string to one we support. */\nexport const asProtocolVersion = (raw: string): Option.Option<ProtocolVersion> =>\n  isProtocolVersion(raw) ? Option.some(raw) : Option.none()\n\n/**\n * The JSON-RPC methods this client issues. Not to be confused with an HTTP\n * method: on Streamable HTTP every one of these travels as a POST, and the\n * name is mirrored into the `Mcp-Method` header.\n */\nexport const McpMethod = Schema.Literals([\n  \"server/discover\",\n  \"initialize\",\n  \"tools/list\",\n  \"tools/call\",\n])\nexport type McpMethod = typeof McpMethod.Type\n\n/** Modern `_meta` keys (SEP-2575): every request self-describes its protocol. */\nexport const META_PROTOCOL_VERSION = \"io.modelcontextprotocol/protocolVersion\"\nexport const META_CLIENT_INFO = \"io.modelcontextprotocol/clientInfo\"\nexport const META_CLIENT_CAPABILITIES = \"io.modelcontextprotocol/clientCapabilities\"\n/** Servers identify themselves in each *result's* `_meta`, not at the top level. */\nexport const META_SERVER_INFO = \"io.modelcontextprotocol/serverInfo\"\n\nexport const CLIENT_INFO = { name: \"@effect-uai/mcp\", version: \"0.12.1\" }\n\n/** Modern JSON-RPC error codes. */\nexport const CODE_HEADER_MISMATCH = -32020\nexport const CODE_MISSING_CLIENT_CAPABILITY = -32021\nexport const CODE_UNSUPPORTED_PROTOCOL_VERSION = -32022\nexport const CODE_METHOD_NOT_FOUND = -32601\n\n/**\n * A reply carrying one of these proves the server speaks a modern version, so\n * era detection corrects and retries instead of falling back to `initialize`.\n */\nexport const MODERN_ERROR_CODES: ReadonlySet<number> = new Set([\n  CODE_HEADER_MISMATCH,\n  CODE_MISSING_CLIENT_CAPABILITY,\n  CODE_UNSUPPORTED_PROTOCOL_VERSION,\n])\n\n// ---------------------------------------------------------------------------\n// JSON-RPC envelope\n// ---------------------------------------------------------------------------\n\nexport const JsonRpcId = Schema.Union([Schema.Number, Schema.String])\nexport type JsonRpcId = typeof JsonRpcId.Type\n\nexport const JsonRpcErrorObject = Schema.Struct({\n  code: Schema.Number,\n  message: Schema.optional(Schema.String),\n  data: Schema.optional(Schema.Unknown),\n})\nexport type JsonRpcErrorObject = typeof JsonRpcErrorObject.Type\n\n/**\n * Any inbound frame: a reply (`id` + `result`/`error`), a server-initiated\n * request (`method` + `id`), or a notification (`method`, no `id`). One\n * loose struct so the reader can classify without a union decode.\n */\nexport const InboundMessage = Schema.Struct({\n  // Null is legal and meaningful: JSON-RPC uses it for errors raised before a\n  // request could be attributed. Rejecting it would drop the frame entirely.\n  id: Schema.optional(Schema.NullOr(JsonRpcId)),\n  result: Schema.optional(Schema.Unknown),\n  error: Schema.optional(JsonRpcErrorObject),\n  method: Schema.optional(Schema.String),\n  params: Schema.optional(Schema.Unknown),\n})\nexport type InboundMessage = typeof InboundMessage.Type\n\nexport const decodeInboundMessage = Schema.decodeUnknownEffect(InboundMessage)\n\n// --- outbound frame builders -----------------------------------------------\n\nexport const requestFrame = (id: JsonRpcId, method: string, params: unknown): string =>\n  JSON.stringify({ jsonrpc: \"2.0\", id, method, params: params ?? {} })\n\nexport const notificationFrame = (method: string, params?: unknown): string =>\n  JSON.stringify(\n    params === undefined ? { jsonrpc: \"2.0\", method } : { jsonrpc: \"2.0\", method, params },\n  )\n\nexport const resultFrame = (id: JsonRpcId, result: unknown): string =>\n  JSON.stringify({ jsonrpc: \"2.0\", id, result })\n\nexport const errorFrame = (id: JsonRpcId, code: number, message: string): string =>\n  JSON.stringify({ jsonrpc: \"2.0\", id, error: { code, message } })\n\n// ---------------------------------------------------------------------------\n// Shared: tools\n// ---------------------------------------------------------------------------\n\nexport const ToolInfo = Schema.Struct({\n  name: Schema.String,\n  description: Schema.optional(Schema.String),\n  inputSchema: Schema.Record(Schema.String, Schema.Unknown),\n})\nexport type ToolInfo = typeof ToolInfo.Type\n\n/**\n * Modern list results may carry cache metadata (`ttlMs` / `cacheScope`);\n * v1 reads but does not act on them (input for a later refresh feature).\n */\nexport const ListToolsResult = Schema.Struct({\n  tools: Schema.Array(ToolInfo),\n  nextCursor: Schema.optional(Schema.String),\n  ttlMs: Schema.optional(Schema.Number),\n  cacheScope: Schema.optional(Schema.String),\n})\nexport type ListToolsResult = typeof ListToolsResult.Type\n\nexport const decodeListToolsResult = Schema.decodeUnknownEffect(ListToolsResult)\n\n// --- content blocks ---------------------------------------------------------\n\nexport const TextContent = Schema.Struct({\n  type: Schema.Literal(\"text\"),\n  text: Schema.String,\n})\nexport type TextContent = typeof TextContent.Type\n\n/** Non-text blocks (image / audio / resource) are placeholder-summarized in v1. */\nexport const OtherContent = Schema.Struct({\n  type: Schema.String,\n})\n\nexport const ContentBlock = Schema.Union([TextContent, OtherContent])\nexport type ContentBlock = typeof ContentBlock.Type\n\nexport const isTextContent = Schema.is(TextContent)\n\nexport const CallToolResult = Schema.Struct({\n  content: Schema.optionalKey(Schema.Array(ContentBlock)),\n  isError: Schema.optional(Schema.Boolean),\n  structuredContent: Schema.optional(Schema.Unknown),\n  // Required on modern results; absent on legacy ones.\n  resultType: Schema.optional(Schema.String),\n})\nexport type CallToolResult = typeof CallToolResult.Type\n\nexport const decodeCallToolResult = Schema.decodeUnknownEffect(CallToolResult)\n\n// ---------------------------------------------------------------------------\n// Modern era (2026-07-28)\n// ---------------------------------------------------------------------------\n\nexport const ServerInfo = Schema.Struct({\n  name: Schema.String,\n  version: Schema.optional(Schema.String),\n  title: Schema.optional(Schema.String),\n})\nexport type ServerInfo = typeof ServerInfo.Type\n\n/** The subset of a result's `_meta` we read. */\nexport const ResultMeta = Schema.Struct({\n  [META_SERVER_INFO]: Schema.optional(ServerInfo),\n})\nexport type ResultMeta = typeof ResultMeta.Type\n\nexport const DiscoverResult = Schema.Struct({\n  supportedVersions: Schema.Array(Schema.String),\n  capabilities: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),\n  // Spec-conformant servers put identity in `_meta`; a top-level `serverInfo`\n  // is accepted too, since that is where the legacy handshake carries it.\n  _meta: Schema.optional(ResultMeta),\n  serverInfo: Schema.optional(ServerInfo),\n  instructions: Schema.optional(Schema.String),\n})\nexport type DiscoverResult = typeof DiscoverResult.Type\n\nexport const decodeDiscoverResult = Schema.decodeUnknownEffect(DiscoverResult)\n\n/**\n * `data` of a `-32022` UnsupportedProtocolVersionError reply. Decoded, not\n * hand-parsed: the shape is server-controlled and may carry extra fields.\n */\nexport const UnsupportedVersionData = Schema.Struct({\n  supported: Schema.optional(Schema.Array(Schema.String)),\n  requested: Schema.optional(Schema.NullOr(Schema.String)),\n})\nexport type UnsupportedVersionData = typeof UnsupportedVersionData.Type\n\nexport const decodeUnsupportedVersionData = Schema.decodeUnknownOption(UnsupportedVersionData)\n\n// ---------------------------------------------------------------------------\n// Legacy era (2025-06-18 / 2025-11-25)\n// ---------------------------------------------------------------------------\n\nexport const InitializeResult = Schema.Struct({\n  protocolVersion: Schema.String,\n  capabilities: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),\n  serverInfo: Schema.optional(ServerInfo),\n  instructions: Schema.optional(Schema.String),\n})\nexport type InitializeResult = typeof InitializeResult.Type\n\nexport const decodeInitializeResult = Schema.decodeUnknownEffect(InitializeResult)\n"],"mappings":"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"}

package/dist/internal/stdioTransport.d.mts

@@ -0,0 +1,15 @@
+import { i as McpError } from "../McpError-DWg9BlW5.mjs";
+import { i as Transport } from "../rpc-Bq95Lio9.mjs";
+import { Effect, Scope } from "effect";
+import { ChildProcessSpawner } from "effect/unstable/process";
+//#region src/internal/stdioTransport.d.ts
+type StdioConfig = {
+  readonly command: string;
+  readonly args?: ReadonlyArray<string>;
+  readonly env?: Record<string, string>;
+  readonly cwd?: string;
+};
+declare const make: (config: StdioConfig) => Effect.Effect<Transport, McpError, Scope.Scope | ChildProcessSpawner.ChildProcessSpawner>;
+//#endregion
+export { StdioConfig, make };
+//# sourceMappingURL=stdioTransport.d.mts.map

package/dist/internal/stdioTransport.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stdioTransport.d.mts","names":[],"sources":["../../src/internal/stdioTransport.ts"],"mappings":";;;;;KAWY;WACD;WACA,OAAO;WACP,MAAM;WACN;;cAKE,OAAI,QACP,gBACP,OAAO,OAAO,WAAW,UAAU,MAAM,QAAQ,oBAAoB"}

package/dist/internal/stdioTransport.mjs

@@ -0,0 +1,46 @@
+import { McpConnectFailed, McpTransportClosed } from "../McpError.mjs";
+import { Effect, Queue, Stream } from "effect";
+import * as JSONL from "@effect-uai/core/JSONL";
+import { ChildProcess } from "effect/unstable/process";
+//#region src/internal/stdioTransport.ts
+/**
+* stdio `Transport`: spawn the server, frame stdout as JSONL (one JSON message
+* per line). Scoped, so the child is killed on scope close. Era-blind; the
+* `meta.headers` a caller passes are HTTP-only and ignored here.
+*/
+const encoder = new TextEncoder();
+const make = (config) => Effect.gen(function* () {
+	const outbound = yield* Queue.make();
+	const stdin = Stream.fromQueue(outbound);
+	const handle = yield* ChildProcess.make(config.command, [...config.args ?? []], {
+		...config.cwd !== void 0 ? { cwd: config.cwd } : {},
+		...config.env !== void 0 ? { env: config.env } : {},
+		stdin: {
+			stream: stdin,
+			endOnDone: true
+		},
+		stdout: "pipe",
+		stderr: "pipe",
+		killSignal: "SIGTERM",
+		forceKillAfter: "2 seconds"
+	}).pipe(Effect.mapError((cause) => new McpConnectFailed({
+		reason: `could not spawn ${config.command}`,
+		raw: cause
+	})));
+	yield* Effect.addFinalizer(() => Queue.end(outbound));
+	const send = (frame) => Queue.offer(outbound, encoder.encode(`${frame}\n`)).pipe(Effect.mapError((cause) => new McpTransportClosed({
+		reason: "server stdin closed",
+		raw: cause
+	})), Effect.asVoid);
+	return {
+		send,
+		messages: handle.stdout.pipe(JSONL.fromBytes, Stream.mapError((cause) => new McpTransportClosed({
+			reason: "server stdout closed",
+			raw: cause
+		})))
+	};
+});
+//#endregion
+export { make };
+
+//# sourceMappingURL=stdioTransport.mjs.map

package/dist/internal/stdioTransport.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"stdioTransport.mjs","names":[],"sources":["../../src/internal/stdioTransport.ts"],"sourcesContent":["/**\n * stdio `Transport`: spawn the server, frame stdout as JSONL (one JSON message\n * per line). Scoped, so the child is killed on scope close. Era-blind; the\n * `meta.headers` a caller passes are HTTP-only and ignored here.\n */\nimport { Cause, Effect, Queue, type Scope, Stream } from \"effect\"\nimport { ChildProcess, ChildProcessSpawner } from \"effect/unstable/process\"\nimport * as JSONL from \"@effect-uai/core/JSONL\"\nimport { McpConnectFailed, type McpError, McpTransportClosed } from \"../McpError.js\"\nimport type { Transport } from \"./rpc.js\"\n\nexport type StdioConfig = {\n  readonly command: string\n  readonly args?: ReadonlyArray<string>\n  readonly env?: Record<string, string>\n  readonly cwd?: string\n}\n\nconst encoder = new TextEncoder()\n\nexport const make = (\n  config: StdioConfig,\n): Effect.Effect<Transport, McpError, Scope.Scope | ChildProcessSpawner.ChildProcessSpawner> =>\n  Effect.gen(function* () {\n    // Outbound frames go through a queue rendered as the child's stdin stream;\n    // `Queue.end` on scope close lets the child see a clean EOF.\n    const outbound = yield* Queue.make<Uint8Array, Cause.Done>()\n    const stdin = Stream.fromQueue(outbound)\n\n    const handle = yield* ChildProcess.make(config.command, [...(config.args ?? [])], {\n      ...(config.cwd !== undefined ? { cwd: config.cwd } : {}),\n      ...(config.env !== undefined ? { env: config.env } : {}),\n      stdin: { stream: stdin, endOnDone: true },\n      stdout: \"pipe\",\n      stderr: \"pipe\",\n      killSignal: \"SIGTERM\",\n      forceKillAfter: \"2 seconds\",\n    }).pipe(\n      Effect.mapError(\n        (cause) =>\n          new McpConnectFailed({ reason: `could not spawn ${config.command}`, raw: cause }),\n      ),\n    )\n    yield* Effect.addFinalizer(() => Queue.end(outbound))\n\n    const send = (frame: string): Effect.Effect<void, McpError> =>\n      Queue.offer(outbound, encoder.encode(`${frame}\\n`)).pipe(\n        Effect.mapError(\n          (cause) =>\n            new McpTransportClosed({ reason: \"server stdin closed\", raw: cause }) as McpError,\n        ),\n        Effect.asVoid,\n      )\n\n    const messages = handle.stdout.pipe(\n      JSONL.fromBytes,\n      Stream.mapError(\n        (cause) => new McpTransportClosed({ reason: \"server stdout closed\", raw: cause }),\n      ),\n    )\n\n    return { send, messages } satisfies Transport\n  })\n"],"mappings":";;;;;;;;;;AAkBA,MAAM,UAAU,IAAI,YAAY;AAEhC,MAAa,QACX,WAEA,OAAO,IAAI,aAAa;CAGtB,MAAM,WAAW,OAAO,MAAM,KAA6B;CAC3D,MAAM,QAAQ,OAAO,UAAU,QAAQ;CAEvC,MAAM,SAAS,OAAO,aAAa,KAAK,OAAO,SAAS,CAAC,GAAI,OAAO,QAAQ,CAAC,CAAE,GAAG;EAChF,GAAI,OAAO,QAAQ,KAAA,IAAY,EAAE,KAAK,OAAO,IAAI,IAAI,CAAC;EACtD,GAAI,OAAO,QAAQ,KAAA,IAAY,EAAE,KAAK,OAAO,IAAI,IAAI,CAAC;EACtD,OAAO;GAAE,QAAQ;GAAO,WAAW;EAAK;EACxC,QAAQ;EACR,QAAQ;EACR,YAAY;EACZ,gBAAgB;CAClB,CAAC,CAAC,CAAC,KACD,OAAO,UACJ,UACC,IAAI,iBAAiB;EAAE,QAAQ,mBAAmB,OAAO;EAAW,KAAK;CAAM,CAAC,CACpF,CACF;CACA,OAAO,OAAO,mBAAmB,MAAM,IAAI,QAAQ,CAAC;CAEpD,MAAM,QAAQ,UACZ,MAAM,MAAM,UAAU,QAAQ,OAAO,GAAG,MAAM,GAAG,CAAC,CAAC,CAAC,KAClD,OAAO,UACJ,UACC,IAAI,mBAAmB;EAAE,QAAQ;EAAuB,KAAK;CAAM,CAAC,CACxE,GACA,OAAO,MACT;CASF,OAAO;EAAE;EAAM,UAPE,OAAO,OAAO,KAC7B,MAAM,WACN,OAAO,UACJ,UAAU,IAAI,mBAAmB;GAAE,QAAQ;GAAwB,KAAK;EAAM,CAAC,CAClF,CAGoB;CAAE;AAC1B,CAAC"}

package/dist/protocol-kjC3iAMb.d.mts

@@ -0,0 +1,35 @@
+import { i as McpError } from "./McpError-DWg9BlW5.mjs";
+import { C as ProtocolVersion, T as ServerInfo, x as McpMethod } from "./schema-D2oUNuo5.mjs";
+import { n as McpConnection, r as SendMeta, t as Inbound } from "./rpc-Bq95Lio9.mjs";
+import { Effect, Option, Scope } from "effect";
+//#region src/internal/protocol.d.ts
+type Protocol = {
+  readonly version: ProtocolVersion;
+  readonly serverInfo: ServerInfo;
+  /** Wrap outgoing params: modern adds the `_meta` envelope, legacy passes through. */
+  readonly envelope: (method: McpMethod, params: unknown) => unknown;
+  /** Per-request transport hints: modern headers, or the legacy session id. */
+  readonly meta: (method: McpMethod, params: unknown) => SendMeta;
+  /** Answer a server-initiated frame. Modern servers never send one. */
+  readonly onInbound: (inbound: Inbound) => Effect.Effect<void>;
+};
+/**
+ * Probe for one protocol era. `None` means "not this era, try the next"; a
+ * failure means the server is this era but unusable (no mutual version).
+ */
+type ProtocolProbe = (connection: McpConnection) => Effect.Effect<Option.Option<Protocol>, McpError, Scope.Scope>;
+/**
+ * A `-32020` / `-32021` / `-32022` reply, which is the spec's era
+ * discriminator: it proves the peer speaks a modern version, so the client
+ * corrects and retries rather than falling back to `initialize`. `supported`
+ * carries the versions a `-32022` offered, decoded through the schema so a
+ * server that adds fields cannot break it.
+ */
+type ModernRejection = {
+  readonly code: number;
+  readonly supported: ReadonlyArray<string>;
+};
+declare const modernRejection: (error: McpError) => Option.Option<ModernRejection>;
+//#endregion
+export { modernRejection as i, Protocol as n, ProtocolProbe as r, ModernRejection as t };
+//# sourceMappingURL=protocol-kjC3iAMb.d.mts.map

package/dist/protocol-kjC3iAMb.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"protocol-kjC3iAMb.d.mts","names":[],"sources":["../src/internal/protocol.ts"],"mappings":";;;;;KAqBY;WACD,SAAS;WACT,YAAY;;WAEZ,WAAW,QAAQ,WAAW;;WAE9B,OAAO,QAAQ,WAAW,oBAAoB;;WAE9C,YAAY,SAAS,YAAY,OAAO;;;;;;KAOvC,iBACV,YAAY,kBACT,OAAO,OAAO,OAAO,OAAO,WAAW,UAAU,MAAM;;;;;;;;KAWhD;WACD;WACA,WAAW;;cAGT,kBAAe,OAAW,aAAW,OAAO,OAAO"}

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/rpc-Bq95Lio9.d.mts

@@ -0,0 +1,34 @@
+import { i as McpError } from "./McpError-DWg9BlW5.mjs";
+import { f as JsonRpcId } from "./schema-D2oUNuo5.mjs";
+import { Effect, Option, Scope, Stream } from "effect";
+//#region src/internal/rpc.d.ts
+/** Per-request transport hints (era headers on HTTP; stdio ignores them). */
+type SendMeta = {
+  readonly headers?: Record<string, string>;
+};
+/** The transport seam: one framed JSON message per `send` / `messages` element. */
+type Transport = {
+  readonly send: (frame: string, meta?: SendMeta) => Effect.Effect<void, McpError>;
+  readonly messages: Stream.Stream<string, McpError>;
+};
+/** A server-initiated request (has `id`) or notification (no `id`). */
+type Inbound = {
+  readonly id: Option.Option<JsonRpcId>;
+  readonly method: string;
+  readonly params: unknown;
+};
+type McpConnection = {
+  readonly request: (method: string, params?: unknown, meta?: SendMeta) => Effect.Effect<unknown, McpError>;
+  readonly notify: (method: string, params?: unknown, meta?: SendMeta) => Effect.Effect<void, McpError>;
+  /** Answer a server-initiated request (legacy era only). */
+  readonly respond: (id: JsonRpcId, result: unknown) => Effect.Effect<void, McpError>;
+  readonly respondError: (id: JsonRpcId, code: number, message: string) => Effect.Effect<void, McpError>;
+};
+/**
+ * Open a scoped connection over an already-open transport. `onInbound`
+ * receives server-initiated frames; era.ts answers them via `transport.send`.
+ */
+declare const open: (transport: Transport, onInbound: (inbound: Inbound) => Effect.Effect<void>) => Effect.Effect<McpConnection, never, Scope.Scope>;
+//#endregion
+export { open as a, Transport as i, McpConnection as n, SendMeta as r, Inbound as t };
+//# sourceMappingURL=rpc-Bq95Lio9.d.mts.map

package/dist/rpc-Bq95Lio9.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rpc-Bq95Lio9.d.mts","names":[],"sources":["../src/internal/rpc.ts"],"mappings":";;;;;KAmBY;WACD,UAAU;;;KAIT;WACD,OAAO,eAAe,OAAO,aAAa,OAAO,aAAa;WAC9D,UAAU,OAAO,eAAe;;;KAI/B;WACD,IAAI,OAAO,OAAO;WAClB;WACA;;KAGC;WACD,UACP,gBACA,kBACA,OAAO,aACJ,OAAO,gBAAgB;WACnB,SACP,gBACA,kBACA,OAAO,aACJ,OAAO,aAAa;;WAEhB,UAAU,IAAI,WAAW,oBAAoB,OAAO,aAAa;WACjE,eACP,IAAI,WACJ,cACA,oBACG,OAAO,aAAa;;;;;;cAoBd,OAAI,WACJ,WAAS,YACR,SAAS,YAAY,OAAO,iBACvC,OAAO,OAAO,sBAAsB,MAAM"}

package/dist/schema-D2oUNuo5.d.mts

@@ -0,0 +1,245 @@
+import { Option, Schema } from "effect";
+//#region src/internal/schema.d.ts
+/** Every protocol version this client can speak. */
+declare const ProtocolVersion: Schema.Literals<readonly ["2026-07-28", "2025-11-25", "2025-06-18"]>;
+type ProtocolVersion = typeof ProtocolVersion.Type;
+/** Newest version we speak: the stateless protocol, and what the probe tries first. */
+declare const LATEST_VERSION = "2026-07-28";
+/** The legacy handshake era we negotiate; 2025-11-25 is wire-compatible. */
+declare const LEGACY_VERSION = "2025-06-18";
+/** Narrow a server-offered version string to one we support. */
+declare const asProtocolVersion: (raw: string) => Option.Option<ProtocolVersion>;
+/**
+ * The JSON-RPC methods this client issues. Not to be confused with an HTTP
+ * method: on Streamable HTTP every one of these travels as a POST, and the
+ * name is mirrored into the `Mcp-Method` header.
+ */
+declare const McpMethod: Schema.Literals<readonly ["server/discover", "initialize", "tools/list", "tools/call"]>;
+type McpMethod = typeof McpMethod.Type;
+/** Modern `_meta` keys (SEP-2575): every request self-describes its protocol. */
+declare const META_PROTOCOL_VERSION = "io.modelcontextprotocol/protocolVersion";
+declare const META_CLIENT_INFO = "io.modelcontextprotocol/clientInfo";
+declare const META_CLIENT_CAPABILITIES = "io.modelcontextprotocol/clientCapabilities";
+/** Servers identify themselves in each *result's* `_meta`, not at the top level. */
+declare const META_SERVER_INFO = "io.modelcontextprotocol/serverInfo";
+declare const CLIENT_INFO: {
+  name: string;
+  version: string;
+};
+/** Modern JSON-RPC error codes. */
+declare const CODE_HEADER_MISMATCH = -32020;
+declare const CODE_MISSING_CLIENT_CAPABILITY = -32021;
+declare const CODE_UNSUPPORTED_PROTOCOL_VERSION = -32022;
+declare const CODE_METHOD_NOT_FOUND = -32601;
+/**
+ * A reply carrying one of these proves the server speaks a modern version, so
+ * era detection corrects and retries instead of falling back to `initialize`.
+ */
+declare const MODERN_ERROR_CODES: ReadonlySet<number>;
+declare const JsonRpcId: Schema.Union<readonly [Schema.Number, Schema.String]>;
+type JsonRpcId = typeof JsonRpcId.Type;
+declare const JsonRpcErrorObject: Schema.Struct<{
+  readonly code: Schema.Number;
+  readonly message: Schema.optional<Schema.String>;
+  readonly data: Schema.optional<Schema.Unknown>;
+}>;
+type JsonRpcErrorObject = typeof JsonRpcErrorObject.Type;
+/**
+ * Any inbound frame: a reply (`id` + `result`/`error`), a server-initiated
+ * request (`method` + `id`), or a notification (`method`, no `id`). One
+ * loose struct so the reader can classify without a union decode.
+ */
+declare const InboundMessage: Schema.Struct<{
+  readonly id: Schema.optional<Schema.NullOr<Schema.Union<readonly [Schema.Number, Schema.String]>>>;
+  readonly result: Schema.optional<Schema.Unknown>;
+  readonly error: Schema.optional<Schema.Struct<{
+    readonly code: Schema.Number;
+    readonly message: Schema.optional<Schema.String>;
+    readonly data: Schema.optional<Schema.Unknown>;
+  }>>;
+  readonly method: Schema.optional<Schema.String>;
+  readonly params: Schema.optional<Schema.Unknown>;
+}>;
+type InboundMessage = typeof InboundMessage.Type;
+declare const decodeInboundMessage: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => import("effect/Effect").Effect<{
+  readonly id?: string | number | null | undefined;
+  readonly result?: unknown;
+  readonly error?: {
+    readonly code: number;
+    readonly message?: string | undefined;
+    readonly data?: unknown;
+  } | undefined;
+  readonly method?: string | undefined;
+  readonly params?: unknown;
+}, Schema.SchemaError, never>;
+declare const requestFrame: (id: JsonRpcId, method: string, params: unknown) => string;
+declare const notificationFrame: (method: string, params?: unknown) => string;
+declare const resultFrame: (id: JsonRpcId, result: unknown) => string;
+declare const errorFrame: (id: JsonRpcId, code: number, message: string) => string;
+declare const ToolInfo: Schema.Struct<{
+  readonly name: Schema.String;
+  readonly description: Schema.optional<Schema.String>;
+  readonly inputSchema: Schema.$Record<Schema.String, Schema.Unknown>;
+}>;
+type ToolInfo = typeof ToolInfo.Type;
+/**
+ * Modern list results may carry cache metadata (`ttlMs` / `cacheScope`);
+ * v1 reads but does not act on them (input for a later refresh feature).
+ */
+declare const ListToolsResult: Schema.Struct<{
+  readonly tools: Schema.$Array<Schema.Struct<{
+    readonly name: Schema.String;
+    readonly description: Schema.optional<Schema.String>;
+    readonly inputSchema: Schema.$Record<Schema.String, Schema.Unknown>;
+  }>>;
+  readonly nextCursor: Schema.optional<Schema.String>;
+  readonly ttlMs: Schema.optional<Schema.Number>;
+  readonly cacheScope: Schema.optional<Schema.String>;
+}>;
+type ListToolsResult = typeof ListToolsResult.Type;
+declare const decodeListToolsResult: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => import("effect/Effect").Effect<{
+  readonly tools: readonly {
+    readonly name: string;
+    readonly description?: string | undefined;
+    readonly inputSchema: {
+      readonly [x: string]: unknown;
+    };
+  }[];
+  readonly nextCursor?: string | undefined;
+  readonly ttlMs?: number | undefined;
+  readonly cacheScope?: string | undefined;
+}, Schema.SchemaError, never>;
+declare const TextContent: Schema.Struct<{
+  readonly type: Schema.Literal<"text">;
+  readonly text: Schema.String;
+}>;
+type TextContent = typeof TextContent.Type;
+/** Non-text blocks (image / audio / resource) are placeholder-summarized in v1. */
+declare const OtherContent: Schema.Struct<{
+  readonly type: Schema.String;
+}>;
+declare const ContentBlock: Schema.Union<readonly [Schema.Struct<{
+  readonly type: Schema.Literal<"text">;
+  readonly text: Schema.String;
+}>, Schema.Struct<{
+  readonly type: Schema.String;
+}>]>;
+type ContentBlock = typeof ContentBlock.Type;
+declare const isTextContent: <I>(input: I) => input is I & {
+  readonly type: "text";
+  readonly text: string;
+};
+declare const CallToolResult: Schema.Struct<{
+  readonly content: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+    readonly type: Schema.Literal<"text">;
+    readonly text: Schema.String;
+  }>, Schema.Struct<{
+    readonly type: Schema.String;
+  }>]>>>;
+  readonly isError: Schema.optional<Schema.Boolean>;
+  readonly structuredContent: Schema.optional<Schema.Unknown>;
+  readonly resultType: Schema.optional<Schema.String>;
+}>;
+type CallToolResult = typeof CallToolResult.Type;
+declare const decodeCallToolResult: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => import("effect/Effect").Effect<{
+  readonly content?: readonly ({
+    readonly type: "text";
+    readonly text: string;
+  } | {
+    readonly type: string;
+  })[];
+  readonly isError?: boolean | undefined;
+  readonly structuredContent?: unknown;
+  readonly resultType?: string | undefined;
+}, Schema.SchemaError, never>;
+declare const ServerInfo: Schema.Struct<{
+  readonly name: Schema.String;
+  readonly version: Schema.optional<Schema.String>;
+  readonly title: Schema.optional<Schema.String>;
+}>;
+type ServerInfo = typeof ServerInfo.Type;
+/** The subset of a result's `_meta` we read. */
+declare const ResultMeta: Schema.Struct<{
+  readonly "io.modelcontextprotocol/serverInfo": Schema.optional<Schema.Struct<{
+    readonly name: Schema.String;
+    readonly version: Schema.optional<Schema.String>;
+    readonly title: Schema.optional<Schema.String>;
+  }>>;
+}>;
+type ResultMeta = typeof ResultMeta.Type;
+declare const DiscoverResult: Schema.Struct<{
+  readonly supportedVersions: Schema.$Array<Schema.String>;
+  readonly capabilities: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
+  readonly _meta: Schema.optional<Schema.Struct<{
+    readonly "io.modelcontextprotocol/serverInfo": Schema.optional<Schema.Struct<{
+      readonly name: Schema.String;
+      readonly version: Schema.optional<Schema.String>;
+      readonly title: Schema.optional<Schema.String>;
+    }>>;
+  }>>;
+  readonly serverInfo: Schema.optional<Schema.Struct<{
+    readonly name: Schema.String;
+    readonly version: Schema.optional<Schema.String>;
+    readonly title: Schema.optional<Schema.String>;
+  }>>;
+  readonly instructions: Schema.optional<Schema.String>;
+}>;
+type DiscoverResult = typeof DiscoverResult.Type;
+declare const decodeDiscoverResult: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => import("effect/Effect").Effect<{
+  readonly supportedVersions: readonly string[];
+  readonly capabilities?: {
+    readonly [x: string]: unknown;
+  } | undefined;
+  readonly _meta?: {
+    readonly "io.modelcontextprotocol/serverInfo"?: {
+      readonly name: string;
+      readonly version?: string | undefined;
+      readonly title?: string | undefined;
+    } | undefined;
+  } | undefined;
+  readonly serverInfo?: {
+    readonly name: string;
+    readonly version?: string | undefined;
+    readonly title?: string | undefined;
+  } | undefined;
+  readonly instructions?: string | undefined;
+}, Schema.SchemaError, never>;
+/**
+ * `data` of a `-32022` UnsupportedProtocolVersionError reply. Decoded, not
+ * hand-parsed: the shape is server-controlled and may carry extra fields.
+ */
+declare const UnsupportedVersionData: Schema.Struct<{
+  readonly supported: Schema.optional<Schema.$Array<Schema.String>>;
+  readonly requested: Schema.optional<Schema.NullOr<Schema.String>>;
+}>;
+type UnsupportedVersionData = typeof UnsupportedVersionData.Type;
+declare const decodeUnsupportedVersionData: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => Option.Option<{
+  readonly supported?: readonly string[] | undefined;
+  readonly requested?: string | null | undefined;
+}>;
+declare const InitializeResult: Schema.Struct<{
+  readonly protocolVersion: Schema.String;
+  readonly capabilities: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
+  readonly serverInfo: Schema.optional<Schema.Struct<{
+    readonly name: Schema.String;
+    readonly version: Schema.optional<Schema.String>;
+    readonly title: Schema.optional<Schema.String>;
+  }>>;
+  readonly instructions: Schema.optional<Schema.String>;
+}>;
+type InitializeResult = typeof InitializeResult.Type;
+declare const decodeInitializeResult: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => import("effect/Effect").Effect<{
+  readonly protocolVersion: string;
+  readonly capabilities?: {
+    readonly [x: string]: unknown;
+  } | undefined;
+  readonly serverInfo?: {
+    readonly name: string;
+    readonly version?: string | undefined;
+    readonly title?: string | undefined;
+  } | undefined;
+  readonly instructions?: string | undefined;
+}, Schema.SchemaError, never>;
+//#endregion
+export { decodeCallToolResult as A, resultFrame as B, ProtocolVersion as C, ToolInfo as D, TextContent as E, decodeUnsupportedVersionData as F, errorFrame as I, isTextContent as L, decodeInboundMessage as M, decodeInitializeResult as N, UnsupportedVersionData as O, decodeListToolsResult as P, notificationFrame as R, OtherContent as S, ServerInfo as T, META_CLIENT_INFO as _, CODE_UNSUPPORTED_PROTOCOL_VERSION as a, MODERN_ERROR_CODES as b, DiscoverResult as c, JsonRpcErrorObject as d, JsonRpcId as f, META_CLIENT_CAPABILITIES as g, ListToolsResult as h, CODE_MISSING_CLIENT_CAPABILITY as i, decodeDiscoverResult as j, asProtocolVersion as k, InboundMessage as l, LEGACY_VERSION as m, CODE_HEADER_MISMATCH as n, CallToolResult as o, LATEST_VERSION as p, CODE_METHOD_NOT_FOUND as r, ContentBlock as s, CLIENT_INFO as t, InitializeResult as u, META_PROTOCOL_VERSION as v, ResultMeta as w, McpMethod as x, META_SERVER_INFO as y, requestFrame as z };
+//# sourceMappingURL=schema-D2oUNuo5.d.mts.map

package/dist/schema-D2oUNuo5.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema-D2oUNuo5.d.mts","names":[],"sources":["../src/internal/schema.ts"],"mappings":";;;cAaa,iBAAe,OAAA;KAChB,yBAAyB,gBAAgB;;cAGxC;;cAGA;;cAKA,oBAAiB,gBAAkB,OAAO,OAAO;;;;;;cAQjD,WAAS,OAAA;KAMV,mBAAmB,UAAU;;cAG5B;cACA;cACA;;cAEA;cAEA;EAAgB;EAAyB;;;cAGzC;cACA;cACA;cACA;;;;;cAMA,oBAAoB;cAUpB,WAAS,OAAA,gBAAA,OAAA,QAAA,OAAA;KACV,mBAAmB,UAAU;cAE5B,oBAAkB,OAAA;;;;;KAKnB,4BAA4B,mBAAmB;;;;;;cAO9C,gBAAc,OAAA;;;;;;;;;;;KASf,wBAAwB,eAAe;cAEtC,uBAAoB,gBAAA,qCAAA,yCAAA;;;;;;;;;;GAA6C,OAAA;cAIjE,eAAY,IAAQ,WAAS,gBAAgB;cAG7C,oBAAiB,gBAAkB;cAKnC,cAAW,IAAQ,WAAS;cAG5B,aAAU,IAAQ,WAAS,cAAc;cAOzC,UAAQ,OAAA;;;;;KAKT,kBAAkB,SAAS;;;;;cAM1B,iBAAe,OAAA;;;;;;;;;;KAMhB,yBAAyB,gBAAgB;cAExC,wBAAqB,gBAAA,qCAAA,yCAAA;;;;;;;;;;;GAA8C,OAAA;cAInE,aAAW,OAAA;;;;KAIZ,qBAAqB,YAAY;;cAGhC,cAAY,OAAA;iBAAZ,OAAA;;cAIA,cAAY,OAAA,gBAAA,OAAA;;;;;;KACb,sBAAsB,aAAa;cAElC,gBAAa,GAAA,OAAA,MAAA,SAAA;;;;cAEb,gBAAc,OAAA;;;;;;;;;;;KAOf,wBAAwB,eAAe;cAEtC,uBAAoB,gBAAA,qCAAA,yCAAA;;;;;;;;;;GAA6C,OAAA;cAMjE,YAAU,OAAA;;;;;KAKX,oBAAoB,WAAW;;cAG9B,YAAU,OAAA;;;;;;;KAGX,oBAAoB,WAAW;cAE9B,gBAAc,OAAA;;;;;;;;;;;;;;;;;KASf,wBAAwB,eAAe;cAEtC,uBAAoB,gBAAA,qCAAA,yCAAA;;;;;;;;;;;;;;;;;;GAA6C,OAAA;;;;;cAMjE,wBAAsB,OAAA;;;;KAIvB,gCAAgC,uBAAuB;cAEtD,+BAA4B,gBAAA,qCAAA,iBAAA,OAAA;;;;cAM5B,kBAAgB,OAAA;;;;;;;;;;KAMjB,0BAA0B,iBAAiB;cAE1C,yBAAsB,gBAAA,qCAAA,yCAAA;;;;;;;;;;;GAA+C,OAAA"}