@shrkcrft/inspector 0.1.0-alpha.2

package/dist/grounding/build-grounding.d.ts

@@ -0,0 +1,53 @@
+/**
+ * `shrk grounding "<task>"` data builder.
+ *
+ * Pure composition of `buildTaskPacket`'s output projected onto a
+ * compact `sharkcraft.grounding/v1` shape. No new ranker, no LLM,
+ * no shell-out. Read-only.
+ *
+ * The grounding view is what an external SDD skill / plugin asks
+ * for when it needs to ground its plan against the live workspace —
+ * rules, knowledge, paths, templates, predicted boundary risks,
+ * trusted verification command IDs.
+ */
+import type { ISharkcraftInspection } from '../sharkcraft-inspector.js';
+export declare const GROUNDING_SCHEMA = "sharkcraft.grounding/v1";
+export interface IGroundingRule {
+    readonly id: string;
+    readonly title: string;
+    readonly priority?: string;
+}
+export interface IGroundingKnowledge {
+    readonly id: string;
+    readonly title: string;
+    readonly scope?: readonly string[];
+    readonly summary?: string;
+}
+export interface IGroundingPath {
+    readonly id: string;
+    readonly title: string;
+}
+export interface IGroundingTemplate {
+    readonly id: string;
+    readonly name: string;
+    readonly appliesWhen?: readonly string[];
+}
+export interface IGroundingReport {
+    readonly schema: typeof GROUNDING_SCHEMA;
+    readonly task: string;
+    readonly generatedAt: string;
+    readonly rules: readonly IGroundingRule[];
+    readonly knowledge: readonly IGroundingKnowledge[];
+    readonly paths: readonly IGroundingPath[];
+    readonly templates: readonly IGroundingTemplate[];
+    readonly verificationCommandIds: readonly string[];
+    readonly recommendedMcpTools: readonly string[];
+    readonly recommendedCliCommands: readonly string[];
+    readonly tokenEstimate: number;
+}
+export interface IBuildGroundingOptions {
+    readonly maxTokens?: number;
+    readonly limit?: number;
+}
+export declare function buildGrounding(task: string, inspection: ISharkcraftInspection, options?: IBuildGroundingOptions): IGroundingReport;
+//# sourceMappingURL=build-grounding.d.ts.map

package/dist/grounding/build-grounding.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"build-grounding.d.ts","sourceRoot":"","sources":["../../src/grounding/build-grounding.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAGH,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,4BAA4B,CAAC;AAGxE,eAAO,MAAM,gBAAgB,4BAA4B,CAAC;AAE1D,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;CAC5B;AAED,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,KAAK,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACnC,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,WAAW,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CAC1C;AAED,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,MAAM,EAAE,OAAO,gBAAgB,CAAC;IACzC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,KAAK,EAAE,SAAS,cAAc,EAAE,CAAC;IAC1C,QAAQ,CAAC,SAAS,EAAE,SAAS,mBAAmB,EAAE,CAAC;IACnD,QAAQ,CAAC,KAAK,EAAE,SAAS,cAAc,EAAE,CAAC;IAC1C,QAAQ,CAAC,SAAS,EAAE,SAAS,kBAAkB,EAAE,CAAC;IAClD,QAAQ,CAAC,sBAAsB,EAAE,SAAS,MAAM,EAAE,CAAC;IACnD,QAAQ,CAAC,mBAAmB,EAAE,SAAS,MAAM,EAAE,CAAC;IAChD,QAAQ,CAAC,sBAAsB,EAAE,SAAS,MAAM,EAAE,CAAC;IACnD,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;CAChC;AAED,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;CACzB;AAED,wBAAgB,cAAc,CAC5B,IAAI,EAAE,MAAM,EACZ,UAAU,EAAE,qBAAqB,EACjC,OAAO,GAAE,sBAA2B,GACnC,gBAAgB,CAoClB"}

package/dist/grounding/build-grounding.js

@@ -0,0 +1,51 @@
+/**
+ * `shrk grounding "<task>"` data builder.
+ *
+ * Pure composition of `buildTaskPacket`'s output projected onto a
+ * compact `sharkcraft.grounding/v1` shape. No new ranker, no LLM,
+ * no shell-out. Read-only.
+ *
+ * The grounding view is what an external SDD skill / plugin asks
+ * for when it needs to ground its plan against the live workspace —
+ * rules, knowledge, paths, templates, predicted boundary risks,
+ * trusted verification command IDs.
+ */
+import { searchKnowledge } from '@shrkcrft/knowledge';
+import { buildTaskPacket } from "../task-packet.js";
+export const GROUNDING_SCHEMA = 'sharkcraft.grounding/v1';
+export function buildGrounding(task, inspection, options = {}) {
+    const limit = options.limit ?? 5;
+    const packet = buildTaskPacket(inspection, task, {
+        maxTokens: options.maxTokens ?? 2500,
+    });
+    const trustedVerificationIds = (inspection.config?.verificationCommands ?? [])
+        .filter((c) => c.trusted !== false)
+        .map((c) => c.id);
+    return {
+        schema: GROUNDING_SCHEMA,
+        task,
+        generatedAt: new Date().toISOString(),
+        rules: packet.relevantRules.slice(0, limit).map((r) => ({
+            id: r.id,
+            title: r.title,
+            ...(r.priority !== undefined ? { priority: r.priority } : {}),
+        })),
+        knowledge: searchKnowledge(inspection.knowledgeEntries, { query: task, limit })
+            .map((hit) => ({
+            id: hit.entry.id,
+            title: hit.entry.title,
+            ...(hit.entry.scope && hit.entry.scope.length > 0 ? { scope: hit.entry.scope } : {}),
+            ...(hit.entry.summary ? { summary: hit.entry.summary } : {}),
+        })),
+        paths: packet.relevantPaths.slice(0, limit).map((p) => ({ id: p.id, title: p.title })),
+        templates: packet.relevantTemplates.slice(0, limit).map((t) => ({
+            id: t.id,
+            name: t.name,
+            ...(t.appliesWhen.length > 0 ? { appliesWhen: t.appliesWhen } : {}),
+        })),
+        verificationCommandIds: trustedVerificationIds,
+        recommendedMcpTools: packet.recommendedMcpTools.slice(0, limit),
+        recommendedCliCommands: packet.recommendedCliCommands.slice(0, limit),
+        tokenEstimate: packet.tokenEstimate,
+    };
+}

package/dist/grounding/nx-projects.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Minimal Nx project graph reader.
+ *
+ * Pure filesystem. NO shell-out to `nx` CLI. NO network. Returns
+ * null when `nx.json` is absent; otherwise walks for `project.json`
+ * files under common Nx layouts (`apps/`, `libs/`, `packages/`) and
+ * returns a `{ name, root, tags }` record.
+ *
+ * Designed for `shrk plan check` cross-project warnings: given a
+ * declared file path, look up which project owns it (by `root`
+ * prefix match) and flag plans that touch multiple projects.
+ */
+export interface INxProject {
+    readonly name: string;
+    readonly root: string;
+    readonly tags: readonly string[];
+}
+export interface INxProjectGraph {
+    readonly projects: readonly INxProject[];
+}
+export declare function loadNxProjects(projectRoot: string): INxProjectGraph | null;
+/**
+ * Given a list of declared file paths (relative to projectRoot) and
+ * an Nx project graph, return the set of unique project NAMES the
+ * files belong to. Files that don't map to any known project are
+ * silently ignored.
+ */
+export declare function mapFilesToProjects(files: readonly string[], graph: INxProjectGraph): readonly string[];
+//# sourceMappingURL=nx-projects.d.ts.map

package/dist/grounding/nx-projects.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nx-projects.d.ts","sourceRoot":"","sources":["../../src/grounding/nx-projects.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAKH,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,CAAC;CAClC;AAED,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,QAAQ,EAAE,SAAS,UAAU,EAAE,CAAC;CAC1C;AAKD,wBAAgB,cAAc,CAAC,WAAW,EAAE,MAAM,GAAG,eAAe,GAAG,IAAI,CAY1E;AAgDD;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,SAAS,MAAM,EAAE,EACxB,KAAK,EAAE,eAAe,GACrB,SAAS,MAAM,EAAE,CAgBnB"}

package/dist/grounding/nx-projects.js

@@ -0,0 +1,109 @@
+/**
+ * Minimal Nx project graph reader.
+ *
+ * Pure filesystem. NO shell-out to `nx` CLI. NO network. Returns
+ * null when `nx.json` is absent; otherwise walks for `project.json`
+ * files under common Nx layouts (`apps/`, `libs/`, `packages/`) and
+ * returns a `{ name, root, tags }` record.
+ *
+ * Designed for `shrk plan check` cross-project warnings: given a
+ * declared file path, look up which project owns it (by `root`
+ * prefix match) and flag plans that touch multiple projects.
+ */
+import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs';
+import * as nodePath from 'node:path';
+const DEFAULT_SEARCH_ROOTS = ['apps', 'libs', 'packages'];
+const MAX_DEPTH = 6;
+export function loadNxProjects(projectRoot) {
+    if (!existsSync(nodePath.join(projectRoot, 'nx.json')))
+        return null;
+    const projects = [];
+    for (const seed of DEFAULT_SEARCH_ROOTS) {
+        const seedAbs = nodePath.join(projectRoot, seed);
+        if (!existsSync(seedAbs))
+            continue;
+        walk(seedAbs, projectRoot, 0, projects);
+    }
+    // Also check the projectRoot itself (single-project workspaces sometimes).
+    const rootProject = readProjectJson(projectRoot, projectRoot);
+    if (rootProject !== null)
+        projects.push(rootProject);
+    return { projects };
+}
+function walk(dir, projectRoot, depth, out) {
+    if (depth > MAX_DEPTH)
+        return;
+    let entries;
+    try {
+        entries = readdirSync(dir);
+    }
+    catch {
+        return;
+    }
+    // If this directory has a project.json, read it and stop recursing into it.
+    const projectJsonPath = nodePath.join(dir, 'project.json');
+    if (existsSync(projectJsonPath)) {
+        const project = readProjectJson(dir, projectRoot);
+        if (project)
+            out.push(project);
+        return;
+    }
+    for (const entry of entries) {
+        if (entry.startsWith('.'))
+            continue;
+        if (entry === 'node_modules' || entry === 'dist' || entry === 'build')
+            continue;
+        const abs = nodePath.join(dir, entry);
+        let s;
+        try {
+            s = statSync(abs);
+        }
+        catch {
+            continue;
+        }
+        if (s.isDirectory())
+            walk(abs, projectRoot, depth + 1, out);
+    }
+}
+function readProjectJson(dir, projectRoot) {
+    const p = nodePath.join(dir, 'project.json');
+    if (!existsSync(p))
+        return null;
+    try {
+        const raw = readFileSync(p, 'utf8');
+        const parsed = JSON.parse(raw);
+        const name = typeof parsed.name === 'string' && parsed.name.length > 0
+            ? parsed.name
+            : nodePath.basename(dir);
+        const tags = Array.isArray(parsed.tags) ? parsed.tags.filter((t) => typeof t === 'string') : [];
+        const root = nodePath.relative(projectRoot, dir) || '.';
+        return { name, root, tags };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Given a list of declared file paths (relative to projectRoot) and
+ * an Nx project graph, return the set of unique project NAMES the
+ * files belong to. Files that don't map to any known project are
+ * silently ignored.
+ */
+export function mapFilesToProjects(files, graph) {
+    // Sort projects by descending root path length so the longest match wins.
+    const sorted = [...graph.projects].sort((a, b) => b.root.length - a.root.length);
+    const hits = new Set();
+    for (const file of files) {
+        const normalized = file.replace(/^\.\//, '');
+        for (const p of sorted) {
+            if (p.root === '.' || p.root === '')
+                continue;
+            const prefix = p.root.endsWith('/') ? p.root : `${p.root}/`;
+            if (normalized === p.root || normalized.startsWith(prefix)) {
+                hits.add(p.name);
+                break;
+            }
+        }
+    }
+    return [...hits];
+}

package/dist/grounding/validate-extracted-plan.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Shared cross-registry validation for an `IExtractedPlan`.
+ *
+ * Both `shrk spec review` and `shrk plan check` go through this
+ * single pipeline. `spec review` extracts via the
+ * `sharkcraft.spec/v1` extractor; `plan check` accepts any extractor
+ * that produces the canonical view.
+ *
+ * Every field is optional — extractors populate what they can read.
+ * The validator only checks what's present; absent fields do not
+ * produce errors.
+ */
+import type { IExtractedPlan, ISpecValidationIssue } from '@shrkcrft/generator';
+import type { ISharkcraftInspection } from '../sharkcraft-inspector.js';
+export interface IExtractedPlanValidation {
+    readonly errors: readonly ISpecValidationIssue[];
+    readonly warnings: readonly ISpecValidationIssue[];
+}
+export declare function validateExtractedPlan(plan: IExtractedPlan, inspection: ISharkcraftInspection): IExtractedPlanValidation;
+//# sourceMappingURL=validate-extracted-plan.d.ts.map

package/dist/grounding/validate-extracted-plan.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate-extracted-plan.d.ts","sourceRoot":"","sources":["../../src/grounding/validate-extracted-plan.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAChF,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,4BAA4B,CAAC;AAExE,MAAM,WAAW,wBAAwB;IACvC,QAAQ,CAAC,MAAM,EAAE,SAAS,oBAAoB,EAAE,CAAC;IACjD,QAAQ,CAAC,QAAQ,EAAE,SAAS,oBAAoB,EAAE,CAAC;CACpD;AAED,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,cAAc,EACpB,UAAU,EAAE,qBAAqB,GAChC,wBAAwB,CA4H1B"}

package/dist/grounding/validate-extracted-plan.js

@@ -0,0 +1,127 @@
+/**
+ * Shared cross-registry validation for an `IExtractedPlan`.
+ *
+ * Both `shrk spec review` and `shrk plan check` go through this
+ * single pipeline. `spec review` extracts via the
+ * `sharkcraft.spec/v1` extractor; `plan check` accepts any extractor
+ * that produces the canonical view.
+ *
+ * Every field is optional — extractors populate what they can read.
+ * The validator only checks what's present; absent fields do not
+ * produce errors.
+ */
+export function validateExtractedPlan(plan, inspection) {
+    const errors = [];
+    const warnings = [];
+    const ruleIds = new Set(inspection.ruleService.list().map((r) => r.id));
+    const knowledgeIds = new Set(inspection.knowledgeEntries.map((k) => k.id));
+    const pathIds = new Set(inspection.pathService.list().map((p) => p.id));
+    const templateIds = new Set(inspection.templates.map((t) => t.id));
+    const trustedCommandIds = new Set((inspection.config?.verificationCommands ?? [])
+        .filter((c) => c.trusted !== false)
+        .map((c) => c.id));
+    const allCommandIds = new Set((inspection.config?.verificationCommands ?? []).map((c) => c.id));
+    const rules = plan.relevantRules ?? [];
+    for (let i = 0; i < rules.length; i++) {
+        const id = rules[i];
+        if (!ruleIds.has(id)) {
+            errors.push({
+                code: 'unknown-rule-id',
+                severity: 'error',
+                field: `relevantRules[${i}]`,
+                message: `Unknown rule id "${id}"`,
+            });
+        }
+    }
+    const knowledge = plan.relevantKnowledge ?? [];
+    for (let i = 0; i < knowledge.length; i++) {
+        const id = knowledge[i];
+        if (!knowledgeIds.has(id)) {
+            errors.push({
+                code: 'unknown-knowledge-id',
+                severity: 'error',
+                field: `relevantKnowledge[${i}]`,
+                message: `Unknown knowledge id "${id}"`,
+            });
+        }
+    }
+    const paths = plan.relevantPaths ?? [];
+    for (let i = 0; i < paths.length; i++) {
+        const id = paths[i];
+        if (!pathIds.has(id)) {
+            errors.push({
+                code: 'unknown-path-id',
+                severity: 'error',
+                field: `relevantPaths[${i}]`,
+                message: `Unknown path id "${id}"`,
+            });
+        }
+    }
+    const templates = plan.proposedTemplates ?? [];
+    for (let i = 0; i < templates.length; i++) {
+        const t = templates[i];
+        if (!templateIds.has(t.templateId)) {
+            errors.push({
+                code: 'unknown-template-id',
+                severity: 'error',
+                field: `proposedTemplates[${i}].templateId`,
+                message: `Unknown template id "${t.templateId}"`,
+            });
+        }
+    }
+    const verificationIds = plan.verificationCommandIds ?? [];
+    for (let i = 0; i < verificationIds.length; i++) {
+        const id = verificationIds[i];
+        if (!allCommandIds.has(id)) {
+            errors.push({
+                code: 'unknown-verification-command',
+                severity: 'error',
+                field: `verificationCommandIds[${i}]`,
+                message: `Unknown verification command "${id}" — declare it in sharkcraft.config.ts verificationCommands[]`,
+            });
+        }
+        else if (!trustedCommandIds.has(id)) {
+            warnings.push({
+                code: 'untrusted-verification-command',
+                severity: 'warning',
+                field: `verificationCommandIds[${i}]`,
+                message: `Verification command "${id}" is declared but not marked trusted — \`spec verify\` will refuse to run it`,
+            });
+        }
+    }
+    // Coverage heuristic — only fires when both AC + verification info are present.
+    const acceptance = plan.acceptanceCriteria ?? [];
+    if (acceptance.length > 0 && verificationIds.length > 0) {
+        const haveTestCommand = verificationIds.some((id) => /test|spec|jest|bun-test|unit|integration|e2e/i.test(id));
+        if (!haveTestCommand) {
+            for (let i = 0; i < acceptance.length; i++) {
+                const ac = acceptance[i];
+                if (ac.verifiedBy?.includes('tests')) {
+                    warnings.push({
+                        code: 'acceptance-tests-without-test-command',
+                        severity: 'warning',
+                        field: `acceptanceCriteria[${i}].verifiedBy`,
+                        message: `Acceptance criterion "${ac.id ?? `#${i}`}" is verified by tests but the plan declares no test-shaped verification command`,
+                    });
+                    break;
+                }
+            }
+        }
+    }
+    // Missing-knowledge heuristic — only fires when the workspace has knowledge entries.
+    const affectedPackages = plan.affectedPackages ?? [];
+    if (affectedPackages.length > 0 && inspection.knowledgeEntries.length > 0) {
+        for (const pkg of affectedPackages) {
+            const hit = inspection.knowledgeEntries.some((k) => k.scope?.some((s) => pkg.includes(s)) ?? false);
+            if (!hit) {
+                warnings.push({
+                    code: 'package-without-knowledge',
+                    severity: 'warning',
+                    field: 'affectedPackages',
+                    message: `Package "${pkg}" has no knowledge entry — consider authoring one alongside the plan`,
+                });
+            }
+        }
+    }
+    return { errors, warnings };
+}

package/dist/healing-plan.d.ts

@@ -0,0 +1,33 @@
+import { type IFailureDiagnostic } from './failure-diagnostics.js';
+export declare const HEALING_PLAN_SCHEMA = "sharkcraft.healing-plan/v1";
+export declare enum HealingInputKind {
+    Error = "error",
+    File = "file",
+    Report = "report",
+    Command = "command"
+}
+export interface IHealingPlan {
+    schema: typeof HEALING_PLAN_SCHEMA;
+    generatedAt: string;
+    inputKind: HealingInputKind;
+    inputSummary: string;
+    detectedDiagnostics: readonly IFailureDiagnostic[];
+    confidence: 'low' | 'medium' | 'high';
+    likelyCauses: readonly string[];
+    safeRecoverySteps: readonly string[];
+    forbiddenQuickFixes: readonly string[];
+    recommendedCommands: readonly string[];
+    relatedConstructs: readonly string[];
+    relatedDocs: readonly string[];
+    humanApprovalRequired: boolean;
+    sourceWritesInvolved: boolean;
+    nextSafestCommand: string;
+    notes: readonly string[];
+}
+export declare function buildHealingPlanFromError(errorText: string): IHealingPlan;
+export declare function buildHealingPlanFromFile(filePath: string): IHealingPlan;
+export declare function buildHealingPlanFromReport(reportPath: string): IHealingPlan;
+export declare function buildHealingPlanFromCommand(command: string, exitCode: number, stderrText: string): IHealingPlan;
+export declare function renderHealingPlanText(p: IHealingPlan): string;
+export declare function renderHealingPlanMarkdown(p: IHealingPlan): string;
+//# sourceMappingURL=healing-plan.d.ts.map

package/dist/healing-plan.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"healing-plan.d.ts","sourceRoot":"","sources":["../src/healing-plan.ts"],"names":[],"mappings":"AAOA,OAAO,EAIL,KAAK,kBAAkB,EACxB,MAAM,0BAA0B,CAAC;AAGlC,eAAO,MAAM,mBAAmB,+BAA+B,CAAC;AAEhE,oBAAY,gBAAgB;IAC1B,KAAK,UAAU;IACf,IAAI,SAAS;IACb,MAAM,WAAW;IACjB,OAAO,YAAY;CACpB;AAED,MAAM,WAAW,YAAY;IAC3B,MAAM,EAAE,OAAO,mBAAmB,CAAC;IACnC,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,gBAAgB,CAAC;IAC5B,YAAY,EAAE,MAAM,CAAC;IACrB,mBAAmB,EAAE,SAAS,kBAAkB,EAAE,CAAC;IACnD,UAAU,EAAE,KAAK,GAAG,QAAQ,GAAG,MAAM,CAAC;IACtC,YAAY,EAAE,SAAS,MAAM,EAAE,CAAC;IAChC,iBAAiB,EAAE,SAAS,MAAM,EAAE,CAAC;IACrC,mBAAmB,EAAE,SAAS,MAAM,EAAE,CAAC;IACvC,mBAAmB,EAAE,SAAS,MAAM,EAAE,CAAC;IACvC,iBAAiB,EAAE,SAAS,MAAM,EAAE,CAAC;IACrC,WAAW,EAAE,SAAS,MAAM,EAAE,CAAC;IAC/B,qBAAqB,EAAE,OAAO,CAAC;IAC/B,oBAAoB,EAAE,OAAO,CAAC;IAC9B,iBAAiB,EAAE,MAAM,CAAC;IAC1B,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;CAC1B;AAoQD,wBAAgB,yBAAyB,CAAC,SAAS,EAAE,MAAM,GAAG,YAAY,CAMzE;AAED,wBAAgB,wBAAwB,CAAC,QAAQ,EAAE,MAAM,GAAG,YAAY,CAcvE;AAED,wBAAgB,0BAA0B,CAAC,UAAU,EAAE,MAAM,GAAG,YAAY,CAqB3E;AAED,wBAAgB,2BAA2B,CACzC,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,MAAM,GACjB,YAAY,CAQd;AAID,wBAAgB,qBAAqB,CAAC,CAAC,EAAE,YAAY,GAAG,MAAM,CAsB7D;AAED,wBAAgB,yBAAyB,CAAC,CAAC,EAAE,YAAY,GAAG,MAAM,CAiBjE"}