@warlock.js/ai-tools 4.5.0

package/esm/mcp/serve.mjs

@@ -0,0 +1,264 @@
+import { McpTransportError } from "../errors.mjs";
+import { extractJsonSchema } from "@warlock.js/ai";
+import { createInterface } from "node:readline";
+
+//#region ../@warlock.js/ai-tools/src/mcp/serve.ts
+/** JSON-RPC version literal every outbound message carries. */
+const JSONRPC_VERSION = "2.0";
+/** Default JSON-Schema dialect emitted for each tool's `inputSchema`. */
+const DEFAULT_SCHEMA_TARGET = "draft-2020-12";
+/** Default advertised server version when the caller omits one. */
+const DEFAULT_VERSION = "4.4.0";
+/** The MCP protocol version this server advertises in `initialize`. */
+const PROTOCOL_VERSION = "2025-06-18";
+/** JSON-RPC standard error codes we emit. */
+const JSON_RPC_METHOD_NOT_FOUND = -32601;
+const JSON_RPC_INVALID_PARAMS = -32602;
+/**
+* Resolve the {@link McpServeSource} (either an object exposing `tools()`
+* or a literal `ToolContract[]`) into a flat contract array.
+*/
+function resolveTools(source) {
+	if (Array.isArray(source)) return source;
+	return source.tools();
+}
+/**
+* The pure protocol core of `serve` — maps one JSON-RPC request to its
+* response, with no I/O. Both the stdio and http serve-transports pump
+* their inbound requests through this, and specs can drive it directly.
+*
+* Handles exactly the MCP slice this package serves: `initialize`,
+* `tools/list`, and `tools/call`. Any other method answers with a
+* JSON-RPC `method not found` error.
+*
+* Constructed via {@link createServeHandler}.
+*/
+var McpServeHandler = class {
+	constructor(source, options) {
+		this.tools = resolveTools(source);
+		this.byName = new Map(this.tools.map((contract) => [contract.name, contract]));
+		this.options = options;
+	}
+	/**
+	* Dispatch one inbound JSON-RPC request to its handler and produce the
+	* response. A handler that throws is mapped to a JSON-RPC error response
+	* — the serve loop never crashes on a bad request.
+	*/
+	async handle(request) {
+		try {
+			switch (request.method) {
+				case "initialize": return this.ok(request.id, this.initializeResult());
+				case "tools/list": return this.ok(request.id, { tools: this.listTools() });
+				case "tools/call": return this.ok(request.id, await this.callTool(request.params));
+				default: return this.error(request.id, JSON_RPC_METHOD_NOT_FOUND, `Method "${request.method}" is not supported by this MCP server.`);
+			}
+		} catch (cause) {
+			const message = cause instanceof Error ? cause.message : String(cause);
+			return this.error(request.id, JSON_RPC_INVALID_PARAMS, message);
+		}
+	}
+	/** Build the `initialize` result advertising name / version / capabilities. */
+	initializeResult() {
+		return {
+			protocolVersion: PROTOCOL_VERSION,
+			capabilities: { tools: {} },
+			serverInfo: {
+				name: this.options.name,
+				version: this.options.version ?? DEFAULT_VERSION
+			}
+		};
+	}
+	/**
+	* Build the `tools/list` payload: one {@link McpToolDescriptor} per
+	* contract, its `inputSchema` extracted via `extractJsonSchema` at the
+	* configured dialect (default `draft-2020-12` — overriding
+	* `extractJsonSchema`'s own `openai-strict` default to a neutral MCP draft).
+	*/
+	listTools() {
+		const target = this.options.schemaTarget ?? DEFAULT_SCHEMA_TARGET;
+		return this.tools.map((contract) => {
+			const inputSchema = extractJsonSchema(contract.input, { target }) ?? {
+				type: "object",
+				properties: {}
+			};
+			return {
+				name: contract.name,
+				description: contract.description,
+				inputSchema
+			};
+		});
+	}
+	/**
+	* Route a `tools/call` to the named contract's `invoke()` and map the
+	* never-throwing {@link import("@warlock.js/ai").ToolInvokeResult}: `data`
+	* → a text content block, `error` → an `isError: true` result. An unknown
+	* tool name throws (mapped to a JSON-RPC error by {@link handle}).
+	*/
+	async callTool(params) {
+		const { name, args } = readCallParams(params);
+		const contract = this.byName.get(name);
+		if (!contract) throw new McpTransportError(`Unknown tool "${name}".`, {
+			type: "protocol",
+			method: "tools/call"
+		});
+		const result = await contract.invoke(args);
+		if (result.error) return {
+			content: [{
+				type: "text",
+				text: result.error.message
+			}],
+			isError: true
+		};
+		return {
+			content: [{
+				type: "text",
+				text: serializeData(result.data)
+			}],
+			isError: false
+		};
+	}
+	/** Build a JSON-RPC success response. */
+	ok(id, result) {
+		return {
+			jsonrpc: JSONRPC_VERSION,
+			id,
+			result
+		};
+	}
+	/** Build a JSON-RPC error response. */
+	error(id, code, message) {
+		return {
+			jsonrpc: JSONRPC_VERSION,
+			id,
+			error: {
+				code,
+				message
+			}
+		};
+	}
+};
+/**
+* Read and validate the `tools/call` params into `{ name, args }`. Throws
+* a typed {@link McpTransportError} when `name` is missing — mapped to a
+* JSON-RPC `invalid params` error by the handler.
+*/
+function readCallParams(params) {
+	if (typeof params !== "object" || params === null) throw new McpTransportError("tools/call params must be an object.", {
+		type: "protocol",
+		method: "tools/call"
+	});
+	const record = params;
+	if (typeof record.name !== "string") throw new McpTransportError("tools/call requires a string `name`.", {
+		type: "protocol",
+		method: "tools/call"
+	});
+	return {
+		name: record.name,
+		args: record.arguments ?? {}
+	};
+}
+/**
+* Serialize a tool's `data` for an MCP text content block — a string is
+* passed verbatim, everything else is JSON-stringified so structured
+* output crosses the wire as text the consuming client can re-parse.
+*/
+function serializeData(data) {
+	if (typeof data === "string") return data;
+	if (data === void 0) return "";
+	return JSON.stringify(data);
+}
+/**
+* Build the pure protocol handler for a serve source. Exposed (alongside
+* {@link serve}) so callers and tests can drive the MCP protocol without an
+* actual transport — feed it a JSON-RPC request, get the response.
+*
+* @param source - The tools to expose (an object with `tools()` or a literal array).
+* @param options - Serve options (name / version / schema target).
+* @returns An object whose `handle(request)` maps a request to a response.
+*/
+function createServeHandler(source, options) {
+	return new McpServeHandler(source, options);
+}
+/**
+* The internal {@link McpServer} — owns a {@link McpServeHandler} and a
+* transport pump. For `stdio` it reads newline-delimited JSON-RPC requests
+* from `process.stdin` and writes responses to `process.stdout`; the
+* `http` transport is accepted but listening is deferred to the host
+* (a serve-over-HTTP needs a server the caller owns).
+*
+* Constructed via {@link serve}; the class itself is internal.
+*/
+var McpServerImpl = class {
+	constructor(source, options) {
+		this.running = false;
+		this.handler = new McpServeHandler(source, options);
+		this.options = options;
+	}
+	async start() {
+		if (this.running) return;
+		if ((this.options.transport ?? { type: "stdio" }).type !== "stdio") throw new McpTransportError("serve() over http requires a host-provided server; only stdio is auto-pumped.", { type: "connect" });
+		this.running = true;
+		this.reader = createInterface({ input: process.stdin });
+		this.reader.on("line", (line) => {
+			this.onLine(line);
+		});
+	}
+	/**
+	* Parse one stdin line as a JSON-RPC request, dispatch it through the
+	* handler, and write the response as a single line to stdout. Non-JSON
+	* lines and notifications (no `id`) are ignored.
+	*/
+	async onLine(line) {
+		const trimmed = line.trim();
+		if (!trimmed) return;
+		let request;
+		try {
+			request = JSON.parse(trimmed);
+		} catch {
+			return;
+		}
+		if (request.id === void 0 || request.id === null) return;
+		const response = await this.handler.handle(request);
+		process.stdout.write(`${JSON.stringify(response)}\n`);
+	}
+	async stop() {
+		this.running = false;
+		this.reader?.close();
+		this.reader = void 0;
+	}
+};
+/**
+* Expose a built agent / supervisor / orchestrator (or a raw
+* `ToolContract[]`) AS an MCP server (Direction B: local primitive → MCP
+* server other clients consume).
+*
+* Enumerates `source.tools()` (or the literal array) once at construction.
+* `tools/list` answers with each tool's `inputSchema` extracted via
+* `extractJsonSchema` at the configured `schemaTarget` (default
+* `draft-2020-12`). `tools/call` routes to the named contract's
+* `invoke()` and maps the never-throwing result — `data` becomes a text
+* content block, `error` becomes an `isError: true` result — so a failing
+* tool surfaces as a normal MCP tool error rather than crashing the server.
+*
+* The default transport is `stdio`, pumped over `process.stdin` /
+* `process.stdout`. Serving over HTTP is left to a host-owned server;
+* `start()` rejects an `http` transport (the protocol core is available
+* via {@link createServeHandler} for a caller's own HTTP wiring).
+*
+* @param source - The tools to expose.
+* @param options - Server name, version, transport, and schema dialect.
+* @returns An {@link McpServer} with `start()` / `stop()`.
+*
+* @example
+* serve(
+*   { tools: () => ws.allTools() },
+*   { name: "warlock-workspace", transport: { type: "stdio" } },
+* ).start();
+*/
+function serve(source, options) {
+	return new McpServerImpl(source, options);
+}
+
+//#endregion
+export { createServeHandler, serve };
+//# sourceMappingURL=serve.mjs.map

package/esm/mcp/serve.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"serve.mjs","names":[],"sources":["../../../../../../../@warlock.js/ai-tools/src/mcp/serve.ts"],"sourcesContent":["import { createInterface, type Interface } from \"node:readline\";\nimport { extractJsonSchema, type ToolContract } from \"@warlock.js/ai\";\nimport type {\n  JsonRpcRequest,\n  JsonRpcResponse,\n  McpServeOptions,\n  McpServeSource,\n  McpServer,\n  McpToolCallResult,\n  McpToolDescriptor,\n} from \"../contracts\";\nimport { McpTransportError } from \"../errors\";\n\n/** JSON-RPC version literal every outbound message carries. */\nconst JSONRPC_VERSION = \"2.0\";\n\n/** Default JSON-Schema dialect emitted for each tool's `inputSchema`. */\nconst DEFAULT_SCHEMA_TARGET = \"draft-2020-12\";\n\n/** Default advertised server version when the caller omits one. */\nconst DEFAULT_VERSION = \"4.4.0\";\n\n/** The MCP protocol version this server advertises in `initialize`. */\nconst PROTOCOL_VERSION = \"2025-06-18\";\n\n/** JSON-RPC standard error codes we emit. */\nconst JSON_RPC_METHOD_NOT_FOUND = -32601;\nconst JSON_RPC_INVALID_PARAMS = -32602;\n\n/**\n * Resolve the {@link McpServeSource} (either an object exposing `tools()`\n * or a literal `ToolContract[]`) into a flat contract array.\n */\nfunction resolveTools(source: McpServeSource): ToolContract[] {\n  if (Array.isArray(source)) {\n    return source;\n  }\n\n  return source.tools();\n}\n\n/**\n * The pure protocol core of `serve` — maps one JSON-RPC request to its\n * response, with no I/O. Both the stdio and http serve-transports pump\n * their inbound requests through this, and specs can drive it directly.\n *\n * Handles exactly the MCP slice this package serves: `initialize`,\n * `tools/list`, and `tools/call`. Any other method answers with a\n * JSON-RPC `method not found` error.\n *\n * Constructed via {@link createServeHandler}.\n */\nclass McpServeHandler {\n  /** The tools this server exposes (snapshotted at construction). */\n  private readonly tools: ToolContract[];\n\n  /** Fast lookup by tool name for `tools/call` dispatch. */\n  private readonly byName: Map<string, ToolContract>;\n\n  /** Construction-time serve options (name / version / schema target). */\n  private readonly options: McpServeOptions;\n\n  public constructor(source: McpServeSource, options: McpServeOptions) {\n    this.tools = resolveTools(source);\n    this.byName = new Map(this.tools.map((contract) => [contract.name, contract]));\n    this.options = options;\n  }\n\n  /**\n   * Dispatch one inbound JSON-RPC request to its handler and produce the\n   * response. A handler that throws is mapped to a JSON-RPC error response\n   * — the serve loop never crashes on a bad request.\n   */\n  public async handle(request: JsonRpcRequest): Promise<JsonRpcResponse> {\n    try {\n      switch (request.method) {\n        case \"initialize\":\n          return this.ok(request.id, this.initializeResult());\n        case \"tools/list\":\n          return this.ok(request.id, { tools: this.listTools() });\n        case \"tools/call\":\n          return this.ok(request.id, await this.callTool(request.params));\n        default:\n          return this.error(\n            request.id,\n            JSON_RPC_METHOD_NOT_FOUND,\n            `Method \"${request.method}\" is not supported by this MCP server.`,\n          );\n      }\n    } catch (cause) {\n      const message = cause instanceof Error ? cause.message : String(cause);\n\n      return this.error(request.id, JSON_RPC_INVALID_PARAMS, message);\n    }\n  }\n\n  /** Build the `initialize` result advertising name / version / capabilities. */\n  private initializeResult(): Record<string, unknown> {\n    return {\n      protocolVersion: PROTOCOL_VERSION,\n      capabilities: { tools: {} },\n      serverInfo: {\n        name: this.options.name,\n        version: this.options.version ?? DEFAULT_VERSION,\n      },\n    };\n  }\n\n  /**\n   * Build the `tools/list` payload: one {@link McpToolDescriptor} per\n   * contract, its `inputSchema` extracted via `extractJsonSchema` at the\n   * configured dialect (default `draft-2020-12` — overriding\n   * `extractJsonSchema`'s own `openai-strict` default to a neutral MCP draft).\n   */\n  private listTools(): McpToolDescriptor[] {\n    const target = this.options.schemaTarget ?? DEFAULT_SCHEMA_TARGET;\n\n    return this.tools.map((contract) => {\n      const inputSchema = extractJsonSchema(contract.input, { target }) ?? {\n        type: \"object\",\n        properties: {},\n      };\n\n      return {\n        name: contract.name,\n        description: contract.description,\n        inputSchema,\n      };\n    });\n  }\n\n  /**\n   * Route a `tools/call` to the named contract's `invoke()` and map the\n   * never-throwing {@link import(\"@warlock.js/ai\").ToolInvokeResult}: `data`\n   * → a text content block, `error` → an `isError: true` result. An unknown\n   * tool name throws (mapped to a JSON-RPC error by {@link handle}).\n   */\n  private async callTool(params: unknown): Promise<McpToolCallResult> {\n    const { name, args } = readCallParams(params);\n    const contract = this.byName.get(name);\n\n    if (!contract) {\n      throw new McpTransportError(`Unknown tool \"${name}\".`, {\n        type: \"protocol\",\n        method: \"tools/call\",\n      });\n    }\n\n    const result = await contract.invoke(args);\n\n    if (result.error) {\n      return {\n        content: [{ type: \"text\", text: result.error.message }],\n        isError: true,\n      };\n    }\n\n    return {\n      content: [{ type: \"text\", text: serializeData(result.data) }],\n      isError: false,\n    };\n  }\n\n  /** Build a JSON-RPC success response. */\n  private ok(id: JsonRpcRequest[\"id\"], result: unknown): JsonRpcResponse {\n    return { jsonrpc: JSONRPC_VERSION, id, result };\n  }\n\n  /** Build a JSON-RPC error response. */\n  private error(id: JsonRpcRequest[\"id\"], code: number, message: string): JsonRpcResponse {\n    return { jsonrpc: JSONRPC_VERSION, id, error: { code, message } };\n  }\n}\n\n/**\n * Read and validate the `tools/call` params into `{ name, args }`. Throws\n * a typed {@link McpTransportError} when `name` is missing — mapped to a\n * JSON-RPC `invalid params` error by the handler.\n */\nfunction readCallParams(params: unknown): { name: string; args: unknown } {\n  if (typeof params !== \"object\" || params === null) {\n    throw new McpTransportError(\"tools/call params must be an object.\", {\n      type: \"protocol\",\n      method: \"tools/call\",\n    });\n  }\n\n  const record = params as { name?: unknown; arguments?: unknown };\n\n  if (typeof record.name !== \"string\") {\n    throw new McpTransportError(\"tools/call requires a string `name`.\", {\n      type: \"protocol\",\n      method: \"tools/call\",\n    });\n  }\n\n  return { name: record.name, args: record.arguments ?? {} };\n}\n\n/**\n * Serialize a tool's `data` for an MCP text content block — a string is\n * passed verbatim, everything else is JSON-stringified so structured\n * output crosses the wire as text the consuming client can re-parse.\n */\nfunction serializeData(data: unknown): string {\n  if (typeof data === \"string\") {\n    return data;\n  }\n\n  if (data === undefined) {\n    return \"\";\n  }\n\n  return JSON.stringify(data);\n}\n\n/**\n * Build the pure protocol handler for a serve source. Exposed (alongside\n * {@link serve}) so callers and tests can drive the MCP protocol without an\n * actual transport — feed it a JSON-RPC request, get the response.\n *\n * @param source - The tools to expose (an object with `tools()` or a literal array).\n * @param options - Serve options (name / version / schema target).\n * @returns An object whose `handle(request)` maps a request to a response.\n */\nexport function createServeHandler(\n  source: McpServeSource,\n  options: McpServeOptions,\n): { handle(request: JsonRpcRequest): Promise<JsonRpcResponse> } {\n  return new McpServeHandler(source, options);\n}\n\n/**\n * The internal {@link McpServer} — owns a {@link McpServeHandler} and a\n * transport pump. For `stdio` it reads newline-delimited JSON-RPC requests\n * from `process.stdin` and writes responses to `process.stdout`; the\n * `http` transport is accepted but listening is deferred to the host\n * (a serve-over-HTTP needs a server the caller owns).\n *\n * Constructed via {@link serve}; the class itself is internal.\n */\nclass McpServerImpl implements McpServer {\n  /** The pure protocol handler. */\n  private readonly handler: McpServeHandler;\n\n  /** Serve options (transport selection lives here). */\n  private readonly options: McpServeOptions;\n\n  /** The stdin line reader while serving over stdio. */\n  private reader: Interface | undefined;\n\n  /** Flipped while the server is actively reading the transport. */\n  private running = false;\n\n  public constructor(source: McpServeSource, options: McpServeOptions) {\n    this.handler = new McpServeHandler(source, options);\n    this.options = options;\n  }\n\n  public async start(): Promise<void> {\n    if (this.running) {\n      return;\n    }\n\n    const transport = this.options.transport ?? { type: \"stdio\" };\n\n    if (transport.type !== \"stdio\") {\n      throw new McpTransportError(\n        \"serve() over http requires a host-provided server; only stdio is auto-pumped.\",\n        { type: \"connect\" },\n      );\n    }\n\n    this.running = true;\n    this.reader = createInterface({ input: process.stdin });\n\n    this.reader.on(\"line\", (line) => {\n      void this.onLine(line);\n    });\n  }\n\n  /**\n   * Parse one stdin line as a JSON-RPC request, dispatch it through the\n   * handler, and write the response as a single line to stdout. Non-JSON\n   * lines and notifications (no `id`) are ignored.\n   */\n  private async onLine(line: string): Promise<void> {\n    const trimmed = line.trim();\n\n    if (!trimmed) {\n      return;\n    }\n\n    let request: JsonRpcRequest;\n\n    try {\n      request = JSON.parse(trimmed) as JsonRpcRequest;\n    } catch {\n      return;\n    }\n\n    if (request.id === undefined || request.id === null) {\n      // A notification (e.g. notifications/initialized) — nothing to answer.\n      return;\n    }\n\n    const response = await this.handler.handle(request);\n    process.stdout.write(`${JSON.stringify(response)}\\n`);\n  }\n\n  public async stop(): Promise<void> {\n    this.running = false;\n    this.reader?.close();\n    this.reader = undefined;\n  }\n}\n\n/**\n * Expose a built agent / supervisor / orchestrator (or a raw\n * `ToolContract[]`) AS an MCP server (Direction B: local primitive → MCP\n * server other clients consume).\n *\n * Enumerates `source.tools()` (or the literal array) once at construction.\n * `tools/list` answers with each tool's `inputSchema` extracted via\n * `extractJsonSchema` at the configured `schemaTarget` (default\n * `draft-2020-12`). `tools/call` routes to the named contract's\n * `invoke()` and maps the never-throwing result — `data` becomes a text\n * content block, `error` becomes an `isError: true` result — so a failing\n * tool surfaces as a normal MCP tool error rather than crashing the server.\n *\n * The default transport is `stdio`, pumped over `process.stdin` /\n * `process.stdout`. Serving over HTTP is left to a host-owned server;\n * `start()` rejects an `http` transport (the protocol core is available\n * via {@link createServeHandler} for a caller's own HTTP wiring).\n *\n * @param source - The tools to expose.\n * @param options - Server name, version, transport, and schema dialect.\n * @returns An {@link McpServer} with `start()` / `stop()`.\n *\n * @example\n * serve(\n *   { tools: () => ws.allTools() },\n *   { name: \"warlock-workspace\", transport: { type: \"stdio\" } },\n * ).start();\n */\nexport function serve(source: McpServeSource, options: McpServeOptions): McpServer {\n  return new McpServerImpl(source, options);\n}\n"],"mappings":"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"}

package/esm/mcp/transport.d.mts

@@ -0,0 +1,48 @@
+import { McpTransport } from "../contracts/mcp.type.mjs";
+import { McpTransportClient } from "./transport.type.mjs";
+
+//#region ../@warlock.js/ai-tools/src/mcp/transport.d.ts
+/**
+ * Build the concrete {@link McpTransportClient} for an {@link McpTransport}
+ * config — a {@link StdioTransport} for `type: "stdio"`, an
+ * {@link HttpTransport} for `type: "http"`. The returned client also
+ * carries an `allocateId()` for the JSON-RPC client to mint request ids.
+ *
+ * @param transport - The transport config (discriminated by `type`).
+ * @returns A transport client paired with its id allocator.
+ */
+declare function createTransport(transport: McpTransport): McpTransportClient & {
+  allocateId(): number;
+};
+/**
+ * A JSON-RPC client over an MCP transport. Either pass an already-built
+ * transport client (tests inject a fake) or an {@link McpTransport} config
+ * to spawn/connect a real one.
+ */
+interface JsonRpcClientHandle {
+  /** Issue a request and resolve with its `result` (throws on error). */
+  call<TResult = unknown>(method: string, params?: unknown, options?: {
+    signal?: AbortSignal;
+    timeoutMs?: number;
+  }): Promise<TResult>;
+  /** Send a one-way notification. */
+  notify(method: string, params?: unknown): Promise<void>;
+  /** Close the underlying transport. */
+  close(): Promise<void>;
+}
+/**
+ * Build a {@link JsonRpcClientHandle} over a transport. Accepts either a
+ * pre-built {@link McpTransportClient} (the test seam — inject a scripted
+ * fake) or an {@link McpTransport} config, in which case the concrete
+ * transport is constructed via {@link createTransport}.
+ *
+ * When a bare {@link McpTransportClient} (without an `allocateId`) is
+ * injected, the client supplies its own monotonic id source.
+ *
+ * @param source - A transport client or an `McpTransport` config.
+ * @returns A JSON-RPC client handle.
+ */
+declare function createJsonRpcClient(source: McpTransport | McpTransportClient): JsonRpcClientHandle;
+//#endregion
+export { JsonRpcClientHandle, createJsonRpcClient, createTransport };
+//# sourceMappingURL=transport.d.mts.map

package/esm/mcp/transport.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transport.d.mts","names":[],"sources":["../../../../../../../@warlock.js/ai-tools/src/mcp/transport.ts"],"mappings":";;;;;;;AAicA;;;;;;iBAAgB,eAAA,CACd,SAAA,EAAW,YAAA,GACV,kBAAkB;EAAK,UAAA;AAAA;AAAU;AA8EpC;;;;AA9EoC,UA8EnB,mBAAA;EAMZ;EAJH,IAAA,oBACE,MAAA,UACA,MAAA,YACA,OAAA;IAAY,MAAA,GAAS,WAAA;IAAa,SAAA;EAAA,IACjC,OAAA,CAAQ,OAAA;EAJX;EAMA,MAAA,CAAO,MAAA,UAAgB,MAAA,aAAmB,OAAA;EALxC;EAOF,KAAA,IAAS,OAAA;AAAA;;;;;;;;;;;;;iBAeK,mBAAA,CACd,MAAA,EAAQ,YAAA,GAAe,kBAAA,GACtB,mBAAA"}