@honua/mcp-server 0.1.4-beta.0 → 0.1.9-beta.0

package/dist/src/tools/admin-install-local.d.ts

@@ -0,0 +1,30 @@
+import { type LocalInstallRuntime } from "@honua/sdk-js/local-install";
+import { z } from "zod";
+export declare const schema: z.ZodObject<{
+    directory: z.ZodString;
+    profile: z.ZodDefault<z.ZodEnum<["quickstart", "gp-dev"]>>;
+    httpPort: z.ZodDefault<z.ZodNumber>;
+    timeoutMs: z.ZodDefault<z.ZodNumber>;
+    confirm: z.ZodLiteral<true>;
+}, "strip", z.ZodTypeAny, {
+    directory: string;
+    profile: "quickstart" | "gp-dev";
+    httpPort: number;
+    timeoutMs: number;
+    confirm: true;
+}, {
+    directory: string;
+    confirm: true;
+    profile?: "quickstart" | "gp-dev" | undefined;
+    httpPort?: number | undefined;
+    timeoutMs?: number | undefined;
+}>;
+export type AdminInstallLocalInput = z.infer<typeof schema>;
+export declare function execute(input: AdminInstallLocalInput, runtime?: LocalInstallRuntime): Promise<{
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    structuredContent: Record<string, unknown>;
+}>;
+//# sourceMappingURL=admin-install-local.d.ts.map

package/dist/src/tools/admin-install-local.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"admin-install-local.d.ts","sourceRoot":"","sources":["../../../src/tools/admin-install-local.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,mBAAmB,EAAqB,MAAM,6BAA6B,CAAC;AAC1F,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;EAMjB,CAAC;AAEH,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,MAAM,CAAC,CAAC;AAE5D,wBAAsB,OAAO,CAAC,KAAK,EAAE,sBAAsB,EAAE,OAAO,GAAE,mBAAwB;;;;;;GAe7F"}

package/dist/src/tools/admin-install-local.js

@@ -0,0 +1,22 @@
+import { installHonuaLocal } from "@honua/sdk-js/local-install";
+import { z } from "zod";
+export const schema = z.object({
+    directory: z.string().min(1).describe("Directory that will own compose.yaml, .env, and MCP configuration."),
+    profile: z.enum(["quickstart", "gp-dev"]).default("quickstart"),
+    httpPort: z.number().int().min(1).max(65535).default(8080),
+    timeoutMs: z.number().int().min(1_000).max(600_000).default(180_000),
+    confirm: z.literal(true).describe("Explicit approval to create files and start Docker containers."),
+});
+export async function execute(input, runtime = {}) {
+    const result = await installHonuaLocal({
+        directory: input.directory,
+        profile: input.profile,
+        httpPort: input.httpPort,
+        timeoutMs: input.timeoutMs,
+    }, runtime);
+    const structuredContent = { ...result };
+    return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        structuredContent,
+    };
+}

package/dist/src/tools/control-plane-command.d.ts

@@ -0,0 +1,99 @@
+/**
+ * The MCP transport adapter for the shared control-plane command layer.
+ *
+ * Every tool registered here is *generated* from `HONUA_COMMANDS` in
+ * `@honua/sdk-js/control-plane`: the name, title, description, and argument
+ * schema are projections of the command's own declaration, and the handler
+ * does exactly three things — build a `HonuaCommandInvocation`, call
+ * `HonuaCommandRuntime.execute`, and render the returned receipt. There is no
+ * MCP-side sequencing, no MCP-side validation beyond the projected schema, and
+ * no MCP-side authorization: an equivalent `honua map publish` invocation, an
+ * equivalent Studio invocation, and a direct `runtime.execute(...)` call all
+ * produce the same receipt and the same `auditKey`, differing only in the
+ * recorded `transport`.
+ *
+ * ## Why the projected object is `passthrough`
+ *
+ * A Zod object strips unknown keys by default. Stripping here would mean an
+ * agent that sent `approvedBy` got a *silent success* instead of the shared
+ * typed refusal, and MCP would then be the one transport where a sealed input
+ * schema is enforced by omission rather than by the command. So the projection
+ * lets unknown keys through to the runtime, where the command's closed schema
+ * (`additionalProperties: false`) rejects them with the same `validation`
+ * `HonuaCommandError` every other transport gets.
+ *
+ * ## What an agent may not assert
+ *
+ * The tool arguments carry no identity fields and no request headers. Acting
+ * identity and tenant come from the host that constructed the runtime — a
+ * model-supplied `actor` would be an authority claim dressed as an argument.
+ * `Idempotency-Key` and `If-Match` are likewise not header inputs: `ifMatch`
+ * and `idempotencyKey` travel as invocation fields so the value on the wire is
+ * the value the receipt records.
+ *
+ * @module
+ */
+import { type HonuaAnyCommand, type HonuaCommandIdentity, type HonuaCommandRuntime } from "@honua/sdk-js/control-plane";
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import { z } from "zod";
+/** Prefix every generated command tool carries. */
+export declare const CONTROL_PLANE_COMMAND_TOOL_PREFIX = "honua_command_";
+/**
+ * Host wiring for the command tools.
+ *
+ * The host owns the credential (through the runtime's client) and the acting
+ * identity echo. Neither is reachable from tool arguments.
+ */
+export interface ControlPlaneCommandMcpHost {
+    /** Runtime built from the caller's own `HonuaClient`; never a shared admin key. */
+    readonly runtime: HonuaCommandRuntime;
+    /** Acting identity echoed onto every receipt. Host-supplied, never model-supplied. */
+    readonly identity?: HonuaCommandIdentity;
+}
+/** `map-package.publish` → `honua_command_map_package_publish`. */
+export declare function controlPlaneCommandToolName(commandId: string): string;
+/**
+ * Project a command's JSON-schema input into the tool's argument schema.
+ *
+ * `input` is the command's own declared shape; the three siblings are the
+ * invocation fields a caller is allowed to set. The outer object is `strict`
+ * so an unknown *invocation* field is an MCP-level mistake, while the inner
+ * object is `passthrough` so an unknown *input* field reaches the command's
+ * sealed schema and is refused there.
+ */
+export declare function controlPlaneCommandToolSchema(command: HonuaAnyCommand): z.ZodObject<{
+    input: z.ZodTypeAny;
+    dryRun: z.ZodOptional<z.ZodBoolean>;
+    idempotencyKey: z.ZodOptional<z.ZodString>;
+    ifMatch: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    input?: any;
+    dryRun?: boolean | undefined;
+    idempotencyKey?: string | undefined;
+    ifMatch?: string | undefined;
+}, {
+    input?: any;
+    dryRun?: boolean | undefined;
+    idempotencyKey?: string | undefined;
+    ifMatch?: string | undefined;
+}>;
+type ControlPlaneCommandToolArgs = z.infer<ReturnType<typeof controlPlaneCommandToolSchema>>;
+/**
+ * Run one command for the MCP transport and render its receipt.
+ *
+ * A {@link HonuaCommandError} is returned as a tool error carrying the shared
+ * serialized taxonomy, not rethrown as an opaque MCP failure: an agent has to
+ * be able to tell a `validation` refusal from a `conflict` it should retry.
+ */
+export declare function execute(host: ControlPlaneCommandMcpHost, command: HonuaAnyCommand, args: ControlPlaneCommandToolArgs): Promise<CallToolResult>;
+/**
+ * Register one MCP tool per catalog command.
+ *
+ * Opt-in, exactly like the NL map-control tools: the platform-free standalone
+ * catalog stays read-only and Honua-server-free unless a host supplies a
+ * control-plane runtime.
+ */
+export declare function registerControlPlaneCommandTools(server: McpServer, host: ControlPlaneCommandMcpHost): void;
+export {};
+//# sourceMappingURL=control-plane-command.d.ts.map

package/dist/src/tools/control-plane-command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"control-plane-command.d.ts","sourceRoot":"","sources":["../../../src/tools/control-plane-command.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AAEH,OAAO,EAEL,KAAK,eAAe,EAEpB,KAAK,oBAAoB,EAGzB,KAAK,mBAAmB,EACzB,MAAM,6BAA6B,CAAC;AACrC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AACzE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oCAAoC,CAAC;AACzE,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,mDAAmD;AACnD,eAAO,MAAM,iCAAiC,mBAAmB,CAAC;AAElE;;;;;GAKG;AACH,MAAM,WAAW,0BAA0B;IACzC,mFAAmF;IACnF,QAAQ,CAAC,OAAO,EAAE,mBAAmB,CAAC;IACtC,sFAAsF;IACtF,QAAQ,CAAC,QAAQ,CAAC,EAAE,oBAAoB,CAAC;CAC1C;AAED,mEAAmE;AACnE,wBAAgB,2BAA2B,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAErE;AAED;;;;;;;;GAQG;AACH,wBAAgB,6BAA6B,CAAC,OAAO,EAAE,eAAe;;;;;;;;;;;;;;;GAgBrE;AAED,KAAK,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAAC,UAAU,CAAC,OAAO,6BAA6B,CAAC,CAAC,CAAC;AAE7F;;;;;;GAMG;AACH,wBAAsB,OAAO,CAC3B,IAAI,EAAE,0BAA0B,EAChC,OAAO,EAAE,eAAe,EACxB,IAAI,EAAE,2BAA2B,GAChC,OAAO,CAAC,cAAc,CAAC,CAsBzB;AAED;;;;;;GAMG;AACH,wBAAgB,gCAAgC,CAAC,MAAM,EAAE,SAAS,EAAE,IAAI,EAAE,0BAA0B,GAAG,IAAI,CAkB1G"}

package/dist/src/tools/control-plane-command.js

@@ -0,0 +1,180 @@
+/**
+ * The MCP transport adapter for the shared control-plane command layer.
+ *
+ * Every tool registered here is *generated* from `HONUA_COMMANDS` in
+ * `@honua/sdk-js/control-plane`: the name, title, description, and argument
+ * schema are projections of the command's own declaration, and the handler
+ * does exactly three things — build a `HonuaCommandInvocation`, call
+ * `HonuaCommandRuntime.execute`, and render the returned receipt. There is no
+ * MCP-side sequencing, no MCP-side validation beyond the projected schema, and
+ * no MCP-side authorization: an equivalent `honua map publish` invocation, an
+ * equivalent Studio invocation, and a direct `runtime.execute(...)` call all
+ * produce the same receipt and the same `auditKey`, differing only in the
+ * recorded `transport`.
+ *
+ * ## Why the projected object is `passthrough`
+ *
+ * A Zod object strips unknown keys by default. Stripping here would mean an
+ * agent that sent `approvedBy` got a *silent success* instead of the shared
+ * typed refusal, and MCP would then be the one transport where a sealed input
+ * schema is enforced by omission rather than by the command. So the projection
+ * lets unknown keys through to the runtime, where the command's closed schema
+ * (`additionalProperties: false`) rejects them with the same `validation`
+ * `HonuaCommandError` every other transport gets.
+ *
+ * ## What an agent may not assert
+ *
+ * The tool arguments carry no identity fields and no request headers. Acting
+ * identity and tenant come from the host that constructed the runtime — a
+ * model-supplied `actor` would be an authority claim dressed as an argument.
+ * `Idempotency-Key` and `If-Match` are likewise not header inputs: `ifMatch`
+ * and `idempotencyKey` travel as invocation fields so the value on the wire is
+ * the value the receipt records.
+ *
+ * @module
+ */
+import { HONUA_COMMANDS, HonuaCommandError, } from "@honua/sdk-js/control-plane";
+import { z } from "zod";
+/** Prefix every generated command tool carries. */
+export const CONTROL_PLANE_COMMAND_TOOL_PREFIX = "honua_command_";
+/** `map-package.publish` → `honua_command_map_package_publish`. */
+export function controlPlaneCommandToolName(commandId) {
+    return `${CONTROL_PLANE_COMMAND_TOOL_PREFIX}${commandId.replace(/[.-]/g, "_")}`;
+}
+/**
+ * Project a command's JSON-schema input into the tool's argument schema.
+ *
+ * `input` is the command's own declared shape; the three siblings are the
+ * invocation fields a caller is allowed to set. The outer object is `strict`
+ * so an unknown *invocation* field is an MCP-level mistake, while the inner
+ * object is `passthrough` so an unknown *input* field reaches the command's
+ * sealed schema and is refused there.
+ */
+export function controlPlaneCommandToolSchema(command) {
+    return z
+        .object({
+        input: zodForSchema(command.inputSchema),
+        dryRun: z
+            .boolean()
+            .optional()
+            .describe("Preview the plan without contacting the server. The command never reaches `execute`."),
+        idempotencyKey: z
+            .string()
+            .min(1)
+            .optional()
+            .describe("Explicit Idempotency-Key. Derived deterministically from the input when omitted."),
+        ifMatch: z.string().min(1).optional().describe("Optimistic-concurrency validator, sent as If-Match."),
+    })
+        .strict();
+}
+/**
+ * Run one command for the MCP transport and render its receipt.
+ *
+ * A {@link HonuaCommandError} is returned as a tool error carrying the shared
+ * serialized taxonomy, not rethrown as an opaque MCP failure: an agent has to
+ * be able to tell a `validation` refusal from a `conflict` it should retry.
+ */
+export async function execute(host, command, args) {
+    const invocation = {
+        transport: "mcp",
+        ...(host.identity ? { identity: host.identity } : {}),
+        ...(args.idempotencyKey ? { idempotencyKey: args.idempotencyKey } : {}),
+        ...(args.ifMatch ? { ifMatch: args.ifMatch } : {}),
+        ...(args.dryRun ? { dryRun: true } : {}),
+    };
+    try {
+        const receipt = await host.runtime.execute(command, args.input, invocation);
+        return { content: [{ type: "text", text: JSON.stringify(receipt, null, 2) }] };
+    }
+    catch (error) {
+        if (error instanceof HonuaCommandError) {
+            return {
+                isError: true,
+                content: [
+                    { type: "text", text: JSON.stringify({ ...error.toJSON(), message: error.message }, null, 2) },
+                ],
+            };
+        }
+        throw error;
+    }
+}
+/**
+ * Register one MCP tool per catalog command.
+ *
+ * Opt-in, exactly like the NL map-control tools: the platform-free standalone
+ * catalog stays read-only and Honua-server-free unless a host supplies a
+ * control-plane runtime.
+ */
+export function registerControlPlaneCommandTools(server, host) {
+    for (const command of Object.values(HONUA_COMMANDS)) {
+        server.registerTool(controlPlaneCommandToolName(command.id), {
+            title: command.title,
+            description: `${command.description} Runs the shared \`${command.id}\` control-plane command and returns its deterministic receipt; the receipt's auditKey matches the equivalent CLI, Studio, or direct-JS invocation.`,
+            inputSchema: controlPlaneCommandToolSchema(command),
+            annotations: {
+                readOnlyHint: command.mode === "read",
+                destructiveHint: false,
+                idempotentHint: true,
+                openWorldHint: true,
+            },
+        }, async (args) => execute(host, command, args));
+    }
+}
+// ---------------------------------------------------------------------------
+// JSON Schema → Zod projection
+// ---------------------------------------------------------------------------
+function zodForSchema(schema) {
+    const type = Array.isArray(schema.type) ? schema.type[0] : schema.type;
+    let base;
+    switch (type) {
+        case "string": {
+            let value = z.string();
+            if (schema.minLength !== undefined)
+                value = value.min(schema.minLength);
+            if (schema.maxLength !== undefined)
+                value = value.max(schema.maxLength);
+            base = value;
+            break;
+        }
+        case "integer":
+        case "number": {
+            let value = z.number();
+            if (type === "integer")
+                value = value.int();
+            if (schema.minimum !== undefined)
+                value = value.min(schema.minimum);
+            if (schema.maximum !== undefined)
+                value = value.max(schema.maximum);
+            base = value;
+            break;
+        }
+        case "boolean":
+            base = z.boolean();
+            break;
+        case "array":
+            base = z.array(schema.items ? zodForSchema(schema.items) : z.unknown());
+            break;
+        case "object":
+            base = zodForObject(schema);
+            break;
+        default:
+            base = z.unknown();
+            break;
+    }
+    return schema.description ? base.describe(schema.description) : base;
+}
+function zodForObject(schema) {
+    const properties = schema.properties;
+    // An object with no declared properties (`options` on `import.create`) is a
+    // free-form bag the command passes through verbatim.
+    if (!properties)
+        return z.record(z.unknown());
+    const required = new Set(schema.required ?? []);
+    const shape = {};
+    for (const [name, property] of Object.entries(properties)) {
+        const value = zodForSchema(property);
+        shape[name] = required.has(name) ? value : value.optional();
+    }
+    // Passthrough is deliberate — see this module's header.
+    return z.object(shape).passthrough();
+}

package/dist/src/tools/docs-search.d.ts

@@ -0,0 +1,100 @@
+import { z } from "zod";
+export declare const schema: z.ZodObject<{
+    query: z.ZodString;
+    limit: z.ZodOptional<z.ZodNumber>;
+    pathPrefix: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    query: string;
+    limit?: number | undefined;
+    pathPrefix?: string | undefined;
+}, {
+    query: string;
+    limit?: number | undefined;
+    pathPrefix?: string | undefined;
+}>;
+export type Input = z.infer<typeof schema>;
+/** One document sliced out of the concatenated corpus. */
+export interface CorpusDocument {
+    file: string;
+    title: string;
+    body: string;
+}
+export interface DocsVersionCitation {
+    package: string;
+    version: string;
+    channel: string;
+    /** Whether the corpus text is trunk development documentation or a release snapshot. */
+    documentationChannel: "development";
+    policy: string;
+    versionsManifest: string;
+}
+/**
+ * Split `llms-full.txt` into its constituent documents. The generator emits
+ * `# File: <path>` as the delimiter for each concatenated document.
+ */
+export declare function splitCorpus(corpus: string): CorpusDocument[];
+/**
+ * The terms a query is actually ranked and excerpted on: distinct tokens with
+ * the stopwords removed. A query made entirely of stopwords ("how do I") keeps
+ * its raw tokens rather than degrading to "no indexed document matched", so
+ * filtering can only ever improve a ranking, never empty one.
+ */
+export declare function queryTermsOf(query: string): string[];
+/** Deterministic lexical score: path and heading matches outweigh body matches. */
+export declare function scoreDocument(document: CorpusDocument, queryTerms: readonly string[]): number;
+/** The most relevant window of a document, trimmed to a token-friendly size. */
+export declare function excerptFor(document: CorpusDocument, queryTerms: readonly string[]): string;
+/** Where the corpus is, and the documentation root its citations resolve against. */
+export interface DocsCorpusLocation {
+    /** The file that is actually read — the configured override when there is one. */
+    corpusPath: string;
+    /** The directory `docs/versions.json`, `package.json`, and the manifest are read from. */
+    root: string;
+}
+/**
+ * Locate the corpus: an explicit `HONUA_DOCS_CORPUS_PATH` (the corpus file
+ * itself, or a directory holding one), otherwise the nearest ancestor directory
+ * holding `llms-full.txt`.
+ *
+ * The override names the file to read, so it is read — its basename is not
+ * assumed to be `llms-full.txt`. Discarding it and reading `<parent>/llms-full.txt`
+ * instead would throw `ENOENT` for a corpus under any other name, or silently
+ * answer from a different sibling file.
+ */
+export declare function resolveDocsCorpus(env?: NodeJS.ProcessEnv, from?: string): DocsCorpusLocation | undefined;
+/** The documentation root holding the corpus, or `undefined` when there is none. */
+export declare function resolveDocsRoot(env?: NodeJS.ProcessEnv, from?: string): string | undefined;
+/**
+ * The release the corpus documents, from the same authoritative sources as
+ * `scripts/docs-versions.mjs`. Prefers the generated `docs/versions.json` and
+ * falls back to `package.json` + `.release-please-manifest.json`.
+ */
+export declare function resolveDocsVersion(root: string): DocsVersionCitation | undefined;
+/**
+ * The exact commit the searched corpus bytes come from, or `undefined` when it
+ * cannot be established.
+ *
+ * `docs/documentation-versions.md` is explicit that a matching version string
+ * is not proof that development documentation describes the npm artifact, and
+ * that every built page identifies its 40-character source commit. A citation
+ * pinned to `trunk` breaks that: `trunk` moves, and the text a reader is sent
+ * to can stop being the text that was searched. So citations are pinned to the
+ * commit instead, using the same `HONUA_SOURCE_REVISION` override
+ * `scripts/build-docs-site.mjs` honours.
+ *
+ * The commit is only used when the corpus at `HEAD` is byte-identical to the
+ * corpus that was read (`git hash-object` against `HEAD:<path>`). A locally
+ * regenerated or edited `llms-full.txt` is not at any commit, and pinning it to
+ * `HEAD` would produce a citation that looks exact and is wrong. When nothing
+ * can be established — an installed package with no checkout, no `git`, a dirty
+ * corpus — the URL stays on `trunk` and the citation reports
+ * `sourceRevision: null` so the consumer can see the link is floating.
+ */
+export declare function resolveCorpusRevision(root: string, corpusPath: string, env?: NodeJS.ProcessEnv): string | undefined;
+export declare function execute(_client: unknown, input: Input): Promise<{
+    content: Array<{
+        type: "text";
+        text: string;
+    }>;
+}>;
+//# sourceMappingURL=docs-search.d.ts.map

package/dist/src/tools/docs-search.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"docs-search.d.ts","sourceRoot":"","sources":["../../../src/tools/docs-search.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAmHxB,eAAO,MAAM,MAAM;;;;;;;;;;;;EAUjB,CAAC;AAEH,MAAM,MAAM,KAAK,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,MAAM,CAAC,CAAC;AAE3C,0DAA0D;AAC1D,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,mBAAmB;IAClC,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,wFAAwF;IACxF,oBAAoB,EAAE,aAAa,CAAC;IACpC,MAAM,EAAE,MAAM,CAAC;IACf,gBAAgB,EAAE,MAAM,CAAC;CAC1B;AAED;;;GAGG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,cAAc,EAAE,CAe5D;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,CAIpD;AAYD,mFAAmF;AACnF,wBAAgB,aAAa,CAAC,QAAQ,EAAE,cAAc,EAAE,UAAU,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAgB7F;AAED,gFAAgF;AAChF,wBAAgB,UAAU,CAAC,QAAQ,EAAE,cAAc,EAAE,UAAU,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAgB1F;AAED,qFAAqF;AACrF,MAAM,WAAW,kBAAkB;IACjC,kFAAkF;IAClF,UAAU,EAAE,MAAM,CAAC;IACnB,0FAA0F;IAC1F,IAAI,EAAE,MAAM,CAAC;CACd;AAED;;;;;;;;;GASG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,GAAE,MAAM,CAAC,UAAwB,EAAE,IAAI,CAAC,EAAE,MAAM,GAAG,kBAAkB,GAAG,SAAS,CAkBrH;AAED,oFAAoF;AACpF,wBAAgB,eAAe,CAAC,GAAG,GAAE,MAAM,CAAC,UAAwB,EAAE,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAEvG;AAeD;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,mBAAmB,GAAG,SAAS,CAoBhF;AAcD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,MAAM,EACZ,UAAU,EAAE,MAAM,EAClB,GAAG,GAAE,MAAM,CAAC,UAAwB,GACnC,MAAM,GAAG,SAAS,CAepB;AAMD,wBAAsB,OAAO,CAAC,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,KAAK;;;;;GA4D3D"}