@mcoda/core 0.1.4

package/dist/services/estimate/EstimateService.d.ts

@@ -0,0 +1,12 @@
+import type { EstimateOptions, EstimateResult } from "./types.js";
+import type { WorkspaceResolution } from "../../workspace/WorkspaceManager.js";
+export declare class EstimateService {
+    private workspace;
+    private constructor();
+    static create(workspace: WorkspaceResolution): Promise<EstimateService>;
+    private computeDurations;
+    private computeEtas;
+    estimate(options: Omit<EstimateOptions, "workspace">): Promise<EstimateResult>;
+    close(): Promise<void>;
+}
+//# sourceMappingURL=EstimateService.d.ts.map

package/dist/services/estimate/EstimateService.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EstimateService.d.ts","sourceRoot":"","sources":["../../../src/services/estimate/EstimateService.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAmC,eAAe,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAEnG,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,qCAAqC,CAAC;AAI/E,qBAAa,eAAe;IACN,OAAO,CAAC,SAAS;IAArC,OAAO;WAEM,MAAM,CAAC,SAAS,EAAE,mBAAmB,GAAG,OAAO,CAAC,eAAe,CAAC;IAI7E,OAAO,CAAC,gBAAgB;IAqBxB,OAAO,CAAC,WAAW;IAmBb,QAAQ,CAAC,OAAO,EAAE,IAAI,CAAC,eAAe,EAAE,WAAW,CAAC,GAAG,OAAO,CAAC,cAAc,CAAC;IAmD9E,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;CAG7B"}

package/dist/services/estimate/EstimateService.js

@@ -0,0 +1,103 @@
+import { BacklogService } from "../backlog/BacklogService.js";
+import { VelocityService } from "./VelocityService.js";
+const HOURS_IN_MS = 3600 * 1000;
+export class EstimateService {
+    constructor(workspace) {
+        this.workspace = workspace;
+    }
+    static async create(workspace) {
+        return new EstimateService(workspace);
+    }
+    computeDurations(totals, velocity) {
+        const safeDivide = (sp, spPerHour) => {
+            if (!sp || sp <= 0)
+                return 0;
+            if (!spPerHour || spPerHour <= 0)
+                return null;
+            return sp / spPerHour;
+        };
+        const implementationHours = safeDivide(totals.implementation.story_points, velocity.implementationSpPerHour);
+        const reviewHours = safeDivide(totals.review.story_points, velocity.reviewSpPerHour);
+        const qaHours = safeDivide(totals.qa.story_points, velocity.qaSpPerHour);
+        const durationsList = [implementationHours, reviewHours, qaHours];
+        const hasNull = durationsList.some((value) => value === null);
+        const numeric = durationsList.filter((value) => value !== null);
+        const totalHours = hasNull || numeric.length === 0 ? null : Math.max(...numeric);
+        return {
+            implementationHours,
+            reviewHours,
+            qaHours,
+            totalHours,
+        };
+    }
+    computeEtas(durations) {
+        const now = Date.now();
+        const addHours = (hours) => {
+            if (hours === null || hours === undefined || hours < 0)
+                return undefined;
+            return new Date(now + hours * HOURS_IN_MS).toISOString();
+        };
+        const readyToReviewEta = durations.implementationHours !== null ? addHours(durations.implementationHours ?? undefined) : undefined;
+        const readyToQaEta = durations.implementationHours !== null && durations.reviewHours !== null
+            ? addHours(Math.max(durations.implementationHours ?? 0, durations.reviewHours ?? 0))
+            : undefined;
+        const completeEta = durations.totalHours !== null ? addHours(durations.totalHours ?? undefined) : undefined;
+        return {
+            readyToReviewEta,
+            readyToQaEta,
+            completeEta,
+        };
+    }
+    async estimate(options) {
+        const backlogService = await BacklogService.create(this.workspace);
+        let backlogTotals;
+        try {
+            const { summary } = await backlogService.getBacklog({
+                projectKey: options.projectKey,
+                epicKey: options.epicKey,
+                storyKey: options.storyKey,
+                assignee: options.assignee,
+            });
+            backlogTotals = summary.totals;
+        }
+        finally {
+            await backlogService.close();
+        }
+        const velocityService = await VelocityService.create(this.workspace);
+        let effectiveVelocity;
+        try {
+            effectiveVelocity = await velocityService.getEffectiveVelocity({
+                projectKey: options.projectKey,
+                epicKey: options.epicKey,
+                storyKey: options.storyKey,
+                assignee: options.assignee,
+                mode: options.mode,
+                windowTasks: options.windowTasks,
+                spPerHourAll: options.spPerHourAll,
+                spPerHourReview: options.spPerHourReview,
+                spPerHourQa: options.spPerHourQa,
+            });
+        }
+        finally {
+            await velocityService.close();
+        }
+        const durationsHours = this.computeDurations(backlogTotals, effectiveVelocity);
+        const etas = this.computeEtas(durationsHours);
+        return {
+            scope: {
+                workspaceId: this.workspace.workspaceId,
+                project: options.projectKey,
+                epic: options.epicKey,
+                story: options.storyKey,
+                assignee: options.assignee,
+            },
+            backlogTotals,
+            effectiveVelocity,
+            durationsHours,
+            etas,
+        };
+    }
+    async close() {
+        // No long-lived resources to release yet, placeholder for symmetry with other services.
+    }
+}

package/dist/services/estimate/VelocityService.d.ts

@@ -0,0 +1,19 @@
+import { WorkspaceResolution } from "../../workspace/WorkspaceManager.js";
+import type { EffectiveVelocity, VelocityOptions } from "./types.js";
+export declare class VelocityService {
+    private workspace;
+    private db;
+    private connection;
+    private globalVelocity?;
+    private constructor();
+    static create(workspace: WorkspaceResolution): Promise<VelocityService>;
+    close(): Promise<void>;
+    private static readGlobalVelocityConfig;
+    private resolveConfig;
+    private resolveScopeIds;
+    private buildTaskFilters;
+    private computeLaneVelocity;
+    private deriveDurationSeconds;
+    getEffectiveVelocity(options?: VelocityOptions): Promise<EffectiveVelocity>;
+}
+//# sourceMappingURL=VelocityService.d.ts.map

package/dist/services/estimate/VelocityService.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"VelocityService.d.ts","sourceRoot":"","sources":["../../../src/services/estimate/VelocityService.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,mBAAmB,EAAE,MAAM,qCAAqC,CAAC;AAC1E,OAAO,KAAK,EAAE,iBAAiB,EAAkB,eAAe,EAAoB,MAAM,YAAY,CAAC;AAKvG,qBAAa,eAAe;IAExB,OAAO,CAAC,SAAS;IACjB,OAAO,CAAC,EAAE;IACV,OAAO,CAAC,UAAU;IAClB,OAAO,CAAC,cAAc,CAAC;IAJzB,OAAO;WAOM,MAAM,CAAC,SAAS,EAAE,mBAAmB,GAAG,OAAO,CAAC,eAAe,CAAC;IAOvE,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;mBAIP,wBAAwB;IAiB7C,OAAO,CAAC,aAAa;YAoCP,eAAe;IAgC7B,OAAO,CAAC,gBAAgB;YAuBV,mBAAmB;IAmEjC,OAAO,CAAC,qBAAqB;IAQvB,oBAAoB,CAAC,OAAO,GAAE,eAAoB,GAAG,OAAO,CAAC,iBAAiB,CAAC;CA2DtF"}

package/dist/services/estimate/VelocityService.js

@@ -0,0 +1,237 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { Connection } from "@mcoda/db";
+import { PathHelper } from "@mcoda/shared";
+const DEFAULT_SP_PER_HOUR = 15;
+const DEFAULT_ALPHA = 0.5;
+export class VelocityService {
+    constructor(workspace, db, connection, globalVelocity) {
+        this.workspace = workspace;
+        this.db = db;
+        this.connection = connection;
+        this.globalVelocity = globalVelocity;
+    }
+    static async create(workspace) {
+        const dbPath = PathHelper.getWorkspaceDbPath(workspace.workspaceRoot);
+        const connection = await Connection.open(dbPath);
+        const globalVelocity = await VelocityService.readGlobalVelocityConfig();
+        return new VelocityService(workspace, connection.db, connection, globalVelocity);
+    }
+    async close() {
+        await this.connection.close();
+    }
+    static async readGlobalVelocityConfig() {
+        const configPath = path.join(PathHelper.getGlobalMcodaDir(), "config.json");
+        try {
+            const raw = await fs.readFile(configPath, "utf8");
+            const parsed = JSON.parse(raw);
+            if (!parsed.velocity)
+                return undefined;
+            return {
+                implementationSpPerHour: parsed.velocity.implementationSpPerHour ?? DEFAULT_SP_PER_HOUR,
+                reviewSpPerHour: parsed.velocity.reviewSpPerHour ?? DEFAULT_SP_PER_HOUR,
+                qaSpPerHour: parsed.velocity.qaSpPerHour ?? DEFAULT_SP_PER_HOUR,
+                alpha: parsed.velocity.alpha ?? DEFAULT_ALPHA,
+            };
+        }
+        catch {
+            return undefined;
+        }
+    }
+    resolveConfig(options) {
+        const base = {
+            implementationSpPerHour: DEFAULT_SP_PER_HOUR,
+            reviewSpPerHour: DEFAULT_SP_PER_HOUR,
+            qaSpPerHour: DEFAULT_SP_PER_HOUR,
+            alpha: DEFAULT_ALPHA,
+        };
+        // Global config first
+        if (this.globalVelocity) {
+            base.implementationSpPerHour = this.globalVelocity.implementationSpPerHour ?? base.implementationSpPerHour;
+            base.reviewSpPerHour = this.globalVelocity.reviewSpPerHour ?? base.reviewSpPerHour;
+            base.qaSpPerHour = this.globalVelocity.qaSpPerHour ?? base.qaSpPerHour;
+            base.alpha = this.globalVelocity.alpha ?? base.alpha;
+        }
+        // Workspace config overrides global
+        if (this.workspace.config?.velocity) {
+            base.implementationSpPerHour =
+                this.workspace.config.velocity.implementationSpPerHour ?? base.implementationSpPerHour;
+            base.reviewSpPerHour = this.workspace.config.velocity.reviewSpPerHour ?? base.reviewSpPerHour;
+            base.qaSpPerHour = this.workspace.config.velocity.qaSpPerHour ?? base.qaSpPerHour;
+            base.alpha = this.workspace.config.velocity.alpha ?? base.alpha;
+        }
+        if (options.spPerHourAll !== undefined) {
+            base.implementationSpPerHour = options.spPerHourAll;
+            base.reviewSpPerHour = options.spPerHourAll;
+            base.qaSpPerHour = options.spPerHourAll;
+        }
+        if (options.spPerHourReview !== undefined) {
+            base.reviewSpPerHour = options.spPerHourReview;
+        }
+        if (options.spPerHourQa !== undefined) {
+            base.qaSpPerHour = options.spPerHourQa;
+        }
+        return base;
+    }
+    async resolveScopeIds(options) {
+        const scope = {};
+        if (options.projectKey) {
+            const row = await this.db.get(`SELECT id FROM projects WHERE key = ?`, options.projectKey);
+            if (!row) {
+                throw new Error(`Unknown project key: ${options.projectKey}`);
+            }
+            scope.projectId = row.id;
+        }
+        if (options.epicKey) {
+            const row = await this.db.get(`SELECT id FROM epics WHERE key = ? ${scope.projectId ? "AND project_id = ?" : ""}`, scope.projectId ? [options.epicKey, scope.projectId] : [options.epicKey]);
+            if (!row) {
+                throw new Error(`Unknown epic key: ${options.epicKey}`);
+            }
+            scope.epicId = row.id;
+        }
+        if (options.storyKey) {
+            const row = await this.db.get(`SELECT id FROM user_stories WHERE key = ? ${scope.epicId ? "AND epic_id = ?" : ""}`, scope.epicId ? [options.storyKey, scope.epicId] : [options.storyKey]);
+            if (!row) {
+                throw new Error(`Unknown user story key: ${options.storyKey}`);
+            }
+            scope.storyId = row.id;
+        }
+        return scope;
+    }
+    buildTaskFilters(scope, assignee) {
+        const clauses = [];
+        const params = [];
+        if (scope.projectId) {
+            clauses.push("t.project_id = ?");
+            params.push(scope.projectId);
+        }
+        if (scope.epicId) {
+            clauses.push("t.epic_id = ?");
+            params.push(scope.epicId);
+        }
+        if (scope.storyId) {
+            clauses.push("t.user_story_id = ?");
+            params.push(scope.storyId);
+        }
+        if (assignee) {
+            clauses.push("LOWER(t.assignee_human) = LOWER(?)");
+            params.push(assignee);
+        }
+        if (clauses.length === 0)
+            return { clause: "", params: [] };
+        return { clause: `AND ${clauses.join(" AND ")}`, params };
+    }
+    async computeLaneVelocity(commandName, scope, assignee, windowTasks) {
+        const runs = await this.db.all(`
+      SELECT id, started_at, completed_at, duration_seconds
+      FROM command_runs
+      WHERE command_name = ?
+        AND status IN ('success','succeeded')
+      ORDER BY COALESCE(completed_at, started_at) DESC
+    `, commandName);
+        let totalSp = 0;
+        let totalDurationSeconds = 0;
+        let samples = 0;
+        const filters = this.buildTaskFilters(scope, assignee);
+        for (const run of runs) {
+            const aggregation = await this.db.get(`
+        SELECT
+          SUM(COALESCE(t.story_points, 0)) as sp,
+          COUNT(*) as tasks
+        FROM task_runs tr
+        INNER JOIN tasks t ON t.id = tr.task_id
+        WHERE tr.command_run_id = ?
+        ${filters.clause}
+      `, run.id, ...filters.params);
+            const taskCount = aggregation?.tasks ?? 0;
+            const sp = aggregation?.sp ?? 0;
+            if (taskCount === 0) {
+                continue;
+            }
+            const durationSeconds = typeof run.duration_seconds === "number" && Number.isFinite(run.duration_seconds)
+                ? run.duration_seconds
+                : this.deriveDurationSeconds(run.started_at, run.completed_at);
+            if (!durationSeconds || durationSeconds <= 0) {
+                continue;
+            }
+            totalSp += sp;
+            totalDurationSeconds += durationSeconds;
+            samples += taskCount;
+            if (samples >= windowTasks)
+                break;
+        }
+        if (samples === 0 || totalDurationSeconds <= 0 || totalSp <= 0) {
+            return { samples: 0 };
+        }
+        return {
+            spPerHour: totalSp / (totalDurationSeconds / 3600),
+            samples,
+        };
+    }
+    deriveDurationSeconds(started, completed) {
+        if (!started || !completed)
+            return undefined;
+        const startMs = Date.parse(started);
+        const endMs = Date.parse(completed);
+        if (Number.isNaN(startMs) || Number.isNaN(endMs) || endMs <= startMs)
+            return undefined;
+        return (endMs - startMs) / 1000;
+    }
+    async getEffectiveVelocity(options = {}) {
+        const mode = options.mode ?? "config";
+        const windowTasks = options.windowTasks ?? 10;
+        const config = this.resolveConfig(options);
+        if (mode === "config") {
+            return {
+                implementationSpPerHour: config.implementationSpPerHour,
+                reviewSpPerHour: config.reviewSpPerHour,
+                qaSpPerHour: config.qaSpPerHour,
+                source: "config",
+            };
+        }
+        const scope = await this.resolveScopeIds(options);
+        const implementation = await this.computeLaneVelocity("work-on-tasks", scope, options.assignee, windowTasks);
+        const review = await this.computeLaneVelocity("code-review", scope, options.assignee, windowTasks);
+        const qa = await this.computeLaneVelocity("qa-tasks", scope, options.assignee, windowTasks);
+        const alpha = config.alpha ?? DEFAULT_ALPHA;
+        const resolveLane = (empirical) => {
+            if (empirical === undefined || empirical <= 0)
+                return config.implementationSpPerHour;
+            if (mode === "empirical")
+                return empirical;
+            return alpha * empirical + (1 - alpha) * config.implementationSpPerHour;
+        };
+        const resolveReviewLane = (empirical) => {
+            if (empirical === undefined || empirical <= 0)
+                return config.reviewSpPerHour;
+            if (mode === "empirical")
+                return empirical;
+            return alpha * empirical + (1 - alpha) * config.reviewSpPerHour;
+        };
+        const resolveQaLane = (empirical) => {
+            if (empirical === undefined || empirical <= 0)
+                return config.qaSpPerHour;
+            if (mode === "empirical")
+                return empirical;
+            return alpha * empirical + (1 - alpha) * config.qaSpPerHour;
+        };
+        const implementationSpPerHour = resolveLane(implementation.spPerHour);
+        const reviewSpPerHour = resolveReviewLane(review.spPerHour);
+        const qaSpPerHour = resolveQaLane(qa.spPerHour);
+        const usedEmpirical = (implementation.spPerHour && implementation.spPerHour > 0) ||
+            (review.spPerHour && review.spPerHour > 0) ||
+            (qa.spPerHour && qa.spPerHour > 0);
+        return {
+            implementationSpPerHour,
+            reviewSpPerHour,
+            qaSpPerHour,
+            source: usedEmpirical ? mode : "config",
+            windowTasks,
+            samples: {
+                implementation: implementation.samples,
+                review: review.samples,
+                qa: qa.samples,
+            },
+        };
+    }
+}

package/dist/services/estimate/types.d.ts

@@ -0,0 +1,30 @@
+import type { EffectiveVelocity, EstimateResult, EstimateDurations, EstimateEtas, VelocitySource } from "@mcoda/shared";
+import type { WorkspaceResolution } from "../../workspace/WorkspaceManager.js";
+export interface VelocityConfig {
+    implementationSpPerHour: number;
+    reviewSpPerHour: number;
+    qaSpPerHour: number;
+    alpha?: number;
+}
+export interface VelocityOptions {
+    projectKey?: string;
+    epicKey?: string;
+    storyKey?: string;
+    assignee?: string;
+    mode?: VelocitySource;
+    windowTasks?: 10 | 20 | 50;
+    spPerHourAll?: number;
+    spPerHourReview?: number;
+    spPerHourQa?: number;
+}
+export interface VelocityScopeIds {
+    projectId?: string;
+    epicId?: string;
+    storyId?: string;
+}
+export interface EstimateOptions extends VelocityOptions {
+    workspace: WorkspaceResolution;
+}
+export type { EstimateDurations, EstimateEtas };
+export type { EffectiveVelocity, EstimateResult, VelocitySource };
+//# sourceMappingURL=types.d.ts.map

package/dist/services/estimate/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/services/estimate/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEV,iBAAiB,EACjB,cAAc,EACd,iBAAiB,EACjB,YAAY,EACZ,cAAc,EACf,MAAM,eAAe,CAAC;AACvB,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,qCAAqC,CAAC;AAE/E,MAAM,WAAW,cAAc;IAC7B,uBAAuB,EAAE,MAAM,CAAC;IAChC,eAAe,EAAE,MAAM,CAAC;IACxB,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,eAAe;IAC9B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,IAAI,CAAC,EAAE,cAAc,CAAC;IACtB,WAAW,CAAC,EAAE,EAAE,GAAG,EAAE,GAAG,EAAE,CAAC;IAC3B,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,gBAAgB;IAC/B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,eAAgB,SAAQ,eAAe;IACtD,SAAS,EAAE,mBAAmB,CAAC;CAChC;AAED,YAAY,EAAE,iBAAiB,EAAE,YAAY,EAAE,CAAC;AAChD,YAAY,EAAE,iBAAiB,EAAE,cAAc,EAAE,cAAc,EAAE,CAAC"}

package/dist/services/estimate/types.js

@@ -0,0 +1 @@
+export {};

package/dist/services/execution/ExecutionService.d.ts

@@ -0,0 +1,3 @@
+export declare class ExecutionService {
+}
+//# sourceMappingURL=ExecutionService.d.ts.map

package/dist/services/execution/ExecutionService.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExecutionService.d.ts","sourceRoot":"","sources":["../../../src/services/execution/ExecutionService.ts"],"names":[],"mappings":"AAAA,qBAAa,gBAAgB;CAAG"}

package/dist/services/execution/ExecutionService.js

@@ -0,0 +1,2 @@
+export class ExecutionService {
+}

package/dist/services/execution/QaFollowupService.d.ts

@@ -0,0 +1,38 @@
+import { TaskCommentInsert, TaskDependencyInsert, TaskInsert, TaskRow, WorkspaceRepository } from '@mcoda/db';
+export interface FollowupSuggestion {
+    title: string;
+    description?: string;
+    type?: string;
+    priority?: number;
+    storyPoints?: number;
+    tags?: string[];
+    epicKeyHint?: string;
+    storyKeyHint?: string;
+    relatedTaskKey?: string;
+    components?: string[];
+    docLinks?: string[];
+    testName?: string;
+    evidenceUrl?: string;
+    artifacts?: string[];
+}
+export declare class QaFollowupService {
+    private workspaceRepo;
+    private workspaceRoot;
+    constructor(workspaceRepo: WorkspaceRepository, workspaceRoot: string);
+    private get cachePath();
+    private readCache;
+    private writeCache;
+    private ensureBugContainer;
+    createFollowupTask(sourceTask: TaskRow & {
+        storyKey?: string;
+        epicKey?: string;
+    }, suggestion: FollowupSuggestion): Promise<{
+        task: TaskInsert & {
+            id: string;
+        };
+        dependency?: TaskDependencyInsert;
+        comment?: TaskCommentInsert;
+    }>;
+    private resolveTargetContainer;
+}
+//# sourceMappingURL=QaFollowupService.d.ts.map

package/dist/services/execution/QaFollowupService.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"QaFollowupService.d.ts","sourceRoot":"","sources":["../../../src/services/execution/QaFollowupService.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,iBAAiB,EACjB,oBAAoB,EACpB,UAAU,EACV,OAAO,EACP,mBAAmB,EACpB,MAAM,WAAW,CAAC;AAMnB,MAAM,WAAW,kBAAkB;IACjC,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;IACtB,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;CACtB;AAgCD,qBAAa,iBAAiB;IAChB,OAAO,CAAC,aAAa;IAAuB,OAAO,CAAC,aAAa;gBAAzD,aAAa,EAAE,mBAAmB,EAAU,aAAa,EAAE,MAAM;IAErF,OAAO,KAAK,SAAS,GAEpB;YAEa,SAAS;YAST,UAAU;YAKV,kBAAkB;IA+C1B,kBAAkB,CACtB,UAAU,EAAE,OAAO,GAAG;QAAE,QAAQ,CAAC,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAA;KAAE,EAC7D,UAAU,EAAE,kBAAkB,GAC7B,OAAO,CAAC;QAAE,IAAI,EAAE,UAAU,GAAG;YAAE,EAAE,EAAE,MAAM,CAAA;SAAE,CAAC;QAAC,UAAU,CAAC,EAAE,oBAAoB,CAAC;QAAC,OAAO,CAAC,EAAE,iBAAiB,CAAA;KAAE,CAAC;YA6EnG,sBAAsB;CA+ErC"}