@wrtnlabs/evidence 0.0.0

package/lib/graph/EvidenceGraph.js

@@ -0,0 +1,1944 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EvidenceGraph = void 0;
+const _assertGuard_1 = __importStar(require("typia/lib/internal/_assertGuard"));
+const _jsonStringifyString_1 = __importStar(require("typia/lib/internal/_jsonStringifyString"));
+const _jsonStringifyNumber_1 = __importStar(require("typia/lib/internal/_jsonStringifyNumber"));
+const _jsonStringifyTail_1 = __importStar(require("typia/lib/internal/_jsonStringifyTail"));
+const _jsonStringifyArray_1 = __importStar(require("typia/lib/internal/_jsonStringifyArray"));
+const typia_1 = __importDefault(require("typia"));
+const EvidenceFileTarget_1 = require("../targets/EvidenceFileTarget");
+const EvidenceInventory_1 = require("./EvidenceInventory");
+const EvidenceFingerprintIndex_1 = require("../internal/EvidenceFingerprintIndex");
+const InventoryMerge_1 = require("../internal/InventoryMerge");
+/**
+ * Evaluates coverage and review policies over captured, materialized populations.
+ *
+ * The checker supplies inventories, selected unit IDs, target resolutions, and
+ * reference policies. This facade validates and captures that input; it does not
+ * load files or infer declarations. Each call creates a fresh evaluator and
+ * returns an owned result, isolating prior diagnostics and caller mutations.
+ *
+ * Evaluation preserves the following boundaries:
+ *
+ * 1. Each claim selects its own semantic hosts and exclusion carriers.
+ * 2. Each reference independently judges coverage, exclusions, cardinality,
+ *    checklist answers, and review freshness, even when populations overlap.
+ * 3. Incomplete analysis remains a failure rather than a passing smaller graph.
+ * 4. Findings requiring cross-reference participation are finalized after all
+ *    applicable references have been examined.
+ *
+ * @example
+ * const graph: EvidenceGraph = new EvidenceGraph(materializedInput);
+ * const first: IEvidenceGraphResult = graph.evaluate();
+ * const second: IEvidenceGraphResult = graph.evaluate();
+ * // The results have independent storage and no accumulated evaluator state.
+ */
+class EvidenceGraph {
+    /**
+     * Validated input snapshot owned by this facade.
+     *
+     * Evaluators read this captured policy and inventory data. Neither later caller
+     * edits nor modifications to an earlier result can change the snapshot.
+     */
+    input;
+    /**
+     * Validates the input shape and captures an independent graph snapshot.
+     *
+     * Semantic inventory and resolution checks occur during evaluation so their
+     * findings can be reported in graph context. Construction performs no source IO.
+     */
+    constructor(input) {
+        this.input = structuredClone((() => {
+            const _ip0 = input => undefined === input["index"] || "number" === typeof input["index"];
+            const _ip1 = input => "error" === input["severity"] || "off" === input["severity"] || "warning" === input["severity"];
+            const _ip2 = input => "object" === typeof input["inventory"] && null !== input["inventory"] && _io2(input["inventory"]);
+            const _ip3 = input => Array.isArray(input["unitIds"]) && input["unitIds"].every(elem => "string" === typeof elem);
+            const _ip4 = input => Array.isArray(input["units"]) && input["units"].every(elem => "object" === typeof elem && null !== elem && _io8(elem));
+            const _ip5 = input => Array.isArray(input["diagnostics"]) && input["diagnostics"].every(elem => "object" === typeof elem && null !== elem && _io15(elem));
+            const _ip6 = input => "string" === typeof input["id"];
+            const _ip7 = input => "string" === typeof input["file"];
+            const _iv0 = new Set(["bigquery", "c", "cpp", "csharp", "dart", "dbml", "go", "java", "javascript", "kotlin", "lua", "markdown", "matlab", "mysql", "objc", "php", "postgresql", "prisma", "python", "ruby", "rust", "scala", "sql", "sqlite", "swagger", "swift", "typescript", "zig"]);
+            const _iv1 = new Set(["column", "file", "function", "h1", "h2", "h3", "h4", "model", "operation", "property", "relation", "type"]);
+            const _ip8 = input => Array.isArray(input["withdrawals"]) && input["withdrawals"].every(elem => "object" === typeof elem && null !== elem && _io10(elem));
+            const _ip9 = input => "object" === typeof input["range"] && null !== input["range"] && _io6(input["range"]);
+            const _ip10 = input => "object" === typeof input["location"] && null !== input["location"] && _io5(input["location"]);
+            const _ip11 = input => Array.isArray(input["segments"]) && input["segments"].every(elem => "string" === typeof elem);
+            const _ip12 = input => "string" === typeof input["hostId"];
+            const _ip13 = input => "string" === typeof input["target"];
+            const _ip14 = input => "object" === typeof input["resolution"] && null !== input["resolution"] && _io19(input["resolution"]);
+            const _ap0 = (input, _path, _exceptionable = true) => undefined === input["index"] || "number" === typeof input["index"] || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".index",
+                expected: "(number | undefined)",
+                value: input["index"]
+            }, _errorFactory);
+            const _ap1 = (input, _path, _exceptionable = true) => "error" === input["severity"] || "off" === input["severity"] || "warning" === input["severity"] || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".severity",
+                expected: "(\"error\" | \"off\" | \"warning\")",
+                value: input["severity"]
+            }, _errorFactory);
+            const _ap2 = (input, _path, _exceptionable = true) => ("object" === typeof input["inventory"] && null !== input["inventory"] || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".inventory",
+                expected: "IEvidenceInventory",
+                value: input["inventory"]
+            }, _errorFactory)) && _ao2(input["inventory"], _path + ".inventory", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".inventory",
+                expected: "IEvidenceInventory",
+                value: input["inventory"]
+            }, _errorFactory);
+            const _ap3 = (input, _path, _exceptionable = true) => (Array.isArray(input["unitIds"]) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".unitIds",
+                expected: "Array<string>",
+                value: input["unitIds"]
+            }, _errorFactory)) && input["unitIds"].every((elem, _index25) => "string" === typeof elem || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".unitIds[" + _index25 + "]",
+                expected: "string",
+                value: elem
+            }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".unitIds",
+                expected: "Array<string>",
+                value: input["unitIds"]
+            }, _errorFactory);
+            const _ap4 = (input, _path, _exceptionable = true) => (Array.isArray(input["units"]) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".units",
+                expected: "Array<IEvidenceUnit>",
+                value: input["units"]
+            }, _errorFactory)) && input["units"].every((elem, _index30) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".units[" + _index30 + "]",
+                expected: "IEvidenceUnit",
+                value: elem
+            }, _errorFactory)) && _ao8(elem, _path + ".units[" + _index30 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".units[" + _index30 + "]",
+                expected: "IEvidenceUnit",
+                value: elem
+            }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".units",
+                expected: "Array<IEvidenceUnit>",
+                value: input["units"]
+            }, _errorFactory);
+            const _ap5 = (input, _path, _exceptionable = true) => (Array.isArray(input["diagnostics"]) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".diagnostics",
+                expected: "Array<IEvidenceDiagnostic>",
+                value: input["diagnostics"]
+            }, _errorFactory)) && input["diagnostics"].every((elem, _index35) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".diagnostics[" + _index35 + "]",
+                expected: "IEvidenceDiagnostic",
+                value: elem
+            }, _errorFactory)) && _ao15(elem, _path + ".diagnostics[" + _index35 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".diagnostics[" + _index35 + "]",
+                expected: "IEvidenceDiagnostic",
+                value: elem
+            }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".diagnostics",
+                expected: "Array<IEvidenceDiagnostic>",
+                value: input["diagnostics"]
+            }, _errorFactory);
+            const _ap6 = (input, _path, _exceptionable = true) => "string" === typeof input["id"] || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".id",
+                expected: "string",
+                value: input["id"]
+            }, _errorFactory);
+            const _ap7 = (input, _path, _exceptionable = true) => "string" === typeof input["file"] || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".file",
+                expected: "string",
+                value: input["file"]
+            }, _errorFactory);
+            const _av0 = new Set(["bigquery", "c", "cpp", "csharp", "dart", "dbml", "go", "java", "javascript", "kotlin", "lua", "markdown", "matlab", "mysql", "objc", "php", "postgresql", "prisma", "python", "ruby", "rust", "scala", "sql", "sqlite", "swagger", "swift", "typescript", "zig"]);
+            const _ae0 = "(\"bigquery\" | \"c\" | \"cpp\" | \"csharp\" | \"dart\" | \"dbml\" | \"go\" | \"java\" | \"javascript\" | \"kotlin\" | \"lua\" | \"markdown\" | \"matlab\" | \"mysql\" | \"objc\" | \"php\" | \"postgresql\" | \"prisma\" | \"python\" | \"ruby\" | \"rust\" | \"scala\" | \"sql\" | \"sqlite\" | \"swagger\" | \"swift\" | \"typescript\" | \"zig\")";
+            const _av1 = new Set(["column", "file", "function", "h1", "h2", "h3", "h4", "model", "operation", "property", "relation", "type"]);
+            const _ap8 = (input, _path, _exceptionable = true) => (Array.isArray(input["withdrawals"]) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".withdrawals",
+                expected: "Array<IEvidenceWithdrawal>",
+                value: input["withdrawals"]
+            }, _errorFactory)) && input["withdrawals"].every((elem, _index40) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".withdrawals[" + _index40 + "]",
+                expected: "IEvidenceWithdrawal",
+                value: elem
+            }, _errorFactory)) && _ao10(elem, _path + ".withdrawals[" + _index40 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".withdrawals[" + _index40 + "]",
+                expected: "IEvidenceWithdrawal",
+                value: elem
+            }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".withdrawals",
+                expected: "Array<IEvidenceWithdrawal>",
+                value: input["withdrawals"]
+            }, _errorFactory);
+            const _ap9 = (input, _path, _exceptionable = true) => ("object" === typeof input["range"] && null !== input["range"] || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".range",
+                expected: "IEvidenceSourceRange",
+                value: input["range"]
+            }, _errorFactory)) && _ao6(input["range"], _path + ".range", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".range",
+                expected: "IEvidenceSourceRange",
+                value: input["range"]
+            }, _errorFactory);
+            const _ap10 = (input, _path, _exceptionable = true) => ("object" === typeof input["location"] && null !== input["location"] || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".location",
+                expected: "IEvidenceSourceLocation",
+                value: input["location"]
+            }, _errorFactory)) && _ao5(input["location"], _path + ".location", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".location",
+                expected: "IEvidenceSourceLocation",
+                value: input["location"]
+            }, _errorFactory);
+            const _ap11 = (input, _path, _exceptionable = true) => (Array.isArray(input["segments"]) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".segments",
+                expected: "Array<string>",
+                value: input["segments"]
+            }, _errorFactory)) && input["segments"].every((elem, _index42) => "string" === typeof elem || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".segments[" + _index42 + "]",
+                expected: "string",
+                value: elem
+            }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".segments",
+                expected: "Array<string>",
+                value: input["segments"]
+            }, _errorFactory);
+            const _ap12 = (input, _path, _exceptionable = true) => "string" === typeof input["hostId"] || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".hostId",
+                expected: "string",
+                value: input["hostId"]
+            }, _errorFactory);
+            const _ap13 = (input, _path, _exceptionable = true) => "string" === typeof input["target"] || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".target",
+                expected: "string",
+                value: input["target"]
+            }, _errorFactory);
+            const _ap14 = (input, _path, _exceptionable = true) => ("object" === typeof input["resolution"] && null !== input["resolution"] || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".resolution",
+                expected: "IEvidenceTargetResolution",
+                value: input["resolution"]
+            }, _errorFactory)) && _ao19(input["resolution"], _path + ".resolution", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".resolution",
+                expected: "IEvidenceTargetResolution",
+                value: input["resolution"]
+            }, _errorFactory);
+            const _ae1 = "(\"ambiguous\" | \"hidden\" | \"incomplete\" | \"malformed\" | \"missing-file\" | \"missing-member\" | \"out-of-population\" | \"resolved\" | \"unsupported-host\")";
+            const _ao0 = (input, _path, _exceptionable = true) => (Array.isArray(input.claims) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".claims",
+                expected: "Array<IEvidenceGraphClaim>",
+                value: input.claims
+            }, _errorFactory)) && input.claims.every((elem, _index24) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".claims[" + _index24 + "]",
+                expected: "IEvidenceGraphClaim",
+                value: elem
+            }, _errorFactory)) && _ao1(elem, _path + ".claims[" + _index24 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".claims[" + _index24 + "]",
+                expected: "IEvidenceGraphClaim",
+                value: elem
+            }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".claims",
+                expected: "Array<IEvidenceGraphClaim>",
+                value: input.claims
+            }, _errorFactory);
+            const _ao1 = (input, _path, _exceptionable = true) => _ap0(input, _path, true && _exceptionable) && (undefined === input.name || "string" === typeof input.name || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".name",
+                expected: "(string | undefined)",
+                value: input.name
+            }, _errorFactory)) && _ap1(input, _path, true && _exceptionable) && _ap2(input, _path, true && _exceptionable) && _ap3(input, _path, true && _exceptionable) && (undefined === input.exclusionHostIds || (Array.isArray(input.exclusionHostIds) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".exclusionHostIds",
+                expected: "(Array<string> | undefined)",
+                value: input.exclusionHostIds
+            }, _errorFactory)) && input.exclusionHostIds.every((elem, _index26) => "string" === typeof elem || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".exclusionHostIds[" + _index26 + "]",
+                expected: "string",
+                value: elem
+            }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".exclusionHostIds",
+                expected: "(Array<string> | undefined)",
+                value: input.exclusionHostIds
+            }, _errorFactory)) && ((Array.isArray(input.references) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".references",
+                expected: "Array<IEvidenceGraphReference>",
+                value: input.references
+            }, _errorFactory)) && input.references.every((elem, _index27) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".references[" + _index27 + "]",
+                expected: "IEvidenceGraphReference",
+                value: elem
+            }, _errorFactory)) && _ao17(elem, _path + ".references[" + _index27 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".references[" + _index27 + "]",
+                expected: "IEvidenceGraphReference",
+                value: elem
+            }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".references",
+                expected: "Array<IEvidenceGraphReference>",
+                value: input.references
+            }, _errorFactory));
+            const _ao10 = (input, _path, _exceptionable = true) => ("hidden" === input.tag || "ignore" === input.tag || "internal" === input.tag || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".tag",
+                expected: "(\"hidden\" | \"ignore\" | \"internal\")",
+                value: input.tag
+            }, _errorFactory)) && _ap10(input, _path, true && _exceptionable);
+            const _ao11 = (input, _path, _exceptionable = true) => _ap7(input, _path, true && _exceptionable) && _ap11(input, _path, true && _exceptionable) && ("string" === typeof input.unitId || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".unitId",
+                expected: "string",
+                value: input.unitId
+            }, _errorFactory));
+            const _ao12 = (input, _path, _exceptionable = true) => _ap6(input, _path, true && _exceptionable) && _ap7(input, _path, true && _exceptionable) && _ap9(input, _path, true && _exceptionable) && (undefined === input.origins || (Array.isArray(input.origins) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".origins",
+                expected: "(Array<string> | undefined)",
+                value: input.origins
+            }, _errorFactory)) && input.origins.every((elem, _index43) => "string" === typeof elem || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".origins[" + _index43 + "]",
+                expected: "string",
+                value: elem
+            }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".origins",
+                expected: "(Array<string> | undefined)",
+                value: input.origins
+            }, _errorFactory)) && (undefined === input.siteId || "string" === typeof input.siteId || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".siteId",
+                expected: "(string | undefined)",
+                value: input.siteId
+            }, _errorFactory)) && _ap3(input, _path, true && _exceptionable) && ("attached" === input.attachment || "unattached" === input.attachment || "unsupported" === input.attachment || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".attachment",
+                expected: "(\"attached\" | \"unattached\" | \"unsupported\")",
+                value: input.attachment
+            }, _errorFactory)) && (undefined === input.problem || "string" === typeof input.problem || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".problem",
+                expected: "(string | undefined)",
+                value: input.problem
+            }, _errorFactory));
+            const _ao13 = (input, _path, _exceptionable = true) => _ap12(input, _path, true && _exceptionable) && _ap13(input, _path, true && _exceptionable) && _ap10(input, _path, true && _exceptionable) && _ap6(input, _path, true && _exceptionable) && ("evidence" === input.kind || "evidenceExclude" === input.kind || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".kind",
+                expected: "(\"evidence\" | \"evidenceExclude\")",
+                value: input.kind
+            }, _errorFactory)) && ("string" === typeof input.reason || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".reason",
+                expected: "string",
+                value: input.reason
+            }, _errorFactory));
+            const _ao14 = (input, _path, _exceptionable = true) => _ap12(input, _path, true && _exceptionable) && _ap13(input, _path, true && _exceptionable) && _ap10(input, _path, true && _exceptionable) && _ap6(input, _path, true && _exceptionable) && ("evidence" === input.reviews || "evidenceExclude" === input.reviews || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".reviews",
+                expected: "(\"evidence\" | \"evidenceExclude\")",
+                value: input.reviews
+            }, _errorFactory)) && (undefined === input.fingerprint || "string" === typeof input.fingerprint || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".fingerprint",
+                expected: "(string | undefined)",
+                value: input.fingerprint
+            }, _errorFactory)) && ("string" === typeof input.description || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".description",
+                expected: "string",
+                value: input.description
+            }, _errorFactory));
+            const _ao15 = (input, _path, _exceptionable = true) => ("string" === typeof input.code || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".code",
+                expected: "string",
+                value: input.code
+            }, _errorFactory)) && ("error" === input.severity || "warning" === input.severity || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".severity",
+                expected: "(\"error\" | \"warning\")",
+                value: input.severity
+            }, _errorFactory)) && ("string" === typeof input.message || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".message",
+                expected: "string",
+                value: input.message
+            }, _errorFactory)) && ("string" === typeof input.repair || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".repair",
+                expected: "string",
+                value: input.repair
+            }, _errorFactory)) && (undefined === input.location || ("object" === typeof input.location && null !== input.location || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".location",
+                expected: "(IEvidenceSourceLocation | undefined)",
+                value: input.location
+            }, _errorFactory)) && _ao5(input.location, _path + ".location", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".location",
+                expected: "(IEvidenceSourceLocation | undefined)",
+                value: input.location
+            }, _errorFactory)) && (undefined === input.claim || "number" === typeof input.claim || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".claim",
+                expected: "(number | undefined)",
+                value: input.claim
+            }, _errorFactory)) && (undefined === input.reference || "number" === typeof input.reference || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".reference",
+                expected: "(number | undefined)",
+                value: input.reference
+            }, _errorFactory)) && (undefined === input.hostId || "string" === typeof input.hostId || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".hostId",
+                expected: "(string | undefined)",
+                value: input.hostId
+            }, _errorFactory)) && (undefined === input.target || "string" === typeof input.target || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".target",
+                expected: "(string | undefined)",
+                value: input.target
+            }, _errorFactory));
+            const _ao16 = (input, _path, _exceptionable = true) => ("string" === typeof input.path || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".path",
+                expected: "string",
+                value: input.path
+            }, _errorFactory)) && ("boolean" === typeof input.recursive || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".recursive",
+                expected: "boolean",
+                value: input.recursive
+            }, _errorFactory));
+            const _ao17 = (input, _path, _exceptionable = true) => _ap0(input, _path, true && _exceptionable) && _ap1(input, _path, true && _exceptionable) && _ap2(input, _path, true && _exceptionable) && _ap3(input, _path, true && _exceptionable) && ((Array.isArray(input.resolutions) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".resolutions",
+                expected: "Array<IEvidenceGraphResolution>",
+                value: input.resolutions
+            }, _errorFactory)) && input.resolutions.every((elem, _index44) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".resolutions[" + _index44 + "]",
+                expected: "IEvidenceGraphResolution",
+                value: elem
+            }, _errorFactory)) && _ao18(elem, _path + ".resolutions[" + _index44 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".resolutions[" + _index44 + "]",
+                expected: "IEvidenceGraphResolution",
+                value: elem
+            }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".resolutions",
+                expected: "Array<IEvidenceGraphResolution>",
+                value: input.resolutions
+            }, _errorFactory)) && (undefined === input.reviewResolutions || (Array.isArray(input.reviewResolutions) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".reviewResolutions",
+                expected: "(Array<IEvidenceGraphReviewResolution> | undefined)",
+                value: input.reviewResolutions
+            }, _errorFactory)) && input.reviewResolutions.every((elem, _index45) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".reviewResolutions[" + _index45 + "]",
+                expected: "IEvidenceGraphReviewResolution",
+                value: elem
+            }, _errorFactory)) && _ao21(elem, _path + ".reviewResolutions[" + _index45 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".reviewResolutions[" + _index45 + "]",
+                expected: "IEvidenceGraphReviewResolution",
+                value: elem
+            }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".reviewResolutions",
+                expected: "(Array<IEvidenceGraphReviewResolution> | undefined)",
+                value: input.reviewResolutions
+            }, _errorFactory)) && (undefined === input.noEvidenceExclude || "boolean" === typeof input.noEvidenceExclude || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".noEvidenceExclude",
+                expected: "(boolean | undefined)",
+                value: input.noEvidenceExclude
+            }, _errorFactory)) && (undefined === input.uniqueEvidence || "boolean" === typeof input.uniqueEvidence || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".uniqueEvidence",
+                expected: "(boolean | undefined)",
+                value: input.uniqueEvidence
+            }, _errorFactory)) && (undefined === input.singleEvidencePerSymbol || "boolean" === typeof input.singleEvidencePerSymbol || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".singleEvidencePerSymbol",
+                expected: "(boolean | undefined)",
+                value: input.singleEvidencePerSymbol
+            }, _errorFactory)) && (undefined === input.checklist || "boolean" === typeof input.checklist || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".checklist",
+                expected: "(boolean | undefined)",
+                value: input.checklist
+            }, _errorFactory)) && (undefined === input.requireReview || "boolean" === typeof input.requireReview || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".requireReview",
+                expected: "(boolean | undefined)",
+                value: input.requireReview
+            }, _errorFactory));
+            const _ao18 = (input, _path, _exceptionable = true) => ("string" === typeof input.declarationId || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".declarationId",
+                expected: "string",
+                value: input.declarationId
+            }, _errorFactory)) && _ap14(input, _path, true && _exceptionable);
+            const _ao19 = (input, _path, _exceptionable = true) => ("ambiguous" === input.status || "hidden" === input.status || "incomplete" === input.status || "malformed" === input.status || "missing-file" === input.status || "missing-member" === input.status || "out-of-population" === input.status || "resolved" === input.status || "unsupported-host" === input.status || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".status",
+                expected: _ae1,
+                value: input.status
+            }, _errorFactory)) && ((Array.isArray(input.addresses) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".addresses",
+                expected: "Array<IEvidenceAddress>",
+                value: input.addresses
+            }, _errorFactory)) && input.addresses.every((elem, _index46) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".addresses[" + _index46 + "]",
+                expected: "IEvidenceAddress",
+                value: elem
+            }, _errorFactory)) && _ao20(elem, _path + ".addresses[" + _index46 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".addresses[" + _index46 + "]",
+                expected: "IEvidenceAddress",
+                value: elem
+            }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".addresses",
+                expected: "Array<IEvidenceAddress>",
+                value: input.addresses
+            }, _errorFactory)) && _ap4(input, _path, true && _exceptionable) && _ap8(input, _path, true && _exceptionable) && _ap5(input, _path, true && _exceptionable);
+            const _ao2 = (input, _path, _exceptionable = true) => (1 === input.schemaVersion || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".schemaVersion",
+                expected: "1",
+                value: input.schemaVersion
+            }, _errorFactory)) && ((Array.isArray(input.sources) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".sources",
+                expected: "Array<IEvidenceSourceFile>",
+                value: input.sources
+            }, _errorFactory)) && input.sources.every((elem, _index28) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".sources[" + _index28 + "]",
+                expected: "IEvidenceSourceFile",
+                value: elem
+            }, _errorFactory)) && _ao3(elem, _path + ".sources[" + _index28 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".sources[" + _index28 + "]",
+                expected: "IEvidenceSourceFile",
+                value: elem
+            }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".sources",
+                expected: "Array<IEvidenceSourceFile>",
+                value: input.sources
+            }, _errorFactory)) && ((Array.isArray(input.annotationRanges) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".annotationRanges",
+                expected: "Array<IEvidenceSourceLocation>",
+                value: input.annotationRanges
+            }, _errorFactory)) && input.annotationRanges.every((elem, _index29) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".annotationRanges[" + _index29 + "]",
+                expected: "IEvidenceSourceLocation",
+                value: elem
+            }, _errorFactory)) && _ao5(elem, _path + ".annotationRanges[" + _index29 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".annotationRanges[" + _index29 + "]",
+                expected: "IEvidenceSourceLocation",
+                value: elem
+            }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".annotationRanges",
+                expected: "Array<IEvidenceSourceLocation>",
+                value: input.annotationRanges
+            }, _errorFactory)) && _ap4(input, _path, true && _exceptionable) && ((Array.isArray(input.addresses) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".addresses",
+                expected: "Array<IEvidencePublicAddress>",
+                value: input.addresses
+            }, _errorFactory)) && input.addresses.every((elem, _index31) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".addresses[" + _index31 + "]",
+                expected: "IEvidencePublicAddress",
+                value: elem
+            }, _errorFactory)) && _ao11(elem, _path + ".addresses[" + _index31 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".addresses[" + _index31 + "]",
+                expected: "IEvidencePublicAddress",
+                value: elem
+            }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".addresses",
+                expected: "Array<IEvidencePublicAddress>",
+                value: input.addresses
+            }, _errorFactory)) && ((Array.isArray(input.hosts) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".hosts",
+                expected: "Array<IEvidenceHost>",
+                value: input.hosts
+            }, _errorFactory)) && input.hosts.every((elem, _index32) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".hosts[" + _index32 + "]",
+                expected: "IEvidenceHost",
+                value: elem
+            }, _errorFactory)) && _ao12(elem, _path + ".hosts[" + _index32 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".hosts[" + _index32 + "]",
+                expected: "IEvidenceHost",
+                value: elem
+            }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".hosts",
+                expected: "Array<IEvidenceHost>",
+                value: input.hosts
+            }, _errorFactory)) && ((Array.isArray(input.declarations) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".declarations",
+                expected: "Array<IEvidenceDeclaration>",
+                value: input.declarations
+            }, _errorFactory)) && input.declarations.every((elem, _index33) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".declarations[" + _index33 + "]",
+                expected: "IEvidenceDeclaration",
+                value: elem
+            }, _errorFactory)) && _ao13(elem, _path + ".declarations[" + _index33 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".declarations[" + _index33 + "]",
+                expected: "IEvidenceDeclaration",
+                value: elem
+            }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".declarations",
+                expected: "Array<IEvidenceDeclaration>",
+                value: input.declarations
+            }, _errorFactory)) && ((Array.isArray(input.reviews) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".reviews",
+                expected: "Array<IEvidenceReview>",
+                value: input.reviews
+            }, _errorFactory)) && input.reviews.every((elem, _index34) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".reviews[" + _index34 + "]",
+                expected: "IEvidenceReview",
+                value: elem
+            }, _errorFactory)) && _ao14(elem, _path + ".reviews[" + _index34 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".reviews[" + _index34 + "]",
+                expected: "IEvidenceReview",
+                value: elem
+            }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".reviews",
+                expected: "Array<IEvidenceReview>",
+                value: input.reviews
+            }, _errorFactory)) && _ap5(input, _path, true && _exceptionable) && ((Array.isArray(input.dependencies) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".dependencies",
+                expected: "Array<IEvidenceSourceDependency>",
+                value: input.dependencies
+            }, _errorFactory)) && input.dependencies.every((elem, _index36) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".dependencies[" + _index36 + "]",
+                expected: "IEvidenceSourceDependency",
+                value: elem
+            }, _errorFactory)) && _ao16(elem, _path + ".dependencies[" + _index36 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".dependencies[" + _index36 + "]",
+                expected: "IEvidenceSourceDependency",
+                value: elem
+            }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".dependencies",
+                expected: "Array<IEvidenceSourceDependency>",
+                value: input.dependencies
+            }, _errorFactory)) && ("boolean" === typeof input.complete || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".complete",
+                expected: "boolean",
+                value: input.complete
+            }, _errorFactory));
+            const _ao20 = (input, _path, _exceptionable = true) => _ap7(input, _path, true && _exceptionable) && _ap11(input, _path, true && _exceptionable);
+            const _ao21 = (input, _path, _exceptionable = true) => ("string" === typeof input.reviewId || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".reviewId",
+                expected: "string",
+                value: input.reviewId
+            }, _errorFactory)) && _ap14(input, _path, true && _exceptionable);
+            const _ao3 = (input, _path, _exceptionable = true) => _ap6(input, _path, true && _exceptionable) && ("string" === typeof input.physicalPath || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".physicalPath",
+                expected: "string",
+                value: input.physicalPath
+            }, _errorFactory)) && ("string" === typeof input.content || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".content",
+                expected: "string",
+                value: input.content
+            }, _errorFactory)) && ("string" === typeof input.digest || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".digest",
+                expected: "string",
+                value: input.digest
+            }, _errorFactory)) && ((Array.isArray(input.addresses) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".addresses",
+                expected: "Array<IEvidenceSourceAddress>",
+                value: input.addresses
+            }, _errorFactory)) && input.addresses.every((elem, _index37) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".addresses[" + _index37 + "]",
+                expected: "IEvidenceSourceAddress",
+                value: elem
+            }, _errorFactory)) && _ao4(elem, _path + ".addresses[" + _index37 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".addresses[" + _index37 + "]",
+                expected: "IEvidenceSourceAddress",
+                value: elem
+            }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".addresses",
+                expected: "Array<IEvidenceSourceAddress>",
+                value: input.addresses
+            }, _errorFactory));
+            const _ao4 = (input, _path, _exceptionable = true) => ("string" === typeof input.absolute || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".absolute",
+                expected: "string",
+                value: input.absolute
+            }, _errorFactory)) && ("string" === typeof input.relative || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".relative",
+                expected: "string",
+                value: input.relative
+            }, _errorFactory)) && ("string" === typeof input.display || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".display",
+                expected: "string",
+                value: input.display
+            }, _errorFactory)) && (undefined === input.selected || "boolean" === typeof input.selected || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".selected",
+                expected: "(boolean | undefined)",
+                value: input.selected
+            }, _errorFactory));
+            const _ao5 = (input, _path, _exceptionable = true) => _ap7(input, _path, true && _exceptionable) && (undefined === input.range || ("object" === typeof input.range && null !== input.range || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".range",
+                expected: "(IEvidenceSourceRange | undefined)",
+                value: input.range
+            }, _errorFactory)) && _ao6(input.range, _path + ".range", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".range",
+                expected: "(IEvidenceSourceRange | undefined)",
+                value: input.range
+            }, _errorFactory));
+            const _ao6 = (input, _path, _exceptionable = true) => (("object" === typeof input.start && null !== input.start || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".start",
+                expected: "IEvidenceSourcePosition",
+                value: input.start
+            }, _errorFactory)) && _ao7(input.start, _path + ".start", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".start",
+                expected: "IEvidenceSourcePosition",
+                value: input.start
+            }, _errorFactory)) && (("object" === typeof input.end && null !== input.end || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".end",
+                expected: "IEvidenceSourcePosition",
+                value: input.end
+            }, _errorFactory)) && _ao7(input.end, _path + ".end", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".end",
+                expected: "IEvidenceSourcePosition",
+                value: input.end
+            }, _errorFactory));
+            const _ao7 = (input, _path, _exceptionable = true) => ("number" === typeof input.offset || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".offset",
+                expected: "number",
+                value: input.offset
+            }, _errorFactory)) && ("number" === typeof input.line || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".line",
+                expected: "number",
+                value: input.line
+            }, _errorFactory)) && ("number" === typeof input.column || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".column",
+                expected: "number",
+                value: input.column
+            }, _errorFactory));
+            const _ao8 = (input, _path, _exceptionable = true) => _ap6(input, _path, true && _exceptionable) && (undefined === input.parentId || "string" === typeof input.parentId || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".parentId",
+                expected: "(string | undefined)",
+                value: input.parentId
+            }, _errorFactory)) && (true === _av0.has(input.type) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".type",
+                expected: _ae0,
+                value: input.type
+            }, _errorFactory)) && (true === _av1.has(input.symbol) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".symbol",
+                expected: "(\"column\" | \"file\" | \"function\" | \"h1\" | \"h2\" | \"h3\" | \"h4\" | \"model\" | \"operation\" | \"property\" | \"relation\" | \"type\")",
+                value: input.symbol
+            }, _errorFactory)) && ((Array.isArray(input.identity) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".identity",
+                expected: "Array<string>",
+                value: input.identity
+            }, _errorFactory)) && input.identity.every((elem, _index38) => "string" === typeof elem || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".identity[" + _index38 + "]",
+                expected: "string",
+                value: elem
+            }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".identity",
+                expected: "Array<string>",
+                value: input.identity
+            }, _errorFactory)) && ("string" === typeof input.name || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".name",
+                expected: "string",
+                value: input.name
+            }, _errorFactory)) && (undefined === input.contentDigest || "string" === typeof input.contentDigest || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".contentDigest",
+                expected: "(string | undefined)",
+                value: input.contentDigest
+            }, _errorFactory)) && ((Array.isArray(input.sites) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".sites",
+                expected: "Array<IEvidenceUnitSite>",
+                value: input.sites
+            }, _errorFactory)) && input.sites.every((elem, _index39) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".sites[" + _index39 + "]",
+                expected: "IEvidenceUnitSite",
+                value: elem
+            }, _errorFactory)) && _ao9(elem, _path + ".sites[" + _index39 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".sites[" + _index39 + "]",
+                expected: "IEvidenceUnitSite",
+                value: elem
+            }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".sites",
+                expected: "Array<IEvidenceUnitSite>",
+                value: input.sites
+            }, _errorFactory)) && _ap8(input, _path, true && _exceptionable);
+            const _ao9 = (input, _path, _exceptionable = true) => _ap6(input, _path, true && _exceptionable) && _ap7(input, _path, true && _exceptionable) && _ap9(input, _path, true && _exceptionable) && ((Array.isArray(input.content) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".content",
+                expected: "Array<IEvidenceSourceRange>",
+                value: input.content
+            }, _errorFactory)) && input.content.every((elem, _index41) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".content[" + _index41 + "]",
+                expected: "IEvidenceSourceRange",
+                value: elem
+            }, _errorFactory)) && _ao6(elem, _path + ".content[" + _index41 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".content[" + _index41 + "]",
+                expected: "IEvidenceSourceRange",
+                value: elem
+            }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".content",
+                expected: "Array<IEvidenceSourceRange>",
+                value: input.content
+            }, _errorFactory));
+            const _io0 = input => Array.isArray(input.claims) && input.claims.every(elem => "object" === typeof elem && null !== elem && _io1(elem));
+            const _io1 = input => _ip0(input) && (undefined === input.name || "string" === typeof input.name) && _ip1(input) && _ip2(input) && _ip3(input) && (undefined === input.exclusionHostIds || Array.isArray(input.exclusionHostIds) && input.exclusionHostIds.every(elem => "string" === typeof elem)) && (Array.isArray(input.references) && input.references.every(elem => "object" === typeof elem && null !== elem && _io17(elem)));
+            const _io10 = input => ("hidden" === input.tag || "ignore" === input.tag || "internal" === input.tag) && _ip10(input);
+            const _io11 = input => _ip7(input) && _ip11(input) && "string" === typeof input.unitId;
+            const _io12 = input => _ip6(input) && _ip7(input) && _ip9(input) && (undefined === input.origins || Array.isArray(input.origins) && input.origins.every(elem => "string" === typeof elem)) && (undefined === input.siteId || "string" === typeof input.siteId) && _ip3(input) && ("attached" === input.attachment || "unattached" === input.attachment || "unsupported" === input.attachment) && (undefined === input.problem || "string" === typeof input.problem);
+            const _io13 = input => _ip12(input) && _ip13(input) && _ip10(input) && _ip6(input) && ("evidence" === input.kind || "evidenceExclude" === input.kind) && "string" === typeof input.reason;
+            const _io14 = input => _ip12(input) && _ip13(input) && _ip10(input) && _ip6(input) && ("evidence" === input.reviews || "evidenceExclude" === input.reviews) && (undefined === input.fingerprint || "string" === typeof input.fingerprint) && "string" === typeof input.description;
+            const _io15 = input => "string" === typeof input.code && ("error" === input.severity || "warning" === input.severity) && "string" === typeof input.message && "string" === typeof input.repair && (undefined === input.location || "object" === typeof input.location && null !== input.location && _io5(input.location)) && (undefined === input.claim || "number" === typeof input.claim) && (undefined === input.reference || "number" === typeof input.reference) && (undefined === input.hostId || "string" === typeof input.hostId) && (undefined === input.target || "string" === typeof input.target);
+            const _io16 = input => "string" === typeof input.path && "boolean" === typeof input.recursive;
+            const _io17 = input => _ip0(input) && _ip1(input) && _ip2(input) && _ip3(input) && (Array.isArray(input.resolutions) && input.resolutions.every(elem => "object" === typeof elem && null !== elem && _io18(elem))) && (undefined === input.reviewResolutions || Array.isArray(input.reviewResolutions) && input.reviewResolutions.every(elem => "object" === typeof elem && null !== elem && _io21(elem))) && (undefined === input.noEvidenceExclude || "boolean" === typeof input.noEvidenceExclude) && (undefined === input.uniqueEvidence || "boolean" === typeof input.uniqueEvidence) && (undefined === input.singleEvidencePerSymbol || "boolean" === typeof input.singleEvidencePerSymbol) && (undefined === input.checklist || "boolean" === typeof input.checklist) && (undefined === input.requireReview || "boolean" === typeof input.requireReview);
+            const _io18 = input => "string" === typeof input.declarationId && _ip14(input);
+            const _io19 = input => ("ambiguous" === input.status || "hidden" === input.status || "incomplete" === input.status || "malformed" === input.status || "missing-file" === input.status || "missing-member" === input.status || "out-of-population" === input.status || "resolved" === input.status || "unsupported-host" === input.status) && (Array.isArray(input.addresses) && input.addresses.every(elem => "object" === typeof elem && null !== elem && _io20(elem))) && _ip4(input) && _ip8(input) && _ip5(input);
+            const _io2 = input => 1 === input.schemaVersion && (Array.isArray(input.sources) && input.sources.every(elem => "object" === typeof elem && null !== elem && _io3(elem))) && (Array.isArray(input.annotationRanges) && input.annotationRanges.every(elem => "object" === typeof elem && null !== elem && _io5(elem))) && _ip4(input) && (Array.isArray(input.addresses) && input.addresses.every(elem => "object" === typeof elem && null !== elem && _io11(elem))) && (Array.isArray(input.hosts) && input.hosts.every(elem => "object" === typeof elem && null !== elem && _io12(elem))) && (Array.isArray(input.declarations) && input.declarations.every(elem => "object" === typeof elem && null !== elem && _io13(elem))) && (Array.isArray(input.reviews) && input.reviews.every(elem => "object" === typeof elem && null !== elem && _io14(elem))) && _ip5(input) && (Array.isArray(input.dependencies) && input.dependencies.every(elem => "object" === typeof elem && null !== elem && _io16(elem))) && "boolean" === typeof input.complete;
+            const _io20 = input => _ip7(input) && _ip11(input);
+            const _io21 = input => "string" === typeof input.reviewId && _ip14(input);
+            const _io3 = input => _ip6(input) && "string" === typeof input.physicalPath && "string" === typeof input.content && "string" === typeof input.digest && (Array.isArray(input.addresses) && input.addresses.every(elem => "object" === typeof elem && null !== elem && _io4(elem)));
+            const _io4 = input => "string" === typeof input.absolute && "string" === typeof input.relative && "string" === typeof input.display && (undefined === input.selected || "boolean" === typeof input.selected);
+            const _io5 = input => _ip7(input) && (undefined === input.range || "object" === typeof input.range && null !== input.range && _io6(input.range));
+            const _io6 = input => "object" === typeof input.start && null !== input.start && _io7(input.start) && ("object" === typeof input.end && null !== input.end && _io7(input.end));
+            const _io7 = input => "number" === typeof input.offset && "number" === typeof input.line && "number" === typeof input.column;
+            const _io8 = input => _ip6(input) && (undefined === input.parentId || "string" === typeof input.parentId) && true === _iv0.has(input.type) && true === _iv1.has(input.symbol) && (Array.isArray(input.identity) && input.identity.every(elem => "string" === typeof elem)) && "string" === typeof input.name && (undefined === input.contentDigest || "string" === typeof input.contentDigest) && (Array.isArray(input.sites) && input.sites.every(elem => "object" === typeof elem && null !== elem && _io9(elem))) && _ip8(input);
+            const _io9 = input => _ip6(input) && _ip7(input) && _ip9(input) && (Array.isArray(input.content) && input.content.every(elem => "object" === typeof elem && null !== elem && _io6(elem)));
+            const __is = input => "object" === typeof input && null !== input && _io0(input);
+            let _errorFactory;
+            return (input, errorFactory) => {
+                if (false === __is(input)) {
+                    _errorFactory = errorFactory;
+                    ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input || _assertGuard_1._assertGuard(true, {
+                        method: "typia.assert",
+                        path: _path + "",
+                        expected: "IEvidenceGraphInput",
+                        value: input
+                    }, _errorFactory)) && _ao0(input, _path + "", true) || _assertGuard_1._assertGuard(true, {
+                        method: "typia.assert",
+                        path: _path + "",
+                        expected: "IEvidenceGraphInput",
+                        value: input
+                    }, _errorFactory))(input, "$input", true);
+                }
+                return input;
+            };
+        })()(input));
+    }
+    /**
+     * Evaluates every independent obligation in the captured input.
+     *
+     * A fresh evaluator prevents coverage sets and deferred diagnostics from leaking
+     * across calls. The returned clone also prevents consumers from mutating records
+     * retained by the facade.
+     */
+    evaluate() {
+        return structuredClone(new GraphEvaluator(this.input).evaluate());
+    }
+    /**
+     * Captures and evaluates input without retaining a graph facade.
+     *
+     * This convenience entry point has the same validation and result ownership as
+     * construction followed by the instance `evaluate` method.
+     */
+    static evaluate(input) {
+        return new EvidenceGraph(input).evaluate();
+    }
+}
+exports.EvidenceGraph = EvidenceGraph;
+/**
+ * Owns coverage accumulation and deferred findings for one graph evaluation.
+ *
+ * Claim and reference contexts keep local populations and resolutions, while this
+ * controller records whether acknowledgements participate anywhere in the graph.
+ * That shared participation state is needed to avoid declaring an unhosted
+ * checklist citation invalid before another applicable reference can explain it.
+ *
+ * The public facade creates a new controller for every evaluation. Its sets and
+ * maps therefore describe one traversal only and must not become facade caches.
+ */
+class GraphEvaluator {
+    /**
+     * Acknowledgements handled by a complete applicable obligation.
+     *
+     * Final checklist reporting consults this set across references, preventing a
+     * citation accepted elsewhere from receiving a premature unhosted finding.
+     */
+    answeredDeclarations = new Set();
+    /**
+     * Findings accumulated during this single traversal.
+     *
+     * Finalization deduplicates equivalent findings after all claims are evaluated.
+     * The array is never reused by a later facade invocation.
+     */
+    diagnostics = [];
+    /**
+     * Acknowledgements whose participation is uncertain because analysis failed.
+     *
+     * Deferred reporting must not infer invalid ownership from a reference that
+     * could not supply a complete population or resolution.
+     */
+    uncertainDeclarations = new Set();
+    /**
+     * Checklist statements awaiting graph-wide participation finalization.
+     *
+     * Each record retains its diagnostic boundary and severity. Later references
+     * can establish that the statement was handled or that its status is uncertain.
+     */
+    unhostedChecklists = new Map();
+    /**
+     * Captured facade input used to create this traversal's claim contexts.
+     *
+     * The controller relies on the facade's shape validation and copy ownership;
+     * it adds evaluation state without replacing or reloading source populations.
+     */
+    input;
+    /**
+     * Binds captured input to empty per-evaluation state.
+     *
+     * The facade owns input validation and cloning. Keeping construction separate
+     * from traversal lets every evaluation start with empty participation sets.
+     */
+    constructor(input) {
+        this.input = input;
+    }
+    /**
+     * Evaluates claims, then finalizes findings that depend on reference participation.
+     *
+     * Inactive obligations do not affect completeness. Every active claim and
+     * reference must be complete, and the final diagnostic list must be empty,
+     * before this graph result is successful.
+     */
+    evaluate() {
+        const claims = this.input.claims.map((claim, index) => this.evaluateClaim(claim, index));
+        // A citation can participate in another reference. Decide deferred checklist
+        // findings only after every claim has recorded accepted or uncertain usage.
+        this.reportUnhostedChecklists();
+        const diagnostics = InventoryMerge_1.InventoryMerge.unique(this.diagnostics, (diagnostic) => (() => {
+            const _so0 = input => `{${_jsonStringifyTail_1._jsonStringifyTail(`"code":${_jsonStringifyString_1._jsonStringifyString(input.code)},"severity":${"\"" + input.severity + "\""},"message":${_jsonStringifyString_1._jsonStringifyString(input.message)},"repair":${_jsonStringifyString_1._jsonStringifyString(input.repair)},${undefined === input.location ? "" : `"location":${undefined !== input.location ? _so1(input.location) : undefined},`}${undefined === input.claim ? "" : `"claim":${undefined !== input.claim ? String(_jsonStringifyNumber_1._jsonStringifyNumber(input.claim)) : undefined},`}${undefined === input.reference ? "" : `"reference":${undefined !== input.reference ? String(_jsonStringifyNumber_1._jsonStringifyNumber(input.reference)) : undefined},`}${undefined === input.hostId ? "" : `"hostId":${undefined !== input.hostId ? _jsonStringifyString_1._jsonStringifyString(input.hostId) : undefined},`}${undefined === input.target ? "" : `"target":${undefined !== input.target ? _jsonStringifyString_1._jsonStringifyString(input.target) : undefined}`}`)}}`;
+            const _so1 = input => `{${_jsonStringifyTail_1._jsonStringifyTail(`"file":${_jsonStringifyString_1._jsonStringifyString(input.file)},${undefined === input.range ? "" : `"range":${undefined !== input.range ? _so2(input.range) : undefined}`}`)}}`;
+            const _so2 = input => `{"start":${_so3(input.start)},"end":${_so3(input.end)}}`;
+            const _so3 = input => `{"offset":${String(_jsonStringifyNumber_1._jsonStringifyNumber(input.offset))},"line":${String(_jsonStringifyNumber_1._jsonStringifyNumber(input.line))},"column":${String(_jsonStringifyNumber_1._jsonStringifyNumber(input.column))}}`;
+            const _io1 = input => "string" === typeof input.file && (undefined === input.range || "object" === typeof input.range && null !== input.range && _io2(input.range));
+            const _io2 = input => "object" === typeof input.start && null !== input.start && _io3(input.start) && ("object" === typeof input.end && null !== input.end && _io3(input.end));
+            const _io3 = input => "number" === typeof input.offset && "number" === typeof input.line && "number" === typeof input.column;
+            return input => _so0(input);
+        })()(diagnostic));
+        const complete = claims.every((claim) => !claim.active ||
+            (claim.complete &&
+                claim.obligations.every((obligation) => !obligation.active || obligation.complete)));
+        return {
+            success: complete && diagnostics.length === 0,
+            claims,
+            diagnostics,
+        };
+    }
+    /**
+     * Evaluates one claim and establishes its independent obligation boundaries.
+     *
+     * Disabled claims produce inactive reference records without touching their
+     * inventories. A complete claim with no selected units is likewise inactive;
+     * otherwise an incomplete claim remains active and marks every child
+     * obligation incomplete so missing extraction cannot reduce required coverage.
+     */
+    evaluateClaim(claim, claimIndex) {
+        if (claim.severity === "off")
+            return {
+                claim: this.claimIndex(claimIndex),
+                active: false,
+                complete: true,
+                obligations: claim.references.map((reference, referenceIndex) => this.inactiveObligation(claimIndex, referenceIndex, reference)),
+            };
+        const inventory = new EvidenceInventory_1.EvidenceInventory([claim.inventory]);
+        const snapshot = inventory.snapshot();
+        const population = inventory.select(claim.unitIds);
+        const context = {
+            claim,
+            inventory: snapshot,
+            population,
+            index: claimIndex,
+        };
+        this.diagnostics.push(...snapshot.diagnostics.map((diagnostic) => this.context(diagnostic, claim.severity, claimIndex)));
+        if (!snapshot.complete)
+            for (const declaration of snapshot.declarations)
+                this.uncertainDeclarations.add(declaration.id);
+        if (snapshot.complete && population.units.length === 0)
+            return {
+                claim: this.claimIndex(claimIndex),
+                active: false,
+                complete: true,
+                obligations: claim.references.map((reference, referenceIndex) => this.inactiveObligation(claimIndex, referenceIndex, reference)),
+            };
+        const obligations = claim.references.map((reference, referenceIndex) => snapshot.complete
+            ? this.evaluateReference(context, reference, referenceIndex)
+            : this.incompleteObligation(claimIndex, referenceIndex, reference));
+        return {
+            claim: this.claimIndex(claimIndex),
+            active: true,
+            complete: snapshot.complete,
+            obligations,
+        };
+    }
+    /**
+     * Prepares one reference obligation and stops before coverage when its inputs are uncertain.
+     *
+     * Reference selection, acknowledgement resolution, and review resolution are
+     * validated at this boundary because each reference owns them independently.
+     * Any incomplete inventory or resolution records participation as uncertain
+     * and returns an incomplete obligation instead of deriving coverage from a
+     * potentially smaller population.
+     */
+    evaluateReference(context, reference, referenceIndex) {
+        const { claim, inventory: claimInventory, index: claimIndex } = context;
+        if (reference.severity === "off")
+            return this.inactiveObligation(claimIndex, referenceIndex, reference);
+        const inventory = new EvidenceInventory_1.EvidenceInventory([reference.inventory]);
+        const snapshot = inventory.snapshot();
+        const population = inventory.select(reference.unitIds);
+        this.validateReferencePolicy(claim, reference, population, claimIndex, referenceIndex);
+        this.diagnostics.push(...snapshot.diagnostics.map((diagnostic) => this.context(diagnostic, reference.severity, claimIndex, referenceIndex)));
+        if (!snapshot.complete)
+            for (const declaration of claimInventory.declarations)
+                this.uncertainDeclarations.add(declaration.id);
+        const unitIds = population.units.map((unit) => unit.id);
+        if (!snapshot.complete)
+            return this.obligation(claimIndex, referenceIndex, true, false, unitIds, [], []);
+        if (unitIds.length === 0) {
+            this.diagnostics.push(this.problem("graph-empty-reference", reference.severity, "The reference contains no selected evidence units.", "Select symbol kinds present in the reference files or correct its source selection.", claimIndex, referenceIndex));
+            return this.obligation(claimIndex, referenceIndex, true, true, [], [], []);
+        }
+        const resolutions = this.resolutions(claimInventory, reference, claimIndex, referenceIndex);
+        const reviewResolutions = this.reviewResolutions(claimInventory, reference, claimIndex, referenceIndex);
+        for (const entry of resolutions)
+            this.diagnostics.push(...entry.resolution.diagnostics.map((diagnostic) => this.context(diagnostic, reference.severity, claimIndex, referenceIndex)));
+        for (const entry of reviewResolutions)
+            this.diagnostics.push(...entry.resolution.diagnostics.map((diagnostic) => this.context(diagnostic, reference.severity, claimIndex, referenceIndex)));
+        const incomplete = [
+            ...resolutions.map((entry) => entry.resolution.status),
+            ...reviewResolutions.map((entry) => entry.resolution.status),
+        ].includes("incomplete");
+        if (incomplete) {
+            for (const entry of resolutions)
+                if (entry.resolution.status === "incomplete")
+                    this.uncertainDeclarations.add(entry.declarationId);
+            if (reviewResolutions.some((entry) => entry.resolution.status === "incomplete"))
+                for (const declaration of claimInventory.declarations)
+                    this.uncertainDeclarations.add(declaration.id);
+            return this.obligation(claimIndex, referenceIndex, true, false, unitIds, [], []);
+        }
+        return this.cover({
+            claim: context,
+            reference,
+            inventory: snapshot,
+            population,
+            index: referenceIndex,
+            resolutions,
+            reviewResolutions,
+        });
+    }
+    /**
+     * Evaluates acknowledgements against one independent reference context.
+     *
+     * Coverage, exclusion conflicts, reviews, and cardinality all use this same
+     * claim/reference boundary. The method retains one edge per accepted statement
+     * so reports can explain both the selected units it covers and the host that
+     * accepted responsibility for them.
+     */
+    cover(context) {
+        const { claim: { claim, inventory: claimInventory, population: claimPopulation, index: claimIndex, }, reference, index: referenceIndex, inventory: referenceInventory, population: referencePopulation, resolutions, } = context;
+        const declarations = new Map(claimInventory.declarations.map((declaration) => [
+            declaration.id,
+            declaration,
+        ]));
+        const selectedHosts = new Map(claimPopulation.hosts.map((host) => [host.id, host.unitIds]));
+        const attachedHosts = new Set(claimInventory.hosts
+            .filter((host) => host.attachment === "attached")
+            .map((host) => host.id));
+        const exclusionHosts = new Set(claim.exclusionHostIds === undefined
+            ? attachedHosts
+            : claim.exclusionHostIds.filter((id) => attachedHosts.has(id)));
+        const units = new Map(referenceInventory.units.map((unit) => [unit.id, unit]));
+        const selectedUnits = referencePopulation.units;
+        const selectedUnitIds = new Set(selectedUnits.map((unit) => unit.id));
+        const scopeIds = new Set(referencePopulation.scopes.map((unit) => unit.id));
+        const fingerprints = new EvidenceFingerprintIndex_1.EvidenceFingerprintIndex(referenceInventory);
+        const checklist = reference.checklist === true;
+        const explainedByHost = new Map();
+        const covered = new Set();
+        const edges = [];
+        for (const entry of resolutions) {
+            const declaration = declarations.get(entry.declarationId);
+            if (declaration === undefined) {
+                this.diagnostics.push(this.problem("graph-resolution-declaration", reference.severity, `Resolution '${entry.declarationId}' has no claim acknowledgement.`, "Rebuild target resolutions from this claim inventory before evaluating the graph.", claimIndex, referenceIndex));
+                continue;
+            }
+            if (entry.resolution.status !== "resolved")
+                continue;
+            const target = entry.resolution.units[0];
+            if (target === undefined ||
+                entry.resolution.units.length !== 1 ||
+                !scopeIds.has(target.id)) {
+                this.diagnostics.push(this.problem("graph-resolution-scope", reference.severity, `Resolved target '${declaration.target}' is outside this reference's selected structural scopes.`, "Resolve the declaration with this reference's exact selected unit IDs.", claimIndex, referenceIndex, declaration));
+                continue;
+            }
+            let unitIds = selectedUnits
+                .filter((unit) => this.descends(unit, target.id, units))
+                .map((unit) => unit.id);
+            if (unitIds.length === 0)
+                continue;
+            const hostUnitIds = selectedHosts.get(declaration.hostId) ?? [];
+            if (declaration.kind === "evidence" &&
+                hostUnitIds.length === 0 &&
+                checklist) {
+                this.recordUnhostedChecklist(declaration, reference.severity, claimIndex, referenceIndex);
+                continue;
+            }
+            if ((declaration.kind === "evidence" && hostUnitIds.length === 0) ||
+                (declaration.kind === "evidenceExclude" &&
+                    !exclusionHosts.has(declaration.hostId))) {
+                this.diagnostics.push(this.problem("graph-out-of-scope-host", reference.severity, `@${declaration.kind} for '${declaration.target}' is outside its eligible claim hosts.`, declaration.kind === "evidence"
+                    ? "Move the acknowledgement to a host selected by the claim's symbol kinds."
+                    : "Move the exclusion to an eligible public carrier in the claim files.", claimIndex, referenceIndex, declaration));
+                continue;
+            }
+            if (declaration.kind === "evidenceExclude" &&
+                reference.noEvidenceExclude === true) {
+                this.diagnostics.push(this.problem("graph-forbidden-exclusion", reference.severity, `@evidenceExclude for '${declaration.target}' is forbidden by noEvidenceExclude.`, "Remove the exclusion and cite the implemented target with positive @evidence.", claimIndex, referenceIndex, declaration));
+                continue;
+            }
+            if (checklist && hostUnitIds.length === 0) {
+                this.recordUnhostedChecklist(declaration, reference.severity, claimIndex, referenceIndex);
+                continue;
+            }
+            if (checklist &&
+                declaration.kind === "evidence" &&
+                !selectedUnitIds.has(target.id)) {
+                this.answeredDeclarations.add(declaration.id);
+                this.diagnostics.push(this.problem("graph-checklist-aggregate", reference.severity, `Positive checklist target '${declaration.target}' names an unselected aggregate containing ${unitIds.length} selected item(s).`, "Cite each selected checklist item this host answers, or exclude the aggregate when none of it applies.", claimIndex, referenceIndex, declaration));
+                for (const hostUnitId of hostUnitIds) {
+                    let explained = explainedByHost.get(hostUnitId);
+                    if (explained === undefined) {
+                        explained = new Set();
+                        explainedByHost.set(hostUnitId, explained);
+                    }
+                    for (const unitId of unitIds)
+                        explained.add(unitId);
+                }
+                continue;
+            }
+            if (checklist && declaration.kind === "evidence")
+                unitIds = [target.id];
+            this.conflicts(declaration, target.id, hostUnitIds, unitIds, edges, declarations, reference.severity, claimIndex, referenceIndex, checklist);
+            edges.push({
+                declarationId: declaration.id,
+                hostId: declaration.hostId,
+                hostUnitIds,
+                kind: declaration.kind,
+                targetUnitId: target.id,
+                unitIds,
+                fingerprint: fingerprints.inspect(target.id).fingerprint,
+            });
+            this.answeredDeclarations.add(declaration.id);
+            if (!checklist)
+                for (const id of unitIds)
+                    covered.add(id);
+        }
+        this.evaluateReviews(context, edges);
+        if (checklist)
+            return this.checklistObligation(context, edges, explainedByHost);
+        this.cardinality(context, edges);
+        const coveredUnitIds = selectedUnits
+            .filter((unit) => covered.has(unit.id))
+            .map((unit) => unit.id);
+        const missingUnits = selectedUnits.filter((unit) => !covered.has(unit.id));
+        for (const unit of missingUnits)
+            this.diagnostics.push(this.problem("graph-missing-acknowledgement", reference.severity, `Missing acknowledgement for '${this.display(referenceInventory, unit)}'.`, reference.noEvidenceExclude === true
+                ? "Cite the claim artifact that implements this unit with positive @evidence."
+                : "Cite the claim artifact that implements this unit with @evidence, or exclude it on an eligible carrier when it does not apply.", claimIndex, referenceIndex, undefined, unit));
+        return this.obligation(claimIndex, referenceIndex, true, true, selectedUnits.map((unit) => unit.id), coveredUnitIds, missingUnits.map((unit) => unit.id), edges);
+    }
+    /**
+     * Computes checklist coverage separately for every selected claim host.
+     *
+     * A checklist does not permit one host's acknowledgement to answer another
+     * host's obligation. Aggregate citations that were diagnosed earlier are kept
+     * as explanations, allowing the result to distinguish an explicitly invalid
+     * aggregate answer from an entirely absent answer.
+     */
+    checklistObligation(context, edges, explainedByHost) {
+        const { claim: { inventory: claimInventory, population: claimPopulation, index: claimIndex, }, reference, index: referenceIndex, inventory: referenceInventory, } = context;
+        const selectedUnits = context.population.units;
+        const coveredByHost = new Map(claimPopulation.units.map((unit) => [unit.id, new Set()]));
+        for (const edge of edges)
+            for (const hostUnitId of edge.hostUnitIds) {
+                const covered = coveredByHost.get(hostUnitId);
+                if (covered === undefined)
+                    continue;
+                for (const unitId of edge.unitIds)
+                    covered.add(unitId);
+            }
+        const hostCoverage = claimPopulation.units.map((host) => {
+            const covered = coveredByHost.get(host.id) ?? new Set();
+            const explained = explainedByHost.get(host.id) ?? new Set();
+            const coveredUnitIds = selectedUnits
+                .filter((unit) => covered.has(unit.id))
+                .map((unit) => unit.id);
+            const missingUnits = selectedUnits.filter((unit) => !covered.has(unit.id));
+            const explainedUnitIds = missingUnits
+                .filter((unit) => explained.has(unit.id))
+                .map((unit) => unit.id);
+            const reportable = missingUnits.filter((unit) => !explained.has(unit.id));
+            if (reportable.length !== 0)
+                this.diagnostics.push(this.problem("graph-checklist-missing", reference.severity, `Host '${this.display(claimInventory, host)}' has not acknowledged ${reportable.length} of ${selectedUnits.length} checklist item(s): ${reportable
+                    .map((unit) => `'${this.display(referenceInventory, unit)}'`)
+                    .join(", ")}.`, reference.noEvidenceExclude === true
+                    ? "Cite every missing checklist item from this host with positive @evidence."
+                    : "Cite every missing checklist item from this host, or exclude the scope that does not apply.", claimIndex, referenceIndex, undefined, host));
+            return {
+                hostUnitId: host.id,
+                coveredUnitIds,
+                missingUnitIds: missingUnits.map((unit) => unit.id),
+                explainedUnitIds,
+            };
+        });
+        const coveredUnitIds = selectedUnits
+            .filter((unit) => hostCoverage.every((host) => host.coveredUnitIds.includes(unit.id)))
+            .map((unit) => unit.id);
+        const covered = new Set(coveredUnitIds);
+        return this.obligation(claimIndex, referenceIndex, true, true, selectedUnits.map((unit) => unit.id), coveredUnitIds, selectedUnits
+            .filter((unit) => !covered.has(unit.id))
+            .map((unit) => unit.id), edges, hostCoverage);
+    }
+    /**
+     * Enforces cardinality policies over positive coverage edges.
+     *
+     * Exclusions do not count as evidence, and aliases cannot inflate counts
+     * because sets use semantic identities. This runs after edge creation so the
+     * policy observes the same host and target scopes reported to callers.
+     */
+    cardinality(context, edges) {
+        const { claim: { inventory: claimInventory, population: claimPopulation, index: claimIndex, }, reference, index: referenceIndex, inventory: referenceInventory, } = context;
+        const selectedUnits = context.population.units;
+        const evidence = edges.filter((edge) => edge.kind === "evidence");
+        if (reference.singleEvidencePerSymbol === true)
+            for (const host of claimPopulation.units) {
+                const cited = new Set(evidence
+                    .filter((edge) => edge.hostUnitIds.includes(host.id))
+                    .flatMap((edge) => edge.unitIds));
+                if (cited.size === 1)
+                    continue;
+                this.diagnostics.push(this.problem("graph-single-evidence-per-symbol", reference.severity, `Host '${this.display(claimInventory, host)}' cites ${cited.size} distinct selected evidence unit(s); singleEvidencePerSymbol requires exactly 1.`, "Keep positive @evidence on this semantic host to exactly one selected unit.", claimIndex, referenceIndex, undefined, host));
+            }
+        if (reference.uniqueEvidence === true)
+            for (const unit of selectedUnits) {
+                const hosts = new Set(evidence
+                    .filter((edge) => edge.unitIds.includes(unit.id))
+                    .flatMap((edge) => edge.hostUnitIds));
+                if (hosts.size <= 1)
+                    continue;
+                this.diagnostics.push(this.problem("graph-unique-evidence", reference.severity, `Evidence unit '${this.display(referenceInventory, unit)}' has ${hosts.size} distinct positive evidence host(s); uniqueEvidence allows at most 1.`, "Keep one selected semantic host for this unit and remove the other positive citations.", claimIndex, referenceIndex, undefined, unit));
+            }
+    }
+    /**
+     * Reports duplicate and contradictory acknowledgement scopes before adding an edge.
+     *
+     * Normal coverage permits one aggregate target to cover several selected units,
+     * while checklist coverage also requires the same host to overlap. Comparing
+     * the appropriate scopes prevents an exclusion or repeated annotation from
+     * silently changing the meaning of an earlier acknowledgement.
+     */
+    conflicts(declaration, targetUnitId, hostUnitIds, unitIds, edges, declarations, severity, claimIndex, referenceIndex, checklist) {
+        if (declaration.kind === "evidence") {
+            const duplicate = edges.find((edge) => edge.kind === "evidence" &&
+                this.overlaps(edge.hostUnitIds, hostUnitIds) &&
+                edge.targetUnitId === targetUnitId);
+            if (duplicate !== undefined)
+                this.diagnostics.push(this.problem("graph-duplicate-evidence", severity, `The same host repeats @evidence for '${declaration.target}'.`, "Keep one acknowledgement for this target on the semantic host.", claimIndex, referenceIndex, declaration));
+        }
+        const opposite = edges.find((edge) => edge.kind !== declaration.kind &&
+            this.overlaps(edge.unitIds, unitIds) &&
+            (!checklist || this.overlaps(edge.hostUnitIds, hostUnitIds)));
+        if (opposite !== undefined) {
+            const previous = declarations.get(opposite.declarationId);
+            this.diagnostics.push(this.problem("graph-conflicting-acknowledgements", severity, `@evidence and @evidenceExclude overlap at '${declaration.target}'.`, previous === undefined
+                ? "Delete whichever acknowledgement states the wrong intent."
+                : `Delete whichever acknowledgement states the wrong intent; the earlier declaration is '${previous.target}'.`, claimIndex, referenceIndex, declaration));
+        }
+        if (declaration.kind === "evidenceExclude") {
+            const duplicate = edges.find((edge) => edge.kind === "evidenceExclude" &&
+                this.overlaps(edge.unitIds, unitIds) &&
+                (!checklist || this.overlaps(edge.hostUnitIds, hostUnitIds)));
+            if (duplicate !== undefined)
+                this.diagnostics.push(this.problem("graph-duplicate-exclusion", severity, `@evidenceExclude for '${declaration.target}' overlaps an earlier exclusion.`, "Keep one exclusion at the widest truthful scope.", claimIndex, referenceIndex, declaration));
+        }
+    }
+    /**
+     * Pairs reviews with acknowledgements by kind, host, and resolved target.
+     *
+     * Reviews validate fingerprints but never discharge missing coverage. This
+     * phase first validates review statements against resolved acknowledgements,
+     * then enforces required-review freshness only for accepted coverage edges.
+     * A malformed review therefore remains diagnostic evidence without becoming a
+     * substitute for the positive or exclusion statement it names.
+     */
+    evaluateReviews(context, edges) {
+        const { claim: { inventory: claimInventory, index: claimIndex }, reference, index: referenceIndex, inventory: referenceInventory, population: referencePopulation, resolutions: declarationResolutions, reviewResolutions, } = context;
+        const declarations = new Map(claimInventory.declarations.map((declaration) => [
+            declaration.id,
+            declaration,
+        ]));
+        const reviews = new Map(claimInventory.reviews.map((review) => [review.id, review]));
+        const hosts = new Map(claimInventory.hosts.map((host) => [host.id, host]));
+        const scopeIds = new Set(referencePopulation.scopes.map((unit) => unit.id));
+        const acknowledgements = [];
+        for (const entry of declarationResolutions) {
+            const declaration = declarations.get(entry.declarationId);
+            const target = entry.resolution.units[0];
+            if (declaration === undefined ||
+                entry.resolution.status !== "resolved" ||
+                target === undefined ||
+                entry.resolution.units.length !== 1 ||
+                !scopeIds.has(target.id))
+                continue;
+            const host = hosts.get(declaration.hostId);
+            acknowledgements.push({
+                declaration,
+                hostUnitIds: host?.attachment === "attached" ? host.unitIds : [],
+                targetUnitId: target.id,
+            });
+        }
+        const records = [];
+        const duplicateKeys = new Set();
+        for (const entry of reviewResolutions) {
+            const review = reviews.get(entry.reviewId);
+            if (review === undefined) {
+                this.diagnostics.push(this.problem("graph-review-resolution-review", reference.severity, `Review resolution '${entry.reviewId}' has no claim review statement.`, "Rebuild review target resolutions from this claim inventory before evaluating the graph.", claimIndex, referenceIndex));
+                continue;
+            }
+            if (entry.resolution.status !== "resolved")
+                continue;
+            const target = entry.resolution.units[0];
+            if (target === undefined ||
+                entry.resolution.units.length !== 1 ||
+                !scopeIds.has(target.id)) {
+                this.diagnostics.push(this.problem("graph-review-resolution-scope", reference.severity, `Resolved review target '${review.target}' is outside this reference's selected structural scopes.`, "Resolve the review with this reference's exact selected unit IDs.", claimIndex, referenceIndex, review));
+                continue;
+            }
+            const host = hosts.get(review.hostId);
+            const hostUnitIds = host?.attachment === "attached" ? host.unitIds : [];
+            const key = JSON.stringify([review.hostId, review.reviews, target.id]);
+            if (duplicateKeys.has(key)) {
+                this.diagnostics.push(this.problem("graph-duplicate-review", reference.severity, `The same documentation position repeats ${this.reviewMarker(review.reviews)} for '${review.target}'.`, "Keep the review that states what was checked and remove the other.", claimIndex, referenceIndex, review));
+                continue;
+            }
+            duplicateKeys.add(key);
+            records.push({ review, hostUnitIds, targetUnitId: target.id });
+        }
+        for (const record of records) {
+            const matching = acknowledgements.some((acknowledgement) => acknowledgement.declaration.kind === record.review.reviews &&
+                acknowledgement.targetUnitId === record.targetUnitId &&
+                this.reviewHostMatches(record, acknowledgement.declaration.hostId, acknowledgement.hostUnitIds));
+            if (matching)
+                continue;
+            const opposite = acknowledgements.find((acknowledgement) => acknowledgement.declaration.kind !== record.review.reviews &&
+                acknowledgement.targetUnitId === record.targetUnitId &&
+                this.reviewHostMatches(record, acknowledgement.declaration.hostId, acknowledgement.hostUnitIds));
+            this.diagnostics.push(opposite === undefined
+                ? this.problem("graph-orphan-review", reference.severity, `${this.reviewMarker(record.review.reviews)} for '${record.review.target}' has no matching acknowledgement on its semantic host.`, `Correct the target, add @${record.review.reviews} when this host answers it, or remove the review.`, claimIndex, referenceIndex, record.review)
+                : this.problem("graph-review-kind", reference.severity, `${this.reviewMarker(record.review.reviews)} for '${record.review.target}' cannot review @${opposite.declaration.kind}.`, `Rewrite it as ${this.reviewMarker(opposite.declaration.kind)}, or correct the acknowledgement kind.`, claimIndex, referenceIndex, record.review));
+        }
+        if (reference.requireReview !== true)
+            return;
+        for (const edge of edges) {
+            const candidates = records.filter((record) => record.review.reviews === edge.kind &&
+                record.targetUnitId === edge.targetUnitId &&
+                this.reviewHostMatches(record, edge.hostId, edge.hostUnitIds));
+            const review = candidates[0]?.review;
+            const marker = this.reviewMarker(edge.kind);
+            const declaration = claimInventory.declarations.find((candidate) => candidate.id === edge.declarationId);
+            if (review === undefined) {
+                const wrongKind = records.some((record) => record.review.reviews !== edge.kind &&
+                    record.targetUnitId === edge.targetUnitId &&
+                    this.reviewHostMatches(record, edge.hostId, edge.hostUnitIds));
+                if (wrongKind)
+                    continue;
+                this.diagnostics.push(this.problem("graph-missing-review", reference.severity, `@${edge.kind} for '${declaration?.target ?? this.displayUnit(referenceInventory, edge.targetUnitId)}' has no matching ${marker}; the current scope fingerprint is '#${edge.fingerprint}'.`, `Add '${marker} ${declaration?.target ?? "<target>"} #${edge.fingerprint} <what you checked>' on the same semantic host.`, claimIndex, referenceIndex, declaration));
+                continue;
+            }
+            if (review.fingerprint === undefined) {
+                this.diagnostics.push(this.problem("graph-missing-review-fingerprint", reference.severity, `${marker} for '${review.target}' has no fingerprint; the current scope fingerprint is '#${edge.fingerprint}'.`, `Write '#${edge.fingerprint}' after the review target so later content changes can expire it.`, claimIndex, referenceIndex, review));
+                continue;
+            }
+            if (review.fingerprint !== edge.fingerprint)
+                this.diagnostics.push(this.problem("graph-stale-review", reference.severity, `${marker} for '${review.target}' names '#${review.fingerprint}', but the current scope fingerprint is '#${edge.fingerprint}'.`, `Review the cited content again and replace the fingerprint with '#${edge.fingerprint}', or correct the acknowledgement if it no longer applies.`, claimIndex, referenceIndex, review));
+        }
+    }
+    /**
+     * Tests whether a review belongs to an acknowledgement's semantic host population.
+     *
+     * Unattached reviews can match only their exact documentation host. Attached
+     * reviews instead match any shared semantic owner, which preserves alias and
+     * multi-owner attachment semantics without matching a different claim host.
+     */
+    reviewHostMatches(review, hostId, hostUnitIds) {
+        return review.hostUnitIds.length === 0
+            ? review.review.hostId === hostId
+            : this.overlaps(review.hostUnitIds, hostUnitIds);
+    }
+    /**
+     * Selects the review marker required by an acknowledgement kind.
+     *
+     * Keeping this mapping in one place makes diagnostics and repair text agree
+     * about whether a positive citation needs @evidenceReview or an exclusion
+     * needs @evidenceExcludeReview.
+     */
+    reviewMarker(kind) {
+        return kind === "evidence" ? "@evidenceReview" : "@evidenceExcludeReview";
+    }
+    /**
+     * Formats a known semantic identity for a diagnostic.
+     *
+     * Resolution records can be stale or invalid, so an unknown identity remains
+     * visible verbatim rather than causing diagnostic construction to fail.
+     */
+    displayUnit(inventory, id) {
+        const unit = inventory.units.find((candidate) => candidate.id === id);
+        return unit === undefined ? id : this.display(inventory, unit);
+    }
+    /**
+     * Validates and orders acknowledgement resolutions within one reference obligation.
+     *
+     * Repeated identical entries collapse to one statement. Conflicting entries
+     * are removed and diagnosed because selecting either outcome would let source
+     * order decide coverage; source-coordinate ordering then stabilizes all valid
+     * edge and diagnostic processing.
+     */
+    resolutions(inventory, reference, claimIndex, referenceIndex) {
+        const declarations = new Map(inventory.declarations.map((declaration) => [
+            declaration.id,
+            declaration,
+        ]));
+        const records = new Map();
+        const conflicts = new Set();
+        for (const entry of reference.resolutions) {
+            if (conflicts.has(entry.declarationId))
+                continue;
+            const previous = records.get(entry.declarationId);
+            if (previous !== undefined &&
+                (() => {
+                    const _ip0 = input => Array.isArray(input["withdrawals"]) && input["withdrawals"].every(elem => "object" === typeof elem && null !== elem && _io6(elem));
+                    const _ip1 = input => "string" === typeof input["file"];
+                    const _ip2 = input => "string" === typeof input["id"];
+                    const _iv0 = new Set(["bigquery", "c", "cpp", "csharp", "dart", "dbml", "go", "java", "javascript", "kotlin", "lua", "markdown", "matlab", "mysql", "objc", "php", "postgresql", "prisma", "python", "ruby", "rust", "scala", "sql", "sqlite", "swagger", "swift", "typescript", "zig"]);
+                    const _iv1 = new Set(["column", "file", "function", "h1", "h2", "h3", "h4", "model", "operation", "property", "relation", "type"]);
+                    const _so0 = input => `{"status":${"\"" + input.status + "\""},"addresses":${`[${_jsonStringifyArray_1._jsonStringifyArray(input.addresses, elem => _so1(elem))}]`},"units":${`[${_jsonStringifyArray_1._jsonStringifyArray(input.units, elem => _so2(elem))}]`},"withdrawals":${`[${_jsonStringifyArray_1._jsonStringifyArray(input.withdrawals, elem => _so6(elem))}]`},"diagnostics":${`[${_jsonStringifyArray_1._jsonStringifyArray(input.diagnostics, elem => _so8(elem))}]`}}`;
+                    const _so1 = input => `{"file":${_jsonStringifyString_1._jsonStringifyString(input.file)},"segments":${`[${_jsonStringifyArray_1._jsonStringifyArray(input.segments, elem => _jsonStringifyString_1._jsonStringifyString(elem))}]`}}`;
+                    const _so2 = input => `{"id":${_jsonStringifyString_1._jsonStringifyString(input.id)},${undefined === input.parentId ? "" : `"parentId":${undefined !== input.parentId ? _jsonStringifyString_1._jsonStringifyString(input.parentId) : undefined},`}"type":${"\"" + input.type + "\""},"symbol":${"\"" + input.symbol + "\""},"identity":${`[${_jsonStringifyArray_1._jsonStringifyArray(input.identity, elem => _jsonStringifyString_1._jsonStringifyString(elem))}]`},"name":${_jsonStringifyString_1._jsonStringifyString(input.name)},${undefined === input.contentDigest ? "" : `"contentDigest":${undefined !== input.contentDigest ? _jsonStringifyString_1._jsonStringifyString(input.contentDigest) : undefined},`}"sites":${`[${_jsonStringifyArray_1._jsonStringifyArray(input.sites, elem => _so3(elem))}]`},"withdrawals":${`[${_jsonStringifyArray_1._jsonStringifyArray(input.withdrawals, elem => _so6(elem))}]`}}`;
+                    const _so3 = input => `{"id":${_jsonStringifyString_1._jsonStringifyString(input.id)},"file":${_jsonStringifyString_1._jsonStringifyString(input.file)},"range":${_so4(input.range)},"content":${`[${_jsonStringifyArray_1._jsonStringifyArray(input.content, elem => _so4(elem))}]`}}`;
+                    const _so4 = input => `{"start":${_so5(input.start)},"end":${_so5(input.end)}}`;
+                    const _so5 = input => `{"offset":${String(_jsonStringifyNumber_1._jsonStringifyNumber(input.offset))},"line":${String(_jsonStringifyNumber_1._jsonStringifyNumber(input.line))},"column":${String(_jsonStringifyNumber_1._jsonStringifyNumber(input.column))}}`;
+                    const _so6 = input => `{"tag":${"\"" + input.tag + "\""},"location":${_so7(input.location)}}`;
+                    const _so7 = input => `{${_jsonStringifyTail_1._jsonStringifyTail(`"file":${_jsonStringifyString_1._jsonStringifyString(input.file)},${undefined === input.range ? "" : `"range":${undefined !== input.range ? _so4(input.range) : undefined}`}`)}}`;
+                    const _so8 = input => `{${_jsonStringifyTail_1._jsonStringifyTail(`"code":${_jsonStringifyString_1._jsonStringifyString(input.code)},"severity":${"\"" + input.severity + "\""},"message":${_jsonStringifyString_1._jsonStringifyString(input.message)},"repair":${_jsonStringifyString_1._jsonStringifyString(input.repair)},${undefined === input.location ? "" : `"location":${undefined !== input.location ? _so7(input.location) : undefined},`}${undefined === input.claim ? "" : `"claim":${undefined !== input.claim ? String(_jsonStringifyNumber_1._jsonStringifyNumber(input.claim)) : undefined},`}${undefined === input.reference ? "" : `"reference":${undefined !== input.reference ? String(_jsonStringifyNumber_1._jsonStringifyNumber(input.reference)) : undefined},`}${undefined === input.hostId ? "" : `"hostId":${undefined !== input.hostId ? _jsonStringifyString_1._jsonStringifyString(input.hostId) : undefined},`}${undefined === input.target ? "" : `"target":${undefined !== input.target ? _jsonStringifyString_1._jsonStringifyString(input.target) : undefined}`}`)}}`;
+                    const _io1 = input => _ip1(input) && (Array.isArray(input.segments) && input.segments.every(elem => "string" === typeof elem));
+                    const _io2 = input => _ip2(input) && (undefined === input.parentId || "string" === typeof input.parentId) && true === _iv0.has(input.type) && true === _iv1.has(input.symbol) && (Array.isArray(input.identity) && input.identity.every(elem => "string" === typeof elem)) && "string" === typeof input.name && (undefined === input.contentDigest || "string" === typeof input.contentDigest) && (Array.isArray(input.sites) && input.sites.every(elem => "object" === typeof elem && null !== elem && _io3(elem))) && _ip0(input);
+                    const _io3 = input => _ip2(input) && _ip1(input) && ("object" === typeof input.range && null !== input.range && _io4(input.range)) && (Array.isArray(input.content) && input.content.every(elem => "object" === typeof elem && null !== elem && _io4(elem)));
+                    const _io4 = input => "object" === typeof input.start && null !== input.start && _io5(input.start) && ("object" === typeof input.end && null !== input.end && _io5(input.end));
+                    const _io5 = input => "number" === typeof input.offset && "number" === typeof input.line && "number" === typeof input.column;
+                    const _io6 = input => ("hidden" === input.tag || "ignore" === input.tag || "internal" === input.tag) && ("object" === typeof input.location && null !== input.location && _io7(input.location));
+                    const _io7 = input => _ip1(input) && (undefined === input.range || "object" === typeof input.range && null !== input.range && _io4(input.range));
+                    const _io8 = input => "string" === typeof input.code && ("error" === input.severity || "warning" === input.severity) && "string" === typeof input.message && "string" === typeof input.repair && (undefined === input.location || "object" === typeof input.location && null !== input.location && _io7(input.location)) && (undefined === input.claim || "number" === typeof input.claim) && (undefined === input.reference || "number" === typeof input.reference) && (undefined === input.hostId || "string" === typeof input.hostId) && (undefined === input.target || "string" === typeof input.target);
+                    return input => _so0(input);
+                })()(previous.resolution) !== (() => {
+                    const _ip0 = input => Array.isArray(input["withdrawals"]) && input["withdrawals"].every(elem => "object" === typeof elem && null !== elem && _io6(elem));
+                    const _ip1 = input => "string" === typeof input["file"];
+                    const _ip2 = input => "string" === typeof input["id"];
+                    const _iv0 = new Set(["bigquery", "c", "cpp", "csharp", "dart", "dbml", "go", "java", "javascript", "kotlin", "lua", "markdown", "matlab", "mysql", "objc", "php", "postgresql", "prisma", "python", "ruby", "rust", "scala", "sql", "sqlite", "swagger", "swift", "typescript", "zig"]);
+                    const _iv1 = new Set(["column", "file", "function", "h1", "h2", "h3", "h4", "model", "operation", "property", "relation", "type"]);
+                    const _so0 = input => `{"status":${"\"" + input.status + "\""},"addresses":${`[${_jsonStringifyArray_1._jsonStringifyArray(input.addresses, elem => _so1(elem))}]`},"units":${`[${_jsonStringifyArray_1._jsonStringifyArray(input.units, elem => _so2(elem))}]`},"withdrawals":${`[${_jsonStringifyArray_1._jsonStringifyArray(input.withdrawals, elem => _so6(elem))}]`},"diagnostics":${`[${_jsonStringifyArray_1._jsonStringifyArray(input.diagnostics, elem => _so8(elem))}]`}}`;
+                    const _so1 = input => `{"file":${_jsonStringifyString_1._jsonStringifyString(input.file)},"segments":${`[${_jsonStringifyArray_1._jsonStringifyArray(input.segments, elem => _jsonStringifyString_1._jsonStringifyString(elem))}]`}}`;
+                    const _so2 = input => `{"id":${_jsonStringifyString_1._jsonStringifyString(input.id)},${undefined === input.parentId ? "" : `"parentId":${undefined !== input.parentId ? _jsonStringifyString_1._jsonStringifyString(input.parentId) : undefined},`}"type":${"\"" + input.type + "\""},"symbol":${"\"" + input.symbol + "\""},"identity":${`[${_jsonStringifyArray_1._jsonStringifyArray(input.identity, elem => _jsonStringifyString_1._jsonStringifyString(elem))}]`},"name":${_jsonStringifyString_1._jsonStringifyString(input.name)},${undefined === input.contentDigest ? "" : `"contentDigest":${undefined !== input.contentDigest ? _jsonStringifyString_1._jsonStringifyString(input.contentDigest) : undefined},`}"sites":${`[${_jsonStringifyArray_1._jsonStringifyArray(input.sites, elem => _so3(elem))}]`},"withdrawals":${`[${_jsonStringifyArray_1._jsonStringifyArray(input.withdrawals, elem => _so6(elem))}]`}}`;
+                    const _so3 = input => `{"id":${_jsonStringifyString_1._jsonStringifyString(input.id)},"file":${_jsonStringifyString_1._jsonStringifyString(input.file)},"range":${_so4(input.range)},"content":${`[${_jsonStringifyArray_1._jsonStringifyArray(input.content, elem => _so4(elem))}]`}}`;
+                    const _so4 = input => `{"start":${_so5(input.start)},"end":${_so5(input.end)}}`;
+                    const _so5 = input => `{"offset":${String(_jsonStringifyNumber_1._jsonStringifyNumber(input.offset))},"line":${String(_jsonStringifyNumber_1._jsonStringifyNumber(input.line))},"column":${String(_jsonStringifyNumber_1._jsonStringifyNumber(input.column))}}`;
+                    const _so6 = input => `{"tag":${"\"" + input.tag + "\""},"location":${_so7(input.location)}}`;
+                    const _so7 = input => `{${_jsonStringifyTail_1._jsonStringifyTail(`"file":${_jsonStringifyString_1._jsonStringifyString(input.file)},${undefined === input.range ? "" : `"range":${undefined !== input.range ? _so4(input.range) : undefined}`}`)}}`;
+                    const _so8 = input => `{${_jsonStringifyTail_1._jsonStringifyTail(`"code":${_jsonStringifyString_1._jsonStringifyString(input.code)},"severity":${"\"" + input.severity + "\""},"message":${_jsonStringifyString_1._jsonStringifyString(input.message)},"repair":${_jsonStringifyString_1._jsonStringifyString(input.repair)},${undefined === input.location ? "" : `"location":${undefined !== input.location ? _so7(input.location) : undefined},`}${undefined === input.claim ? "" : `"claim":${undefined !== input.claim ? String(_jsonStringifyNumber_1._jsonStringifyNumber(input.claim)) : undefined},`}${undefined === input.reference ? "" : `"reference":${undefined !== input.reference ? String(_jsonStringifyNumber_1._jsonStringifyNumber(input.reference)) : undefined},`}${undefined === input.hostId ? "" : `"hostId":${undefined !== input.hostId ? _jsonStringifyString_1._jsonStringifyString(input.hostId) : undefined},`}${undefined === input.target ? "" : `"target":${undefined !== input.target ? _jsonStringifyString_1._jsonStringifyString(input.target) : undefined}`}`)}}`;
+                    const _io1 = input => _ip1(input) && (Array.isArray(input.segments) && input.segments.every(elem => "string" === typeof elem));
+                    const _io2 = input => _ip2(input) && (undefined === input.parentId || "string" === typeof input.parentId) && true === _iv0.has(input.type) && true === _iv1.has(input.symbol) && (Array.isArray(input.identity) && input.identity.every(elem => "string" === typeof elem)) && "string" === typeof input.name && (undefined === input.contentDigest || "string" === typeof input.contentDigest) && (Array.isArray(input.sites) && input.sites.every(elem => "object" === typeof elem && null !== elem && _io3(elem))) && _ip0(input);
+                    const _io3 = input => _ip2(input) && _ip1(input) && ("object" === typeof input.range && null !== input.range && _io4(input.range)) && (Array.isArray(input.content) && input.content.every(elem => "object" === typeof elem && null !== elem && _io4(elem)));
+                    const _io4 = input => "object" === typeof input.start && null !== input.start && _io5(input.start) && ("object" === typeof input.end && null !== input.end && _io5(input.end));
+                    const _io5 = input => "number" === typeof input.offset && "number" === typeof input.line && "number" === typeof input.column;
+                    const _io6 = input => ("hidden" === input.tag || "ignore" === input.tag || "internal" === input.tag) && ("object" === typeof input.location && null !== input.location && _io7(input.location));
+                    const _io7 = input => _ip1(input) && (undefined === input.range || "object" === typeof input.range && null !== input.range && _io4(input.range));
+                    const _io8 = input => "string" === typeof input.code && ("error" === input.severity || "warning" === input.severity) && "string" === typeof input.message && "string" === typeof input.repair && (undefined === input.location || "object" === typeof input.location && null !== input.location && _io7(input.location)) && (undefined === input.claim || "number" === typeof input.claim) && (undefined === input.reference || "number" === typeof input.reference) && (undefined === input.hostId || "string" === typeof input.hostId) && (undefined === input.target || "string" === typeof input.target);
+                    return input => _so0(input);
+                })()(entry.resolution)) {
+                this.diagnostics.push(this.problem("graph-conflicting-resolution", reference.severity, `Acknowledgement '${entry.declarationId}' has conflicting target resolutions.`, "Resolve each acknowledgement once per reference population.", claimIndex, referenceIndex, declarations.get(entry.declarationId)));
+                records.delete(entry.declarationId);
+                conflicts.add(entry.declarationId);
+            }
+            else
+                records.set(entry.declarationId, entry);
+        }
+        return Array.from(records.values()).sort((x, y) => this.compareStatements(declarations.get(x.declarationId), declarations.get(y.declarationId), x.declarationId, y.declarationId));
+    }
+    /**
+     * Validates and orders review resolutions without combining them with acknowledgements.
+     *
+     * Reviews have their own target-resolution lifecycle. Conflicts therefore
+     * invalidate only the review statement and cannot alter acknowledgement
+     * coverage or mask a missing positive citation.
+     */
+    reviewResolutions(inventory, reference, claimIndex, referenceIndex) {
+        const reviews = new Map(inventory.reviews.map((review) => [review.id, review]));
+        const records = new Map();
+        const conflicts = new Set();
+        for (const entry of reference.reviewResolutions ?? []) {
+            if (conflicts.has(entry.reviewId))
+                continue;
+            const previous = records.get(entry.reviewId);
+            if (previous !== undefined &&
+                (() => {
+                    const _ip0 = input => Array.isArray(input["withdrawals"]) && input["withdrawals"].every(elem => "object" === typeof elem && null !== elem && _io6(elem));
+                    const _ip1 = input => "string" === typeof input["file"];
+                    const _ip2 = input => "string" === typeof input["id"];
+                    const _iv0 = new Set(["bigquery", "c", "cpp", "csharp", "dart", "dbml", "go", "java", "javascript", "kotlin", "lua", "markdown", "matlab", "mysql", "objc", "php", "postgresql", "prisma", "python", "ruby", "rust", "scala", "sql", "sqlite", "swagger", "swift", "typescript", "zig"]);
+                    const _iv1 = new Set(["column", "file", "function", "h1", "h2", "h3", "h4", "model", "operation", "property", "relation", "type"]);
+                    const _so0 = input => `{"status":${"\"" + input.status + "\""},"addresses":${`[${_jsonStringifyArray_1._jsonStringifyArray(input.addresses, elem => _so1(elem))}]`},"units":${`[${_jsonStringifyArray_1._jsonStringifyArray(input.units, elem => _so2(elem))}]`},"withdrawals":${`[${_jsonStringifyArray_1._jsonStringifyArray(input.withdrawals, elem => _so6(elem))}]`},"diagnostics":${`[${_jsonStringifyArray_1._jsonStringifyArray(input.diagnostics, elem => _so8(elem))}]`}}`;
+                    const _so1 = input => `{"file":${_jsonStringifyString_1._jsonStringifyString(input.file)},"segments":${`[${_jsonStringifyArray_1._jsonStringifyArray(input.segments, elem => _jsonStringifyString_1._jsonStringifyString(elem))}]`}}`;
+                    const _so2 = input => `{"id":${_jsonStringifyString_1._jsonStringifyString(input.id)},${undefined === input.parentId ? "" : `"parentId":${undefined !== input.parentId ? _jsonStringifyString_1._jsonStringifyString(input.parentId) : undefined},`}"type":${"\"" + input.type + "\""},"symbol":${"\"" + input.symbol + "\""},"identity":${`[${_jsonStringifyArray_1._jsonStringifyArray(input.identity, elem => _jsonStringifyString_1._jsonStringifyString(elem))}]`},"name":${_jsonStringifyString_1._jsonStringifyString(input.name)},${undefined === input.contentDigest ? "" : `"contentDigest":${undefined !== input.contentDigest ? _jsonStringifyString_1._jsonStringifyString(input.contentDigest) : undefined},`}"sites":${`[${_jsonStringifyArray_1._jsonStringifyArray(input.sites, elem => _so3(elem))}]`},"withdrawals":${`[${_jsonStringifyArray_1._jsonStringifyArray(input.withdrawals, elem => _so6(elem))}]`}}`;
+                    const _so3 = input => `{"id":${_jsonStringifyString_1._jsonStringifyString(input.id)},"file":${_jsonStringifyString_1._jsonStringifyString(input.file)},"range":${_so4(input.range)},"content":${`[${_jsonStringifyArray_1._jsonStringifyArray(input.content, elem => _so4(elem))}]`}}`;
+                    const _so4 = input => `{"start":${_so5(input.start)},"end":${_so5(input.end)}}`;
+                    const _so5 = input => `{"offset":${String(_jsonStringifyNumber_1._jsonStringifyNumber(input.offset))},"line":${String(_jsonStringifyNumber_1._jsonStringifyNumber(input.line))},"column":${String(_jsonStringifyNumber_1._jsonStringifyNumber(input.column))}}`;
+                    const _so6 = input => `{"tag":${"\"" + input.tag + "\""},"location":${_so7(input.location)}}`;
+                    const _so7 = input => `{${_jsonStringifyTail_1._jsonStringifyTail(`"file":${_jsonStringifyString_1._jsonStringifyString(input.file)},${undefined === input.range ? "" : `"range":${undefined !== input.range ? _so4(input.range) : undefined}`}`)}}`;
+                    const _so8 = input => `{${_jsonStringifyTail_1._jsonStringifyTail(`"code":${_jsonStringifyString_1._jsonStringifyString(input.code)},"severity":${"\"" + input.severity + "\""},"message":${_jsonStringifyString_1._jsonStringifyString(input.message)},"repair":${_jsonStringifyString_1._jsonStringifyString(input.repair)},${undefined === input.location ? "" : `"location":${undefined !== input.location ? _so7(input.location) : undefined},`}${undefined === input.claim ? "" : `"claim":${undefined !== input.claim ? String(_jsonStringifyNumber_1._jsonStringifyNumber(input.claim)) : undefined},`}${undefined === input.reference ? "" : `"reference":${undefined !== input.reference ? String(_jsonStringifyNumber_1._jsonStringifyNumber(input.reference)) : undefined},`}${undefined === input.hostId ? "" : `"hostId":${undefined !== input.hostId ? _jsonStringifyString_1._jsonStringifyString(input.hostId) : undefined},`}${undefined === input.target ? "" : `"target":${undefined !== input.target ? _jsonStringifyString_1._jsonStringifyString(input.target) : undefined}`}`)}}`;
+                    const _io1 = input => _ip1(input) && (Array.isArray(input.segments) && input.segments.every(elem => "string" === typeof elem));
+                    const _io2 = input => _ip2(input) && (undefined === input.parentId || "string" === typeof input.parentId) && true === _iv0.has(input.type) && true === _iv1.has(input.symbol) && (Array.isArray(input.identity) && input.identity.every(elem => "string" === typeof elem)) && "string" === typeof input.name && (undefined === input.contentDigest || "string" === typeof input.contentDigest) && (Array.isArray(input.sites) && input.sites.every(elem => "object" === typeof elem && null !== elem && _io3(elem))) && _ip0(input);
+                    const _io3 = input => _ip2(input) && _ip1(input) && ("object" === typeof input.range && null !== input.range && _io4(input.range)) && (Array.isArray(input.content) && input.content.every(elem => "object" === typeof elem && null !== elem && _io4(elem)));
+                    const _io4 = input => "object" === typeof input.start && null !== input.start && _io5(input.start) && ("object" === typeof input.end && null !== input.end && _io5(input.end));
+                    const _io5 = input => "number" === typeof input.offset && "number" === typeof input.line && "number" === typeof input.column;
+                    const _io6 = input => ("hidden" === input.tag || "ignore" === input.tag || "internal" === input.tag) && ("object" === typeof input.location && null !== input.location && _io7(input.location));
+                    const _io7 = input => _ip1(input) && (undefined === input.range || "object" === typeof input.range && null !== input.range && _io4(input.range));
+                    const _io8 = input => "string" === typeof input.code && ("error" === input.severity || "warning" === input.severity) && "string" === typeof input.message && "string" === typeof input.repair && (undefined === input.location || "object" === typeof input.location && null !== input.location && _io7(input.location)) && (undefined === input.claim || "number" === typeof input.claim) && (undefined === input.reference || "number" === typeof input.reference) && (undefined === input.hostId || "string" === typeof input.hostId) && (undefined === input.target || "string" === typeof input.target);
+                    return input => _so0(input);
+                })()(previous.resolution) !== (() => {
+                    const _ip0 = input => Array.isArray(input["withdrawals"]) && input["withdrawals"].every(elem => "object" === typeof elem && null !== elem && _io6(elem));
+                    const _ip1 = input => "string" === typeof input["file"];
+                    const _ip2 = input => "string" === typeof input["id"];
+                    const _iv0 = new Set(["bigquery", "c", "cpp", "csharp", "dart", "dbml", "go", "java", "javascript", "kotlin", "lua", "markdown", "matlab", "mysql", "objc", "php", "postgresql", "prisma", "python", "ruby", "rust", "scala", "sql", "sqlite", "swagger", "swift", "typescript", "zig"]);
+                    const _iv1 = new Set(["column", "file", "function", "h1", "h2", "h3", "h4", "model", "operation", "property", "relation", "type"]);
+                    const _so0 = input => `{"status":${"\"" + input.status + "\""},"addresses":${`[${_jsonStringifyArray_1._jsonStringifyArray(input.addresses, elem => _so1(elem))}]`},"units":${`[${_jsonStringifyArray_1._jsonStringifyArray(input.units, elem => _so2(elem))}]`},"withdrawals":${`[${_jsonStringifyArray_1._jsonStringifyArray(input.withdrawals, elem => _so6(elem))}]`},"diagnostics":${`[${_jsonStringifyArray_1._jsonStringifyArray(input.diagnostics, elem => _so8(elem))}]`}}`;
+                    const _so1 = input => `{"file":${_jsonStringifyString_1._jsonStringifyString(input.file)},"segments":${`[${_jsonStringifyArray_1._jsonStringifyArray(input.segments, elem => _jsonStringifyString_1._jsonStringifyString(elem))}]`}}`;
+                    const _so2 = input => `{"id":${_jsonStringifyString_1._jsonStringifyString(input.id)},${undefined === input.parentId ? "" : `"parentId":${undefined !== input.parentId ? _jsonStringifyString_1._jsonStringifyString(input.parentId) : undefined},`}"type":${"\"" + input.type + "\""},"symbol":${"\"" + input.symbol + "\""},"identity":${`[${_jsonStringifyArray_1._jsonStringifyArray(input.identity, elem => _jsonStringifyString_1._jsonStringifyString(elem))}]`},"name":${_jsonStringifyString_1._jsonStringifyString(input.name)},${undefined === input.contentDigest ? "" : `"contentDigest":${undefined !== input.contentDigest ? _jsonStringifyString_1._jsonStringifyString(input.contentDigest) : undefined},`}"sites":${`[${_jsonStringifyArray_1._jsonStringifyArray(input.sites, elem => _so3(elem))}]`},"withdrawals":${`[${_jsonStringifyArray_1._jsonStringifyArray(input.withdrawals, elem => _so6(elem))}]`}}`;
+                    const _so3 = input => `{"id":${_jsonStringifyString_1._jsonStringifyString(input.id)},"file":${_jsonStringifyString_1._jsonStringifyString(input.file)},"range":${_so4(input.range)},"content":${`[${_jsonStringifyArray_1._jsonStringifyArray(input.content, elem => _so4(elem))}]`}}`;
+                    const _so4 = input => `{"start":${_so5(input.start)},"end":${_so5(input.end)}}`;
+                    const _so5 = input => `{"offset":${String(_jsonStringifyNumber_1._jsonStringifyNumber(input.offset))},"line":${String(_jsonStringifyNumber_1._jsonStringifyNumber(input.line))},"column":${String(_jsonStringifyNumber_1._jsonStringifyNumber(input.column))}}`;
+                    const _so6 = input => `{"tag":${"\"" + input.tag + "\""},"location":${_so7(input.location)}}`;
+                    const _so7 = input => `{${_jsonStringifyTail_1._jsonStringifyTail(`"file":${_jsonStringifyString_1._jsonStringifyString(input.file)},${undefined === input.range ? "" : `"range":${undefined !== input.range ? _so4(input.range) : undefined}`}`)}}`;
+                    const _so8 = input => `{${_jsonStringifyTail_1._jsonStringifyTail(`"code":${_jsonStringifyString_1._jsonStringifyString(input.code)},"severity":${"\"" + input.severity + "\""},"message":${_jsonStringifyString_1._jsonStringifyString(input.message)},"repair":${_jsonStringifyString_1._jsonStringifyString(input.repair)},${undefined === input.location ? "" : `"location":${undefined !== input.location ? _so7(input.location) : undefined},`}${undefined === input.claim ? "" : `"claim":${undefined !== input.claim ? String(_jsonStringifyNumber_1._jsonStringifyNumber(input.claim)) : undefined},`}${undefined === input.reference ? "" : `"reference":${undefined !== input.reference ? String(_jsonStringifyNumber_1._jsonStringifyNumber(input.reference)) : undefined},`}${undefined === input.hostId ? "" : `"hostId":${undefined !== input.hostId ? _jsonStringifyString_1._jsonStringifyString(input.hostId) : undefined},`}${undefined === input.target ? "" : `"target":${undefined !== input.target ? _jsonStringifyString_1._jsonStringifyString(input.target) : undefined}`}`)}}`;
+                    const _io1 = input => _ip1(input) && (Array.isArray(input.segments) && input.segments.every(elem => "string" === typeof elem));
+                    const _io2 = input => _ip2(input) && (undefined === input.parentId || "string" === typeof input.parentId) && true === _iv0.has(input.type) && true === _iv1.has(input.symbol) && (Array.isArray(input.identity) && input.identity.every(elem => "string" === typeof elem)) && "string" === typeof input.name && (undefined === input.contentDigest || "string" === typeof input.contentDigest) && (Array.isArray(input.sites) && input.sites.every(elem => "object" === typeof elem && null !== elem && _io3(elem))) && _ip0(input);
+                    const _io3 = input => _ip2(input) && _ip1(input) && ("object" === typeof input.range && null !== input.range && _io4(input.range)) && (Array.isArray(input.content) && input.content.every(elem => "object" === typeof elem && null !== elem && _io4(elem)));
+                    const _io4 = input => "object" === typeof input.start && null !== input.start && _io5(input.start) && ("object" === typeof input.end && null !== input.end && _io5(input.end));
+                    const _io5 = input => "number" === typeof input.offset && "number" === typeof input.line && "number" === typeof input.column;
+                    const _io6 = input => ("hidden" === input.tag || "ignore" === input.tag || "internal" === input.tag) && ("object" === typeof input.location && null !== input.location && _io7(input.location));
+                    const _io7 = input => _ip1(input) && (undefined === input.range || "object" === typeof input.range && null !== input.range && _io4(input.range));
+                    const _io8 = input => "string" === typeof input.code && ("error" === input.severity || "warning" === input.severity) && "string" === typeof input.message && "string" === typeof input.repair && (undefined === input.location || "object" === typeof input.location && null !== input.location && _io7(input.location)) && (undefined === input.claim || "number" === typeof input.claim) && (undefined === input.reference || "number" === typeof input.reference) && (undefined === input.hostId || "string" === typeof input.hostId) && (undefined === input.target || "string" === typeof input.target);
+                    return input => _so0(input);
+                })()(entry.resolution)) {
+                this.diagnostics.push(this.problem("graph-conflicting-review-resolution", reference.severity, `Review '${entry.reviewId}' has conflicting target resolutions.`, "Resolve each review once per reference population.", claimIndex, referenceIndex, reviews.get(entry.reviewId)));
+                records.delete(entry.reviewId);
+                conflicts.add(entry.reviewId);
+            }
+            else
+                records.set(entry.reviewId, entry);
+        }
+        return Array.from(records.values()).sort((x, y) => this.compareStatements(reviews.get(x.reviewId), reviews.get(y.reviewId), x.reviewId, y.reviewId));
+    }
+    /**
+     * Orders statements by physical source position and stable identity.
+     *
+     * Missing locations sort before known offsets through an explicit key, making
+     * invalid adapter records deterministic without inventing a source position.
+     */
+    compareStatements(x, y, xId, yId) {
+        const xLocation = x === undefined ? undefined : x.location;
+        const yLocation = y === undefined ? undefined : y.location;
+        const xOffset = xLocation?.range === undefined ? -1 : xLocation.range.start.offset;
+        const yOffset = yLocation?.range === undefined ? -1 : yLocation.range.start.offset;
+        const xKey = JSON.stringify([xLocation?.file ?? "", xOffset, xId]);
+        const yKey = JSON.stringify([yLocation?.file ?? "", yOffset, yId]);
+        return InventoryMerge_1.InventoryMerge.compare(xKey, yKey);
+    }
+    /**
+     * Tests structural ancestry through explicit parent identities.
+     *
+     * Coverage scopes must not be inferred from display names or accessor text.
+     * The visited set bounds malformed parent cycles so an invalid inventory can
+     * still yield its diagnostic result without hanging graph evaluation.
+     */
+    descends(unit, ancestorId, units) {
+        const visited = new Set();
+        let current = unit;
+        while (current !== undefined && !visited.has(current.id)) {
+            if (current.id === ancestorId)
+                return true;
+            visited.add(current.id);
+            current =
+                current.parentId === undefined
+                    ? undefined
+                    : units.get(current.parentId);
+        }
+        return false;
+    }
+    /**
+     * Tests whether two semantic-identity collections share a member.
+     *
+     * Callers use this for host and target scope relations where duplicated aliases
+     * must not change the boolean result.
+     */
+    overlaps(x, y) {
+        const right = new Set(y);
+        return x.some((id) => right.has(id));
+    }
+    /**
+     * Formats the preferred public address of a semantic unit for diagnostics.
+     *
+     * An address from a selected source is preferred so the repair text reflects
+     * the configured population. If no public address exists, the semantic name
+     * remains a useful fallback for invalid or partially extracted inventory data.
+     */
+    display(inventory, unit) {
+        const selectedFiles = new Set(inventory.sources.flatMap((source) => source.addresses.flatMap((address) => address.selected === false
+            ? []
+            : [EvidenceFileTarget_1.EvidenceFileTarget.normalize(address.absolute)])));
+        const addresses = inventory.addresses
+            .filter((address) => address.unitId === unit.id)
+            .sort((x, y) => InventoryMerge_1.InventoryMerge.compare(JSON.stringify([x.file, x.segments]), JSON.stringify([y.file, y.segments])));
+        const address = addresses.find((candidate) => selectedFiles.has(EvidenceFileTarget_1.EvidenceFileTarget.normalize(candidate.file))) ?? addresses[0];
+        if (address === undefined)
+            return unit.name;
+        return address.segments.length === 0
+            ? address.file
+            : EvidenceFileTarget_1.EvidenceFileTarget.format(address);
+    }
+    /**
+     * Applies an obligation's severity and configured coordinates to an existing diagnostic.
+     *
+     * Inventory diagnostics carry adapter facts but no graph boundary. This wrapper
+     * preserves their repair data while adding the claim/reference identity needed
+     * to distinguish repeated populations in one check result.
+     */
+    context(diagnostic, severity, claim, reference) {
+        if (severity === "off")
+            throw new Error("Disabled graph state cannot emit a diagnostic.");
+        return {
+            ...diagnostic,
+            severity,
+            message: `${this.label(claim, reference)}: ${diagnostic.message}`,
+            claim: this.claimIndex(claim),
+            ...(reference === undefined
+                ? {}
+                : { reference: this.referenceIndex(claim, reference) }),
+        };
+    }
+    /**
+     * Creates a graph diagnostic with the most specific available repair location.
+     *
+     * A statement location wins because its annotation should be edited; otherwise
+     * a missing-coverage finding points at the selected unit's first declaration
+     * site. Disabled obligations are forbidden from emitting findings, protecting
+     * the inactive-result contract.
+     */
+    problem(code, severity, message, repair, claim, reference, statement, unit) {
+        if (severity === "off")
+            throw new Error("Disabled graph state cannot emit a diagnostic.");
+        const site = unit === undefined ? undefined : unit.sites[0];
+        return {
+            code,
+            severity,
+            message: `${this.label(claim, reference)}: ${message}`,
+            repair,
+            claim: this.claimIndex(claim),
+            reference: this.referenceIndex(claim, reference),
+            ...(statement === undefined
+                ? site === undefined
+                    ? {}
+                    : { location: { file: site.file, range: site.range } }
+                : {
+                    location: statement.location,
+                    hostId: statement.hostId,
+                    target: statement.target,
+                }),
+        };
+    }
+    /**
+     * Formats a claim and optional reference boundary for a diagnostic message.
+     *
+     * Display numbering uses configured indexes rather than array positions, so
+     * filtering or duplicated policies cannot make a report point at another
+     * configuration entry.
+     */
+    label(claim, reference) {
+        const input = this.input.claims[claim];
+        const name = input?.name;
+        const configuredClaim = this.claimIndex(claim);
+        const label = name === undefined || name.length === 0
+            ? `Claim ${configuredClaim + 1}`
+            : `Claim ${configuredClaim + 1} ('${name}')`;
+        return reference === undefined
+            ? label
+            : `${label} reference ${this.referenceIndex(claim, reference) + 1}`;
+    }
+    /**
+     * Maps an input claim position to its configured stable index.
+     *
+     * The positional fallback preserves a usable boundary for malformed or
+     * partially constructed graph input that lacks an indexed claim record.
+     */
+    claimIndex(position) {
+        return this.input.claims[position]?.index ?? position;
+    }
+    /**
+     * Maps a reference position to its configured stable index within a claim.
+     *
+     * This fallback mirrors claim indexing so diagnostics remain attributable even
+     * while reporting an invalid graph structure.
+     */
+    referenceIndex(claim, position) {
+        const input = this.input.claims[claim];
+        return input === undefined
+            ? position
+            : (input.references[position]?.index ?? position);
+    }
+    /**
+     * Rejects policy combinations that have no coherent checklist interpretation.
+     *
+     * Checklist asks every selected host to answer every Markdown item, whereas
+     * cardinality and gathered exclusions impose incompatible global rules. Fail
+     * early rather than producing coverage findings whose denominator is unclear.
+     */
+    validateReferencePolicy(claim, reference, population, claimIndex, referenceIndex) {
+        if (reference.checklist !== true)
+            return;
+        if (reference.uniqueEvidence === true ||
+            reference.singleEvidencePerSymbol === true)
+            throw new Error(`${this.label(claimIndex, referenceIndex)} combines checklist with an incompatible cardinality policy.`);
+        if ((claim.exclusionHostIds?.length ?? 0) !== 0 &&
+            reference.noEvidenceExclude !== true)
+            throw new Error(`${this.label(claimIndex, referenceIndex)} combines checklist with gathered exclusion carriers.`);
+        if (population.units.some((unit) => unit.type !== "markdown"))
+            throw new Error(`${this.label(claimIndex, referenceIndex)} applies checklist to a non-Markdown reference population.`);
+    }
+    /**
+     * Defers an unhosted checklist finding until every reference can participate.
+     *
+     * The same declaration may be an eligible answer under another obligation.
+     * For duplicate deferred records, the error severity is retained over warning
+     * so final reporting cannot weaken the strongest applicable policy.
+     */
+    recordUnhostedChecklist(declaration, severity, claim, reference) {
+        const previous = this.unhostedChecklists.get(declaration.id);
+        if (previous === undefined ||
+            (previous.severity === "warning" && severity === "error"))
+            this.unhostedChecklists.set(declaration.id, {
+                declaration,
+                severity,
+                claim,
+                reference,
+            });
+    }
+    /**
+     * Reports deferred checklist annotations that remain conclusively unhosted.
+     *
+     * Accepted participation suppresses the finding, and uncertain participation
+     * suppresses it as well because an incomplete reference cannot prove that the
+     * declaration is ineligible everywhere.
+     */
+    reportUnhostedChecklists() {
+        for (const record of this.unhostedChecklists.values()) {
+            if (this.answeredDeclarations.has(record.declaration.id) ||
+                this.uncertainDeclarations.has(record.declaration.id))
+                continue;
+            this.diagnostics.push(this.problem("graph-unhosted-checklist", record.severity, `@${record.declaration.kind} for '${record.declaration.target}' is not attached to a selected checklist host.`, "Move the acknowledgement onto a selected semantic host that owes this checklist item.", record.claim, record.reference, record.declaration));
+        }
+    }
+    /**
+     * Creates a successful inactive obligation without evaluating coverage.
+     *
+     * The configured unit IDs are retained for query reporting, but no selected,
+     * covered, or missing population is claimed while its policy is disabled.
+     */
+    inactiveObligation(claim, reference, input) {
+        return this.obligation(claim, reference, false, true, input.unitIds, [], []);
+    }
+    /**
+     * Creates an active but incomplete obligation after analysis failure.
+     *
+     * It retains configured IDs for inspection while leaving coverage sets empty,
+     * preventing callers from interpreting a partial traversal as an uncovered
+     * or successfully covered population.
+     */
+    incompleteObligation(claim, reference, input) {
+        return this.obligation(claim, reference, input.severity !== "off", false, input.unitIds, [], []);
+    }
+    /**
+     * Builds the report record for one configured claim/reference obligation.
+     *
+     * All paths use this constructor so active and completeness flags, configured
+     * coordinates, coverage sets, accepted acknowledgement edges, and optional
+     * host-local checklist coverage remain aligned in exported graph results.
+     */
+    obligation(claim, reference, active, complete, unitIds, coveredUnitIds, missingUnitIds, edges = [], hostCoverage = []) {
+        return {
+            claim: this.claimIndex(claim),
+            reference: this.referenceIndex(claim, reference),
+            active,
+            complete,
+            unitIds,
+            coveredUnitIds,
+            missingUnitIds,
+            edges,
+            hostCoverage,
+        };
+    }
+}