unreal-engine-mcp-server 0.5.21 → 0.6.0-a

package/dist/tools/catalog/capabilities/catalog-schema.d.ts

@@ -0,0 +1,243 @@
+import { z } from 'zod';
+export declare const CapabilityCatalogSchema: z.ZodArray<z.ZodObject<{
+    behavior: z.ZodObject<{
+        semantics: z.ZodObject<{
+            preview: z.ZodObject<{
+                mode: z.ZodEnum<{
+                    simulate: "simulate";
+                    none: "none";
+                    "validate-only": "validate-only";
+                }>;
+                reports: z.ZodArray<z.ZodEnum<{
+                    "affected-objects": "affected-objects";
+                    "affected-packages": "affected-packages";
+                    risk: "risk";
+                    "estimated-cost": "estimated-cost";
+                    "validation-plan": "validation-plan";
+                }>>;
+                evidence: z.ZodObject<{
+                    grade: z.ZodEnum<{
+                        "pessimistic-default": "pessimistic-default";
+                        "source-verified": "source-verified";
+                        "contract-derived": "contract-derived";
+                    }>;
+                    citation: z.ZodString;
+                }, z.core.$strict>;
+            }, z.core.$strict>;
+            undo: z.ZodObject<{
+                mode: z.ZodEnum<{
+                    none: "none";
+                    transaction: "transaction";
+                }>;
+                transactionScope: z.ZodNullable<z.ZodString>;
+                evidence: z.ZodObject<{
+                    grade: z.ZodEnum<{
+                        "pessimistic-default": "pessimistic-default";
+                        "source-verified": "source-verified";
+                        "contract-derived": "contract-derived";
+                    }>;
+                    citation: z.ZodString;
+                }, z.core.$strict>;
+            }, z.core.$strict>;
+            compensation: z.ZodObject<{
+                mode: z.ZodEnum<{
+                    none: "none";
+                    "inverse-capability": "inverse-capability";
+                    "manual-cleanup": "manual-cleanup";
+                }>;
+                inverse: z.ZodArray<z.core.$ZodBranded<z.ZodString, "CapabilityId", "out">>;
+                guidance: z.ZodNullable<z.ZodString>;
+                evidence: z.ZodObject<{
+                    grade: z.ZodEnum<{
+                        "pessimistic-default": "pessimistic-default";
+                        "source-verified": "source-verified";
+                        "contract-derived": "contract-derived";
+                    }>;
+                    citation: z.ZodString;
+                }, z.core.$strict>;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+        effect: z.ZodEnum<{
+            read: "read";
+            write: "write";
+            destructive: "destructive";
+        }>;
+        idempotency: z.ZodEnum<{
+            "non-idempotent": "non-idempotent";
+            idempotent: "idempotent";
+            "idempotency-key": "idempotency-key";
+        }>;
+        longRunning: z.ZodBoolean;
+        safeToRetry: z.ZodBoolean;
+        supportsPreview: z.ZodBoolean;
+        supportsUndo: z.ZodBoolean;
+    }, z.core.$strict>;
+    hashes: z.ZodObject<{
+        algorithm: z.ZodLiteral<"sha256">;
+        schema: z.ZodString;
+        content: z.ZodString;
+    }, z.core.$strict>;
+    id: z.core.$ZodBranded<z.ZodString, "CapabilityId", "out">;
+    aliases: z.ZodArray<z.core.$ZodBranded<z.ZodString, "CapabilityAlias", "out">>;
+    legacyIds: z.ZodArray<z.ZodObject<{
+        tool: z.core.$ZodBranded<z.ZodString, "LegacyToolName", "out">;
+        action: z.core.$ZodBranded<z.ZodString, "LegacyActionName", "out">;
+        provenance: z.ZodOptional<z.ZodEnum<{
+            "legacy-surface": "legacy-surface";
+            "post-migration": "post-migration";
+        }>>;
+        folded: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<import("./model.js").JsonValue, unknown, z.core.$ZodTypeInternals<import("./model.js").JsonValue, unknown>>>>;
+    }, z.core.$strict>>;
+    discovery: z.ZodObject<{
+        domain: z.ZodString;
+        family: z.ZodString;
+        topics: z.ZodArray<z.ZodString>;
+        summary: z.ZodString;
+        whenToUse: z.ZodArray<z.ZodString>;
+        whenNotToUse: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>;
+    schemas: z.ZodObject<{
+        input: z.ZodObject<{
+            $schema: z.ZodLiteral<"https://json-schema.org/draft/2020-12/schema">;
+            type: z.ZodLiteral<"object">;
+            properties: z.ZodRecord<z.ZodString, z.ZodType<import("./model.js").JsonValue, unknown, z.core.$ZodTypeInternals<import("./model.js").JsonValue, unknown>>>;
+            required: z.ZodArray<z.ZodString>;
+            additionalProperties: z.ZodUnion<readonly [z.ZodBoolean, z.ZodRecord<z.ZodString, z.ZodType<import("./model.js").JsonValue, unknown, z.core.$ZodTypeInternals<import("./model.js").JsonValue, unknown>>>]>;
+            requiredOneOf: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>;
+        output: z.ZodObject<{
+            $schema: z.ZodLiteral<"https://json-schema.org/draft/2020-12/schema">;
+            type: z.ZodLiteral<"object">;
+            properties: z.ZodRecord<z.ZodString, z.ZodType<import("./model.js").JsonValue, unknown, z.core.$ZodTypeInternals<import("./model.js").JsonValue, unknown>>>;
+            required: z.ZodArray<z.ZodString>;
+            additionalProperties: z.ZodUnion<readonly [z.ZodBoolean, z.ZodRecord<z.ZodString, z.ZodType<import("./model.js").JsonValue, unknown, z.core.$ZodTypeInternals<import("./model.js").JsonValue, unknown>>>]>;
+            requiredOneOf: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    examples: z.ZodArray<z.ZodObject<{
+        title: z.ZodString;
+        input: z.ZodRecord<z.ZodString, z.ZodType<import("./model.js").JsonValue, unknown, z.core.$ZodTypeInternals<import("./model.js").JsonValue, unknown>>>;
+        output: z.ZodRecord<z.ZodString, z.ZodType<import("./model.js").JsonValue, unknown, z.core.$ZodTypeInternals<import("./model.js").JsonValue, unknown>>>;
+    }, z.core.$strict>>;
+    availability: z.ZodObject<{
+        unreal: z.ZodObject<{
+            min: z.ZodReadonly<z.ZodObject<{
+                major: z.ZodLiteral<5>;
+                minor: z.ZodNumber;
+                patch: z.ZodNumber;
+                channel: z.ZodEnum<{
+                    stable: "stable";
+                    preview: "preview";
+                }>;
+                preview: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strict>>;
+            max: z.ZodReadonly<z.ZodObject<{
+                major: z.ZodLiteral<5>;
+                minor: z.ZodNumber;
+                patch: z.ZodNumber;
+                channel: z.ZodEnum<{
+                    stable: "stable";
+                    preview: "preview";
+                }>;
+                preview: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+        requiredPlugins: z.ZodArray<z.ZodString>;
+        editorStates: z.ZodArray<z.ZodEnum<{
+            edit: "edit";
+            pie: "pie";
+            simulate: "simulate";
+        }>>;
+    }, z.core.$strict>;
+    policy: z.ZodObject<{
+        requiredScope: z.ZodEnum<{
+            read: "read";
+            write: "write";
+            destructive: "destructive";
+            admin: "admin";
+        }>;
+        consent: z.ZodEnum<{
+            none: "none";
+            explicit: "explicit";
+            elevated: "elevated";
+        }>;
+        dataAccess: z.ZodEnum<{
+            none: "none";
+            "project-read": "project-read";
+            "project-write": "project-write";
+            "engine-read": "engine-read";
+        }>;
+    }, z.core.$strict>;
+    cost: z.ZodObject<{
+        latency: z.ZodEnum<{
+            instant: "instant";
+            interactive: "interactive";
+            "long-running": "long-running";
+        }>;
+        resources: z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+        }>;
+    }, z.core.$strict>;
+    routing: z.ZodObject<{
+        parentTool: z.core.$ZodBranded<z.ZodString, "LegacyToolName", "out">;
+        dispatchAction: z.core.$ZodBranded<z.ZodString, "LegacyActionName", "out">;
+        dispatchMode: z.ZodEnum<{
+            action: "action";
+            tool: "tool";
+            local: "local";
+        }>;
+        dispatchBy: z.ZodOptional<z.ZodObject<{
+            param: z.ZodString;
+            actions: z.ZodRecord<z.ZodString, z.core.$ZodBranded<z.ZodString, "LegacyActionName", "out">>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    normalization: z.ZodObject<{
+        class: z.ZodEnum<{
+            A_TRUE_DUPLICATE: "A_TRUE_DUPLICATE";
+            B_ALIAS: "B_ALIAS";
+            C_SAME_VERB_DIFFERENT_TARGET: "C_SAME_VERB_DIFFERENT_TARGET";
+            D_COMPOSITE: "D_COMPOSITE";
+            E_PRESET_WORKFLOW: "E_PRESET_WORKFLOW";
+            F_OBSOLETE_VERSION_SPECIFIC: "F_OBSOLETE_VERSION_SPECIFIC";
+        }>;
+        disposition: z.ZodEnum<{
+            canonical: "canonical";
+            merge: "merge";
+            alias: "alias";
+            retain: "retain";
+            decompose: "decompose";
+            preset: "preset";
+            remove: "remove";
+        }>;
+        rationale: z.ZodString;
+        aliasOf: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "CapabilityId", "out">>;
+        provenance: z.ZodOptional<z.ZodEnum<{
+            "legacy-surface": "legacy-surface";
+            "post-migration": "post-migration";
+        }>>;
+    }, z.core.$strict>;
+    deprecation: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        status: z.ZodLiteral<"active">;
+    }, z.core.$strict>, z.ZodObject<{
+        status: z.ZodEnum<{
+            deprecated: "deprecated";
+            removed: "removed";
+        }>;
+        since: z.ZodString;
+        guidance: z.ZodString;
+        replacement: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "CapabilityId", "out">>;
+    }, z.core.$strict>], "status">;
+    parent: z.ZodObject<{
+        parent: z.core.$ZodBranded<z.ZodString, "LegacyToolName", "out">;
+        description: z.ZodString;
+        category: z.ZodEnum<{
+            core: "core";
+            world: "world";
+            gameplay: "gameplay";
+            utility: "utility";
+        }>;
+    }, z.core.$strict>;
+}, z.core.$strict>>;
+//# sourceMappingURL=catalog-schema.d.ts.map

package/dist/tools/catalog/capabilities/catalog-schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"catalog-schema.d.ts","sourceRoot":"","sources":["../../../../src/tools/catalog/capabilities/catalog-schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAQxB,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBA0EhC,CAAC"}

package/dist/tools/catalog/capabilities/catalog-schema.js

@@ -0,0 +1,82 @@
+import { z } from 'zod';
+import { CapabilityRecordSchema } from './record-schema.js';
+function legacyKey(legacy) {
+    return `${legacy.tool}::${legacy.action}`;
+}
+export const CapabilityCatalogSchema = z
+    .array(CapabilityRecordSchema)
+    .superRefine((records, ctx) => {
+    const canonicalByIndex = new Map();
+    const aliasSeen = new Map();
+    const legacySeen = new Map();
+    for (const [index, record] of records.entries()) {
+        if (canonicalByIndex.has(record.id) && canonicalByIndex.get(record.id) !== index) {
+            ctx.addIssue({
+                code: 'custom',
+                path: [index, 'id'],
+                message: 'duplicate canonical capability id'
+            });
+        }
+        else {
+            canonicalByIndex.set(record.id, index);
+        }
+        if (aliasSeen.has(record.id)) {
+            ctx.addIssue({
+                code: 'custom',
+                path: [index, 'id'],
+                message: 'canonical id collides with an earlier capability alias'
+            });
+        }
+        const aliasLocal = new Set();
+        for (const [position, alias] of record.aliases.entries()) {
+            if (canonicalByIndex.has(alias)) {
+                ctx.addIssue({
+                    code: 'custom',
+                    path: [index, 'aliases', position],
+                    message: 'alias collides with a canonical capability id'
+                });
+            }
+            if (aliasSeen.has(alias) && aliasSeen.get(alias) !== index) {
+                ctx.addIssue({
+                    code: 'custom',
+                    path: [index, 'aliases', position],
+                    message: 'duplicate capability alias across records'
+                });
+            }
+            else if (aliasLocal.has(alias)) {
+                ctx.addIssue({
+                    code: 'custom',
+                    path: [index, 'aliases', position],
+                    message: 'duplicate capability alias within record'
+                });
+            }
+            else {
+                aliasLocal.add(alias);
+                aliasSeen.set(alias, index);
+            }
+        }
+        const legacyLocal = new Set();
+        for (const [position, legacy] of record.legacyIds.entries()) {
+            const key = legacyKey(legacy);
+            if (legacySeen.has(key) && legacySeen.get(key) !== index) {
+                ctx.addIssue({
+                    code: 'custom',
+                    path: [index, 'legacyIds', position],
+                    message: 'duplicate legacy capability id across records'
+                });
+            }
+            else if (legacyLocal.has(key)) {
+                ctx.addIssue({
+                    code: 'custom',
+                    path: [index, 'legacyIds', position],
+                    message: 'duplicate legacy capability id within record'
+                });
+            }
+            else {
+                legacyLocal.add(key);
+                legacySeen.set(key, index);
+            }
+        }
+    }
+});
+//# sourceMappingURL=catalog-schema.js.map

package/dist/tools/catalog/capabilities/catalog-schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"catalog-schema.js","sourceRoot":"","sources":["../../../../src/tools/catalog/capabilities/catalog-schema.ts"],"names":[],"mappings":"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"}

package/dist/tools/catalog/capabilities/constants.d.ts

@@ -0,0 +1,22 @@
+export declare const DRAFT_2020_12_SCHEMA_URI: "https://json-schema.org/draft/2020-12/schema";
+export declare const UNREAL_RELEASE_CHANNELS: readonly ["stable", "preview"];
+export declare const EDITOR_STATES: readonly ["edit", "pie", "simulate"];
+export declare const BEHAVIOR_EFFECTS: readonly ["read", "write", "destructive"];
+export declare const IDEMPOTENCY_CLASSES: readonly ["non-idempotent", "idempotent", "idempotency-key"];
+export declare const POLICY_SCOPES: readonly ["read", "write", "destructive", "admin"];
+export declare const CONSENT_MODES: readonly ["none", "explicit", "elevated"];
+export declare const DATA_ACCESS_CLASSES: readonly ["none", "project-read", "project-write", "engine-read"];
+export declare const LATENCY_CLASSES: readonly ["instant", "interactive", "long-running"];
+export declare const RESOURCE_CLASSES: readonly ["low", "medium", "high"];
+export declare const DISPATCH_MODES: readonly ["tool", "action", "local"];
+export declare const NORMALIZATION_CLASSES: readonly ["A_TRUE_DUPLICATE", "B_ALIAS", "C_SAME_VERB_DIFFERENT_TARGET", "D_COMPOSITE", "E_PRESET_WORKFLOW", "F_OBSOLETE_VERSION_SPECIFIC"];
+export declare const NORMALIZATION_DISPOSITIONS: readonly ["canonical", "merge", "alias", "retain", "decompose", "preset", "remove"];
+export declare const CAPABILITY_PROVENANCE: readonly ["legacy-surface", "post-migration"];
+export declare const DEPRECATION_STATUSES: readonly ["active", "deprecated", "removed"];
+export declare const HASH_ALGORITHM: "sha256";
+export declare const PREVIEW_MODES: readonly ["none", "validate-only", "simulate"];
+export declare const PREVIEW_REPORTS: readonly ["affected-objects", "affected-packages", "risk", "estimated-cost", "validation-plan"];
+export declare const UNDO_MODES: readonly ["none", "transaction"];
+export declare const COMPENSATION_MODES: readonly ["none", "inverse-capability", "manual-cleanup"];
+export declare const SEMANTICS_EVIDENCE_GRADES: readonly ["pessimistic-default", "source-verified", "contract-derived"];
+//# sourceMappingURL=constants.d.ts.map

package/dist/tools/catalog/capabilities/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../../src/tools/catalog/capabilities/constants.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,wBAAwB,EAAG,8CAAuD,CAAC;AAEhG,eAAO,MAAM,uBAAuB,gCAAiC,CAAC;AACtE,eAAO,MAAM,aAAa,sCAAuC,CAAC;AAClE,eAAO,MAAM,gBAAgB,2CAA4C,CAAC;AAC1E,eAAO,MAAM,mBAAmB,8DAA+D,CAAC;AAChG,eAAO,MAAM,aAAa,oDAAqD,CAAC;AAChF,eAAO,MAAM,aAAa,2CAA4C,CAAC;AACvE,eAAO,MAAM,mBAAmB,mEAAoE,CAAC;AACrG,eAAO,MAAM,eAAe,qDAAsD,CAAC;AACnF,eAAO,MAAM,gBAAgB,oCAAqC,CAAC;AACnE,eAAO,MAAM,cAAc,sCAAuC,CAAC;AACnE,eAAO,MAAM,qBAAqB,6IAOxB,CAAC;AACX,eAAO,MAAM,0BAA0B,qFAQ7B,CAAC;AAGX,eAAO,MAAM,qBAAqB,+CAAgD,CAAC;AACnF,eAAO,MAAM,oBAAoB,8CAA+C,CAAC;AACjF,eAAO,MAAM,cAAc,EAAG,QAAiB,CAAC;AAIhD,eAAO,MAAM,aAAa,gDAAiD,CAAC;AAC5E,eAAO,MAAM,eAAe,iGAMlB,CAAC;AAKX,eAAO,MAAM,UAAU,kCAAmC,CAAC;AAC3D,eAAO,MAAM,kBAAkB,2DAA4D,CAAC;AAC5F,eAAO,MAAM,yBAAyB,yEAI5B,CAAC"}

package/dist/tools/catalog/capabilities/constants.js

@@ -0,0 +1,47 @@
+export const DRAFT_2020_12_SCHEMA_URI = 'https://json-schema.org/draft/2020-12/schema';
+export const UNREAL_RELEASE_CHANNELS = ['stable', 'preview'];
+export const EDITOR_STATES = ['edit', 'pie', 'simulate'];
+export const BEHAVIOR_EFFECTS = ['read', 'write', 'destructive'];
+export const IDEMPOTENCY_CLASSES = ['non-idempotent', 'idempotent', 'idempotency-key'];
+export const POLICY_SCOPES = ['read', 'write', 'destructive', 'admin'];
+export const CONSENT_MODES = ['none', 'explicit', 'elevated'];
+export const DATA_ACCESS_CLASSES = ['none', 'project-read', 'project-write', 'engine-read'];
+export const LATENCY_CLASSES = ['instant', 'interactive', 'long-running'];
+export const RESOURCE_CLASSES = ['low', 'medium', 'high'];
+export const DISPATCH_MODES = ['tool', 'action', 'local'];
+export const NORMALIZATION_CLASSES = [
+    'A_TRUE_DUPLICATE',
+    'B_ALIAS',
+    'C_SAME_VERB_DIFFERENT_TARGET',
+    'D_COMPOSITE',
+    'E_PRESET_WORKFLOW',
+    'F_OBSOLETE_VERSION_SPECIFIC'
+];
+export const NORMALIZATION_DISPOSITIONS = [
+    'canonical',
+    'merge',
+    'alias',
+    'retain',
+    'decompose',
+    'preset',
+    'remove'
+];
+export const CAPABILITY_PROVENANCE = ['legacy-surface', 'post-migration'];
+export const DEPRECATION_STATUSES = ['active', 'deprecated', 'removed'];
+export const HASH_ALGORITHM = 'sha256';
+export const PREVIEW_MODES = ['none', 'validate-only', 'simulate'];
+export const PREVIEW_REPORTS = [
+    'affected-objects',
+    'affected-packages',
+    'risk',
+    'estimated-cost',
+    'validation-plan'
+];
+export const UNDO_MODES = ['none', 'transaction'];
+export const COMPENSATION_MODES = ['none', 'inverse-capability', 'manual-cleanup'];
+export const SEMANTICS_EVIDENCE_GRADES = [
+    'pessimistic-default',
+    'source-verified',
+    'contract-derived'
+];
+//# sourceMappingURL=constants.js.map

package/dist/tools/catalog/capabilities/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.js","sourceRoot":"","sources":["../../../../src/tools/catalog/capabilities/constants.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,wBAAwB,GAAG,8CAAuD,CAAC;AAEhG,MAAM,CAAC,MAAM,uBAAuB,GAAG,CAAC,QAAQ,EAAE,SAAS,CAAU,CAAC;AACtE,MAAM,CAAC,MAAM,aAAa,GAAG,CAAC,MAAM,EAAE,KAAK,EAAE,UAAU,CAAU,CAAC;AAClE,MAAM,CAAC,MAAM,gBAAgB,GAAG,CAAC,MAAM,EAAE,OAAO,EAAE,aAAa,CAAU,CAAC;AAC1E,MAAM,CAAC,MAAM,mBAAmB,GAAG,CAAC,gBAAgB,EAAE,YAAY,EAAE,iBAAiB,CAAU,CAAC;AAChG,MAAM,CAAC,MAAM,aAAa,GAAG,CAAC,MAAM,EAAE,OAAO,EAAE,aAAa,EAAE,OAAO,CAAU,CAAC;AAChF,MAAM,CAAC,MAAM,aAAa,GAAG,CAAC,MAAM,EAAE,UAAU,EAAE,UAAU,CAAU,CAAC;AACvE,MAAM,CAAC,MAAM,mBAAmB,GAAG,CAAC,MAAM,EAAE,cAAc,EAAE,eAAe,EAAE,aAAa,CAAU,CAAC;AACrG,MAAM,CAAC,MAAM,eAAe,GAAG,CAAC,SAAS,EAAE,aAAa,EAAE,cAAc,CAAU,CAAC;AACnF,MAAM,CAAC,MAAM,gBAAgB,GAAG,CAAC,KAAK,EAAE,QAAQ,EAAE,MAAM,CAAU,CAAC;AACnE,MAAM,CAAC,MAAM,cAAc,GAAG,CAAC,MAAM,EAAE,QAAQ,EAAE,OAAO,CAAU,CAAC;AACnE,MAAM,CAAC,MAAM,qBAAqB,GAAG;IACnC,kBAAkB;IAClB,SAAS;IACT,8BAA8B;IAC9B,aAAa;IACb,mBAAmB;IACnB,6BAA6B;CACrB,CAAC;AACX,MAAM,CAAC,MAAM,0BAA0B,GAAG;IACxC,WAAW;IACX,OAAO;IACP,OAAO;IACP,QAAQ;IACR,WAAW;IACX,QAAQ;IACR,QAAQ;CACA,CAAC;AAGX,MAAM,CAAC,MAAM,qBAAqB,GAAG,CAAC,gBAAgB,EAAE,gBAAgB,CAAU,CAAC;AACnF,MAAM,CAAC,MAAM,oBAAoB,GAAG,CAAC,QAAQ,EAAE,YAAY,EAAE,SAAS,CAAU,CAAC;AACjF,MAAM,CAAC,MAAM,cAAc,GAAG,QAAiB,CAAC;AAIhD,MAAM,CAAC,MAAM,aAAa,GAAG,CAAC,MAAM,EAAE,eAAe,EAAE,UAAU,CAAU,CAAC;AAC5E,MAAM,CAAC,MAAM,eAAe,GAAG;IAC7B,kBAAkB;IAClB,mBAAmB;IACnB,MAAM;IACN,gBAAgB;IAChB,iBAAiB;CACT,CAAC;AAKX,MAAM,CAAC,MAAM,UAAU,GAAG,CAAC,MAAM,EAAE,aAAa,CAAU,CAAC;AAC3D,MAAM,CAAC,MAAM,kBAAkB,GAAG,CAAC,MAAM,EAAE,oBAAoB,EAAE,gBAAgB,CAAU,CAAC;AAC5F,MAAM,CAAC,MAAM,yBAAyB,GAAG;IACvC,qBAAqB;IACrB,iBAAiB;IACjB,kBAAkB;CACV,CAAC"}