@shrkcrft/inspector 0.1.0-alpha.2

package/dist/quality-baseline.js

@@ -0,0 +1,433 @@
+import { createHash } from 'node:crypto';
+import { existsSync, mkdirSync, readFileSync, readdirSync, statSync, unlinkSync, writeFileSync, } from 'node:fs';
+import * as nodePath from 'node:path';
+import { buildAiReadinessReport } from "./ai-readiness.js";
+import { buildCoverageReport } from "./coverage-report.js";
+import { buildQualityReport } from "./quality-report.js";
+export const QUALITY_BASELINE_SCHEMA = 'sharkcraft.quality-baseline/v1';
+function nowIso() {
+    return new Date().toISOString();
+}
+function gateNumeric(gate, key) {
+    const v = gate.data?.[key];
+    return typeof v === 'number' ? v : 0;
+}
+function readSharkcraftVersion(projectRoot) {
+    // Best-effort: look for the toolkit's own package.json next to the inspector.
+    // Falls back to '0.0.0' rather than throwing if discovery fails.
+    const candidates = [
+        nodePath.join(projectRoot, 'package.json'),
+    ];
+    try {
+        // Walk up from this file to find packages/inspector/package.json.
+        const here = new URL('.', import.meta.url).pathname;
+        const insp = nodePath.resolve(here, '..', 'package.json');
+        candidates.unshift(insp);
+    }
+    catch {
+        /* ignore */
+    }
+    for (const p of candidates) {
+        try {
+            if (!existsSync(p))
+                continue;
+            const v = JSON.parse(readFileSync(p, 'utf8'));
+            if (v.version)
+                return v.version;
+        }
+        catch {
+            /* ignore */
+        }
+    }
+    return '0.0.0';
+}
+function configHashFor(inspection) {
+    const file = inspection.configFile;
+    if (!file || !existsSync(file))
+        return null;
+    try {
+        const content = readFileSync(file, 'utf8');
+        return createHash('sha256').update(content).digest('hex').slice(0, 16);
+    }
+    catch {
+        return null;
+    }
+}
+function packSignaturesSummary(inspection) {
+    const summary = {
+        total: 0,
+        verified: 0,
+        unverified: 0,
+        invalid: 0,
+        notChecked: 0,
+    };
+    for (const pack of inspection.packs.validPacks ?? []) {
+        summary.total += 1;
+        const status = pack.signatureStatus;
+        if (status === 'verified')
+            summary.verified += 1;
+        else if (status === 'invalid-signature')
+            summary.invalid += 1;
+        else if (status === 'not-checked' || !status)
+            summary.notChecked += 1;
+        else
+            summary.unverified += 1;
+    }
+    return summary;
+}
+function categoryScoresFrom(inspection) {
+    const out = [];
+    try {
+        const cov = buildCoverageReport(inspection);
+        for (const c of cov.categories) {
+            out.push({ id: `coverage:${c.id}`, score: c.score });
+        }
+        out.push({ id: 'coverage:overall', score: cov.overall });
+    }
+    catch {
+        /* ignore */
+    }
+    try {
+        const r = buildAiReadinessReport(inspection);
+        out.push({ id: 'readiness:overall', score: r.score });
+    }
+    catch {
+        /* ignore */
+    }
+    return out;
+}
+function extractBaseline(inspection, report) {
+    const drift = report.drift;
+    const readiness = (() => {
+        try {
+            return buildAiReadinessReport(inspection).score;
+        }
+        catch {
+            return 0;
+        }
+    })();
+    return {
+        schema: QUALITY_BASELINE_SCHEMA,
+        createdAt: nowIso(),
+        projectRoot: inspection.projectRoot,
+        sharkcraftVersion: readSharkcraftVersion(inspection.projectRoot),
+        configHash: configHashFor(inspection),
+        qualityScore: report.score,
+        readinessScore: readiness,
+        blockers: report.blockers,
+        warnings: report.warnings,
+        gates: report.gates.map((g) => ({
+            id: g.id,
+            passed: g.passed,
+            errors: gateNumeric(g, 'errors'),
+            warnings: gateNumeric(g, 'warnings'),
+        })),
+        categoryScores: categoryScoresFrom(inspection),
+        driftFindings: drift?.findings.length ?? 0,
+        driftErrors: drift?.counts.error ?? 0,
+        driftWarnings: drift?.counts.warning ?? 0,
+        packSignatures: packSignaturesSummary(inspection),
+    };
+}
+export async function createQualityBaseline(inspection, outFile) {
+    const report = await buildQualityReport({
+        inspection,
+        config: {},
+    });
+    const baseline = extractBaseline(inspection, report);
+    mkdirSync(nodePath.dirname(outFile), { recursive: true });
+    writeFileSync(outFile, JSON.stringify(baseline, null, 2) + '\n', 'utf8');
+    return baseline;
+}
+export function readQualityBaseline(file) {
+    if (!existsSync(file))
+        return null;
+    try {
+        return JSON.parse(readFileSync(file, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+export function diffQualityBaselineFiles(oldFile, newFile) {
+    const oldBaseline = readQualityBaseline(oldFile);
+    const newBaseline = readQualityBaseline(newFile);
+    if (!oldBaseline || !newBaseline)
+        return null;
+    const categoryDeltas = [];
+    const newCats = new Map((newBaseline.categoryScores ?? []).map((c) => [c.id, c.score]));
+    for (const oldCat of oldBaseline.categoryScores ?? []) {
+        const cur = newCats.get(oldCat.id) ?? 0;
+        if (cur === oldCat.score)
+            continue;
+        categoryDeltas.push({ id: oldCat.id, old: oldCat.score, new: cur, delta: cur - oldCat.score });
+    }
+    // Per-gate warning movement: gates that flipped passed→failed produce "new warnings".
+    const oldGates = new Map(oldBaseline.gates.map((g) => [g.id, g]));
+    const newWarnings = [];
+    const resolvedWarnings = [];
+    for (const g of newBaseline.gates) {
+        const b = oldGates.get(g.id);
+        if (!b)
+            continue;
+        if (b.passed && !g.passed)
+            newWarnings.push(`gate ${g.id} now failing`);
+        if (!b.passed && g.passed)
+            resolvedWarnings.push(`gate ${g.id} now passing`);
+        if (g.warnings > b.warnings)
+            newWarnings.push(`gate ${g.id} warnings +${g.warnings - b.warnings}`);
+        if (g.warnings < b.warnings)
+            resolvedWarnings.push(`gate ${g.id} warnings -${b.warnings - g.warnings}`);
+    }
+    return {
+        schema: 'sharkcraft.quality-baseline-diff/v1',
+        oldFile,
+        newFile,
+        oldBaseline,
+        newBaseline,
+        scoreDelta: newBaseline.qualityScore - oldBaseline.qualityScore,
+        blockersDelta: newBaseline.blockers - oldBaseline.blockers,
+        warningsDelta: newBaseline.warnings - oldBaseline.warnings,
+        categoryDeltas,
+        resolvedWarnings,
+        newWarnings,
+        signatureChanges: {
+            addedVerified: Math.max(0, newBaseline.packSignatures.verified - oldBaseline.packSignatures.verified),
+            lostVerified: Math.max(0, oldBaseline.packSignatures.verified - newBaseline.packSignatures.verified),
+        },
+        configHashChanged: oldBaseline.configHash !== newBaseline.configHash,
+    };
+}
+export function listQualityBaselineHistory(cwd, baselineDir) {
+    const dir = baselineDir ?? nodePath.join(cwd, '.sharkcraft', 'baselines');
+    const entries = [];
+    if (existsSync(dir)) {
+        try {
+            for (const f of readdirSync(dir)) {
+                if (!f.endsWith('.json'))
+                    continue;
+                const full = nodePath.join(dir, f);
+                try {
+                    if (!statSync(full).isFile())
+                        continue;
+                }
+                catch {
+                    continue;
+                }
+                const b = readQualityBaseline(full);
+                if (!b)
+                    continue;
+                entries.push({
+                    file: full,
+                    createdAt: b.createdAt,
+                    qualityScore: b.qualityScore,
+                    readinessScore: b.readinessScore,
+                    blockers: b.blockers,
+                    warnings: b.warnings,
+                    configHash: b.configHash ?? null,
+                    signaturesVerified: b.packSignatures?.verified ?? 0,
+                    signaturesTotal: b.packSignatures?.total ?? 0,
+                });
+            }
+        }
+        catch {
+            /* ignore */
+        }
+    }
+    // Sort newest first by createdAt.
+    entries.sort((a, b) => b.createdAt.localeCompare(a.createdAt));
+    return {
+        schema: 'sharkcraft.quality-baseline-history/v1',
+        baselineDir: dir,
+        entries,
+        latest: entries[0] ?? null,
+        previous: entries[1] ?? null,
+    };
+}
+export function pruneQualityBaselines(input) {
+    const dir = input.baselineDir ?? nodePath.join(input.cwd, '.sharkcraft', 'baselines');
+    const keep = Math.max(1, input.keep ?? 10);
+    if (!existsSync(dir)) {
+        return {
+            schema: 'sharkcraft.quality-baseline-prune/v1',
+            baselineDir: dir,
+            kept: [],
+            pruned: [],
+            dryRun: !input.write,
+        };
+    }
+    const files = [];
+    try {
+        for (const f of readdirSync(dir)) {
+            if (!f.endsWith('.json'))
+                continue;
+            const full = nodePath.join(dir, f);
+            try {
+                if (!statSync(full).isFile())
+                    continue;
+            }
+            catch {
+                continue;
+            }
+            files.push(full);
+        }
+    }
+    catch {
+        /* ignore */
+    }
+    // Sort by createdAt inside each baseline (descending). Fallback: filename.
+    files.sort((a, b) => {
+        const ba = readQualityBaseline(a)?.createdAt ?? a;
+        const bb = readQualityBaseline(b)?.createdAt ?? b;
+        return bb.localeCompare(ba);
+    });
+    const kept = files.slice(0, keep);
+    const pruned = files.slice(keep);
+    if (input.write) {
+        for (const f of pruned) {
+            try {
+                unlinkSync(f);
+            }
+            catch {
+                /* ignore */
+            }
+        }
+    }
+    return {
+        schema: 'sharkcraft.quality-baseline-prune/v1',
+        baselineDir: dir,
+        kept,
+        pruned,
+        dryRun: !input.write,
+    };
+}
+const HIGHER_IS_BETTER = new Set(['qualityScore', 'readinessScore']);
+const LOWER_IS_BETTER = new Set([
+    'blockers',
+    'warnings',
+    'driftFindings',
+    'driftErrors',
+    'driftWarnings',
+]);
+function classify(metric, delta) {
+    if (delta === 0)
+        return 'unchanged';
+    if (HIGHER_IS_BETTER.has(metric))
+        return delta > 0 ? 'improved' : 'regressed';
+    if (LOWER_IS_BETTER.has(metric))
+        return delta < 0 ? 'improved' : 'regressed';
+    return 'unchanged';
+}
+export async function compareQualityBaseline(inspection, baselineFile) {
+    const baseline = readQualityBaseline(baselineFile);
+    if (!baseline)
+        return null;
+    const report = await buildQualityReport({ inspection, config: {} });
+    const current = extractBaseline(inspection, report);
+    const deltas = [];
+    const scalarMetrics = [
+        'qualityScore',
+        'readinessScore',
+        'blockers',
+        'warnings',
+        'driftFindings',
+        'driftErrors',
+        'driftWarnings',
+    ];
+    for (const metric of scalarMetrics) {
+        const b = baseline[metric];
+        const c = current[metric];
+        const delta = c - b;
+        deltas.push({
+            metric,
+            baseline: b,
+            current: c,
+            delta,
+            direction: classify(metric, delta),
+        });
+    }
+    // Gate-level deltas (passes only).
+    const baselineGates = new Map(baseline.gates.map((g) => [g.id, g]));
+    for (const g of current.gates) {
+        const b = baselineGates.get(g.id);
+        if (!b)
+            continue;
+        if (b.passed === g.passed)
+            continue;
+        deltas.push({
+            metric: `gate:${g.id}`,
+            baseline: b.passed ? 1 : 0,
+            current: g.passed ? 1 : 0,
+            delta: (g.passed ? 1 : 0) - (b.passed ? 1 : 0),
+            direction: g.passed ? 'improved' : 'regressed',
+        });
+    }
+    // Category score deltas.
+    const baselineCats = new Map((baseline.categoryScores ?? []).map((c) => [c.id, c]));
+    for (const c of current.categoryScores ?? []) {
+        const b = baselineCats.get(c.id);
+        if (!b)
+            continue;
+        const delta = c.score - b.score;
+        if (delta === 0)
+            continue;
+        deltas.push({
+            metric: `category:${c.id}`,
+            baseline: b.score,
+            current: c.score,
+            delta,
+            // Category scores are always "higher is better".
+            direction: delta > 0 ? 'improved' : 'regressed',
+        });
+    }
+    return {
+        schema: 'sharkcraft.quality-baseline-comparison/v1',
+        baselineFile,
+        baseline,
+        current,
+        deltas,
+        regressions: deltas.filter((d) => d.direction === 'regressed'),
+        improvements: deltas.filter((d) => d.direction === 'improved'),
+    };
+}
+function esc(s) {
+    return s.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+}
+export function renderQualityBaselineHtml(baseline, comparison) {
+    const parts = [];
+    parts.push('<!doctype html><html><head><meta charset="utf-8">');
+    parts.push('<title>SharkCraft quality baseline</title>');
+    parts.push('<style>body{font:14px/1.4 -apple-system,sans-serif;max-width:980px;margin:24px auto;padding:0 16px;color:#1f2328}');
+    parts.push('h1{font-size:20px;border-bottom:1px solid #d0d7de;padding-bottom:8px}h2{font-size:16px;margin-top:24px}');
+    parts.push('table{border-collapse:collapse;width:100%;margin:8px 0}th,td{border:1px solid #d0d7de;padding:6px 10px;text-align:left}th{background:#f6f8fa}');
+    parts.push('.tag{display:inline-block;padding:2px 8px;border-radius:9999px;font-size:11px;font-weight:600}');
+    parts.push('.tag.improved{background:#dafbe1;color:#1a7f37}.tag.regressed{background:#ffebe9;color:#cf222e}.tag.unchanged{background:#eaeef2;color:#57606a}');
+    parts.push('</style></head><body>');
+    parts.push('<h1>SharkCraft quality baseline</h1>');
+    parts.push(`<p><strong>Captured:</strong> ${esc(baseline.createdAt)}<br>`);
+    parts.push(`<strong>Toolkit version:</strong> ${esc(baseline.sharkcraftVersion)} ·`);
+    parts.push(`<strong>Config hash:</strong> <code>${esc(baseline.configHash ?? '(none)')}</code></p>`);
+    parts.push('<h2>Headline metrics</h2><table><thead><tr><th>Metric</th><th>Value</th></tr></thead><tbody>');
+    parts.push(`<tr><td>Quality score</td><td>${baseline.qualityScore}</td></tr>`);
+    parts.push(`<tr><td>Readiness score</td><td>${baseline.readinessScore}</td></tr>`);
+    parts.push(`<tr><td>Blockers</td><td>${baseline.blockers}</td></tr>`);
+    parts.push(`<tr><td>Warnings</td><td>${baseline.warnings}</td></tr>`);
+    parts.push(`<tr><td>Drift findings</td><td>${baseline.driftFindings}</td></tr>`);
+    parts.push(`<tr><td>Pack signatures</td><td>${baseline.packSignatures.verified}/${baseline.packSignatures.total} verified</td></tr>`);
+    parts.push('</tbody></table>');
+    parts.push('<h2>Category scores</h2><table><thead><tr><th>Category</th><th>Score</th></tr></thead><tbody>');
+    for (const c of baseline.categoryScores) {
+        parts.push(`<tr><td>${esc(c.id)}</td><td>${c.score}</td></tr>`);
+    }
+    parts.push('</tbody></table>');
+    if (comparison) {
+        parts.push('<h2>Comparison</h2><table><thead><tr><th>Metric</th><th>Baseline</th><th>Current</th><th>Δ</th><th>Direction</th></tr></thead><tbody>');
+        for (const d of comparison.deltas) {
+            parts.push(`<tr><td>${esc(d.metric)}</td><td>${d.baseline}</td><td>${d.current}</td><td>${d.delta}</td><td><span class="tag ${d.direction}">${d.direction}</span></td></tr>`);
+        }
+        parts.push('</tbody></table>');
+    }
+    parts.push('<p><em>Generated by SharkCraft quality baseline v2.</em></p>');
+    parts.push('</body></html>');
+    return parts.join('\n') + '\n';
+}

package/dist/quality-html.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Self-contained HTML rendering for the quality report. No external assets,
+ * no JS, dark-mode aware.
+ */
+import type { IQualityReport } from './quality-report.js';
+export declare function renderQualityHtml(report: IQualityReport): string;
+//# sourceMappingURL=quality-html.d.ts.map

package/dist/quality-html.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"quality-html.d.ts","sourceRoot":"","sources":["../src/quality-html.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AA2B1D,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,cAAc,GAAG,MAAM,CAwChE"}

package/dist/quality-html.js

@@ -0,0 +1,64 @@
+const CSS = `
+*{box-sizing:border-box}body{font-family:-apple-system,BlinkMacSystemFont,"Segoe UI",Roboto,sans-serif;margin:0;background:#0f1419;color:#e6e1cf;padding:2rem;line-height:1.55}
+h1,h2,h3{margin-top:1.4rem;color:#bae67e}
+table{border-collapse:collapse;width:100%;margin:.8rem 0}
+th,td{text-align:left;padding:.4rem .6rem;border-bottom:1px solid #2a3138}
+th{background:#1c2329;color:#9aa5b0}
+.badge{display:inline-block;padding:.1rem .5rem;border-radius:.25rem;font-size:.75rem;font-weight:600;text-transform:uppercase}
+.b-pass{background:#28432e;color:#bae67e}.b-warn{background:#3a3a2e;color:#ffd580}.b-fail{background:#5a1f1f;color:#ff9f9f}
+.b-skip{background:#2e3a4a;color:#7fd0ff}
+pre{background:#1c2329;padding:.8rem;border-radius:.4rem;overflow-x:auto}
+code{background:#1c2329;padding:.05rem .3rem;border-radius:.2rem}
+.score{font-size:2.2rem;font-weight:700}
+@media (prefers-color-scheme: light){body{background:#fafaf7;color:#1f2329}h1,h2,h3{color:#266a2e}th{background:#eee;color:#222}pre,code{background:#eee}}
+`;
+function escapeHtml(s) {
+    return s.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;').replace(/'/g, '&#39;');
+}
+function badgeFor(overall) {
+    if (overall === 'pass')
+        return `<span class="badge b-pass">${overall}</span>`;
+    if (overall === 'warn')
+        return `<span class="badge b-warn">${overall}</span>`;
+    return `<span class="badge b-fail">${overall}</span>`;
+}
+export function renderQualityHtml(report) {
+    const out = [];
+    out.push('<!doctype html>');
+    out.push('<html lang="en"><head><meta charset="utf-8"><title>SharkCraft quality report</title>');
+    out.push(`<style>${CSS}</style></head><body>`);
+    out.push('<h1>SharkCraft quality report</h1>');
+    out.push('<p>');
+    out.push(`<span class="score">${report.score}</span>&nbsp;${badgeFor(report.overall)}`);
+    out.push(`&nbsp;blockers <strong>${report.blockers}</strong> · warnings <strong>${report.warnings}</strong>`);
+    out.push('</p>');
+    out.push('<h2>Gates</h2>');
+    out.push('<table><thead><tr><th>Gate</th><th>Verdict</th><th>Blocking</th><th>Executed</th><th>Notes</th></tr></thead><tbody>');
+    for (const g of report.gates) {
+        const tag = g.passed ? 'b-pass' : g.blocking ? 'b-fail' : 'b-warn';
+        const verdict = g.passed ? 'pass' : g.blocking ? 'fail' : 'warn';
+        out.push(`<tr><td><code>${escapeHtml(g.id)}</code> — ${escapeHtml(g.label)}</td>` +
+            `<td><span class="badge ${tag}">${verdict}</span></td>` +
+            `<td>${g.blocking ? 'yes' : 'no'}</td>` +
+            `<td>${g.executed ? 'yes' : `<span class="badge b-skip">skipped</span>`}</td>` +
+            `<td>${g.notes.map(escapeHtml).join('<br>')}</td></tr>`);
+    }
+    out.push('</tbody></table>');
+    if (report.drift) {
+        out.push('<h2>Drift</h2>');
+        const counts = report.drift.counts ?? {};
+        out.push('<table><tbody>');
+        for (const [k, v] of Object.entries(counts)) {
+            out.push(`<tr><th>${escapeHtml(k)}</th><td>${v}</td></tr>`);
+        }
+        out.push('</tbody></table>');
+    }
+    if (report.nextRecommendations.length > 0) {
+        out.push('<h2>Next recommendations</h2><ul>');
+        for (const r of report.nextRecommendations)
+            out.push(`<li>${escapeHtml(r)}</li>`);
+        out.push('</ul>');
+    }
+    out.push('</body></html>');
+    return out.join('\n') + '\n';
+}

package/dist/quality-report.d.ts

@@ -0,0 +1,49 @@
+import { type IDriftReport } from './drift.js';
+import type { ISharkcraftInspection } from './sharkcraft-inspector.js';
+export interface IQualityGateResult {
+    id: string;
+    label: string;
+    passed: boolean;
+    blocking: boolean;
+    /** When true, the gate would normally run a shell command. MCP skips these. */
+    runsShell: boolean;
+    /** Whether the gate was actually executed in this run (false ⇒ skipped). */
+    executed: boolean;
+    notes: readonly string[];
+    data?: Record<string, unknown>;
+}
+export interface IQualityReport {
+    overall: 'pass' | 'fail' | 'warn';
+    blockers: number;
+    warnings: number;
+    score: number;
+    gates: readonly IQualityGateResult[];
+    nextRecommendations: readonly string[];
+    /** Drift report attached when the drift gate ran. */
+    drift?: IDriftReport;
+}
+export interface IQualityConfig {
+    minReadiness?: number;
+    requireBoundaryClean?: boolean;
+    requireDriftClean?: boolean;
+    requireAgentTests?: boolean;
+    requireContextTests?: boolean;
+    requirePackSignatures?: boolean;
+}
+export interface IBuildQualityReportInput {
+    inspection: ISharkcraftInspection;
+    config: IQualityConfig;
+    strict?: boolean;
+    /**
+     * When true, skip gates whose `runsShell` would be true and record them as
+     * `executed: false` with a note pointing to the CLI command. Used by the MCP
+     * read-only path so the server never executes shell commands.
+     */
+    skipShell?: boolean;
+}
+/**
+ * Build a quality report from an inspection. Pure orchestration over the
+ * existing inspector helpers — no IO outside what those helpers already do.
+ */
+export declare function buildQualityReport(input: IBuildQualityReportInput): Promise<IQualityReport>;
+//# sourceMappingURL=quality-report.d.ts.map

package/dist/quality-report.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"quality-report.d.ts","sourceRoot":"","sources":["../src/quality-report.ts"],"names":[],"mappings":"AAOA,OAAO,EAAoB,KAAK,YAAY,EAAE,MAAM,YAAY,CAAC;AAUjE,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,2BAA2B,CAAC;AAEvE,MAAM,WAAW,kBAAkB;IACjC,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,OAAO,CAAC;IAChB,QAAQ,EAAE,OAAO,CAAC;IAClB,+EAA+E;IAC/E,SAAS,EAAE,OAAO,CAAC;IACnB,4EAA4E;IAC5E,QAAQ,EAAE,OAAO,CAAC;IAClB,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;IACzB,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAChC;AAED,MAAM,WAAW,cAAc;IAC7B,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,CAAC;IAClC,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,SAAS,kBAAkB,EAAE,CAAC;IACrC,mBAAmB,EAAE,SAAS,MAAM,EAAE,CAAC;IACvC,qDAAqD;IACrD,KAAK,CAAC,EAAE,YAAY,CAAC;CACtB;AAED,MAAM,WAAW,cAAc;IAC7B,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B,qBAAqB,CAAC,EAAE,OAAO,CAAC;CACjC;AAED,MAAM,WAAW,wBAAwB;IACvC,UAAU,EAAE,qBAAqB,CAAC;IAClC,MAAM,EAAE,cAAc,CAAC;IACvB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB;;;;OAIG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAED;;;GAGG;AACH,wBAAsB,kBAAkB,CACtC,KAAK,EAAE,wBAAwB,GAC9B,OAAO,CAAC,cAAc,CAAC,CA0OzB"}