@mcpmake/core 0.2.0

package/dist/emitter/templates/task-manager.ts.hbs

@@ -0,0 +1,139 @@
+/**
+ * MCP Task state machine for async/long-running operations.
+ *
+ * Tasks are created when a tool returns 202 Accepted. The task manager
+ * tracks state transitions and notifies via SSE when status changes.
+ */
+
+import { randomUUID } from 'node:crypto';
+import { EventEmitter } from 'node:events';
+
+export type TaskStatus = 'working' | 'input_required' | 'completed' | 'failed' | 'cancelled';
+
+export interface Task {
+  id: string;
+  toolName: string;
+  status: TaskStatus;
+  result?: unknown;
+  error?: string;
+  createdAt: string;
+  updatedAt: string;
+}
+
+export interface TaskStatusChangeEvent {
+  task: Task;
+  previousStatus: TaskStatus;
+}
+
+const tasks = new Map<string, Task>();
+const MAX_TASKS = 1000;
+
+/**
+ * Event emitter for task status changes.
+ * Emits 'statusChange' events with { task, previousStatus }.
+ */
+export const taskEvents = new EventEmitter();
+
+export function createTask(toolName: string): Task {
+  // Evict oldest if at capacity
+  if (tasks.size >= MAX_TASKS) {
+    const oldest = tasks.keys().next().value;
+    if (oldest) tasks.delete(oldest);
+  }
+
+  const task: Task = {
+    id: randomUUID(),
+    toolName,
+    status: 'working',
+    createdAt: new Date().toISOString(),
+    updatedAt: new Date().toISOString(),
+  };
+
+  tasks.set(task.id, task);
+  return task;
+}
+
+export function getTask(taskId: string): Task | undefined {
+  return tasks.get(taskId);
+}
+
+export function updateTask(
+  taskId: string,
+  update: { status?: TaskStatus; result?: unknown; error?: string },
+): Task | undefined {
+  const task = tasks.get(taskId);
+  if (!task) return undefined;
+
+  const previousStatus = task.status;
+  if (update.status) task.status = update.status;
+  if (update.result !== undefined) task.result = update.result;
+  if (update.error !== undefined) task.error = update.error;
+  task.updatedAt = new Date().toISOString();
+
+  if (task.status !== previousStatus) {
+    taskEvents.emit('statusChange', { task, previousStatus } as TaskStatusChangeEvent);
+  }
+
+  return task;
+}
+
+export function cancelTask(taskId: string): Task | undefined {
+  const task = tasks.get(taskId);
+  if (!task) return undefined;
+  if (task.status === 'completed' || task.status === 'failed') return task;
+
+  const previousStatus = task.status;
+  task.status = 'cancelled';
+  task.updatedAt = new Date().toISOString();
+
+  taskEvents.emit('statusChange', { task, previousStatus } as TaskStatusChangeEvent);
+
+  return task;
+}
+
+export function listTasks(status?: TaskStatus, limit?: number): Task[] {
+  const all = [...tasks.values()];
+  const filtered = status ? all.filter((t) => t.status === status) : all;
+  return limit !== undefined && limit > 0 ? filtered.slice(0, limit) : filtered;
+}
+
+/**
+ * Returns a promise that resolves with the task when it reaches a terminal
+ * state (completed, failed, cancelled), or rejects if the timeout elapses.
+ */
+export function getResult(taskId: string, timeoutMs: number = 30000): Promise<Task> {
+  return new Promise((resolve, reject) => {
+    const task = tasks.get(taskId);
+    if (!task) {
+      reject(new Error(`Task ${taskId} not found`));
+      return;
+    }
+
+    // Already in a terminal state
+    if (task.status === 'completed' || task.status === 'failed' || task.status === 'cancelled') {
+      resolve(task);
+      return;
+    }
+
+    const cleanup = (): void => {
+      taskEvents.removeListener('statusChange', onChange);
+      clearTimeout(timer);
+    };
+
+    const timer = setTimeout(() => {
+      cleanup();
+      reject(new Error('timeout'));
+    }, timeoutMs);
+
+    const onChange = (event: TaskStatusChangeEvent): void => {
+      if (event.task.id !== taskId) return;
+      const s = event.task.status;
+      if (s === 'completed' || s === 'failed' || s === 'cancelled') {
+        cleanup();
+        resolve(event.task);
+      }
+    };
+
+    taskEvents.on('statusChange', onChange);
+  });
+}

package/dist/emitter/templates/task-sse.ts.hbs

@@ -0,0 +1,105 @@
+/**
+ * Server-Sent Events endpoint for real-time task status notifications.
+ */
+
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import { taskEvents, type TaskStatusChangeEvent } from './task-manager.js';
+
+interface SseConnection {
+  res: ServerResponse;
+  taskIdFilter: string | null;
+}
+
+const connections = new Set<SseConnection>();
+
+const HEARTBEAT_INTERVAL_MS = 30000;
+let heartbeatTimer: ReturnType<typeof setInterval> | null = null;
+
+function ensureHeartbeat(): void {
+  if (heartbeatTimer) return;
+  heartbeatTimer = setInterval(() => {
+    for (const conn of connections) {
+      if (!conn.res.writableEnded) {
+        conn.res.write(':ping\n\n');
+      }
+    }
+  }, HEARTBEAT_INTERVAL_MS);
+  heartbeatTimer.unref();
+}
+
+function stopHeartbeatIfEmpty(): void {
+  if (connections.size === 0 && heartbeatTimer) {
+    clearInterval(heartbeatTimer);
+    heartbeatTimer = null;
+  }
+}
+
+function broadcast(eventName: string, data: unknown, taskId: string): void {
+  const payload = `event: ${eventName}\ndata: ${JSON.stringify(data)}\n\n`;
+  for (const conn of connections) {
+    if (conn.res.writableEnded) continue;
+    if (conn.taskIdFilter && conn.taskIdFilter !== taskId) continue;
+    conn.res.write(payload);
+  }
+}
+
+/* Subscribe to task status changes and broadcast SSE events */
+taskEvents.on('statusChange', (event: TaskStatusChangeEvent) => {
+  const { task } = event;
+
+  broadcast('task.status', {
+    taskId: task.id,
+    status: task.status,
+    updatedAt: task.updatedAt,
+  }, task.id);
+
+  if (task.status === 'completed') {
+    broadcast('task.completed', {
+      taskId: task.id,
+      status: 'completed',
+      result: task.result,
+    }, task.id);
+  } else if (task.status === 'failed') {
+    broadcast('task.failed', {
+      taskId: task.id,
+      status: 'failed',
+      error: task.error,
+    }, task.id);
+  }
+});
+
+/**
+ * Handle the SSE endpoint: GET /tasks/events
+ * Returns true if the request was handled.
+ */
+export function handleTaskSse(
+  req: IncomingMessage,
+  res: ServerResponse,
+  url: URL,
+): boolean {
+  if (url.pathname !== '/tasks/events' || (req.method ?? 'GET') !== 'GET') {
+    return false;
+  }
+
+  const taskIdFilter = url.searchParams.get('taskId') ?? null;
+
+  res.writeHead(200, {
+    'Content-Type': 'text/event-stream',
+    'Cache-Control': 'no-cache',
+    Connection: 'keep-alive',
+  });
+
+  // Initial comment to confirm connection
+  res.write(':connected\n\n');
+
+  const conn: SseConnection = { res, taskIdFilter };
+  connections.add(conn);
+  ensureHeartbeat();
+
+  req.on('close', () => {
+    connections.delete(conn);
+    stopHeartbeatIfEmpty();
+  });
+
+  return true;
+}

package/dist/emitter/templates/tool-handler.ts.hbs

@@ -0,0 +1,142 @@
+import { z } from 'zod';
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { executeRequest } from '../http.js';
+import { applyJqFilter } from '../response-filter.js';
+import type { AppConfig } from '../config.js';
+{{#if isAsync}}
+import { createTask, updateTask } from '../task-manager.js';
+{{/if}}
+
+// Per-call control arguments shared by every generated tool. These are optional
+// and stripped before the upstream request is built, so omitting them preserves
+// the original behavior exactly.
+const controlSchema = {
+  jq_filter: z
+    .string()
+    .optional()
+    .describe(
+      'Optional jq-style filter applied to the JSON response before it is returned ' +
+        '(e.g. ".data", ".items[0].id", ".items[]"). Trims large responses.',
+    ),
+  idempotency_key: z
+    .string()
+    .optional()
+    .describe(
+      'Optional Idempotency-Key header for safe retries of mutating requests. ' +
+        'Ignored for read-only operations.',
+    ),
+};
+
+const inputSchema = ({{{inputSchemaCode}}}).extend(controlSchema);
+{{#if outputSchemaCode}}
+const outputSchema = {{{outputSchemaCode}}};
+{{/if}}
+
+/** Execute the HTTP request for this tool and return the (optionally filtered) data. */
+async function runRequest(rawInput: Record<string, unknown>, config: AppConfig): Promise<unknown> {
+  // Pull off the per-call control args so they are never forwarded upstream.
+  const { jq_filter: jqFilter, idempotency_key: idempotencyKey, ...input } = rawInput;
+  const url = buildUrl(input, config.baseUrl);
+
+  const response = await executeRequest({
+    method: '{{method}}',
+    url,
+{{#if hasRequestBody}}
+    body: input.body,
+    contentType: '{{requestBodyContentType}}',
+{{/if}}
+    headers: {},
+    config,
+    idempotencyKey: typeof idempotencyKey === 'string' ? idempotencyKey : undefined,
+  });
+
+  let result: unknown = response.data;
+{{#if jqFilter}}
+  // Build-time x-mcp-jq-filter (applied first when no per-call filter is given).
+  if (typeof jqFilter !== 'string') {
+    result = applyJqFilter(result, '{{{jqFilter}}}');
+  }
+{{/if}}
+  // Per-call jq_filter takes precedence (absent → unchanged).
+  if (typeof jqFilter === 'string' && jqFilter) {
+    result = applyJqFilter(result, jqFilter);
+  }
+  return result;
+}
+
+export function register(server: McpServer, config: AppConfig): void {
+  server.registerTool(
+    '{{name}}',
+    {
+      title: '{{title}}',
+      description: `{{{description}}}`,
+      inputSchema,
+{{#if outputSchemaCode}}
+      outputSchema,
+{{/if}}
+{{#if annotations}}
+      annotations: {
+{{#if annotations.readOnlyHint}}
+        readOnlyHint: true,
+{{/if}}
+{{#if annotations.destructiveHint}}
+        destructiveHint: true,
+{{/if}}
+{{#if annotations.idempotentHint}}
+        idempotentHint: true,
+{{/if}}
+      },
+{{/if}}
+    },
+    async (input) => {
+{{#if isAsync}}
+      // Tasks extension (2026-07-28): a long-running tool answers immediately
+      // with a task handle and runs the work in the background; the client
+      // drives it with tasks/get / tasks/update / tasks/cancel. VERIFY the
+      // returned handle envelope against the final spec.
+      const task = createTask('{{name}}');
+      void (async () => {
+        try {
+          const result = await runRequest(input as Record<string, unknown>, config);
+          updateTask(task.id, { status: 'completed', result });
+        } catch (error) {
+          updateTask(task.id, {
+            status: 'failed',
+            error: error instanceof Error ? error.message : String(error),
+          });
+        }
+      })();
+      const handle = { taskId: task.id, status: task.status };
+      return {
+        content: [{ type: 'text' as const, text: JSON.stringify({ task: handle }, null, 2) }],
+        structuredContent: { task: handle },
+      };
+{{else}}
+      try {
+        const result = await runRequest(input as Record<string, unknown>, config);
+        return {
+          content: [
+            {
+              type: 'text' as const,
+              text: JSON.stringify(result, null, 2),
+            },
+          ],
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: 'text' as const, text: `Error: ${message}` }],
+          isError: true,
+        };
+      }
+{{/if}}
+    },
+  );
+}
+
+function buildUrl(
+  params: Record<string, unknown>,
+  baseUrl: string,
+): string {
+{{{buildUrlBody}}}
+}

package/dist/emitter/templates/tool-index.ts.hbs

@@ -0,0 +1,42 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { AppConfig } from '../config.js';
+{{#each tools}}
+import { register as register{{capitalize functionName}} } from './{{fileName}}.js';
+{{/each}}
+
+/**
+ * Runtime tool filtering.
+ *
+ * Two optional env vars narrow which tools are registered at startup (works for
+ * both the stdio and HTTP transports). When neither is set, every tool is
+ * registered exactly as before — this is purely additive.
+ *
+ *   MCP_TOOLS          comma-separated allowlist; only these tool names register
+ *   MCP_EXCLUDE_TOOLS  comma-separated denylist; these tool names never register
+ *
+ * The denylist is applied after the allowlist. Names are matched exactly (the
+ * tool names shown in tools/list).
+ */
+function parseList(raw: string | undefined): Set<string> | undefined {
+  if (!raw) return undefined;
+  const names = raw
+    .split(',')
+    .map((s) => s.trim())
+    .filter(Boolean);
+  return names.length > 0 ? new Set(names) : undefined;
+}
+
+const allow = parseList(process.env.MCP_TOOLS);
+const deny = parseList(process.env.MCP_EXCLUDE_TOOLS);
+
+export function isToolEnabled(name: string): boolean {
+  if (allow && !allow.has(name)) return false;
+  if (deny && deny.has(name)) return false;
+  return true;
+}
+
+export function registerAllTools(server: McpServer, config: AppConfig): void {
+{{#each tools}}
+  if (isToolEnabled('{{name}}')) register{{capitalize functionName}}(server, config);
+{{/each}}
+}

package/dist/emitter/templates/tool-test.ts.hbs

@@ -0,0 +1,57 @@
+import { describe, it, expect } from 'vitest';
+import { z } from 'zod';
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { AppConfig } from '../../src/config.js';
+import { register } from '../../src/tools/{{fileName}}.js';
+
+/**
+ * Capture the server.registerTool() call without a real MCP server or any
+ * network access. The tool's HTTP handler is never invoked here.
+ */
+function capture(): { name: string; def: Record<string, unknown>; handler: unknown }[] {
+  const calls: { name: string; def: Record<string, unknown>; handler: unknown }[] = [];
+  const server = {
+    registerTool(name: string, def: Record<string, unknown>, handler: unknown) {
+      calls.push({ name, def, handler });
+    },
+  } as unknown as McpServer;
+  const config = {
+    baseUrl: 'https://example.test',
+    maxRetries: 0,
+    requestIntervalMs: 0,
+  } as unknown as AppConfig;
+  register(server, config);
+  return calls;
+}
+
+describe('{{name}}', () => {
+  // Tool: {{name}} — {{method}} {{pathTemplate}}
+
+  it('registers exactly one tool under its name', () => {
+    const calls = capture();
+    expect(calls).toHaveLength(1);
+    expect(calls[0].name).toBe('{{name}}');
+  });
+
+  it('exposes a title and description', () => {
+    const { def } = capture()[0];
+    expect(def.title).toBeTruthy();
+    expect(typeof def.description).toBe('string');
+  });
+
+  it('registers a callable handler', () => {
+    expect(typeof capture()[0].handler).toBe('function');
+  });
+
+  it('has a well-formed input schema', () => {
+    const raw = capture()[0].def.inputSchema as unknown;
+    // inputSchema is a Zod raw shape (record of validators); it must build into
+    // a usable object schema and run without throwing.
+    const schema =
+      raw && typeof (raw as { safeParse?: unknown }).safeParse === 'function'
+        ? (raw as z.ZodTypeAny)
+        : z.object(raw as z.ZodRawShape);
+    const result = schema.safeParse({});
+    expect(typeof result.success).toBe('boolean');
+  });
+});

package/dist/emitter/templates/trace.ts.hbs

@@ -0,0 +1,79 @@
+/**
+ * W3C Trace Context propagation (https://www.w3.org/TR/trace-context/).
+ *
+ * The HTTP server reads an inbound `traceparent` (joining a distributed trace)
+ * or starts a fresh one, binds it to the request via AsyncLocalStorage, and the
+ * HTTP executor stamps it onto every upstream API call so the trace spans the
+ * API hop. Stdio servers never establish a context, so upstream calls simply
+ * carry no trace headers (the store is empty — `traceHeaders()` returns `{}`).
+ */
+
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { randomBytes } from 'node:crypto';
+
+export interface TraceContext {
+  /** 32-hex trace id, shared across the whole distributed trace. */
+  traceId: string;
+  /** 16-hex span id for this server's work (the parent of upstream calls). */
+  spanId: string;
+  /** 2-hex trace-flags (`01` = sampled). */
+  flags: string;
+  /** Opaque vendor `tracestate`, propagated verbatim when present. */
+  traceState?: string;
+}
+
+const storage = new AsyncLocalStorage<TraceContext>();
+
+const TRACEPARENT_RE = /^00-([0-9a-f]{32})-([0-9a-f]{16})-([0-9a-f]{2})$/;
+const INVALID_TRACE_ID = '0'.repeat(32);
+
+/** Parse a `traceparent` header; returns its trace id + flags, or null if invalid. */
+export function parseTraceparent(
+  header: string | undefined,
+): { traceId: string; flags: string } | null {
+  if (!header) return null;
+  const match = TRACEPARENT_RE.exec(header.trim().toLowerCase());
+  if (!match) return null;
+  const traceId = match[1];
+  const flags = match[3];
+  if (traceId === INVALID_TRACE_ID) return null;
+  return { traceId, flags };
+}
+
+/**
+ * Build the context for a request: continue a valid inbound trace, otherwise
+ * start a new one. A fresh span id is always minted for this server's work.
+ */
+export function deriveContext(traceparent?: string, tracestate?: string): TraceContext {
+  const parent = parseTraceparent(traceparent);
+  return {
+    traceId: parent?.traceId ?? randomBytes(16).toString('hex'),
+    spanId: randomBytes(8).toString('hex'),
+    flags: parent?.flags ?? '01',
+    traceState: tracestate?.trim() || undefined,
+  };
+}
+
+/** Format a context as a `traceparent` header value. */
+export function formatTraceparent(ctx: TraceContext): string {
+  return `00-${ctx.traceId}-${ctx.spanId}-${ctx.flags}`;
+}
+
+/** Run `fn` with `ctx` bound as the active trace context for its async subtree. */
+export function runWithTrace<T>(ctx: TraceContext, fn: () => T): T {
+  return storage.run(ctx, fn);
+}
+
+/** The active trace context, or undefined outside a traced request. */
+export function currentTrace(): TraceContext | undefined {
+  return storage.getStore();
+}
+
+/** Trace headers to stamp on an upstream request, or `{}` when no trace is active. */
+export function traceHeaders(): Record<string, string> {
+  const ctx = storage.getStore();
+  if (!ctx) return {};
+  const headers: Record<string, string> = { traceparent: formatTraceparent(ctx) };
+  if (ctx.traceState) headers.tracestate = ctx.traceState;
+  return headers;
+}

package/dist/emitter/templates/tsconfig.json.hbs

@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "Node16",
+    "moduleResolution": "Node16",
+    "outDir": "dist",
+    "rootDir": "src",
+    "declaration": true,
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": ["node_modules", "dist"]
+}

package/dist/emitter/templates/types.ts.hbs

@@ -0,0 +1,5 @@
+export interface ApiResponse {
+  status: number;
+  data: unknown;
+  headers: Record<string, string>;
+}

package/dist/emitter/worker-template-loader.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Template loader for Cloudflare Workers MCP server templates.
+ * Parallel to template-loader.ts but reads from worker-templates/.
+ */
+export declare function renderWorkerTemplate(name: string, data: any): string;
+//# sourceMappingURL=worker-template-loader.d.ts.map

package/dist/emitter/worker-template-loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker-template-loader.d.ts","sourceRoot":"","sources":["../../src/emitter/worker-template-loader.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAwBH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,GAAG,GAAG,MAAM,CAUpE"}

package/dist/emitter/worker-template-loader.js

@@ -0,0 +1,34 @@
+/**
+ * Template loader for Cloudflare Workers MCP server templates.
+ * Parallel to template-loader.ts but reads from worker-templates/.
+ */
+import { readFileSync } from 'node:fs';
+import { resolve, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import Handlebars from 'handlebars';
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const WORKER_TEMPLATE_DIR = resolve(__dirname, 'worker-templates');
+const workerTemplateCache = new Map();
+// Register helpers (same as template-loader.ts — Handlebars helpers are global).
+// These may already be registered; Handlebars silently overwrites, which is fine.
+Handlebars.registerHelper('eq', function (a, b) {
+    return a === b;
+});
+Handlebars.registerHelper('capitalize', function (str) {
+    if (!str)
+        return str;
+    return str.charAt(0).toUpperCase() + str.slice(1);
+});
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function renderWorkerTemplate(name, data) {
+    if (!workerTemplateCache.has(name)) {
+        const templatePath = resolve(WORKER_TEMPLATE_DIR, `${name}.hbs`);
+        if (!templatePath.startsWith(WORKER_TEMPLATE_DIR + '/')) {
+            throw new Error(`Invalid worker template name: ${name}`);
+        }
+        const raw = readFileSync(templatePath, 'utf-8');
+        workerTemplateCache.set(name, Handlebars.compile(raw, { noEscape: true }));
+    }
+    return workerTemplateCache.get(name)(data);
+}
+//# sourceMappingURL=worker-template-loader.js.map

package/dist/emitter/worker-template-loader.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker-template-loader.js","sourceRoot":"","sources":["../../src/emitter/worker-template-loader.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AACvC,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAC7C,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AACzC,OAAO,UAAU,MAAM,YAAY,CAAC;AAEpC,MAAM,SAAS,GAAG,OAAO,CAAC,aAAa,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC;AAC1D,MAAM,mBAAmB,GAAG,OAAO,CAAC,SAAS,EAAE,kBAAkB,CAAC,CAAC;AAEnE,MAAM,mBAAmB,GAAG,IAAI,GAAG,EAAuC,CAAC;AAE3E,iFAAiF;AACjF,kFAAkF;AAClF,UAAU,CAAC,cAAc,CAAC,IAAI,EAAE,UAAU,CAAU,EAAE,CAAU;IAC9D,OAAO,CAAC,KAAK,CAAC,CAAC;AACjB,CAAC,CAAC,CAAC;AAEH,UAAU,CAAC,cAAc,CAAC,YAAY,EAAE,UAAU,GAAW;IAC3D,IAAI,CAAC,GAAG;QAAE,OAAO,GAAG,CAAC;IACrB,OAAO,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,WAAW,EAAE,GAAG,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;AACpD,CAAC,CAAC,CAAC;AAEH,8DAA8D;AAC9D,MAAM,UAAU,oBAAoB,CAAC,IAAY,EAAE,IAAS;IAC1D,IAAI,CAAC,mBAAmB,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC;QACnC,MAAM,YAAY,GAAG,OAAO,CAAC,mBAAmB,EAAE,GAAG,IAAI,MAAM,CAAC,CAAC;QACjE,IAAI,CAAC,YAAY,CAAC,UAAU,CAAC,mBAAmB,GAAG,GAAG,CAAC,EAAE,CAAC;YACxD,MAAM,IAAI,KAAK,CAAC,iCAAiC,IAAI,EAAE,CAAC,CAAC;QAC3D,CAAC;QACD,MAAM,GAAG,GAAG,YAAY,CAAC,YAAY,EAAE,OAAO,CAAC,CAAC;QAChD,mBAAmB,CAAC,GAAG,CAAC,IAAI,EAAE,UAAU,CAAC,OAAO,CAAC,GAAG,EAAE,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC;IAC7E,CAAC;IACD,OAAO,mBAAmB,CAAC,GAAG,CAAC,IAAI,CAAE,CAAC,IAAI,CAAC,CAAC;AAC9C,CAAC"}