@shrkcrft/inspector 0.1.0-alpha.1

package/dist/changed-preflight.d.ts

@@ -0,0 +1,59 @@
+export declare const CHANGED_PREFLIGHT_SCHEMA = "sharkcraft.changed-preflight/v1";
+export declare enum PreflightProfile {
+    Quick = "quick",
+    Standard = "standard",
+    Strict = "strict"
+}
+export declare enum PreflightAction {
+    Run = "run",
+    Skip = "skip",
+    Recommend = "recommend"
+}
+export interface IPreflightGate {
+    readonly id: string;
+    readonly title: string;
+    readonly command: string;
+    readonly action: PreflightAction;
+    readonly reason: string;
+    /** When `run`, whether the operator may pass `--canFail`-style continue flags. */
+    readonly canFail: boolean;
+}
+export interface IPreflightVerdict {
+    readonly action: 'ok' | 'attention';
+    readonly summary: string;
+}
+export interface IChangedPreflightPlan {
+    readonly schema: typeof CHANGED_PREFLIGHT_SCHEMA;
+    readonly profile: PreflightProfile;
+    readonly changedFiles: ReadonlyArray<string>;
+    readonly classifications: IChangedFilesClassification;
+    readonly gates: ReadonlyArray<IPreflightGate>;
+    readonly verdict: IPreflightVerdict;
+    readonly explanations: ReadonlyArray<string>;
+}
+export interface IChangedFilesClassification {
+    readonly anyEngineSource: boolean;
+    readonly anyPackages: boolean;
+    readonly anyTests: boolean;
+    readonly anySharkcraftAssets: boolean;
+    readonly anyKnowledgeRefs: boolean;
+    readonly anyPackContrib: boolean;
+    readonly anyTemplatesOrPacks: boolean;
+    readonly anyCliCatalog: boolean;
+    readonly anyMcpOrTools: boolean;
+    readonly anySafetyAreas: boolean;
+    readonly anyConfigOrDocs: boolean;
+}
+/**
+ * Build a preflight plan from the changed-file set and profile.
+ *
+ * The planner does NOT execute anything; it returns the gate list. CLI
+ * callers decide whether to spawn them.
+ */
+export declare function planChangedPreflight(options: {
+    readonly projectRoot: string;
+    readonly changedFiles: ReadonlyArray<string>;
+    readonly profile?: PreflightProfile;
+}): IChangedPreflightPlan;
+export declare function renderChangedPreflightText(plan: IChangedPreflightPlan): string;
+//# sourceMappingURL=changed-preflight.d.ts.map

package/dist/changed-preflight.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"changed-preflight.d.ts","sourceRoot":"","sources":["../src/changed-preflight.ts"],"names":[],"mappings":"AAeA,eAAO,MAAM,wBAAwB,oCAAoC,CAAC;AAE1E,oBAAY,gBAAgB;IAC1B,KAAK,UAAU;IACf,QAAQ,aAAa;IACrB,MAAM,WAAW;CAClB;AAED,oBAAY,eAAe;IACzB,GAAG,QAAQ;IACX,IAAI,SAAS;IACb,SAAS,cAAc;CACxB;AAED,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,MAAM,EAAE,eAAe,CAAC;IACjC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,kFAAkF;IAClF,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;CAC3B;AAED,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,MAAM,EAAE,IAAI,GAAG,WAAW,CAAC;IACpC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAED,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,MAAM,EAAE,OAAO,wBAAwB,CAAC;IACjD,QAAQ,CAAC,OAAO,EAAE,gBAAgB,CAAC;IACnC,QAAQ,CAAC,YAAY,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IAC7C,QAAQ,CAAC,eAAe,EAAE,2BAA2B,CAAC;IACtD,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAC,cAAc,CAAC,CAAC;IAC9C,QAAQ,CAAC,OAAO,EAAE,iBAAiB,CAAC;IACpC,QAAQ,CAAC,YAAY,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;CAC9C;AAED,MAAM,WAAW,2BAA2B;IAC1C,QAAQ,CAAC,eAAe,EAAE,OAAO,CAAC;IAClC,QAAQ,CAAC,WAAW,EAAE,OAAO,CAAC;IAC9B,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;IAC3B,QAAQ,CAAC,mBAAmB,EAAE,OAAO,CAAC;IACtC,QAAQ,CAAC,gBAAgB,EAAE,OAAO,CAAC;IACnC,QAAQ,CAAC,cAAc,EAAE,OAAO,CAAC;IACjC,QAAQ,CAAC,mBAAmB,EAAE,OAAO,CAAC;IACtC,QAAQ,CAAC,aAAa,EAAE,OAAO,CAAC;IAChC,QAAQ,CAAC,aAAa,EAAE,OAAO,CAAC;IAChC,QAAQ,CAAC,cAAc,EAAE,OAAO,CAAC;IACjC,QAAQ,CAAC,eAAe,EAAE,OAAO,CAAC;CACnC;AA+CD;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE;IAC5C,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,YAAY,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IAC7C,QAAQ,CAAC,OAAO,CAAC,EAAE,gBAAgB,CAAC;CACrC,GAAG,qBAAqB,CA8QxB;AAED,wBAAgB,0BAA0B,CAAC,IAAI,EAAE,qBAAqB,GAAG,MAAM,CAiB9E"}

package/dist/changed-preflight.js

@@ -0,0 +1,358 @@
+/**
+ * Changed-only preflight planner.
+ *
+ * Given a workspace + a changed-file set, decide which read-only gates a
+ * preflight run should execute. The output is pure data (a list of
+ * `IPreflightGate` rows tagged `run / skip / recommend`) plus an
+ * `IPreflightVerdict`. Actual execution lives in the CLI command — this
+ * module never spawns processes.
+ *
+ * Gates are selected from changed-file shape, not from configuration. The
+ * planner is intentionally conservative: a gate's `skip` decision is always
+ * accompanied by a reason so the operator can see what was elided.
+ */
+import * as nodePath from 'node:path';
+export const CHANGED_PREFLIGHT_SCHEMA = 'sharkcraft.changed-preflight/v1';
+export var PreflightProfile;
+(function (PreflightProfile) {
+    PreflightProfile["Quick"] = "quick";
+    PreflightProfile["Standard"] = "standard";
+    PreflightProfile["Strict"] = "strict";
+})(PreflightProfile || (PreflightProfile = {}));
+export var PreflightAction;
+(function (PreflightAction) {
+    PreflightAction["Run"] = "run";
+    PreflightAction["Skip"] = "skip";
+    PreflightAction["Recommend"] = "recommend";
+})(PreflightAction || (PreflightAction = {}));
+function classifyChangedFiles(files) {
+    const norm = files.map((f) => f.replace(/\\/g, '/'));
+    const match = (re) => norm.some((p) => re.test(p));
+    const anyEngineSource = match(/^packages\/[^/]+\/src\//);
+    const anyPackages = match(/^packages\//);
+    const anyTests = match(/__tests__\/|\.test\.ts$|e2e\//);
+    const anySharkcraftAssets = match(/^sharkcraft\//);
+    const anyKnowledgeRefs = match(/^sharkcraft\/knowledge\.ts$/) || match(/^sharkcraft\/knowledge\//);
+    const anyPackContrib = match(/^packages\/[^/]+\/dist\/manifest\.json$/) ||
+        match(/^packages\/[^/]+\/package\.json$/) ||
+        match(/^packages\/[^/]+\/src\/assets\//);
+    const anyTemplatesOrPacks = match(/^sharkcraft\/templates\.ts$/) ||
+        anyPackContrib ||
+        match(/^sharkcraft\/scaffold-patterns\.ts$/);
+    const anyCliCatalog = match(/^packages\/cli\/src\/commands\//) ||
+        match(/^packages\/cli\/src\/main\.ts$/) ||
+        match(/^packages\/cli\/src\/command-/);
+    const anyMcpOrTools = match(/^packages\/mcp-server\//);
+    const anySafetyAreas = anyMcpOrTools ||
+        match(/^packages\/.*safety/) ||
+        match(/^packages\/generator\//) ||
+        match(/^packages\/cli\/src\/commands\/apply\.command\.ts$/) ||
+        match(/^packages\/cli\/src\/commands\/contract.*\.ts$/);
+    const anyConfigOrDocs = match(/^docs\//) || match(/^CHANGELOG\.md$/);
+    return {
+        anyEngineSource,
+        anyPackages,
+        anyTests,
+        anySharkcraftAssets,
+        anyKnowledgeRefs,
+        anyPackContrib,
+        anyTemplatesOrPacks,
+        anyCliCatalog,
+        anyMcpOrTools,
+        anySafetyAreas,
+        anyConfigOrDocs,
+    };
+}
+/**
+ * Build a preflight plan from the changed-file set and profile.
+ *
+ * The planner does NOT execute anything; it returns the gate list. CLI
+ * callers decide whether to spawn them.
+ */
+export function planChangedPreflight(options) {
+    const profile = options.profile ?? PreflightProfile.Standard;
+    const cls = classifyChangedFiles(options.changedFiles);
+    const explanations = [];
+    const gates = [];
+    // 1) Boundary check — needed when engine src changed.
+    if (cls.anyEngineSource) {
+        gates.push({
+            id: 'boundaries',
+            title: 'Layer boundaries (changed-only)',
+            command: 'shrk check boundaries --changed-only --json',
+            action: PreflightAction.Run,
+            reason: 'engine source files changed',
+            canFail: false,
+        });
+    }
+    else {
+        gates.push({
+            id: 'boundaries',
+            title: 'Layer boundaries (changed-only)',
+            command: 'shrk check boundaries --changed-only',
+            action: PreflightAction.Skip,
+            reason: 'no engine src changed',
+            canFail: true,
+        });
+    }
+    // 2) Import hygiene — needed when engine src changed.
+    if (cls.anyEngineSource) {
+        gates.push({
+            id: 'imports',
+            title: 'Import hygiene (changed-only)',
+            command: 'shrk check imports --changed-only --json',
+            action: PreflightAction.Run,
+            reason: 'engine source files changed',
+            canFail: false,
+        });
+    }
+    else {
+        gates.push({
+            id: 'imports',
+            title: 'Import hygiene (changed-only)',
+            command: 'shrk check imports --changed-only',
+            action: PreflightAction.Skip,
+            reason: 'no engine src changed',
+            canFail: true,
+        });
+    }
+    // 3) Knowledge stale check.
+    if (cls.anyKnowledgeRefs || cls.anyEngineSource) {
+        gates.push({
+            id: 'knowledge-stale',
+            title: 'Knowledge stale check',
+            command: 'shrk knowledge stale-check --ci',
+            action: PreflightAction.Run,
+            reason: 'knowledge or referenced source changed',
+            canFail: true,
+        });
+    }
+    else {
+        gates.push({
+            id: 'knowledge-stale',
+            title: 'Knowledge stale check',
+            command: 'shrk knowledge stale-check',
+            action: PreflightAction.Skip,
+            reason: 'no knowledge or source changes',
+            canFail: true,
+        });
+    }
+    // 4) Template drift.
+    if (cls.anyTemplatesOrPacks) {
+        gates.push({
+            id: 'templates-drift',
+            title: 'Template drift',
+            command: 'shrk templates drift --json',
+            action: PreflightAction.Run,
+            reason: 'templates or pack contributions changed',
+            canFail: true,
+        });
+    }
+    else {
+        gates.push({
+            id: 'templates-drift',
+            title: 'Template drift',
+            command: 'shrk templates drift',
+            action: PreflightAction.Skip,
+            reason: 'no template or pack contribution changes',
+            canFail: true,
+        });
+    }
+    // 5) Self-config doctor.
+    if (cls.anySharkcraftAssets || cls.anyPackContrib) {
+        gates.push({
+            id: 'self-config-doctor',
+            title: 'Self-config doctor v2',
+            command: 'shrk self-config doctor --strict',
+            action: PreflightAction.Run,
+            reason: 'sharkcraft/ assets or pack contributions changed',
+            canFail: false,
+        });
+    }
+    else {
+        gates.push({
+            id: 'self-config-doctor',
+            title: 'Self-config doctor v2',
+            command: 'shrk self-config doctor',
+            action: PreflightAction.Skip,
+            reason: 'no self-config changes',
+            canFail: true,
+        });
+    }
+    // 6) Pack signature status — when any pack files changed.
+    if (cls.anyPackContrib) {
+        gates.push({
+            id: 'packs-signature',
+            title: 'Pack signature freshness',
+            command: 'shrk packs signature-status --format json',
+            action: PreflightAction.Run,
+            reason: 'pack contributions changed — re-check signatures',
+            canFail: true,
+        });
+    }
+    else {
+        gates.push({
+            id: 'packs-signature',
+            title: 'Pack signature freshness',
+            command: 'shrk packs signature-status',
+            action: PreflightAction.Skip,
+            reason: 'no pack contribution changes',
+            canFail: true,
+        });
+    }
+    // 7) Commands doctor — when CLI/catalog changed.
+    if (cls.anyCliCatalog) {
+        gates.push({
+            id: 'commands-doctor',
+            title: 'CLI commands doctor',
+            command: 'shrk commands doctor --json',
+            action: PreflightAction.Run,
+            reason: 'CLI / catalog files changed',
+            canFail: false,
+        });
+    }
+    else {
+        gates.push({
+            id: 'commands-doctor',
+            title: 'CLI commands doctor',
+            command: 'shrk commands doctor',
+            action: PreflightAction.Skip,
+            reason: 'no CLI / catalog changes',
+            canFail: true,
+        });
+    }
+    // 8) Safety audit (deep) — only on strict profile or safety-area changes.
+    if (cls.anySafetyAreas || profile === PreflightProfile.Strict) {
+        gates.push({
+            id: 'safety-audit-deep',
+            title: 'Safety audit (deep)',
+            command: 'shrk safety audit --deep --json',
+            action: PreflightAction.Run,
+            reason: cls.anySafetyAreas
+                ? 'MCP / generator / contract / safety files changed'
+                : 'strict profile selected',
+            canFail: false,
+        });
+    }
+    else {
+        gates.push({
+            id: 'safety-audit-deep',
+            title: 'Safety audit (deep)',
+            command: 'shrk safety audit --deep',
+            action: PreflightAction.Recommend,
+            reason: 'not strict mode and no safety-area changes — recommended only',
+            canFail: true,
+        });
+    }
+    // 9) Tests — only recommended unless strict profile.
+    if (profile === PreflightProfile.Strict && cls.anyEngineSource) {
+        gates.push({
+            id: 'tests',
+            title: 'Bun test suite (focused subset where possible)',
+            command: 'bun test',
+            action: PreflightAction.Run,
+            reason: 'strict profile + engine src changed',
+            canFail: false,
+        });
+    }
+    else if (cls.anyEngineSource || cls.anyTests) {
+        gates.push({
+            id: 'tests',
+            title: 'Bun test suite',
+            command: 'bun test',
+            action: PreflightAction.Recommend,
+            reason: 'engine src or tests changed; full suite not auto-run',
+            canFail: true,
+        });
+    }
+    else {
+        gates.push({
+            id: 'tests',
+            title: 'Bun test suite',
+            command: 'bun test',
+            action: PreflightAction.Skip,
+            reason: 'no engine src or test changes',
+            canFail: true,
+        });
+    }
+    // 10) Typecheck — always recommended on the quick profile; run on standard+.
+    if (cls.anyEngineSource) {
+        if (profile === PreflightProfile.Quick) {
+            gates.push({
+                id: 'typecheck',
+                title: 'TypeScript --noEmit',
+                command: 'bun x tsc -p tsconfig.base.json --noEmit',
+                action: PreflightAction.Recommend,
+                reason: 'engine src changed; not auto-run on quick profile',
+                canFail: true,
+            });
+        }
+        else {
+            gates.push({
+                id: 'typecheck',
+                title: 'TypeScript --noEmit',
+                command: 'bun x tsc -p tsconfig.base.json --noEmit',
+                action: PreflightAction.Run,
+                reason: 'engine src changed',
+                canFail: false,
+            });
+        }
+    }
+    else {
+        gates.push({
+            id: 'typecheck',
+            title: 'TypeScript --noEmit',
+            command: 'bun x tsc -p tsconfig.base.json --noEmit',
+            action: PreflightAction.Skip,
+            reason: 'no engine src changed',
+            canFail: true,
+        });
+    }
+    // Profile-specific tweaks.
+    if (profile === PreflightProfile.Quick) {
+        // Quick: drop "Recommend" entries to "Skip" so the operator has a tight loop.
+        explanations.push('quick profile: gates flagged Recommend are not surfaced as actionable; pass --profile standard for the fuller loop.');
+    }
+    else if (profile === PreflightProfile.Strict) {
+        explanations.push('strict profile: tests + safety audit run on engine-affecting changes.');
+    }
+    else {
+        explanations.push('standard profile: type / boundary / hygiene / self-config gates run; tests recommended.');
+    }
+    const wouldRun = gates.filter((g) => g.action === PreflightAction.Run);
+    const wouldSkip = gates.filter((g) => g.action === PreflightAction.Skip);
+    const recommended = gates.filter((g) => g.action === PreflightAction.Recommend);
+    const verdict = {
+        action: wouldRun.length > 0 ? 'attention' : 'ok',
+        summary: `would run ${wouldRun.length}, skip ${wouldSkip.length}, recommend ${recommended.length}`,
+    };
+    void nodePath;
+    return {
+        schema: CHANGED_PREFLIGHT_SCHEMA,
+        profile,
+        changedFiles: options.changedFiles,
+        classifications: cls,
+        gates,
+        verdict,
+        explanations,
+    };
+}
+export function renderChangedPreflightText(plan) {
+    const lines = [];
+    lines.push('=== Changed-only preflight plan ===');
+    lines.push(`  profile        ${plan.profile}`);
+    lines.push(`  changed files  ${plan.changedFiles.length}`);
+    lines.push(`  verdict        ${plan.verdict.action} (${plan.verdict.summary})`);
+    lines.push('');
+    for (const g of plan.gates) {
+        lines.push(`  [${g.action.padEnd(9)}] ${g.id.padEnd(22)} ${g.command}`);
+        lines.push(`              reason: ${g.reason}`);
+    }
+    if (plan.explanations.length > 0) {
+        lines.push('');
+        lines.push('Notes:');
+        for (const n of plan.explanations)
+            lines.push(`  • ${n}`);
+    }
+    return lines.join('\n') + '\n';
+}

package/dist/changed-scope.d.ts

@@ -0,0 +1,112 @@
+/**
+ * Changed-scope quality model v2.
+ *
+ * Generalised classification of any finding (boundary violation, policy
+ * failure, drift entry, quality issue, doctor warning…) against a set of
+ * changed files plus an optional baseline.
+ *
+ * Each finding falls into one of seven buckets:
+ *
+ *   new-in-changed-file        — finding lives in a changed file and was NOT
+ *                                in the baseline.
+ *   existing-touched           — finding exists in baseline AND the finding's
+ *                                file is in the changed set.
+ *   existing-untouched-hidden  — finding exists in baseline AND finding's file
+ *                                is not changed; suppressed from the
+ *                                "introduced by this change" view.
+ *   resolved                   — finding existed in baseline but is no longer
+ *                                present in the current result.
+ *   unknown                    — finding has no file path, so we cannot bucket
+ *                                it against changed files.
+ *   unchanged                  — baseline and current both report this finding
+ *                                in an unchanged file. Same as
+ *                                existing-untouched-hidden but logically
+ *                                preserved as "no change".
+ *   out-of-scope               — finding lives outside any explicit scope the
+ *                                caller passed (e.g. a non-relevant package).
+ *
+ * Inputs are pure data — this module does not run git, does not read files,
+ * does not call out to language servers. Callers pre-compute the changed-file
+ * set with `resolveChangedFiles` from `boundaries-changed-only.ts` (or pass
+ * an explicit list), then feed everything in.
+ *
+ * Schema: sharkcraft.changed-scope/v1
+ */
+export declare const CHANGED_SCOPE_SCHEMA = "sharkcraft.changed-scope/v1";
+export declare enum ChangedFindingBucket {
+    NewInChangedFile = "new-in-changed-file",
+    ExistingTouched = "existing-touched",
+    ExistingUntouchedHidden = "existing-untouched-hidden",
+    Resolved = "resolved",
+    Unknown = "unknown",
+    Unchanged = "unchanged",
+    OutOfScope = "out-of-scope"
+}
+export interface IChangedScopeFinding {
+    /**
+     * Stable identity key: code + file + extra qualifier. Used to detect
+     * whether the same finding existed in the baseline.
+     */
+    key: string;
+    /** Optional file path the finding originates from. */
+    file?: string;
+    /** Optional ruleId / code category for grouping. */
+    code?: string;
+    /** Optional human-readable severity, surfaced verbatim. */
+    severity?: string;
+    /** Optional message for rendering. */
+    message?: string;
+    /** Arbitrary opaque payload preserved on the way through. */
+    data?: Readonly<Record<string, unknown>>;
+}
+export interface IChangedScopeClassifyOptions {
+    /** Project root for path normalisation (absolute → relative). */
+    projectRoot: string;
+    /** Current run findings. */
+    current: ReadonlyArray<IChangedScopeFinding>;
+    /** Optional baseline findings (same shape). */
+    baseline?: ReadonlyArray<IChangedScopeFinding>;
+    /** Changed-file set, project-relative ('/'-normalised). */
+    changedFiles: ReadonlyArray<string>;
+    /**
+     * Optional explicit scope list. When set, files outside it become
+     * `out-of-scope`. Empty list means "no scope restriction".
+     */
+    scopeFiles?: ReadonlyArray<string>;
+}
+export interface IChangedScopeClassifiedFinding {
+    finding: IChangedScopeFinding;
+    bucket: ChangedFindingBucket;
+}
+export interface IChangedScopeClassification {
+    schema: typeof CHANGED_SCOPE_SCHEMA;
+    changedFiles: ReadonlyArray<string>;
+    classified: ReadonlyArray<IChangedScopeClassifiedFinding>;
+    counts: {
+        newInChangedFile: number;
+        existingTouched: number;
+        existingUntouchedHidden: number;
+        resolved: number;
+        unknown: number;
+        unchanged: number;
+        outOfScope: number;
+    };
+    /** Findings whose bucket is `new-in-changed-file` (most actionable). */
+    newIssues: ReadonlyArray<IChangedScopeFinding>;
+    /** Findings whose bucket is `existing-touched`. */
+    existingTouched: ReadonlyArray<IChangedScopeFinding>;
+    /**
+     * Existing findings hidden from the headline view but still reachable
+     * by callers that want them.
+     */
+    hiddenBaseline: ReadonlyArray<IChangedScopeFinding>;
+    /** Findings that were in the baseline but no longer appear. */
+    resolved: ReadonlyArray<IChangedScopeFinding>;
+}
+export declare function classifyChangedScope(opts: IChangedScopeClassifyOptions): IChangedScopeClassification;
+/**
+ * Convenience helper for callers that want the headline numbers in
+ * one line of text.
+ */
+export declare function summariseChangedScope(classification: IChangedScopeClassification): string;
+//# sourceMappingURL=changed-scope.d.ts.map

package/dist/changed-scope.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"changed-scope.d.ts","sourceRoot":"","sources":["../src/changed-scope.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAIH,eAAO,MAAM,oBAAoB,gCAAgC,CAAC;AAElE,oBAAY,oBAAoB;IAC9B,gBAAgB,wBAAwB;IACxC,eAAe,qBAAqB;IACpC,uBAAuB,8BAA8B;IACrD,QAAQ,aAAa;IACrB,OAAO,YAAY;IACnB,SAAS,cAAc;IACvB,UAAU,iBAAiB;CAC5B;AAED,MAAM,WAAW,oBAAoB;IACnC;;;OAGG;IACH,GAAG,EAAE,MAAM,CAAC;IACZ,sDAAsD;IACtD,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,oDAAoD;IACpD,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,2DAA2D;IAC3D,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,sCAAsC;IACtC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,6DAA6D;IAC7D,IAAI,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;CAC1C;AAED,MAAM,WAAW,4BAA4B;IAC3C,iEAAiE;IACjE,WAAW,EAAE,MAAM,CAAC;IACpB,4BAA4B;IAC5B,OAAO,EAAE,aAAa,CAAC,oBAAoB,CAAC,CAAC;IAC7C,+CAA+C;IAC/C,QAAQ,CAAC,EAAE,aAAa,CAAC,oBAAoB,CAAC,CAAC;IAC/C,2DAA2D;IAC3D,YAAY,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IACpC;;;OAGG;IACH,UAAU,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;CACpC;AAED,MAAM,WAAW,8BAA8B;IAC7C,OAAO,EAAE,oBAAoB,CAAC;IAC9B,MAAM,EAAE,oBAAoB,CAAC;CAC9B;AAED,MAAM,WAAW,2BAA2B;IAC1C,MAAM,EAAE,OAAO,oBAAoB,CAAC;IACpC,YAAY,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IACpC,UAAU,EAAE,aAAa,CAAC,8BAA8B,CAAC,CAAC;IAC1D,MAAM,EAAE;QACN,gBAAgB,EAAE,MAAM,CAAC;QACzB,eAAe,EAAE,MAAM,CAAC;QACxB,uBAAuB,EAAE,MAAM,CAAC;QAChC,QAAQ,EAAE,MAAM,CAAC;QACjB,OAAO,EAAE,MAAM,CAAC;QAChB,SAAS,EAAE,MAAM,CAAC;QAClB,UAAU,EAAE,MAAM,CAAC;KACpB,CAAC;IACF,wEAAwE;IACxE,SAAS,EAAE,aAAa,CAAC,oBAAoB,CAAC,CAAC;IAC/C,mDAAmD;IACnD,eAAe,EAAE,aAAa,CAAC,oBAAoB,CAAC,CAAC;IACrD;;;OAGG;IACH,cAAc,EAAE,aAAa,CAAC,oBAAoB,CAAC,CAAC;IACpD,+DAA+D;IAC/D,QAAQ,EAAE,aAAa,CAAC,oBAAoB,CAAC,CAAC;CAC/C;AAoBD,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,4BAA4B,GACjC,2BAA2B,CAsG7B;AAED;;;GAGG;AACH,wBAAgB,qBAAqB,CACnC,cAAc,EAAE,2BAA2B,GAC1C,MAAM,CAQR"}