@shrkcrft/inspector 0.1.0-alpha.30 → 0.1.0-alpha.31

package/dist/knowledge-entry-verdict.d.ts

@@ -0,0 +1,17 @@
+/**
+ * One entry's verdict in the staleness sweep — three buckets, never one.
+ *
+ * The sweep used to report only reference-level counts, so an entry that
+ * declared NO references contributed nothing and was folded into the healthy
+ * total: the less verifiable a corpus was, the healthier it looked. An entry
+ * the check could not examine is its own bucket, reported with its id.
+ */
+export declare enum KnowledgeEntryVerdict {
+    /** At least one reference / anchor was checked, and every checked one resolved. */
+    Verified = "verified",
+    /** At least one checked reference / anchor did not resolve. */
+    Stale = "stale",
+    /** Nothing about this entry could be checked — see its reason. */
+    Unverifiable = "unverifiable"
+}
+//# sourceMappingURL=knowledge-entry-verdict.d.ts.map

package/dist/knowledge-entry-verdict.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"knowledge-entry-verdict.d.ts","sourceRoot":"","sources":["../src/knowledge-entry-verdict.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,oBAAY,qBAAqB;IAC/B,mFAAmF;IACnF,QAAQ,aAAa;IACrB,+DAA+D;IAC/D,KAAK,UAAU;IACf,kEAAkE;IAClE,YAAY,iBAAiB;CAC9B"}

package/dist/knowledge-entry-verdict.js

@@ -0,0 +1,17 @@
+/**
+ * One entry's verdict in the staleness sweep — three buckets, never one.
+ *
+ * The sweep used to report only reference-level counts, so an entry that
+ * declared NO references contributed nothing and was folded into the healthy
+ * total: the less verifiable a corpus was, the healthier it looked. An entry
+ * the check could not examine is its own bucket, reported with its id.
+ */
+export var KnowledgeEntryVerdict;
+(function (KnowledgeEntryVerdict) {
+    /** At least one reference / anchor was checked, and every checked one resolved. */
+    KnowledgeEntryVerdict["Verified"] = "verified";
+    /** At least one checked reference / anchor did not resolve. */
+    KnowledgeEntryVerdict["Stale"] = "stale";
+    /** Nothing about this entry could be checked — see its reason. */
+    KnowledgeEntryVerdict["Unverifiable"] = "unverifiable";
+})(KnowledgeEntryVerdict || (KnowledgeEntryVerdict = {}));

package/dist/knowledge-graph.d.ts

@@ -22,6 +22,12 @@ export interface IKnowledgeGraph {
     edges: IGraphEdge[];
     /** Convenience: lookup by composite id (kind:id). */
     byId: ReadonlyMap<string, IGraphNode>;
+    /**
+     * Declared edges NOT drawn because an endpoint is not a node of this graph
+     * (a dangling id, or a kind the graph does not model). A shrunken graph says
+     * it shrank — `shrk self-config xrefs --dangling-only` lists the ids.
+     */
+    droppedEdges?: number;
 }
 /**
  * Build the full SharkCraft knowledge graph for the current inspection.

package/dist/knowledge-graph.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"knowledge-graph.d.ts","sourceRoot":"","sources":["../src/knowledge-graph.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,2BAA2B,CAAC;AAEvE,MAAM,MAAM,aAAa,GACrB,WAAW,GACX,MAAM,GACN,MAAM,GACN,UAAU,GACV,UAAU,GACV,QAAQ,GACR,MAAM,GACN,UAAU,GACV,KAAK,CAAC;AAEV,MAAM,WAAW,UAAU;IACzB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,aAAa,CAAC;IACpB,KAAK,EAAE,MAAM,CAAC;IACd,iCAAiC;IACjC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,4CAA4C;IAC5C,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,MAAM,iBAAiB,GACzB,kBAAkB,GAClB,cAAc,GACd,cAAc,GACd,iBAAiB,GACjB,mBAAmB,GACnB,0BAA0B,GAC1B,kBAAkB,GAClB,uBAAuB,GACvB,uBAAuB,GACvB,UAAU,CAAC;AAEf,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;IACX,QAAQ,EAAE,iBAAiB,CAAC;IAC5B,qDAAqD;IACrD,GAAG,EAAE,MAAM,CAAC;CACb;AAED,MAAM,WAAW,eAAe;IAC9B,KAAK,EAAE,UAAU,EAAE,CAAC;IACpB,KAAK,EAAE,UAAU,EAAE,CAAC;IACpB,qDAAqD;IACrD,IAAI,EAAE,WAAW,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;CACvC;AAMD;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,UAAU,EAAE,qBAAqB,GAAG,eAAe,CAyQtF;AAED,MAAM,WAAW,cAAc;IAC7B,oCAAoC;IACpC,IAAI,EAAE,MAAM,CAAC;IACb,8DAA8D;IAC9D,GAAG,CAAC,EAAE;QAAE,QAAQ,EAAE,iBAAiB,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE,CAAC;CACpD;AAED,MAAM,WAAW,UAAU;IACzB,KAAK,EAAE,OAAO,CAAC;IACf,KAAK,EAAE,cAAc,EAAE,CAAC;IACxB,gFAAgF;IAChF,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;;;;OAKG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAC3B,KAAK,EAAE,eAAe,EACtB,OAAO,EAAE;IAAE,IAAI,CAAC,EAAE,aAAa,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAE,EAC7C,KAAK,EAAE;IAAE,IAAI,CAAC,EAAE,aAAa,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAE,GAC1C,UAAU,CA+DZ;AAgDD;;GAEG;AACH,wBAAgB,YAAY,CAC1B,KAAK,EAAE,eAAe,EACtB,GAAG,EAAE;IAAE,IAAI,CAAC,EAAE,aAAa,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAE,GACxC;IACD,IAAI,EAAE,UAAU,GAAG,IAAI,CAAC;IACxB,QAAQ,EAAE,UAAU,EAAE,CAAC;IACvB,QAAQ,EAAE,UAAU,EAAE,CAAC;CACxB,GAAG,IAAI,CA+BP"}
+{"version":3,"file":"knowledge-graph.d.ts","sourceRoot":"","sources":["../src/knowledge-graph.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,2BAA2B,CAAC;AAEvE,MAAM,MAAM,aAAa,GACrB,WAAW,GACX,MAAM,GACN,MAAM,GACN,UAAU,GACV,UAAU,GACV,QAAQ,GACR,MAAM,GACN,UAAU,GACV,KAAK,CAAC;AAEV,MAAM,WAAW,UAAU;IACzB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,aAAa,CAAC;IACpB,KAAK,EAAE,MAAM,CAAC;IACd,iCAAiC;IACjC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,4CAA4C;IAC5C,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,MAAM,iBAAiB,GACzB,kBAAkB,GAClB,cAAc,GACd,cAAc,GACd,iBAAiB,GACjB,mBAAmB,GACnB,0BAA0B,GAC1B,kBAAkB,GAClB,uBAAuB,GACvB,uBAAuB,GACvB,UAAU,CAAC;AAEf,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;IACX,QAAQ,EAAE,iBAAiB,CAAC;IAC5B,qDAAqD;IACrD,GAAG,EAAE,MAAM,CAAC;CACb;AAED,MAAM,WAAW,eAAe;IAC9B,KAAK,EAAE,UAAU,EAAE,CAAC;IACpB,KAAK,EAAE,UAAU,EAAE,CAAC;IACpB,qDAAqD;IACrD,IAAI,EAAE,WAAW,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;IACtC;;;;OAIG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAMD;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,UAAU,EAAE,qBAAqB,GAAG,eAAe,CA0RtF;AAED,MAAM,WAAW,cAAc;IAC7B,oCAAoC;IACpC,IAAI,EAAE,MAAM,CAAC;IACb,8DAA8D;IAC9D,GAAG,CAAC,EAAE;QAAE,QAAQ,EAAE,iBAAiB,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE,CAAC;CACpD;AAED,MAAM,WAAW,UAAU;IACzB,KAAK,EAAE,OAAO,CAAC;IACf,KAAK,EAAE,cAAc,EAAE,CAAC;IACxB,gFAAgF;IAChF,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;;;;OAKG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAC3B,KAAK,EAAE,eAAe,EACtB,OAAO,EAAE;IAAE,IAAI,CAAC,EAAE,aAAa,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAE,EAC7C,KAAK,EAAE;IAAE,IAAI,CAAC,EAAE,aAAa,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAE,GAC1C,UAAU,CA+DZ;AAgDD;;GAEG;AACH,wBAAgB,YAAY,CAC1B,KAAK,EAAE,eAAe,EACtB,GAAG,EAAE;IAAE,IAAI,CAAC,EAAE,aAAa,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAE,GACxC;IACD,IAAI,EAAE,UAAU,GAAG,IAAI,CAAC;IACxB,QAAQ,EAAE,UAAU,EAAE,CAAC;IACvB,QAAQ,EAAE,UAAU,EAAE,CAAC;CACxB,GAAG,IAAI,CA+BP"}

package/dist/knowledge-graph.js

@@ -9,6 +9,7 @@ export function buildKnowledgeGraph(inspection) {
     const nodes = [];
     const edges = [];
     const byId = new Map();
+    let droppedEdges = 0;
     function addNode(n) {
         const key = nodeKey(n.kind, n.id);
         if (byId.has(key))
@@ -19,10 +20,12 @@ export function buildKnowledgeGraph(inspection) {
     function addEdge(from, to, relation, why) {
         const fromKey = nodeKey(from.kind, from.id);
         const toKey = nodeKey(to.kind, to.id);
-        if (!byId.has(toKey))
-            return; // don't add edges to nodes we didn't see
-        if (!byId.has(fromKey))
+        // An edge to a node we didn't see is not drawn — but it is COUNTED, so the
+        // graph never reads as complete while it silently lost edges.
+        if (!byId.has(toKey) || !byId.has(fromKey)) {
+            droppedEdges += 1;
             return;
+        }
         edges.push({ from: fromKey, to: toKey, relation, why });
     }
     function sourceOf(map, id) {
@@ -142,8 +145,10 @@ export function buildKnowledgeGraph(inspection) {
                             : byId.has(kKey)
                                 ? 'knowledge'
                                 : null;
-                if (!targetKind)
+                if (!targetKind) {
+                    droppedEdges += 1;
                     continue;
+                }
                 addEdge({ kind: 'pipeline', id: pipeline.id }, { kind: targetKind, id: ref }, 'pipeline-step-references', `step ${step.id} references`);
             }
         }
@@ -157,11 +162,17 @@ export function buildKnowledgeGraph(inspection) {
             addEdge({ kind: 'boundary', id: r.id }, { kind: 'path', id }, 'boundary-related-path', 'relatedPathConventions');
         }
     }
-    // Pack contributions: pack → its contributed items.
+    // Pack contributions: pack → its contributed items. A contributed rule or
+    // path convention is a `rule:` / `path:` node, not a `knowledge:` one — the
+    // edge used to target `knowledge:<id>` and was silently dropped for both.
+    const entryKinds = new Map();
+    for (const e of inspection.knowledgeEntries) {
+        entryKinds.set(e.id, String(e.type) === 'rule' ? 'rule' : String(e.type) === 'path' ? 'path' : 'knowledge');
+    }
     for (const [id, src] of inspection.entrySources) {
         if (src.type !== 'pack' || !src.packageName)
             continue;
-        addEdge({ kind: 'pack', id: src.packageName }, { kind: 'knowledge', id }, 'pack-contributes', 'knowledge entry');
+        addEdge({ kind: 'pack', id: src.packageName }, { kind: entryKinds.get(id) ?? 'knowledge', id }, 'pack-contributes', 'knowledge entry');
     }
     for (const [id, src] of inspection.templateSources) {
         if (src.type !== 'pack' || !src.packageName)
@@ -183,7 +194,7 @@ export function buildKnowledgeGraph(inspection) {
             continue;
         addEdge({ kind: 'pack', id: src.packageName }, { kind: 'boundary', id }, 'pack-contributes', 'boundary rule');
     }
-    return { nodes, edges, byId };
+    return { nodes, edges, byId, droppedEdges };
 }
 /**
  * Find the shortest directed path (BFS) between two graph nodes. Edges are

package/dist/knowledge-kind-bucket.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Per-kind counts of a staleness sweep — by asset kind (knowledge / boundary
+ * rule / policy) and by knowledge entry `type`.
+ *
+ * `scanned: 0` means the kind was NOT IN THE SWEEP, which a renderer must say
+ * in words — a row of zeros cannot tell "clean" from "never looked".
+ */
+export interface IKnowledgeKindBucket {
+    /** Subjects of this kind the sweep visited. */
+    scanned: number;
+    /** Of those, how many declare no references / anchors at all. */
+    zeroReferences: number;
+    /** References + anchors checked for this kind. */
+    referencesChecked: number;
+    verified: number;
+    stale: number;
+    unverifiable: number;
+}
+//# sourceMappingURL=knowledge-kind-bucket.d.ts.map

package/dist/knowledge-kind-bucket.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"knowledge-kind-bucket.d.ts","sourceRoot":"","sources":["../src/knowledge-kind-bucket.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,MAAM,WAAW,oBAAoB;IACnC,+CAA+C;IAC/C,OAAO,EAAE,MAAM,CAAC;IAChB,iEAAiE;IACjE,cAAc,EAAE,MAAM,CAAC;IACvB,kDAAkD;IAClD,iBAAiB,EAAE,MAAM,CAAC;IAC1B,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,YAAY,EAAE,MAAM,CAAC;CACtB"}

package/dist/knowledge-kind-bucket.js

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

package/dist/knowledge-load-failure.d.ts

@@ -0,0 +1,23 @@
+/**
+ * One knowledge-bearing file (`knowledgeFiles` / `ruleFiles` / `pathFiles` /
+ * `docsFiles`, local or pack-contributed) whose entries never reached the
+ * corpus — it failed to import, timed out, was skipped as a cached failure, or
+ * is declared by the config and does not exist.
+ *
+ * Read off `inspection.loaderDiagnostics` (the ONE record of what each loader
+ * did) by `describeInspectionDiscovery`. A corpus verdict over a load failure
+ * examined part of what it was told to, so it is never a pass.
+ */
+export interface IKnowledgeLoadFailure {
+    /** Project-relative when inside the project, else absolute. */
+    readonly file: string;
+    /** The loader slot (`knowledge` / `rules` / `paths` / `docs`). */
+    readonly kind: string;
+    /** `failed` / `timeout` / `cached-failed` / `missing`. */
+    readonly status: string;
+    /** The loader's message (the import error), or why nothing was read. */
+    readonly message: string;
+    /** Set for a pack-contributed file. */
+    readonly packName?: string;
+}
+//# sourceMappingURL=knowledge-load-failure.d.ts.map

package/dist/knowledge-load-failure.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"knowledge-load-failure.d.ts","sourceRoot":"","sources":["../src/knowledge-load-failure.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,MAAM,WAAW,qBAAqB;IACpC,+DAA+D;IAC/D,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,kEAAkE;IAClE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,0DAA0D;IAC1D,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,wEAAwE;IACxE,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,uCAAuC;IACvC,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;CAC5B"}

package/dist/knowledge-load-failure.js

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

package/dist/knowledge-reference-kind-bucket.d.ts

@@ -0,0 +1,11 @@
+/** Per-reference-kind outcome counts of a staleness sweep (`file`, `symbol`, `template`, …). */
+export interface IKnowledgeReferenceKindBucket {
+    checked: number;
+    ok: number;
+    stale: number;
+    missing: number;
+    unknown: number;
+    /** Malformed references of this kind (a missing required field) — never checked. */
+    invalid: number;
+}
+//# sourceMappingURL=knowledge-reference-kind-bucket.d.ts.map

package/dist/knowledge-reference-kind-bucket.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"knowledge-reference-kind-bucket.d.ts","sourceRoot":"","sources":["../src/knowledge-reference-kind-bucket.ts"],"names":[],"mappings":"AAAA,gGAAgG;AAChG,MAAM,WAAW,6BAA6B;IAC5C,OAAO,EAAE,MAAM,CAAC;IAChB,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,oFAAoF;IACpF,OAAO,EAAE,MAAM,CAAC;CACjB"}

package/dist/knowledge-reference-kind-bucket.js

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

package/dist/knowledge-stale-advisory.d.ts

@@ -0,0 +1,14 @@
+import type { IAssetReference } from '@shrkcrft/core';
+import type { KnowledgeAdvisoryCode } from './knowledge-advisory-code.js';
+import type { ReferenceAssetKind } from './reference-asset-kind.js';
+/** One advisory from a staleness sweep — reported, never gating by itself. */
+export interface IKnowledgeStaleAdvisory {
+    readonly code: KnowledgeAdvisoryCode;
+    /** The entry / boundary rule / policy the advisory is about. */
+    readonly subjectId: string;
+    readonly assetKind: ReferenceAssetKind;
+    readonly message: string;
+    /** A reference that would verify the claim, ready to paste into `references[]`. */
+    readonly suggestion?: IAssetReference;
+}
+//# sourceMappingURL=knowledge-stale-advisory.d.ts.map

package/dist/knowledge-stale-advisory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"knowledge-stale-advisory.d.ts","sourceRoot":"","sources":["../src/knowledge-stale-advisory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AACtD,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,8BAA8B,CAAC;AAC1E,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAEpE,8EAA8E;AAC9E,MAAM,WAAW,uBAAuB;IACtC,QAAQ,CAAC,IAAI,EAAE,qBAAqB,CAAC;IACrC,gEAAgE;IAChE,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,SAAS,EAAE,kBAAkB,CAAC;IACvC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,mFAAmF;IACnF,QAAQ,CAAC,UAAU,CAAC,EAAE,eAAe,CAAC;CACvC"}

package/dist/knowledge-stale-advisory.js

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

package/dist/knowledge-stale-coverage.d.ts

@@ -0,0 +1,19 @@
+/**
+ * The three entry buckets of a staleness sweep, over the entries in scope.
+ *
+ * `verified + stale + unverifiable === entriesInScope`, always. The CLI renders
+ * the unverifiable count AND its percentage on the summary line where a bare
+ * `0 stale` used to sit, and turns {@link referencedRatio} into the verdict's
+ * coverage (`examined` = verified + stale).
+ */
+export interface IKnowledgeStaleCoverage {
+    readonly entriesInScope: number;
+    readonly verified: number;
+    readonly stale: number;
+    readonly unverifiable: number;
+    /** `unverifiable / entriesInScope × 100`, one decimal place; 0 for an empty scope. */
+    readonly unverifiablePct: number;
+    /** `(verified + stale) / entriesInScope` — the share the check could examine; 0 for an empty scope. */
+    readonly referencedRatio: number;
+}
+//# sourceMappingURL=knowledge-stale-coverage.d.ts.map

package/dist/knowledge-stale-coverage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"knowledge-stale-coverage.d.ts","sourceRoot":"","sources":["../src/knowledge-stale-coverage.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,MAAM,WAAW,uBAAuB;IACtC,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,sFAAsF;IACtF,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC,uGAAuG;IACvG,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;CAClC"}

package/dist/knowledge-stale-coverage.js

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

package/dist/knowledge-stale-gate-flags.d.ts

@@ -0,0 +1,33 @@
+import type { IVerdictCoverage } from '@shrkcrft/core';
+/**
+ * What a caller of the knowledge stale-check gate asked for EXPLICITLY — the
+ * flags of `shrk knowledge stale-check` / `verify`. `shrk quality`, `shrk
+ * release readiness` and every `buildQualityReport` consumer (MCP, the
+ * dashboard, the report site) pass `{}`: they run on the config alone.
+ *
+ * `knowledgeStaleGateInput` folds these over the config's `knowledgeCheck`
+ * block — the ONE place that precedence is decided (a flag wins) — so the verb,
+ * the quality gate and readiness cannot read the config three ways.
+ */
+export interface IKnowledgeStaleGateFlags {
+    /** `--ci`. */
+    readonly ci?: boolean;
+    /** The verb's own `--strict` (required references only, like `--ci`). */
+    readonly strict?: boolean;
+    /** Validated `--fail-on` categories. Absent / empty = not given: `knowledgeCheck.failOn` applies. */
+    readonly failOn?: readonly string[];
+    /** `--min-referenced` — wins over `knowledgeCheck.minReferenced`. */
+    readonly minReferenced?: {
+        readonly ratio: number;
+        readonly acceptedBy: string;
+    };
+    /** `--require-references` (ORed with `knowledgeCheck.requireReferences`). */
+    readonly requireReferences?: boolean;
+    /** `allowEmptyValve(args, entriesInScope)`. Never set from config. */
+    readonly emptyAcceptance?: Pick<IVerdictCoverage, 'acceptedBy'>;
+    /** `--stale-after`, in days — the window the `aged` category measures against. */
+    readonly staleAfterDays?: number;
+    /** `--as-of` (only meaningful with a `--stale-after` window). */
+    readonly asOf?: string;
+}
+//# sourceMappingURL=knowledge-stale-gate-flags.d.ts.map

package/dist/knowledge-stale-gate-flags.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"knowledge-stale-gate-flags.d.ts","sourceRoot":"","sources":["../src/knowledge-stale-gate-flags.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAEvD;;;;;;;;;GASG;AACH,MAAM,WAAW,wBAAwB;IACvC,cAAc;IACd,QAAQ,CAAC,EAAE,CAAC,EAAE,OAAO,CAAC;IACtB,yEAAyE;IACzE,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC;IAC1B,qGAAqG;IACrG,QAAQ,CAAC,MAAM,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACpC,qEAAqE;IACrE,QAAQ,CAAC,aAAa,CAAC,EAAE;QAAE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAA;KAAE,CAAC;IACjF,6EAA6E;IAC7E,QAAQ,CAAC,iBAAiB,CAAC,EAAE,OAAO,CAAC;IACrC,sEAAsE;IACtE,QAAQ,CAAC,eAAe,CAAC,EAAE,IAAI,CAAC,gBAAgB,EAAE,YAAY,CAAC,CAAC;IAChE,kFAAkF;IAClF,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,CAAC;IACjC,iEAAiE;IACjE,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;CACxB"}

package/dist/knowledge-stale-gate-flags.js

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

package/dist/knowledge-stale-gate-input.d.ts

@@ -0,0 +1,46 @@
+import type { IVerdictCoverage } from '@shrkcrft/core';
+import type { IInspectionDiscovery } from './inspection-discovery.js';
+/**
+ * What the knowledge stale-check verdict is decided FROM, besides the report —
+ * the flags of `shrk knowledge stale-check`, or the config `knowledgeCheck`
+ * block when `shrk quality` / `buildQualityReport` runs the same gate.
+ */
+export interface IKnowledgeStaleGateInput {
+    /** `--ci`: required references that fail are blocking. */
+    readonly ci: boolean;
+    /** The verb's own `--strict` (required references, like `--ci`). */
+    readonly strict: boolean;
+    /** Validated `--fail-on` categories (see `KNOWLEDGE_FAIL_ON_CATEGORIES`). */
+    readonly failOn: ReadonlySet<string>;
+    /**
+     * `--min-referenced <ratio>` (or `knowledgeCheck.minReferenced`): the least
+     * share of in-scope entries the check must examine. Below it the run FAILS;
+     * at or above it the remaining unverifiable entries are ACCEPTED, and the
+     * acceptance is printed with `acceptedBy` verbatim.
+     */
+    readonly minReferenced?: {
+        readonly ratio: number;
+        readonly acceptedBy: string;
+    };
+    /** `--require-references` / `--fail-on unverifiable` / `knowledgeCheck.requireReferences`. */
+    readonly requireReferences: boolean;
+    /**
+     * The `--allow-empty` valve (`allowEmptyValve(args, entriesInScope)`), or `{}`.
+     * Honoured ONLY for a legitimately empty scope — never over a missing
+     * `sharkcraft/` folder or a config that failed to load.
+     */
+    readonly emptyAcceptance: Pick<IVerdictCoverage, 'acceptedBy'>;
+    /** The run was narrowed to a changeset (`--changed-only` / `--since` / `--staged` / `--files`). */
+    readonly scoped: boolean;
+    /** Where discovery landed — the refusal names it when nothing was loaded. */
+    readonly discovery: IInspectionDiscovery;
+    /**
+     * Set when the request can never be evaluated as asked — a category that
+     * cannot fire (`aged` with no `--stale-after` window, from a flag or from
+     * `knowledgeCheck.failOn`), or `--as-of` with no window to date. The verb
+     * exits `3`; `shrk quality` reports the item `error`; readiness is not ready.
+     * Never a verdict.
+     */
+    readonly usageProblem?: string;
+}
+//# sourceMappingURL=knowledge-stale-gate-input.d.ts.map

package/dist/knowledge-stale-gate-input.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"knowledge-stale-gate-input.d.ts","sourceRoot":"","sources":["../src/knowledge-stale-gate-input.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AACvD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAC;AAEtE;;;;GAIG;AACH,MAAM,WAAW,wBAAwB;IACvC,0DAA0D;IAC1D,QAAQ,CAAC,EAAE,EAAE,OAAO,CAAC;IACrB,oEAAoE;IACpE,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;IACzB,6EAA6E;IAC7E,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IACrC;;;;;OAKG;IACH,QAAQ,CAAC,aAAa,CAAC,EAAE;QAAE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAA;KAAE,CAAC;IACjF,8FAA8F;IAC9F,QAAQ,CAAC,iBAAiB,EAAE,OAAO,CAAC;IACpC;;;;OAIG;IACH,QAAQ,CAAC,eAAe,EAAE,IAAI,CAAC,gBAAgB,EAAE,YAAY,CAAC,CAAC;IAC/D,mGAAmG;IACnG,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;IACzB,6EAA6E;IAC7E,QAAQ,CAAC,SAAS,EAAE,oBAAoB,CAAC;IACzC;;;;;;OAMG;IACH,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;CAChC"}

package/dist/knowledge-stale-gate-input.js

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

package/dist/knowledge-stale-gate-result.d.ts

@@ -0,0 +1,33 @@
+import type { IVerdictCoverage } from '@shrkcrft/core';
+import type { IKnowledgeStaleGateRule } from './knowledge-stale-gate-rule.js';
+/**
+ * The knowledge stale-check verdict INPUTS, before settling: a proposed exit,
+ * the run coverage (entries examined of entries in scope) and the rules.
+ * `shrk knowledge stale-check` settles them with `buildGateEnvelope`; `shrk
+ * quality` and `buildQualityReport` (MCP, the dashboard, the report site) with
+ * `settleKnowledgeStaleGate` — the same numbers either way.
+ */
+export interface IKnowledgeStaleGate {
+    /** 0 / 1 / 2 from what was found — settle it; never return it raw. */
+    readonly proposed: number;
+    /** Why `proposed` is 1: each blocking condition, in order. */
+    readonly reasons: readonly string[];
+    readonly requiredStale: number;
+    readonly requiredMissing: number;
+    /** The envelope rules (`knowledge-references`, `knowledge-files`), or none for an empty scope. */
+    readonly rules: readonly IKnowledgeStaleGateRule[];
+    /** Knowledge entries examined (verified + stale) of entries in scope. */
+    readonly runCoverage: IVerdictCoverage;
+    /** True when 0 entries loaded because discovery / config failed — `--allow-empty` never clears that. */
+    readonly discoveryFailed: boolean;
+    /** One-line explanation for a not-verified verdict, when there is a better one than the shortfall. */
+    readonly notVerifiedLead?: string;
+    /**
+     * Round 13: failing (stale / missing) references this mode WAIVED — blocking
+     * nothing, printed as an acceptance (`knowledge-references`'
+     * `unitAcceptance`). The ✓ sentence names them instead of claiming "no stale
+     * or missing references".
+     */
+    readonly waived: number;
+}
+//# sourceMappingURL=knowledge-stale-gate-result.d.ts.map

package/dist/knowledge-stale-gate-result.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"knowledge-stale-gate-result.d.ts","sourceRoot":"","sources":["../src/knowledge-stale-gate-result.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AACvD,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,gCAAgC,CAAC;AAE9E;;;;;;GAMG;AACH,MAAM,WAAW,mBAAmB;IAClC,sEAAsE;IACtE,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,8DAA8D;IAC9D,QAAQ,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;IACpC,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC,kGAAkG;IAClG,QAAQ,CAAC,KAAK,EAAE,SAAS,uBAAuB,EAAE,CAAC;IACnD,yEAAyE;IACzE,QAAQ,CAAC,WAAW,EAAE,gBAAgB,CAAC;IACvC,wGAAwG;IACxG,QAAQ,CAAC,eAAe,EAAE,OAAO,CAAC;IAClC,sGAAsG;IACtG,QAAQ,CAAC,eAAe,CAAC,EAAE,MAAM,CAAC;IAClC;;;;;OAKG;IACH,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB"}

package/dist/knowledge-stale-gate-result.js

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

package/dist/knowledge-stale-gate-rule.d.ts

@@ -0,0 +1,33 @@
+import type { IVerdictCoverage } from '@shrkcrft/core';
+import type { IKnowledgeStaleGateViolation } from './knowledge-stale-gate-violation.js';
+/**
+ * One rule of the knowledge stale-check verdict (`knowledge-references`, or
+ * `knowledge-files` for a knowledge file that never loaded). Structurally a
+ * CLI gate-envelope rule (`IGateRuleResult` of type `knowledge`): the verb
+ * passes it to `buildGateEnvelope` as is, and `shrk quality` / every
+ * `buildQualityReport` consumer settles the SAME record through core's
+ * `settleVerdict` — the inspector cannot import the CLI's type, so the shape
+ * lives here, below both.
+ */
+export interface IKnowledgeStaleGateRule {
+    readonly id: string;
+    readonly type: 'knowledge';
+    readonly status: 'passed' | 'failed' | 'skipped' | 'error';
+    readonly severity: 'error' | 'warning';
+    readonly counts: Readonly<Record<string, number>>;
+    readonly violations: readonly IKnowledgeStaleGateViolation[];
+    readonly skipReason?: string;
+    readonly error?: string;
+    /** What the rule examined against what it was asked to. REQUIRED. */
+    readonly coverage: IVerdictCoverage;
+    /**
+     * An ACCEPTANCE riding next to `coverage` (round 13), folded by the envelope
+     * exactly like a selector unit acceptance (`ruleVerdictRecords`): the failing
+     * references this run's mode waived — `required: false` under `--ci` /
+     * `--strict`, or outside the chosen `--fail-on` categories — printed in
+     * `accepted` at exit 0, so the ✓ line never stands over a STALE row in
+     * silence. Never a shortfall; `rules[].status` never reads it.
+     */
+    readonly unitAcceptance?: IVerdictCoverage;
+}
+//# sourceMappingURL=knowledge-stale-gate-rule.d.ts.map

package/dist/knowledge-stale-gate-rule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"knowledge-stale-gate-rule.d.ts","sourceRoot":"","sources":["../src/knowledge-stale-gate-rule.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AACvD,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,qCAAqC,CAAC;AAExF;;;;;;;;GAQG;AACH,MAAM,WAAW,uBAAuB;IACtC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC;IAC3B,QAAQ,CAAC,MAAM,EAAE,QAAQ,GAAG,QAAQ,GAAG,SAAS,GAAG,OAAO,CAAC;IAC3D,QAAQ,CAAC,QAAQ,EAAE,OAAO,GAAG,SAAS,CAAC;IACvC,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IAClD,QAAQ,CAAC,UAAU,EAAE,SAAS,4BAA4B,EAAE,CAAC;IAC7D,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,qEAAqE;IACrE,QAAQ,CAAC,QAAQ,EAAE,gBAAgB,CAAC;IACpC;;;;;;;OAOG;IACH,QAAQ,CAAC,cAAc,CAAC,EAAE,gBAAgB,CAAC;CAC5C"}

package/dist/knowledge-stale-gate-rule.js

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

package/dist/knowledge-stale-gate-violation.d.ts

@@ -0,0 +1,13 @@
+/**
+ * One failing reference / anchor / entry in a knowledge stale-check rule —
+ * structurally the CLI gate envelope's `IGateViolation`, so the verb hands the
+ * rule to `buildGateEnvelope` unchanged.
+ */
+export interface IKnowledgeStaleGateViolation {
+    readonly id: string;
+    readonly file?: string;
+    readonly line?: number;
+    readonly message?: string;
+    readonly hint?: string;
+}
+//# sourceMappingURL=knowledge-stale-gate-violation.d.ts.map

package/dist/knowledge-stale-gate-violation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"knowledge-stale-gate-violation.d.ts","sourceRoot":"","sources":["../src/knowledge-stale-gate-violation.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,MAAM,WAAW,4BAA4B;IAC3C,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;CACxB"}

package/dist/knowledge-stale-gate-violation.js

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

package/dist/knowledge-stale-gate.d.ts

@@ -0,0 +1,83 @@
+/**
+ * THE knowledge stale-check verdict — decided once, from the one report.
+ *
+ * `shrk knowledge stale-check` / `verify` settle it through `buildGateEnvelope`;
+ * `shrk quality`, `shrk release readiness` and every `buildQualityReport`
+ * consumer (MCP `get_quality_report`, the dashboard, the report site) through
+ * `settleKnowledgeStaleGate`. All of them call this, so the corpus verdict an
+ * agent chains on and the one the pre-push bundle folds cannot disagree.
+ * (Round 11 review: it lived in the CLI, so the MCP report — which cannot
+ * import the CLI — had no knowledge gate at all and read `pass` over a stale
+ * corpus `shrk quality` failed.)
+ *
+ * STRICT BY DEFAULT: every in-scope entry the check could not examine (no
+ * checkable `references[]` / `anchors[]`) is a coverage shortfall on the
+ * verdict, so a run with any unverifiable entry settles to `2` (not verified)
+ * — never `0`. The only ways to a `0` over an unverifiable remainder are
+ * explicit and printed: `--min-referenced <ratio>` (or
+ * `knowledgeCheck.minReferenced`) accepts the remainder when the examined share
+ * is at least the ratio, and fails the run below it; `--allow-empty` accepts a
+ * legitimately EMPTY scope only.
+ */
+import type { ISharkCraftConfig } from '@shrkcrft/config';
+import { type ISettledVerdict } from '@shrkcrft/core';
+import type { IInspectionDiscovery } from './inspection-discovery.js';
+import { type IKnowledgeStaleReport } from './knowledge-stale.js';
+import type { IKnowledgeStaleGateFlags } from './knowledge-stale-gate-flags.js';
+import type { IKnowledgeStaleGateInput } from './knowledge-stale-gate-input.js';
+import type { IKnowledgeStaleGate } from './knowledge-stale-gate-result.js';
+/**
+ * Every `--fail-on` category. `all` keeps its historical meaning (any stale or
+ * missing reference); the round-11 categories are opt-in BY NAME, so no
+ * existing `--fail-on all` pipeline changes behaviour. (A MALFORMED reference
+ * is never a pass in any mode — it is a coverage shortfall, exit 2;
+ * `--fail-on invalid` makes it a failure, exit 1.)
+ */
+export declare const KNOWLEDGE_FAIL_ON_CATEGORIES: readonly string[];
+/** Parse `--min-referenced`: a ratio `0..1` or a percentage `NN%`. `null` when malformed. */
+export declare function parseMinReferenced(raw: string): number | null;
+/** `0.266…` → `26.7%`, `1` → `100%`. */
+export declare function formatPct(ratio: number): string;
+/**
+ * Decide the stale-check verdict inputs. Pure: the report, the flags, the
+ * discovery — nothing else.
+ */
+export declare function evaluateKnowledgeStaleGate(report: IKnowledgeStaleReport, input: IKnowledgeStaleGateInput): IKnowledgeStaleGate;
+/**
+ * A request whose `aged` category (or `--as-of`) has no `--stale-after` window
+ * to measure against can never fire — the vacuous-category class `--fail-on
+ * bogus` is refused for. `undefined` when the request is well-formed.
+ */
+export declare function knowledgeStaleWindowProblem(failOn: ReadonlySet<string>, agedFromConfig: boolean, staleAfterDays: number | undefined, asOf: string | undefined): string | undefined;
+/**
+ * THE stale-check input — the verb's flags folded over the config's
+ * `knowledgeCheck` block. `shrk knowledge stale-check`, `shrk quality`, `shrk
+ * release readiness` and `buildQualityReport` all build their input here, so
+ * for a config-only request the verb's exit, the quality gate and
+ * `knowledgeCheck.ready` are one answer (they used to read the block three
+ * different ways).
+ *
+ * Precedence (a flag wins):
+ *   - `--fail-on` replaces `knowledgeCheck.failOn` wholesale;
+ *   - `knowledgeCheck.strict: true` ("promote any stale to a failure") adds
+ *     `all` to the config's list; the verb's `--strict` / `--ci` (the R30
+ *     required-only modes) take precedence over any `failOn`;
+ *   - `--min-referenced` over `knowledgeCheck.minReferenced` (each printed as
+ *     its own acceptance);
+ *   - `--require-references` OR `knowledgeCheck.requireReferences`;
+ *   - `--allow-empty` is a flag only — never read from config.
+ */
+export declare function knowledgeStaleGateInput(o: {
+    readonly flags: IKnowledgeStaleGateFlags;
+    readonly knowledgeCheck: ISharkCraftConfig['knowledgeCheck'];
+    readonly discovery: IInspectionDiscovery;
+    readonly scoped: boolean;
+}): IKnowledgeStaleGateInput;
+/**
+ * Settle a stale-check verdict WITHOUT an envelope (`shrk quality`, `shrk
+ * release readiness`, `buildQualityReport`) — exactly the fold
+ * `buildGateEnvelope` applies for the verb: the run coverage plus every rule's
+ * coverage, subject = rule id.
+ */
+export declare function settleKnowledgeStaleGate(gate: IKnowledgeStaleGate): ISettledVerdict;
+//# sourceMappingURL=knowledge-stale-gate.d.ts.map

package/dist/knowledge-stale-gate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"knowledge-stale-gate.d.ts","sourceRoot":"","sources":["../src/knowledge-stale-gate.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAC1D,OAAO,EAAqC,KAAK,eAAe,EAAyB,MAAM,gBAAgB,CAAC;AAGhH,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAC;AAGtE,OAAO,EAAyB,KAAK,qBAAqB,EAAE,MAAM,sBAAsB,CAAC;AACzF,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,iCAAiC,CAAC;AAChF,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,iCAAiC,CAAC;AAChF,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,kCAAkC,CAAC;AAU5E;;;;;;GAMG;AACH,eAAO,MAAM,4BAA4B,EAAE,SAAS,MAAM,EAazD,CAAC;AAKF,6FAA6F;AAC7F,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAK7D;AAED,wCAAwC;AACxC,wBAAgB,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAG/C;AA6CD;;;GAGG;AACH,wBAAgB,0BAA0B,CACxC,MAAM,EAAE,qBAAqB,EAC7B,KAAK,EAAE,wBAAwB,GAC9B,mBAAmB,CA4RrB;AAED;;;;GAIG;AACH,wBAAgB,2BAA2B,CACzC,MAAM,EAAE,WAAW,CAAC,MAAM,CAAC,EAC3B,cAAc,EAAE,OAAO,EACvB,cAAc,EAAE,MAAM,GAAG,SAAS,EAClC,IAAI,EAAE,MAAM,GAAG,SAAS,GACvB,MAAM,GAAG,SAAS,CASpB;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,uBAAuB,CAAC,CAAC,EAAE;IACzC,QAAQ,CAAC,KAAK,EAAE,wBAAwB,CAAC;IACzC,QAAQ,CAAC,cAAc,EAAE,iBAAiB,CAAC,gBAAgB,CAAC,CAAC;IAC7D,QAAQ,CAAC,SAAS,EAAE,oBAAoB,CAAC;IACzC,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;CAC1B,GAAG,wBAAwB,CA8B3B;AAED;;;;;GAKG;AACH,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,mBAAmB,GAAG,eAAe,CASnF"}