@oscharko-dev/keiko-quality-intelligence 0.2.0

package/dist/domain/figma/visionAugmentation.js

@@ -0,0 +1,48 @@
+// Vision augmentation merge for the Figma-snapshot QI source (Epic #750, Issue #754).
+//
+// Capability-routed vision (a multimodal model reading the rendered screen, selected via #810) may
+// add image-derived semantics the structural IR cannot reveal. This module enforces the load-bearing
+// invariant STRUCTURALLY: vision augments, it never OVERRIDES the IR. The deterministic baseline
+// text is preserved byte-for-byte and the vision hints are appended as a clearly-labelled, separate,
+// additive section — there is no code path by which a vision hint can mutate or remove a baseline
+// line. With no hints (no multimodal capability, or a garbage/thrown result the caller drops to an
+// empty list), the output IS the baseline text unchanged.
+const MAX_HINTS = 24;
+const MAX_HINT_CHARS = 500;
+const VISION_SECTION_HEADER = "Vision-derived semantic hints (additive — cross-check against the structural baseline above; " +
+    "never overrides it):";
+// Drop empties and over-long entries, normalise whitespace, and de-duplicate while preserving order.
+// A model that returns garbage (empty strings, an over-long blob) contributes nothing rather than
+// corrupting the atom.
+function sanitiseHints(hints) {
+    const seen = new Set();
+    const out = [];
+    for (const raw of hints) {
+        if (typeof raw !== "string")
+            continue;
+        const trimmed = raw.replace(/\s+/gu, " ").trim();
+        if (trimmed.length === 0 || trimmed.length > MAX_HINT_CHARS)
+            continue;
+        if (seen.has(trimmed))
+            continue;
+        seen.add(trimmed);
+        out.push(trimmed);
+        if (out.length >= MAX_HINTS)
+            break;
+    }
+    return out;
+}
+/**
+ * Merge vision hints into the deterministic baseline text WITHOUT overriding it. The baseline text is
+ * always the prefix of the result; hints (if any survive sanitisation) follow under a labelled
+ * section. When no hint survives, the result text is identical to `baselineText`, so the structural
+ * baseline always ships and the vision contribution is provably additive.
+ */
+export function mergeVisionHints(baselineText, hints) {
+    const clean = sanitiseHints(hints);
+    if (clean.length === 0) {
+        return { text: baselineText, augmentedCount: 0 };
+    }
+    const section = [VISION_SECTION_HEADER, ...clean.map((hint) => `- ${hint}`)].join("\n");
+    return { text: `${baselineText}\n\n${section}`, augmentedCount: clean.length };
+}

package/dist/domain/intentDerivation.d.ts

@@ -0,0 +1,21 @@
+import type { QualityIntelligence } from "@oscharko-dev/keiko-contracts";
+import type { PolicyProfile } from "./policyProfile.js";
+export interface IntentSummary {
+    /** Distinct themes (high-level subject buckets) the envelopes touch. */
+    readonly themes: readonly string[];
+    /** Candidate requirement phrases extracted from envelope display labels. */
+    readonly requirementCandidates: readonly string[];
+    /** Lower-cased risk-shaped keywords spotted across envelope display labels. */
+    readonly riskHints: readonly string[];
+    /** Derived priority bucket, biased by the policy profile. */
+    readonly priorityHint: QualityIntelligence.QualityIntelligencePriority | "unknown";
+}
+/**
+ * Derive a deterministic `IntentSummary` from the supplied envelopes. Returns
+ * an empty summary when the input list is empty.
+ *
+ * @param envelopes Source envelopes (browser-safe display labels only).
+ * @param profile Policy profile. Defaults to `regressionDefault`.
+ */
+export declare const deriveIntent: (envelopes: readonly QualityIntelligence.QualityIntelligenceSourceEnvelope[], profile?: PolicyProfile) => IntentSummary;
+//# sourceMappingURL=intentDerivation.d.ts.map

package/dist/domain/intentDerivation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"intentDerivation.d.ts","sourceRoot":"","sources":["../../src/domain/intentDerivation.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,+BAA+B,CAAC;AAGzE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAGxD,MAAM,WAAW,aAAa;IAC5B,wEAAwE;IACxE,QAAQ,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC;IACnC,4EAA4E;IAC5E,QAAQ,CAAC,qBAAqB,EAAE,SAAS,MAAM,EAAE,CAAC;IAClD,+EAA+E;IAC/E,QAAQ,CAAC,SAAS,EAAE,SAAS,MAAM,EAAE,CAAC;IACtC,6DAA6D;IAC7D,QAAQ,CAAC,YAAY,EAAE,mBAAmB,CAAC,2BAA2B,GAAG,SAAS,CAAC;CACpF;AA+ED;;;;;;GAMG;AACH,eAAO,MAAM,YAAY,GACvB,WAAW,SAAS,mBAAmB,CAAC,iCAAiC,EAAE,EAC3E,UAAS,aAAiC,KACzC,aA2CF,CAAC"}

package/dist/domain/intentDerivation.js

@@ -0,0 +1,126 @@
+// Quality Intelligence intent derivation (Epic #270, Issue #272).
+//
+// Derives a structured `IntentSummary` from a list of source envelopes using
+// deterministic lexical heuristics only — no embeddings, no model calls.
+//
+// Structurally inspired by
+// Test Intelligence reference (TI) packages/core-engine/src/intent-derivation.ts
+// (deriveBusinessTestIntentIr), but rewritten to consume the Keiko contracts
+// surface. The TI reference performs the same role (turn structured input
+// into a list of business intents) but reaches into UI-specific node trees;
+// our Keiko port stays envelope-shaped and policy-driven.
+import { isMeaningfulText, normaliseText } from "./assertions.js";
+import { regressionDefault } from "./policyProfile.js";
+const REQUIREMENT_VERB_PATTERNS = [
+    /\b(must|shall|should|cannot|may not|may|will)\b/iu,
+    /\b(verify|ensure|confirm|reject|prevent|allow|deny)\b/iu,
+];
+const THEME_SEPARATOR = /[\s–—:;|/,.()[\]{}]+/u;
+const extractThemes = (label) => {
+    const normalised = normaliseText(label);
+    if (normalised.length === 0) {
+        return [];
+    }
+    const tokens = normalised.split(THEME_SEPARATOR);
+    const themes = new Set();
+    for (const token of tokens) {
+        const lowered = token.toLowerCase();
+        if (lowered.length < 3) {
+            continue;
+        }
+        themes.add(lowered);
+    }
+    return Array.from(themes).sort();
+};
+const lookLikeRequirementPhrase = (text) => {
+    for (const pattern of REQUIREMENT_VERB_PATTERNS) {
+        if (pattern.test(text)) {
+            return true;
+        }
+    }
+    return false;
+};
+const detectRiskHints = (text, profile) => {
+    const lowered = text.toLowerCase();
+    const hits = new Set();
+    for (const keywords of Object.values(profile.riskKeywords)) {
+        for (const keyword of keywords) {
+            if (lowered.includes(keyword)) {
+                hits.add(keyword);
+            }
+        }
+    }
+    return Array.from(hits).sort();
+};
+const derivePriority = (text, profile) => {
+    if (text.length === 0) {
+        return "unknown";
+    }
+    const lowered = text.toLowerCase();
+    const priorityBuckets = [
+        "P0",
+        "P1",
+        "P2",
+        "P3",
+    ];
+    for (let bucketIndex = 0; bucketIndex < profile.priorityKeywords.length; bucketIndex += 1) {
+        const keywords = profile.priorityKeywords[bucketIndex] ?? [];
+        for (const keyword of keywords) {
+            if (lowered.includes(keyword)) {
+                const mapped = priorityBuckets[bucketIndex];
+                if (mapped !== undefined) {
+                    return mapped;
+                }
+            }
+        }
+    }
+    return profile.defaultPriority;
+};
+const compareLowercase = (left, right) => left < right ? -1 : left > right ? 1 : 0;
+/**
+ * Derive a deterministic `IntentSummary` from the supplied envelopes. Returns
+ * an empty summary when the input list is empty.
+ *
+ * @param envelopes Source envelopes (browser-safe display labels only).
+ * @param profile Policy profile. Defaults to `regressionDefault`.
+ */
+export const deriveIntent = (envelopes, profile = regressionDefault) => {
+    if (envelopes.length === 0) {
+        return Object.freeze({
+            themes: Object.freeze([]),
+            requirementCandidates: Object.freeze([]),
+            riskHints: Object.freeze([]),
+            priorityHint: "unknown",
+        });
+    }
+    const themes = new Set();
+    const requirements = new Set();
+    const risks = new Set();
+    let aggregateLowered = "";
+    for (const envelope of envelopes) {
+        const normalised = normaliseText(envelope.displayLabel);
+        if (!isMeaningfulText(normalised)) {
+            continue;
+        }
+        for (const theme of extractThemes(normalised)) {
+            themes.add(theme);
+        }
+        if (lookLikeRequirementPhrase(normalised)) {
+            requirements.add(normalised);
+        }
+        for (const hint of detectRiskHints(normalised, profile)) {
+            risks.add(hint);
+        }
+        aggregateLowered =
+            aggregateLowered.length === 0
+                ? normalised.toLowerCase()
+                : `${aggregateLowered}\n${normalised.toLowerCase()}`;
+    }
+    const priorityHint = derivePriority(aggregateLowered, profile);
+    return Object.freeze({
+        themes: Object.freeze(Array.from(themes).sort(compareLowercase)),
+        requirementCandidates: Object.freeze(Array.from(requirements).sort(compareLowercase)),
+        riskHints: Object.freeze(Array.from(risks).sort(compareLowercase)),
+        priorityHint,
+    });
+};

package/dist/domain/policyProfile.d.ts

@@ -0,0 +1,37 @@
+import type { QualityIntelligence } from "@oscharko-dev/keiko-contracts";
+export interface PolicyProfile {
+    /** Stable identifier, used by callers to attribute outputs. */
+    readonly id: string;
+    /** Display-only label. */
+    readonly displayLabel: string;
+    /**
+     * Lower-cased keywords that, when present in source envelopes or atoms,
+     * bias the derived intent's priority toward the head of this list.
+     * Ordering implies severity: index 0 is the highest-priority bucket.
+     */
+    readonly priorityKeywords: readonly (readonly string[])[];
+    /**
+     * Lower-cased keywords that signal a risk class. The first matching class
+     * (in the order risk-classes are enumerated below) wins. Pure heuristic.
+     */
+    readonly riskKeywords: Readonly<Record<QualityIntelligence.QualityIntelligenceRiskClass, readonly string[]>>;
+    /** Default risk class when no risk keyword matches. */
+    readonly defaultRiskClass: QualityIntelligence.QualityIntelligenceRiskClass;
+    /** Default priority when no priority keyword matches. */
+    readonly defaultPriority: QualityIntelligence.QualityIntelligencePriority;
+}
+/**
+ * Default profile for banking workflows. Heightens safety/compliance terms.
+ */
+export declare const bankingDefault: PolicyProfile;
+/**
+ * Default profile for insurance workflows. Tracks policy/claim language.
+ */
+export declare const insuranceDefault: PolicyProfile;
+/**
+ * Default profile for regression suites. Biases toward existing functional
+ * paths over novel discovery.
+ */
+export declare const regressionDefault: PolicyProfile;
+export declare const ALL_POLICY_PROFILES: readonly PolicyProfile[];
+//# sourceMappingURL=policyProfile.d.ts.map

package/dist/domain/policyProfile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"policyProfile.d.ts","sourceRoot":"","sources":["../../src/domain/policyProfile.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,+BAA+B,CAAC;AAEzE,MAAM,WAAW,aAAa;IAC5B,+DAA+D;IAC/D,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,0BAA0B;IAC1B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B;;;;OAIG;IACH,QAAQ,CAAC,gBAAgB,EAAE,SAAS,CAAC,SAAS,MAAM,EAAE,CAAC,EAAE,CAAC;IAC1D;;;OAGG;IACH,QAAQ,CAAC,YAAY,EAAE,QAAQ,CAC7B,MAAM,CAAC,mBAAmB,CAAC,4BAA4B,EAAE,SAAS,MAAM,EAAE,CAAC,CAC5E,CAAC;IACF,uDAAuD;IACvD,QAAQ,CAAC,gBAAgB,EAAE,mBAAmB,CAAC,4BAA4B,CAAC;IAC5E,yDAAyD;IACzD,QAAQ,CAAC,eAAe,EAAE,mBAAmB,CAAC,2BAA2B,CAAC;CAC3E;AAcD;;GAEG;AACH,eAAO,MAAM,cAAc,EAAE,aAkB3B,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,gBAAgB,EAAE,aAkB7B,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,iBAAiB,EAAE,aAkB9B,CAAC;AAEH,eAAO,MAAM,mBAAmB,EAAE,SAAS,aAAa,EAItD,CAAC"}

package/dist/domain/policyProfile.js

@@ -0,0 +1,94 @@
+// Quality Intelligence policy-profile constants (Epic #270, Issue #272).
+//
+// Pure data, deeply frozen. A policy profile carries the per-domain heuristic
+// configuration that downstream callers (validators, test-design model,
+// coverage relevance) blend with the source envelopes. v1 only encodes the
+// fields the test-design model needs; richer governance policies land with
+// #282.
+//
+// Inspired structurally by the per-domain heuristics under
+// Test Intelligence reference (TI) packages/core-engine/src/intent-derivation.ts
+// — porting the lexical hints, not any provider-specific tuning.
+const freezeProfile = (profile) => {
+    for (const keywords of profile.priorityKeywords) {
+        Object.freeze(keywords);
+    }
+    Object.freeze(profile.priorityKeywords);
+    for (const value of Object.values(profile.riskKeywords)) {
+        Object.freeze(value);
+    }
+    Object.freeze(profile.riskKeywords);
+    return Object.freeze(profile);
+};
+/**
+ * Default profile for banking workflows. Heightens safety/compliance terms.
+ */
+export const bankingDefault = freezeProfile({
+    id: "banking-default",
+    displayLabel: "Banking — default",
+    priorityKeywords: [
+        ["fraud", "aml", "kyc", "sanction"],
+        ["payment", "transfer", "settlement", "interest"],
+        ["statement", "balance", "ledger"],
+        ["preference", "theme", "marketing"],
+    ],
+    riskKeywords: {
+        safety: ["unauthorised", "lockout", "credential", "session"],
+        compliance: ["aml", "kyc", "gdpr", "regulator", "sanction", "audit"],
+        regression: ["regression", "smoke", "release"],
+        functional: ["enter", "submit", "confirm", "cancel"],
+        visual: ["layout", "spacing", "colour", "color", "icon"],
+    },
+    defaultRiskClass: "compliance",
+    defaultPriority: "P2",
+});
+/**
+ * Default profile for insurance workflows. Tracks policy/claim language.
+ */
+export const insuranceDefault = freezeProfile({
+    id: "insurance-default",
+    displayLabel: "Insurance — default",
+    priorityKeywords: [
+        ["fraud", "denial", "fatality"],
+        ["claim", "policy", "premium", "underwriting"],
+        ["quote", "renewal"],
+        ["preference", "marketing", "newsletter"],
+    ],
+    riskKeywords: {
+        safety: ["fatal", "injury", "exposure"],
+        compliance: ["regulator", "gdpr", "consent", "broker"],
+        regression: ["regression", "smoke"],
+        functional: ["submit", "renew", "approve", "decline"],
+        visual: ["layout", "spacing", "icon", "logo"],
+    },
+    defaultRiskClass: "functional",
+    defaultPriority: "P2",
+});
+/**
+ * Default profile for regression suites. Biases toward existing functional
+ * paths over novel discovery.
+ */
+export const regressionDefault = freezeProfile({
+    id: "regression-default",
+    displayLabel: "Regression — default",
+    priorityKeywords: [
+        ["smoke", "critical-path", "release"],
+        ["regression"],
+        ["edge-case"],
+        ["nice-to-have"],
+    ],
+    riskKeywords: {
+        safety: ["crash", "data-loss"],
+        compliance: ["audit", "log"],
+        regression: ["regression", "smoke", "release", "stable"],
+        functional: ["form", "click", "submit"],
+        visual: ["layout", "colour", "color", "spacing"],
+    },
+    defaultRiskClass: "regression",
+    defaultPriority: "P2",
+});
+export const ALL_POLICY_PROFILES = Object.freeze([
+    bankingDefault,
+    insuranceDefault,
+    regressionDefault,
+]);

package/dist/domain/requirementExcerpt.d.ts

@@ -0,0 +1,9 @@
+/** Maximum excerpt length in characters, including the trailing ellipsis. */
+export declare const REQUIREMENT_EXCERPT_MAX_CHARS: 96;
+/**
+ * Build a short, redacted, single-line excerpt of an atom's canonical text. Returns `undefined`
+ * for empty/whitespace-only input so callers can simply omit the optional field. Deterministic:
+ * same input always yields the same excerpt (no timestamps, no randomness).
+ */
+export declare function buildRequirementExcerpt(canonicalText: string): string | undefined;
+//# sourceMappingURL=requirementExcerpt.d.ts.map

package/dist/domain/requirementExcerpt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"requirementExcerpt.d.ts","sourceRoot":"","sources":["../../src/domain/requirementExcerpt.ts"],"names":[],"mappings":"AA0BA,6EAA6E;AAC7E,eAAO,MAAM,6BAA6B,EAAG,EAAW,CAAC;AAIzD;;;;GAIG;AACH,wBAAgB,uBAAuB,CAAC,aAAa,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAKjF"}

package/dist/domain/requirementExcerpt.js

@@ -0,0 +1,39 @@
+// Human-readable requirement excerpt for coverage/traceability surfaces (Epic #734, Issue #790).
+//
+// Coverage matrix rows, gap findings and the traceability matrix historically carried atom ids
+// only — auditors could not tell WHICH requirement `qi-atom-…` is without manually cross-
+// referencing the source. This helper derives a short, redaction-safe excerpt from an atom's
+// server-side canonical text so those surfaces become auditor-readable without ever persisting
+// raw source content.
+//
+// Ordering is load-bearing: unsafe bidi/zero-width/control code points are stripped FIRST, then the
+// FULL text is redacted, then whitespace-collapsed, then truncated.
+//   * Stripping before redaction is a redaction SAFEGUARD, not just cosmetics: a credential
+//     obfuscated by an interstitial zero-width character (e.g. an AWS key with a U+200B inside it)
+//     slips past redact() — whose patterns match contiguous characters — and would survive into the
+//     excerpt. Removing the spoofing code points first de-obfuscates the text so redact() sees, and
+//     scrubs, the real secret. It also keeps the audit-ready coverage/traceability surfaces free of
+//     invisible/bidi characters (symmetric with the candidate-text chokepoint normaliseCandidateText).
+//   * Truncating before redaction could split a secret across the cut so the remainder no longer
+//     matches any redaction pattern (a partial AWS key is still a leak); redacting first makes the
+//     truncation operate on already-safe text.
+// Persistence redacts every string leaf again (defense in depth), so a stored excerpt is redacted at
+// least twice; the format-char strip sits upstream of every persisted coverage/finding/export surface.
+import { redact } from "@oscharko-dev/keiko-security";
+import { stripUnsafeFormatChars } from "./assertions.js";
+/** Maximum excerpt length in characters, including the trailing ellipsis. */
+export const REQUIREMENT_EXCERPT_MAX_CHARS = 96;
+const ELLIPSIS = "…";
+/**
+ * Build a short, redacted, single-line excerpt of an atom's canonical text. Returns `undefined`
+ * for empty/whitespace-only input so callers can simply omit the optional field. Deterministic:
+ * same input always yields the same excerpt (no timestamps, no randomness).
+ */
+export function buildRequirementExcerpt(canonicalText) {
+    const collapsed = redact(stripUnsafeFormatChars(canonicalText)).replace(/\s+/gu, " ").trim();
+    if (collapsed.length === 0)
+        return undefined;
+    if (collapsed.length <= REQUIREMENT_EXCERPT_MAX_CHARS)
+        return collapsed;
+    return collapsed.slice(0, REQUIREMENT_EXCERPT_MAX_CHARS - ELLIPSIS.length).trimEnd() + ELLIPSIS;
+}

package/dist/domain/staleness.d.ts

@@ -0,0 +1,56 @@
+/** A reason why a single candidate is stale. */
+export interface StalenessReason {
+    readonly candidateId: string;
+    readonly reason: "source-changed" | "source-removed";
+    readonly envelopeId: string;
+}
+/** Partitioned staleness report for a full run. */
+export interface StalenessResult {
+    readonly fresh: readonly string[];
+    readonly changedStale: readonly StalenessReason[];
+    readonly orphanedStale: readonly StalenessReason[];
+}
+export interface CompareStalenessArgs {
+    /** Fingerprints persisted with the original run (from manifest.sourceFingerprints). */
+    readonly oldFingerprints: readonly {
+        envelopeId: string;
+        integrityHashSha256Hex: string;
+    }[];
+    /** Optional atom-level fingerprints persisted with the original run (post-fix runs only). */
+    readonly oldAtomFingerprints?: readonly {
+        atomId: string;
+        envelopeId: string;
+        canonicalHashSha256Hex: string;
+        replacementGroupId?: string;
+        replacementOrdinal?: number;
+    }[];
+    /** Evidence refs from the manifest (atomId → envelopeId mapping). */
+    readonly evidenceRefs: readonly {
+        envelopeId: string;
+        atomId: string;
+    }[];
+    /** Candidates to classify. */
+    readonly candidates: readonly {
+        id: string;
+        derivedFromAtomIds: readonly string[];
+    }[];
+    /** Fingerprints from re-ingesting the current sources right now. */
+    readonly currentFingerprints: readonly {
+        envelopeId: string;
+        integrityHashSha256Hex: string;
+    }[];
+    /** Optional atom-level fingerprints from re-ingesting the current sources right now. */
+    readonly currentAtomFingerprints?: readonly {
+        atomId: string;
+        envelopeId: string;
+        canonicalHashSha256Hex: string;
+        replacementGroupId?: string;
+        replacementOrdinal?: number;
+    }[];
+}
+/**
+ * Classify each candidate as fresh or stale based on whether their source envelopes have changed
+ * since the run was persisted. Pure, deterministic; candidate input order is preserved.
+ */
+export declare function compareStaleness(args: CompareStalenessArgs): StalenessResult;
+//# sourceMappingURL=staleness.d.ts.map

package/dist/domain/staleness.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"staleness.d.ts","sourceRoot":"","sources":["../../src/domain/staleness.ts"],"names":[],"mappings":"AASA,gDAAgD;AAChD,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,MAAM,EAAE,gBAAgB,GAAG,gBAAgB,CAAC;IACrD,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;CAC7B;AAED,mDAAmD;AACnD,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;IAClC,QAAQ,CAAC,YAAY,EAAE,SAAS,eAAe,EAAE,CAAC;IAClD,QAAQ,CAAC,aAAa,EAAE,SAAS,eAAe,EAAE,CAAC;CACpD;AAED,MAAM,WAAW,oBAAoB;IACnC,uFAAuF;IACvF,QAAQ,CAAC,eAAe,EAAE,SAAS;QAAE,UAAU,EAAE,MAAM,CAAC;QAAC,sBAAsB,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;IAC5F,6FAA6F;IAC7F,QAAQ,CAAC,mBAAmB,CAAC,EAAE,SAAS;QACtC,MAAM,EAAE,MAAM,CAAC;QACf,UAAU,EAAE,MAAM,CAAC;QACnB,sBAAsB,EAAE,MAAM,CAAC;QAC/B,kBAAkB,CAAC,EAAE,MAAM,CAAC;QAC5B,kBAAkB,CAAC,EAAE,MAAM,CAAC;KAC7B,EAAE,CAAC;IACJ,qEAAqE;IACrE,QAAQ,CAAC,YAAY,EAAE,SAAS;QAAE,UAAU,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;IACzE,8BAA8B;IAC9B,QAAQ,CAAC,UAAU,EAAE,SAAS;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,kBAAkB,EAAE,SAAS,MAAM,EAAE,CAAA;KAAE,EAAE,CAAC;IACtF,oEAAoE;IACpE,QAAQ,CAAC,mBAAmB,EAAE,SAAS;QAAE,UAAU,EAAE,MAAM,CAAC;QAAC,sBAAsB,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;IAChG,wFAAwF;IACxF,QAAQ,CAAC,uBAAuB,CAAC,EAAE,SAAS;QAC1C,MAAM,EAAE,MAAM,CAAC;QACf,UAAU,EAAE,MAAM,CAAC;QACnB,sBAAsB,EAAE,MAAM,CAAC;QAC/B,kBAAkB,CAAC,EAAE,MAAM,CAAC;QAC5B,kBAAkB,CAAC,EAAE,MAAM,CAAC;KAC7B,EAAE,CAAC;CACL;AAoaD;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,oBAAoB,GAAG,eAAe,CAgC5E"}