@unifiedcommerce/core 0.1.0 → 0.2.0

package/dist/interfaces/mcp/server.js

@@ -1,515 +1,30 @@
-import { buildAnalyticsScope } from "../../modules/analytics/types.js";
 import { orderStateMachine } from "../../kernel/state-machine/machine.js";
-import { enrichEntityForAgent, enrichInventoryForAgent, enrichOrderForAgent, } from "./context-enrichment.js";
-function textContent(value) {
-    return {
-        content: [{ type: "text", text: JSON.stringify(value, null, 2) }],
-    };
+import { coreTools } from "./tools/index.js";
+import { registerToolsOnServer } from "./tools/registry.js";
+// ─── Core Tool Registration ─────────────────────────────────────────────────
+export function registerCoreTools(server, kernel) {
+    registerToolsOnServer(server, kernel, coreTools);
 }
-function asObject(params) {
-    if (!params || typeof params !== "object" || Array.isArray(params))
-        return {};
-    return params;
-}
-function readString(params, key) {
-    const value = params[key];
-    return typeof value === "string" ? value : undefined;
-}
-function readNumber(params, key) {
-    const value = params[key];
-    return typeof value === "number" && Number.isFinite(value)
-        ? value
-        : undefined;
-}
-function readStringArray(params, key) {
-    const value = params[key];
-    if (!Array.isArray(value))
-        return [];
-    return value.filter((item) => typeof item === "string");
-}
-function validationError(message) {
-    return {
-        error: {
-            code: "VALIDATION_FAILED",
-            message,
-        },
-    };
-}
-export function registerMCPCapabilities(kernel) {
-    return {
-        tools: [
-            {
-                name: "catalog_search",
-                description: "Search the catalog. Filter by type, status, category, brand, price range, free-text. Returns paginated results with pricing and availability.",
-                inputSchema: {
-                    type: "object",
-                    properties: {
-                        query: { type: "string" },
-                        type: { type: "string" },
-                        status: { type: "string" },
-                        categorySlug: { type: "string" },
-                        brandSlug: { type: "string" },
-                        page: { type: "number", default: 1 },
-                        limit: { type: "number", default: 20 },
-                    },
-                },
-                handler: async (params) => {
-                    const input = asObject(params);
-                    const query = (readString(input, "query") ?? "").trim().toLowerCase();
-                    const page = readNumber(input, "page") ?? 1;
-                    const limit = readNumber(input, "limit") ?? 20;
-                    const type = readString(input, "type");
-                    const status = readString(input, "status");
-                    const categorySlug = readString(input, "categorySlug");
-                    const brandSlug = readString(input, "brandSlug");
-                    if (query.length > 0) {
-                        const searchResult = await kernel.services.search.query({
-                            query,
-                            page,
-                            limit,
-                            filters: {
-                                ...(type ? { type } : {}),
-                                ...(status ? { status } : {}),
-                                ...(categorySlug ? { category: categorySlug } : {}),
-                                ...(brandSlug ? { brand: brandSlug } : {}),
-                            },
-                        });
-                        if (!searchResult.ok)
-                            return { error: searchResult.error };
-                        const enrichedItems = await Promise.all(searchResult.value.hits.map(async (hit) => {
-                            const entityResult = await kernel.services.catalog.getById(hit.id);
-                            if (entityResult.ok) {
-                                return enrichEntityForAgent(entityResult.value, kernel);
-                            }
-                            return hit.document;
-                        }));
-                        return textContent({
-                            items: await Promise.all(enrichedItems),
-                            pagination: {
-                                page: searchResult.value.page,
-                                limit: searchResult.value.limit,
-                                total: searchResult.value.total,
-                                totalPages: Math.max(1, Math.ceil(searchResult.value.total / searchResult.value.limit)),
-                            },
-                            facets: searchResult.value.facets,
-                        });
-                    }
-                    const result = await kernel.services.catalog.list({
-                        filter: {
-                            ...(type ? { type } : {}),
-                            ...(status ? { status } : {}),
-                            ...(categorySlug ? { category: categorySlug } : {}),
-                            ...(brandSlug ? { brand: brandSlug } : {}),
-                        },
-                        pagination: {
-                            page,
-                            limit,
-                        },
-                    });
-                    if (!result.ok)
-                        return { error: result.error };
-                    return textContent({
-                        ...result.value,
-                        items: await Promise.all(result.value.items.map((item) => enrichEntityForAgent(item, kernel))),
-                    });
-                },
-            },
-            {
-                name: "catalog_create_entity",
-                description: "Create a new catalog entity. Requires type, slug, title. Created in draft status.",
-                inputSchema: {
-                    type: "object",
-                    required: ["type", "slug", "title"],
-                    properties: {
-                        type: { type: "string" },
-                        slug: { type: "string" },
-                        title: { type: "string" },
-                        description: { type: "string" },
-                        metadata: { type: "object" },
-                    },
-                },
-                handler: async (params) => {
-                    const input = asObject(params);
-                    const type = readString(input, "type");
-                    const slug = readString(input, "slug");
-                    const title = readString(input, "title");
-                    const description = readString(input, "description");
-                    if (!type || !slug || !title) {
-                        return validationError("type, slug, and title are required.");
-                    }
-                    const result = await kernel.services.catalog.create({
-                        type,
-                        slug,
-                        attributes: {
-                            locale: "en",
-                            title,
-                            ...(description !== undefined ? { description } : {}),
-                        },
-                        ...(input.metadata &&
-                            typeof input.metadata === "object" &&
-                            !Array.isArray(input.metadata)
-                            ? { metadata: input.metadata }
-                            : {}),
-                    }, kernel.getMCPActor());
-                    if (!result.ok)
-                        return { error: result.error };
-                    return textContent(await enrichEntityForAgent(result.value, kernel));
-                },
-            },
-            {
-                name: "inventory_check",
-                description: "Check stock levels for one or more entities/variants.",
-                inputSchema: {
-                    type: "object",
-                    required: ["entityIds"],
-                    properties: {
-                        entityIds: {
-                            type: "array",
-                            items: { type: "string" },
-                        },
-                    },
-                },
-                handler: async (params) => {
-                    const input = asObject(params);
-                    const entityIds = readStringArray(input, "entityIds");
-                    if (entityIds.length === 0) {
-                        return validationError("entityIds is required.");
-                    }
-                    const result = await kernel.services.inventory.checkMultiple(entityIds);
-                    if (!result.ok)
-                        return { error: result.error };
-                    const enriched = await Promise.all(Object.entries(result.value).map(async ([entityId, available]) => {
-                        const levelsResult = await kernel.services.inventory.getLevelsByEntityId(entityId);
-                        const levels = levelsResult.ok ? levelsResult.value : [];
-                        const reorderThreshold = levels[0]?.reorderThreshold;
-                        const reorderQuantity = levels[0]?.reorderQuantity;
-                        return enrichInventoryForAgent({
-                            entityId,
-                            available,
-                            ...(reorderThreshold !== undefined ? { reorderThreshold } : {}),
-                            ...(reorderQuantity !== undefined ? { reorderQuantity } : {}),
-                        });
-                    }));
-                    return textContent(enriched);
-                },
-            },
-            {
-                name: "inventory_adjust",
-                description: "Adjust inventory. Positive adds stock, negative removes. Requires reason.",
-                inputSchema: {
-                    type: "object",
-                    required: ["entityId", "adjustment", "reason"],
-                    properties: {
-                        entityId: { type: "string" },
-                        variantId: { type: "string" },
-                        adjustment: { type: "number" },
-                        reason: { type: "string" },
-                    },
-                },
-                handler: async (params) => {
-                    const input = asObject(params);
-                    const entityId = readString(input, "entityId");
-                    const adjustment = readNumber(input, "adjustment");
-                    const reason = readString(input, "reason");
-                    const variantId = readString(input, "variantId");
-                    if (!entityId || adjustment === undefined || !reason) {
-                        return validationError("entityId, adjustment, and reason are required.");
-                    }
-                    const result = await kernel.services.inventory.adjust({
-                        entityId,
-                        adjustment,
-                        reason,
-                        ...(variantId !== undefined ? { variantId } : {}),
-                    }, kernel.getMCPActor());
-                    if (!result.ok)
-                        return { error: result.error };
-                    const availableResult = await kernel.services.inventory.getAvailable(entityId, variantId);
-                    return textContent(enrichInventoryForAgent({
-                        entityId,
-                        available: availableResult.ok ? availableResult.value : 0,
-                        ...(result.value.reorderThreshold !== undefined
-                            ? { reorderThreshold: result.value.reorderThreshold }
-                            : {}),
-                        ...(result.value.reorderQuantity !== undefined
-                            ? { reorderQuantity: result.value.reorderQuantity }
-                            : {}),
-                    }));
-                },
-            },
-            {
-                name: "cart_create",
-                description: "Create a new shopping cart. Returns cart ID for subsequent operations.",
-                inputSchema: {
-                    type: "object",
-                    properties: {
-                        customerId: { type: "string" },
-                        currency: { type: "string", default: "USD" },
-                    },
-                },
-                handler: async (params) => {
-                    const input = asObject(params);
-                    const customerId = readString(input, "customerId");
-                    const currency = readString(input, "currency");
-                    const result = await kernel.services.cart.create({
-                        ...(customerId !== undefined ? { customerId } : {}),
-                        ...(currency !== undefined ? { currency } : {}),
-                    }, kernel.getMCPActor());
-                    if (!result.ok)
-                        return { error: result.error };
-                    return textContent(result.value);
-                },
-            },
-            {
-                name: "cart_add_item",
-                description: "Add item to cart. If entity has variants and no variantId provided, fails with available variants.",
-                inputSchema: {
-                    type: "object",
-                    required: ["cartId", "entityId"],
-                    properties: {
-                        cartId: { type: "string" },
-                        entityId: { type: "string" },
-                        variantId: { type: "string" },
-                        quantity: { type: "number", default: 1 },
-                    },
-                },
-                handler: async (params) => {
-                    const input = asObject(params);
-                    const cartId = readString(input, "cartId");
-                    const entityId = readString(input, "entityId");
-                    const variantId = readString(input, "variantId");
-                    const quantity = readNumber(input, "quantity");
-                    if (!cartId || !entityId) {
-                        return validationError("cartId and entityId are required.");
-                    }
-                    const result = await kernel.services.cart.addItem({
-                        cartId,
-                        entityId,
-                        ...(variantId !== undefined ? { variantId } : {}),
-                        quantity: quantity ?? 1,
-                    }, kernel.getMCPActor());
-                    if (!result.ok)
-                        return { error: result.error };
-                    return textContent(result.value);
-                },
-            },
-            {
-                name: "order_get",
-                description: "Get order details by ID or order number. Includes line items, payment, fulfillment, and AI context.",
-                inputSchema: {
-                    type: "object",
-                    properties: {
-                        orderId: { type: "string" },
-                        orderNumber: { type: "string" },
-                    },
-                },
-                handler: async (params) => {
-                    const input = asObject(params);
-                    const orderId = readString(input, "orderId");
-                    const orderNumber = readString(input, "orderNumber");
-                    if (!orderId && !orderNumber) {
-                        return validationError("Either orderId or orderNumber is required.");
-                    }
-                    const result = orderId
-                        ? await kernel.services.orders.getById(orderId, kernel.getMCPActor())
-                        : await kernel.services.orders.getByNumber(orderNumber ?? "", kernel.getMCPActor());
-                    if (!result.ok)
-                        return { error: result.error };
-                    const enriched = enrichOrderForAgent(result.value, kernel.getMCPActor().permissions);
-                    return textContent(enriched);
-                },
-            },
-            {
-                name: "order_list",
-                description: "List orders with pagination and optional status filter.",
-                inputSchema: {
-                    type: "object",
-                    properties: {
-                        page: { type: "number", default: 1 },
-                        limit: { type: "number", default: 20 },
-                        status: { type: "string" },
-                    },
-                },
-                handler: async (params) => {
-                    const input = asObject(params);
-                    const page = readNumber(input, "page");
-                    const limit = readNumber(input, "limit");
-                    const status = readString(input, "status");
-                    const result = await kernel.services.orders.list({
-                        ...(page !== undefined ? { page } : {}),
-                        ...(limit !== undefined ? { limit } : {}),
-                        ...(status !== undefined ? { status } : {}),
-                    }, kernel.getMCPActor());
-                    if (!result.ok)
-                        return { error: result.error };
-                    return textContent({
-                        ...result.value,
-                        items: result.value.items.map((order) => enrichOrderForAgent(order, kernel.getMCPActor().permissions)),
-                    });
-                },
-            },
-            {
-                name: "analytics_query",
-                description: "Query analytics using semantic measures, dimensions, time dimensions, and filters.",
-                inputSchema: {
-                    type: "object",
-                    required: ["measures"],
-                    properties: {
-                        measures: {
-                            type: "array",
-                            items: { type: "string" },
-                        },
-                        dimensions: {
-                            type: "array",
-                            items: { type: "string" },
-                        },
-                        timeDimensions: {
-                            type: "array",
-                            items: {
-                                type: "object",
-                                properties: {
-                                    dimension: { type: "string" },
-                                    granularity: {
-                                        type: "string",
-                                        enum: ["day", "week", "month", "year"],
-                                    },
-                                    dateRange: {
-                                        oneOf: [
-                                            { type: "string" },
-                                            {
-                                                type: "array",
-                                                items: { type: "string" },
-                                                minItems: 2,
-                                                maxItems: 2,
-                                            },
-                                        ],
-                                    },
-                                },
-                                required: ["dimension"],
-                            },
-                        },
-                        filters: {
-                            type: "array",
-                            items: {
-                                type: "object",
-                                properties: {
-                                    member: { type: "string" },
-                                    operator: {
-                                        type: "string",
-                                        enum: [
-                                            "equals",
-                                            "notEquals",
-                                            "contains",
-                                            "in",
-                                            "notIn",
-                                            "gt",
-                                            "gte",
-                                            "lt",
-                                            "lte",
-                                            "beforeDate",
-                                            "afterDate",
-                                            "inDateRange",
-                                        ],
-                                    },
-                                    values: {
-                                        type: "array",
-                                        items: { type: "string" },
-                                    },
-                                },
-                                required: ["member", "operator"],
-                            },
-                        },
-                        order: {
-                            type: "object",
-                            additionalProperties: {
-                                type: "string",
-                                enum: ["asc", "desc"],
-                            },
-                        },
-                        limit: { type: "number", default: 100 },
-                    },
-                },
-                handler: async (params) => {
-                    const input = asObject(params);
-                    const measures = readStringArray(input, "measures");
-                    const limit = readNumber(input, "limit");
-                    if (measures.length === 0) {
-                        return validationError("measures is required.");
-                    }
-                    const queryParams = {
-                        measures,
-                        ...(Array.isArray(input.dimensions)
-                            ? {
-                                dimensions: input.dimensions.filter((item) => typeof item === "string"),
-                            }
-                            : {}),
-                        ...(Array.isArray(input.timeDimensions)
-                            ? {
-                                timeDimensions: input.timeDimensions,
-                            }
-                            : {}),
-                        ...(Array.isArray(input.filters)
-                            ? {
-                                filters: input.filters,
-                            }
-                            : {}),
-                        ...(input.order &&
-                            typeof input.order === "object" &&
-                            !Array.isArray(input.order)
-                            ? {
-                                order: input.order,
-                            }
-                            : {}),
-                        ...(limit !== undefined ? { limit } : {}),
-                    };
-                    // Scope is always derived from the actor — never manually constructed.
-                    const analyticsScope = buildAnalyticsScope(kernel.getMCPActor());
-                    const result = await kernel.services.analytics.query(queryParams, analyticsScope);
-                    if (!result.ok)
-                        return { error: result.error };
-                    return textContent(result.value);
-                },
-            },
-            {
-                name: "analytics_meta",
-                description: "List available analytics measures, dimensions, segments, and models.",
-                inputSchema: {
-                    type: "object",
-                },
-                handler: async () => {
-                    const metaScope = buildAnalyticsScope(kernel.getMCPActor());
-                    const result = await kernel.services.analytics.getMeta();
-                    if (!result.ok)
-                        return { error: result.error };
-                    return textContent(result.value);
-                },
-            },
-        ],
-        resources: [
-            {
-                uri: "commerce://schema/entity-types",
-                name: "Entity Type Schema",
-                description: "Complete schema of all entity types, fields, variants, fulfillment strategies.",
+// ─── Core Resource Registration ─────────────────────────────────────────────
+export function registerCoreResources(server, kernel) {
+    server.registerResource("Entity Type Schema", "commerce://schema/entity-types", {
+        description: "Complete entity type schema including fields, variants, and fulfillment strategies.",
+        mimeType: "application/json",
+    }, async (uri) => ({
+        contents: [{
+                uri: uri.toString(),
+                text: JSON.stringify(kernel.config.entities ?? {}, null, 2),
                 mimeType: "application/json",
-                handler: async () => ({
-                    content: [
-                        {
-                            type: "text",
-                            text: JSON.stringify(kernel.config.entities ?? {}, null, 2),
-                        },
-                    ],
-                }),
-            },
-            {
-                uri: "commerce://schema/order-states",
-                name: "Order State Machine",
-                description: "All order states and valid transitions.",
+            }],
+    }));
+    server.registerResource("Order State Machine", "commerce://schema/order-states", {
+        description: "Valid order status transitions and the complete state machine definition.",
+        mimeType: "application/json",
+    }, async (uri) => ({
+        contents: [{
+                uri: uri.toString(),
+                text: JSON.stringify(orderStateMachine, null, 2),
                 mimeType: "application/json",
-                handler: async () => ({
-                    content: [
-                        { type: "text", text: JSON.stringify(orderStateMachine, null, 2) },
-                    ],
-                }),
-            },
-        ],
-    };
+            }],
+    }));
 }

package/dist/interfaces/mcp/tool-builder.d.ts

@@ -0,0 +1,120 @@
+/**
+ * Fluent builder for STRAP-pattern MCP tools.
+ *
+ * Produces a single MCPTool with an `action` enum from multiple
+ * action definitions. Each action has its own Zod schema and typed handler.
+ *
+ * @example
+ * ```typescript
+ * import { toolBuilder } from "@unifiedcommerce/core";
+ *
+ * mcpTools: (ctx) => {
+ *   const t = toolBuilder("loyalty", "Manage loyalty points and rewards.");
+ *
+ *   t.action("balance", "Check a customer's point balance and tier.")
+ *     .input(z.object({ customerId: z.string().describe("Customer UUID") }))
+ *     .handler(async ({ customerId }, { services }) =>
+ *       (services as LoyaltyServices).loyalty.getPoints(customerId),
+ *     );
+ *
+ *   t.action("earn", "Award points to a customer.")
+ *     .input(z.object({
+ *       customerId: z.string().describe("Customer UUID"),
+ *       amount: z.number().int().positive().describe("Points to award"),
+ *     }))
+ *     .handler(async ({ customerId, amount }, { services }) =>
+ *       (services as LoyaltyServices).loyalty.earn(customerId, amount),
+ *     );
+ *
+ *   return t.build(ctx);
+ * },
+ * ```
+ */
+import { z } from "zod";
+import type { MCPTool } from "../../config/types.js";
+import type { PluginContext } from "../../kernel/plugin/manifest.js";
+interface ActionHandlerContext {
+    services: Record<string, unknown>;
+    db: unknown;
+    logger: {
+        info(msg: string, data?: unknown): void;
+        warn(msg: string, data?: unknown): void;
+        error(msg: string, data?: unknown): void;
+    };
+}
+interface ActionDefinition {
+    name: string;
+    description: string;
+    inputSchema: z.ZodObject<z.ZodRawShape>;
+    handler: (args: Record<string, unknown>, ctx: ActionHandlerContext) => Promise<unknown>;
+}
+/**
+ * Fluent chain returned by `t.action(name, description)`.
+ *
+ * Generic parameter `TArgs` tracks the inferred input type so that
+ * `.handler()` receives fully typed args — no manual casts needed.
+ * The type is carried as a plain object type (not z.infer) so consumers
+ * don't need `zod` types available at compile time.
+ */
+declare class ActionChain<TArgs extends Record<string, unknown> = Record<string, unknown>> {
+    private _name;
+    private _description;
+    private _actions;
+    private _input;
+    private _handler;
+    constructor(_name: string, _description: string, _actions: ActionDefinition[]);
+    /**
+     * Define the Zod input schema for this action.
+     * Returns a new chain typed with the inferred output so `.handler()` gets typed args.
+     *
+     * The dual generic `TSchema` / `TOut` lets TypeScript:
+     * 1. Infer `TSchema` from the ZodObject's raw shape (for internal storage)
+     * 2. Infer `TOut` from the ZodObject's output type (for handler typing)
+     * Since `TOut` is a plain object type (not `z.infer`), the emitted `.d.ts`
+     * doesn't require consumers to have `zod` types at compile time.
+     */
+    input<TSchema extends z.ZodRawShape, TOut extends Record<string, unknown> = z.infer<z.ZodObject<TSchema>>>(schema: z.ZodObject<TSchema> & {
+        _zod: {
+            output: TOut;
+        };
+    }): ActionChain<TOut>;
+    /**
+     * Define the handler for this action.
+     * Receives typed args (inferred from `.input()`) and a context with services and db.
+     * Return any value — it is auto-wrapped in MCP result format.
+     */
+    handler(fn: (args: TArgs, ctx: ActionHandlerContext) => Promise<unknown>): void;
+}
+declare class ToolBuilderImpl {
+    private _name;
+    private _description;
+    private _actions;
+    constructor(_name: string, _description: string);
+    /**
+     * Define an action on this STRAP tool.
+     * Returns a chain where you call .input(schema).handler(fn).
+     */
+    action(name: string, description: string): ActionChain;
+    /**
+     * Build the MCPTool[] array (always 1 tool) from all registered actions.
+     *
+     * Automatically:
+     * - Creates the `action` enum from action names
+     * - Merges all action input schemas (fields become optional)
+     * - Generates description listing all actions
+     * - Generates switch/case dispatch
+     * - Wraps results in MCP content format
+     * - Handles errors consistently
+     */
+    build(ctx: PluginContext): MCPTool[];
+}
+/**
+ * Create a STRAP-pattern MCP tool builder.
+ *
+ * @param name - Tool name in snake_case (e.g., "loyalty", "pos_shift")
+ * @param description - Base description explaining the tool's domain.
+ *   Action descriptions are appended automatically.
+ */
+export declare function toolBuilder(name: string, description: string): ToolBuilderImpl;
+export {};
+//# sourceMappingURL=tool-builder.d.ts.map

package/dist/interfaces/mcp/tool-builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-builder.d.ts","sourceRoot":"","sources":["../../../src/interfaces/mcp/tool-builder.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AACrD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iCAAiC,CAAC;AAIrE,UAAU,oBAAoB;IAC5B,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAClC,EAAE,EAAE,OAAO,CAAC;IACZ,MAAM,EAAE;QAAE,IAAI,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,GAAG,IAAI,CAAC;QAAC,IAAI,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,GAAG,IAAI,CAAC;QAAC,KAAK,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,GAAG,IAAI,CAAA;KAAE,CAAC;CACxI;AAED,UAAU,gBAAgB;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC;IACxC,OAAO,EAAE,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,GAAG,EAAE,oBAAoB,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;CACzF;AAID;;;;;;;GAOG;AACH,cAAM,WAAW,CAAC,KAAK,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAK7E,OAAO,CAAC,KAAK;IACb,OAAO,CAAC,YAAY;IACpB,OAAO,CAAC,QAAQ;IANlB,OAAO,CAAC,MAAM,CAA4C;IAC1D,OAAO,CAAC,QAAQ,CAA+F;gBAGrG,KAAK,EAAE,MAAM,EACb,YAAY,EAAE,MAAM,EACpB,QAAQ,EAAE,gBAAgB,EAAE;IAGtC;;;;;;;;;OASG;IACH,KAAK,CAAC,OAAO,SAAS,CAAC,CAAC,WAAW,EAAE,IAAI,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC,EACvG,MAAM,EAAE,CAAC,CAAC,SAAS,CAAC,OAAO,CAAC,GAAG;QAAE,IAAI,EAAE;YAAE,MAAM,EAAE,IAAI,CAAA;SAAE,CAAA;KAAE,GACxD,WAAW,CAAC,IAAI,CAAC;IAQpB;;;;OAIG;IACH,OAAO,CAAC,EAAE,EAAE,CAAC,IAAI,EAAE,KAAK,EAAE,GAAG,EAAE,oBAAoB,KAAK,OAAO,CAAC,OAAO,CAAC,GAAG,IAAI;CAShF;AAID,cAAM,eAAe;IAIjB,OAAO,CAAC,KAAK;IACb,OAAO,CAAC,YAAY;IAJtB,OAAO,CAAC,QAAQ,CAA0B;gBAGhC,KAAK,EAAE,MAAM,EACb,YAAY,EAAE,MAAM;IAG9B;;;OAGG;IACH,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,WAAW;IAItD;;;;;;;;;;OAUG;IACH,KAAK,CAAC,GAAG,EAAE,aAAa,GAAG,OAAO,EAAE;CA8GrC;AAID;;;;;;GAMG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,eAAe,CAE9E"}