@honua/mcp-server 0.0.10-alpha.0 → 0.1.0-beta.0

package/dist/src/eval/cli.js

@@ -0,0 +1,118 @@
+#!/usr/bin/env node
+import { mkdirSync, writeFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { resolveCorpus } from "./corpus.js";
+import { parseDriverName, selectDrivers } from "./drivers/index.js";
+import { renderMarkdown } from "./report.js";
+import { runEval } from "./runner.js";
+/**
+ * Cross-model MCP workflow eval CLI (honua-server #1956).
+ *
+ * Modes:
+ *   (default)        Run the eval, write artifacts, exit non-zero if the
+ *                    deterministic control did not pass every scenario.
+ *   --artifact-only  Run the eval, write artifacts, ALWAYS exit 0 (evidence
+ *                    upload step; runs with always() in CI).
+ *   --offline        Force the in-memory fixture surface + deterministic driver
+ *                    only, even if API keys / HONUA_MCP_REMOTE_URL are set.
+ *   --driver <name>  Run the deterministic control plus the named live driver(s)
+ *                    (repeatable or comma-separated): anthropic | openai | bedrock.
+ *                    The named driver is run even if its key/opt-in is absent so an
+ *                    explicit request yields an honest driverError, not a silent
+ *                    skip. Without --driver, drivers are auto-resolved from env.
+ *   --corpus <name>  Select the corpus explicitly: analyst | operator | northstar |
+ *                    all. This overrides HONUA_EVAL_CORPUS and is how the `eval:live`
+ *                    script targets the operator surface without relying on shell env
+ *                    (cross-platform). `northstar` targets the three P1-gate
+ *                    workflows. Defaults to the env-driven selection.
+ *
+ * Corpus selection is env-driven (see `resolveCorpus`): default is the analyst
+ * corpus (in-process SDK fixture surface, the CI control); `HONUA_EVAL_CORPUS=operator`
+ * targets the honua-server operator MCP surface for live runs; `all` runs both.
+ *
+ * Offline and deterministic by default: zero model/API calls. Live cross-model
+ * runs activate when ANTHROPIC_API_KEY / OPENAI_API_KEY are set (Anthropic/OpenAI
+ * APIs) or HONUA_EVAL_BEDROCK is set (Claude via Amazon Bedrock, AWS credential
+ * chain), and live remote MCP runs when HONUA_MCP_REMOTE_URL is set. Keys are
+ * never hardcoded — they come from the environment.
+ */
+const CORPUS_NAMES = ["analyst", "operator", "northstar", "standalone", "all"];
+function parseArgs(argv) {
+    let artifactOnly = false;
+    let offline = false;
+    let outDir = fileURLToPath(new URL("../../../", import.meta.url));
+    const drivers = [];
+    let corpus;
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        if (arg === "--artifact-only") {
+            artifactOnly = true;
+        }
+        else if (arg === "--offline") {
+            offline = true;
+        }
+        else if (arg === "--out-dir") {
+            const value = argv[++i];
+            if (!value) {
+                throw new Error("--out-dir requires a directory argument");
+            }
+            outDir = resolve(value);
+        }
+        else if (arg === "--corpus") {
+            const value = argv[++i];
+            if (!value || !CORPUS_NAMES.includes(value)) {
+                throw new Error(`--corpus requires one of: ${CORPUS_NAMES.join(", ")}`);
+            }
+            corpus = value;
+        }
+        else if (arg === "--driver") {
+            const value = argv[++i];
+            if (!value) {
+                throw new Error("--driver requires a driver name (anthropic | openai | bedrock)");
+            }
+            for (const name of value.split(",")) {
+                const trimmed = name.trim();
+                if (trimmed.length > 0) {
+                    drivers.push(parseDriverName(trimmed));
+                }
+            }
+        }
+    }
+    return { artifactOnly, offline, outDir, drivers, ...(corpus ? { corpus } : {}) };
+}
+/** Map the `--corpus` alias to the corresponding HONUA_EVAL_CORPUS selection. */
+function corpusForName(name) {
+    const selector = name === "analyst" ? "" : name; // analyst is the env default
+    return resolveCorpus({ ...process.env, HONUA_EVAL_CORPUS: selector });
+}
+async function main() {
+    const { artifactOnly, offline, outDir, drivers, corpus } = parseArgs(process.argv.slice(2));
+    const report = await runEval({
+        forceOffline: offline,
+        ...(drivers.length > 0 ? { drivers: selectDrivers(drivers) } : {}),
+        ...(corpus ? { corpus: corpusForName(corpus) } : {}),
+        ...(corpus === "standalone" ? { forceStandaloneSurface: true } : {}),
+    });
+    mkdirSync(outDir, { recursive: true });
+    const jsonPath = resolve(outDir, "mcp-eval-results.json");
+    const mdPath = resolve(outDir, "mcp-eval-results.md");
+    writeFileSync(jsonPath, `${JSON.stringify(report, null, 2)}\n`, "utf8");
+    writeFileSync(mdPath, renderMarkdown(report), "utf8");
+    const s = report.summary;
+    const status = s.pass ? "PASS" : "FAIL";
+    process.stdout.write(`MCP cross-model eval ${status}: ${s.scenarios} scenarios, ${s.modelsEvaluated} models ` +
+        `(${s.liveModelsEvaluated} live), surface=${report.surface.backend}.\n`);
+    for (const m of report.models) {
+        process.stdout.write(`  ${m.id}: success ${(m.successRate * 100).toFixed(0)}%, clarify ${(m.clarificationRate * 100).toFixed(0)}%, ` +
+            `edit ${(m.editRate * 100).toFixed(0)}% (${m.pass}/${m.scenarios} passed)\n`);
+    }
+    process.stdout.write(`Artifacts: ${jsonPath}\n           ${mdPath}\n`);
+    if (!artifactOnly && !s.pass) {
+        process.exitCode = 1;
+    }
+}
+main().catch((err) => {
+    process.stderr.write(`Eval error: ${err instanceof Error ? (err.stack ?? err.message) : String(err)}\n`);
+    process.exit(1);
+});

package/dist/src/eval/corpus.d.ts

@@ -0,0 +1,34 @@
+import type { Scenario } from "./types.js";
+/**
+ * Held-out corpus of GIS workflows for the cross-model eval (honua-server #1956).
+ *
+ * Each scenario is a natural-language GIS task plus declarative success criteria.
+ * The `script` is the "ideal client" tool trajectory the deterministic offline
+ * driver follows; live LLM drivers (Claude, GPT) plan their own calls from the
+ * prompt and the advertised tool catalog. Criteria are graded identically across
+ * all drivers, so the same corpus measures any client against any workflow.
+ *
+ * Tool/argument shapes target the canonical honua MCP catalog and resolve
+ * against the offline fixture backend (service "Parks", layer 0).
+ */
+export declare const CORPUS: Scenario[];
+/**
+ * Select the corpus to run from the environment (honua-server #1956).
+ *
+ * The default `analyst` corpus targets the in-process SDK fixture surface and is
+ * the CI control. `operator` selects {@link OPERATOR_CORPUS} for live runs against
+ * the honua-server operator MCP surface; `northstar` selects {@link NORTHSTAR_CORPUS},
+ * the three P1-gate workflows (also live-gated); `all` runs every corpus
+ * back-to-back. Selection is case-insensitive and falls back to the analyst corpus
+ * for any unset/unknown value so CI behavior is unchanged unless `HONUA_EVAL_CORPUS`
+ * is set explicitly.
+ */
+export declare function resolveCorpus(env?: NodeJS.ProcessEnv): Scenario[];
+/**
+ * Whether a corpus selection targets the PLATFORM-FREE standalone surface (a plain
+ * public FeatureServer fixture) rather than the Honua operator/analyst surface.
+ * The offline runner uses this to pick the census fixture client so the standalone
+ * corpus resolves against real recorded non-Honua data.
+ */
+export declare function isStandaloneCorpus(env?: NodeJS.ProcessEnv): boolean;
+//# sourceMappingURL=corpus.d.ts.map

package/dist/src/eval/corpus.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"corpus.d.ts","sourceRoot":"","sources":["../../../src/eval/corpus.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAE3C;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,MAAM,EAAE,QAAQ,EAkG5B,CAAC;AAEF;;;;;;;;;;GAUG;AACH,wBAAgB,aAAa,CAAC,GAAG,GAAE,MAAM,CAAC,UAAwB,GAAG,QAAQ,EAAE,CAiB9E;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,GAAE,MAAM,CAAC,UAAwB,GAAG,OAAO,CAEhF"}

package/dist/src/eval/corpus.js

@@ -0,0 +1,150 @@
+import { NORTHSTAR_CORPUS } from "./northstar-corpus.js";
+import { OPERATOR_CORPUS } from "./operator-corpus.js";
+import { STANDALONE_CORPUS } from "./standalone-corpus.js";
+/**
+ * Held-out corpus of GIS workflows for the cross-model eval (honua-server #1956).
+ *
+ * Each scenario is a natural-language GIS task plus declarative success criteria.
+ * The `script` is the "ideal client" tool trajectory the deterministic offline
+ * driver follows; live LLM drivers (Claude, GPT) plan their own calls from the
+ * prompt and the advertised tool catalog. Criteria are graded identically across
+ * all drivers, so the same corpus measures any client against any workflow.
+ *
+ * Tool/argument shapes target the canonical honua MCP catalog and resolve
+ * against the offline fixture backend (service "Parks", layer 0).
+ */
+export const CORPUS = [
+    {
+        id: "discover-services",
+        title: "Discover available feature services",
+        category: "discovery",
+        prompt: "I'm new to this server. What feature services are available to query? Just list them.",
+        criteria: {
+            requiredTools: ["honua_list_services"],
+            answerMustInclude: ["Parks"],
+        },
+        script: [{ tool: "honua_list_services", args: {} }],
+    },
+    {
+        id: "inspect-layer-schema",
+        title: "Inspect a layer's schema before querying",
+        category: "grounding",
+        prompt: "Before I query the Parks service, show me the schema of its first layer (layer 0) — the fields and geometry type.",
+        criteria: {
+            requiredTools: ["honua_describe_layer"],
+            answerMustInclude: ["OBJECTID"],
+        },
+        script: [{ tool: "honua_describe_layer", args: { serviceId: "Parks", layerId: 0 } }],
+    },
+    {
+        id: "count-then-query",
+        title: "Check cardinality, then fetch a sample",
+        category: "query",
+        prompt: "How many features are in the Parks service layer 0? Then show me a couple of them.",
+        criteria: {
+            requiredTools: ["honua_count_features", "honua_query_features"],
+            expectedToolSequence: ["honua_count_features", "honua_query_features"],
+            answerMustInclude: ["Park A"],
+        },
+        script: [
+            { tool: "honua_count_features", args: { serviceId: "Parks", layerId: 0 } },
+            { tool: "honua_query_features", args: { serviceId: "Parks", layerId: 0, limit: 2 } },
+        ],
+    },
+    {
+        id: "discover-then-query",
+        title: "End-to-end discover → query",
+        category: "multi-step",
+        prompt: "I don't know what's on this server. Find a feature service and show me a few features from one of its layers.",
+        criteria: {
+            requiredTools: ["honua_list_services", "honua_query_features"],
+            expectedToolSequence: ["honua_list_services", "honua_query_features"],
+            answerMustInclude: ["Park"],
+        },
+        script: [
+            { tool: "honua_list_services", args: {} },
+            { tool: "honua_query_features", args: { serviceId: "Parks", layerId: 0, limit: 2 } },
+        ],
+    },
+    {
+        id: "aggregate-statistic",
+        title: "Compute an aggregate statistic",
+        category: "analysis",
+        prompt: "What is the average of the VALUE field for the Parks service, layer 0?",
+        criteria: {
+            requiredTools: ["honua_statistics"],
+            answerMustInclude: ["statistics"],
+        },
+        script: [
+            {
+                tool: "honua_statistics",
+                args: { serviceId: "Parks", layerId: 0, statisticType: "avg", onField: "VALUE" },
+            },
+        ],
+    },
+    {
+        id: "spatial-extent",
+        title: "Get the spatial extent of a layer",
+        category: "query",
+        prompt: "What is the bounding box / spatial extent of the Parks service, layer 0?",
+        criteria: {
+            requiredTools: ["honua_get_extent"],
+            answerMustInclude: ["extent"],
+        },
+        script: [{ tool: "honua_get_extent", args: { serviceId: "Parks", layerId: 0 } }],
+    },
+    {
+        id: "capability-gap",
+        title: "Explain a capability gap honestly",
+        category: "grounding",
+        prompt: "Can I run an attribute query against a WMTS source on this platform? If not, what should I do instead?",
+        criteria: {
+            requiredTools: ["honua_explain_capability_gap"],
+            answerMustInclude: ["explanation"],
+        },
+        script: [
+            {
+                tool: "honua_explain_capability_gap",
+                args: { capability: "query", protocol: "wmts" },
+            },
+        ],
+    },
+];
+/**
+ * Select the corpus to run from the environment (honua-server #1956).
+ *
+ * The default `analyst` corpus targets the in-process SDK fixture surface and is
+ * the CI control. `operator` selects {@link OPERATOR_CORPUS} for live runs against
+ * the honua-server operator MCP surface; `northstar` selects {@link NORTHSTAR_CORPUS},
+ * the three P1-gate workflows (also live-gated); `all` runs every corpus
+ * back-to-back. Selection is case-insensitive and falls back to the analyst corpus
+ * for any unset/unknown value so CI behavior is unchanged unless `HONUA_EVAL_CORPUS`
+ * is set explicitly.
+ */
+export function resolveCorpus(env = process.env) {
+    switch ((env.HONUA_EVAL_CORPUS ?? "").trim().toLowerCase()) {
+        case "operator":
+            return OPERATOR_CORPUS;
+        case "northstar":
+            return NORTHSTAR_CORPUS;
+        case "standalone":
+            return STANDALONE_CORPUS;
+        case "all":
+            // `all` spans the Honua-surface corpora only. The platform-free standalone
+            // corpus targets a DIFFERENT surface (a plain FeatureServer fixture) and is
+            // selected explicitly via `standalone`; mixing it here would run its
+            // census-specific scenarios against an operator surface.
+            return [...CORPUS, ...OPERATOR_CORPUS, ...NORTHSTAR_CORPUS];
+        default:
+            return CORPUS;
+    }
+}
+/**
+ * Whether a corpus selection targets the PLATFORM-FREE standalone surface (a plain
+ * public FeatureServer fixture) rather than the Honua operator/analyst surface.
+ * The offline runner uses this to pick the census fixture client so the standalone
+ * corpus resolves against real recorded non-Honua data.
+ */
+export function isStandaloneCorpus(env = process.env) {
+    return (env.HONUA_EVAL_CORPUS ?? "").trim().toLowerCase() === "standalone";
+}

package/dist/src/eval/drivers/anthropic.d.ts

@@ -0,0 +1,14 @@
+import type { ModelDriver, Scenario, WorkflowContext, WorkflowTranscript } from "../types.js";
+export interface AnthropicDriverOptions {
+    apiKey?: string | undefined;
+    model?: string;
+}
+export declare class AnthropicDriver implements ModelDriver {
+    readonly vendor: "anthropic";
+    readonly id: string;
+    private readonly apiKey;
+    constructor(options?: AnthropicDriverOptions);
+    isAvailable(): boolean;
+    runWorkflow(scenario: Scenario, ctx: WorkflowContext): Promise<WorkflowTranscript>;
+}
+//# sourceMappingURL=anthropic.d.ts.map

package/dist/src/eval/drivers/anthropic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"anthropic.d.ts","sourceRoot":"","sources":["../../../../src/eval/drivers/anthropic.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,QAAQ,EAAkB,eAAe,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAoC9G,MAAM,WAAW,sBAAsB;IACrC,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC5B,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,qBAAa,eAAgB,YAAW,WAAW;IACjD,QAAQ,CAAC,MAAM,EAAG,WAAW,CAAU;IACvC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAqB;gBAEhC,OAAO,GAAE,sBAA2B;IAKhD,WAAW,IAAI,OAAO;IAIhB,WAAW,CAAC,QAAQ,EAAE,QAAQ,EAAE,GAAG,EAAE,eAAe,GAAG,OAAO,CAAC,kBAAkB,CAAC;CAoFzF"}

package/dist/src/eval/drivers/anthropic.js

@@ -0,0 +1,120 @@
+/**
+ * Claude client driver for the cross-model eval (honua-server #1956).
+ *
+ * Gated behind ANTHROPIC_API_KEY and a dynamically-imported `@anthropic-ai/sdk`
+ * — neither is a dependency of this package, so the offline CI path never needs
+ * them. Live runs use the latest Opus model (claude-opus-4-8) with a manual
+ * tool-use loop over the advertised MCP catalog. A synthetic `ask_user` tool
+ * lets the model signal that it needs clarification, which the harness records
+ * separately from success/failure.
+ *
+ * Live cross-model runs are tracked under honua-io/honua-server#1956.
+ */
+const ASK_USER_TOOL = {
+    name: "ask_user",
+    description: "Call this ONLY if the request is too ambiguous to proceed. Provide the clarifying question you would ask.",
+    input_schema: {
+        type: "object",
+        properties: { question: { type: "string" } },
+        required: ["question"],
+        additionalProperties: false,
+    },
+};
+const SYSTEM_PROMPT = "You are a GIS analyst working through the Honua MCP tools. Complete the user's task by calling the available tools. " +
+    "Ground every step in real tool results — do not invent service names, layers, or fields. " +
+    "If, and only if, the request is genuinely ambiguous and you cannot proceed, call ask_user. " +
+    "When finished, give a concise final answer that references what the tools returned.";
+const MAX_ITERATIONS = 8;
+const DEFAULT_MODEL = "claude-opus-4-8";
+export class AnthropicDriver {
+    vendor = "anthropic";
+    id;
+    apiKey;
+    constructor(options = {}) {
+        this.id = options.model ?? DEFAULT_MODEL;
+        this.apiKey = options.apiKey ?? process.env.ANTHROPIC_API_KEY;
+    }
+    isAvailable() {
+        return typeof this.apiKey === "string" && this.apiKey.length > 0;
+    }
+    async runWorkflow(scenario, ctx) {
+        const steps = [];
+        const transcript = {
+            scenarioId: scenario.id,
+            modelId: this.id,
+            steps,
+            finalAnswer: "",
+            clarificationRequested: false,
+            errorCount: 0,
+        };
+        let Anthropic;
+        try {
+            // Variable specifier → not statically resolved; keeps @anthropic-ai/sdk
+            // an optional, non-bundled dependency for live runs only.
+            const specifier = "@anthropic-ai/sdk";
+            const mod = (await import(specifier));
+            Anthropic = mod.default;
+        }
+        catch {
+            transcript.driverError = "@anthropic-ai/sdk is not installed (required for live Claude eval runs)";
+            return transcript;
+        }
+        if (!this.apiKey) {
+            transcript.driverError = "ANTHROPIC_API_KEY is not set";
+            return transcript;
+        }
+        const client = new Anthropic({ apiKey: this.apiKey });
+        const tools = [
+            ...ctx.tools.map((t) => ({ name: t.name, description: t.description, input_schema: t.inputSchema })),
+            ASK_USER_TOOL,
+        ];
+        const messages = [{ role: "user", content: scenario.prompt }];
+        try {
+            for (let i = 0; i < MAX_ITERATIONS; i++) {
+                const response = await client.messages.create({
+                    model: this.id,
+                    max_tokens: 4096,
+                    system: SYSTEM_PROMPT,
+                    tools,
+                    messages,
+                });
+                const toolUses = response.content.filter((b) => b.type === "tool_use");
+                const text = response.content
+                    .filter((b) => b.type === "text")
+                    .map((b) => b.text)
+                    .join("\n");
+                if (response.stop_reason !== "tool_use" || toolUses.length === 0) {
+                    transcript.finalAnswer = text;
+                    return transcript;
+                }
+                messages.push({ role: "assistant", content: response.content });
+                const toolResults = [];
+                for (const use of toolUses) {
+                    if (use.name === ASK_USER_TOOL.name) {
+                        transcript.clarificationRequested = true;
+                        transcript.finalAnswer = text;
+                        return transcript;
+                    }
+                    const result = await ctx.callTool(use.name, (use.input ?? {}));
+                    steps.push({ tool: use.name, args: (use.input ?? {}), isError: result.isError });
+                    if (result.isError) {
+                        transcript.errorCount++;
+                    }
+                    toolResults.push({
+                        type: "tool_result",
+                        tool_use_id: use.id,
+                        content: result.text,
+                        is_error: result.isError,
+                    });
+                }
+                messages.push({ role: "user", content: toolResults });
+            }
+            transcript.driverError = `exceeded ${MAX_ITERATIONS} tool-use iterations without finishing`;
+            return transcript;
+        }
+        catch (err) {
+            transcript.driverError = err instanceof Error ? err.message : String(err);
+            return transcript;
+        }
+    }
+}

package/dist/src/eval/drivers/bedrock.d.ts

@@ -0,0 +1,54 @@
+import type { ModelDriver, Scenario, ToolDescriptor, WorkflowContext, WorkflowTranscript } from "../types.js";
+export interface BedrockDriverOptions {
+    /** Bedrock model id or inference-profile id. Defaults to Sonnet 4.5. */
+    model?: string | undefined;
+    /** AWS region. Defaults to AWS_REGION, then us-west-2. */
+    region?: string | undefined;
+    /** Opt-in flag value (defaults to process.env.HONUA_EVAL_BEDROCK). */
+    enabled?: string | undefined;
+}
+export declare class BedrockDriver implements ModelDriver {
+    readonly vendor: "bedrock";
+    readonly id: string;
+    readonly region: string;
+    private readonly enabled;
+    constructor(options?: BedrockDriverOptions);
+    isAvailable(): boolean;
+    runWorkflow(scenario: Scenario, ctx: WorkflowContext): Promise<WorkflowTranscript>;
+}
+/** Map MCP tool descriptors to Bedrock Converse `toolSpec` entries. */
+export declare function toBedrockTools(tools: ToolDescriptor[]): BedrockTool[];
+/** Pull tool-use blocks out of a Converse content array. */
+export declare function extractToolUses(content: BedrockContentBlock[]): BedrockToolUse[];
+/** Concatenate text blocks of a Converse content array. */
+export declare function extractText(content: BedrockContentBlock[]): string;
+/** Build a Converse `toolResult` content block to feed back to the model. */
+export declare function toToolResultBlock(toolUseId: string, text: string, isError: boolean): BedrockContentBlock;
+interface BedrockToolUse {
+    toolUseId: string;
+    name: string;
+    input?: unknown;
+}
+interface BedrockToolResult {
+    toolUseId: string;
+    content: {
+        text: string;
+    }[];
+    status: "error" | "success";
+}
+interface BedrockContentBlock {
+    text?: string;
+    toolUse?: BedrockToolUse;
+    toolResult?: BedrockToolResult;
+}
+interface BedrockTool {
+    toolSpec: {
+        name: string;
+        description: string;
+        inputSchema: {
+            json: Record<string, unknown>;
+        };
+    };
+}
+export {};
+//# sourceMappingURL=bedrock.d.ts.map

package/dist/src/eval/drivers/bedrock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bedrock.d.ts","sourceRoot":"","sources":["../../../../src/eval/drivers/bedrock.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,WAAW,EACX,QAAQ,EACR,cAAc,EAEd,eAAe,EACf,kBAAkB,EACnB,MAAM,aAAa,CAAC;AAgErB,MAAM,WAAW,oBAAoB;IACnC,wEAAwE;IACxE,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC3B,0DAA0D;IAC1D,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC5B,sEAAsE;IACtE,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CAC9B;AAED,qBAAa,aAAc,YAAW,WAAW;IAC/C,QAAQ,CAAC,MAAM,EAAG,SAAS,CAAU;IACrC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAU;gBAEtB,OAAO,GAAE,oBAAyB;IAO9C,WAAW,IAAI,OAAO;IAIhB,WAAW,CAAC,QAAQ,EAAE,QAAQ,EAAE,GAAG,EAAE,eAAe,GAAG,OAAO,CAAC,kBAAkB,CAAC;CAyEzF;AAUD,uEAAuE;AACvE,wBAAgB,cAAc,CAAC,KAAK,EAAE,cAAc,EAAE,GAAG,WAAW,EAAE,CAQrE;AAED,4DAA4D;AAC5D,wBAAgB,eAAe,CAAC,OAAO,EAAE,mBAAmB,EAAE,GAAG,cAAc,EAAE,CAIhF;AAED,2DAA2D;AAC3D,wBAAgB,WAAW,CAAC,OAAO,EAAE,mBAAmB,EAAE,GAAG,MAAM,CAKlE;AAED,6EAA6E;AAC7E,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,GAAG,mBAAmB,CAQxG;AAID,UAAU,cAAc;IACtB,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AACD,UAAU,iBAAiB;IACzB,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;IAC5B,MAAM,EAAE,OAAO,GAAG,SAAS,CAAC;CAC7B;AACD,UAAU,mBAAmB;IAC3B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,cAAc,CAAC;IACzB,UAAU,CAAC,EAAE,iBAAiB,CAAC;CAChC;AAKD,UAAU,WAAW;IACnB,QAAQ,EAAE;QACR,IAAI,EAAE,MAAM,CAAC;QACb,WAAW,EAAE,MAAM,CAAC;QACpB,WAAW,EAAE;YAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;SAAE,CAAC;KAChD,CAAC;CACH"}