@wrtnlabs/evidence 0.0.0

package/lib/graph/EvidenceInventory.js

@@ -0,0 +1,1165 @@
+"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.EvidenceInventory = void 0;
+const _assertGuard_1 = __importStar(require("typia/lib/internal/_assertGuard"));
+const _jsonStringifyNumber_1 = __importStar(require("typia/lib/internal/_jsonStringifyNumber"));
+const _jsonStringifyArray_1 = __importStar(require("typia/lib/internal/_jsonStringifyArray"));
+const _jsonStringifyString_1 = __importStar(require("typia/lib/internal/_jsonStringifyString"));
+const _jsonStringifyTail_1 = __importStar(require("typia/lib/internal/_jsonStringifyTail"));
+const typia_1 = __importDefault(require("typia"));
+const InventoryMerge_1 = require("../internal/InventoryMerge");
+const SourceText_1 = require("../internal/SourceText");
+/**
+ * Reconciles adapter records and indexes independently selected evidence populations.
+ *
+ * Construction captures the supplied inventories, merges compatible identities,
+ * and checks source ranges, parent relationships, addresses, and host ownership.
+ * Inconsistent records leave diagnostics and an incomplete inventory instead of
+ * silently disappearing from the denominator. Normalization makes snapshots and
+ * serialization deterministic.
+ *
+ * Selection distinguishes required units from their addressable ancestors and
+ * propagates withdrawals through explicit parent links. Resolution then matches
+ * an exact file and segmented accessor within that scope. Aliases can name one
+ * identity; an address naming several identities remains ambiguous.
+ *
+ * Snapshots, populations, and resolutions are owned copies. Mutating one result
+ * cannot affect this index or a later selection.
+ *
+ * @example
+ * const inventory: EvidenceInventory = new EvidenceInventory([adapterOutput]);
+ * const population: IEvidencePopulation = inventory.select([methodId]);
+ * const target: IEvidenceResolution = inventory.resolve(
+ *   { file: "api.ts", segments: ["Client"] },
+ *   [methodId],
+ * );
+ * // Client may resolve as an aggregate owner while only its method is required.
+ */
+class EvidenceInventory {
+    /**
+     * Reconciled records owned by this index.
+     *
+     * Validation appends findings here before normalization. Public methods return
+     * copies so callers cannot invalidate the lookup tables by editing a snapshot.
+     */
+    data;
+    /**
+     * Semantic identity lookup over the reconciled units.
+     *
+     * Parent traversal uses these IDs rather than public names. The same table
+     * supports validation of addresses, hosts, and selected identities.
+     */
+    units = new Map();
+    /**
+     * Effective withdrawals for each unit, including its ancestors' directives.
+     *
+     * Validation computes these chains once. Selection excludes affected units,
+     * while resolution retains the directive locations to explain hidden targets.
+     */
+    withdrawals = new Map();
+    /**
+     * Captures, reconciles, and validates one or more adapter inventories.
+     *
+     * Shape validation rejects malformed input. Semantic inconsistencies become
+     * inventory diagnostics so callers can inspect the partial records and their
+     * incomplete status rather than receiving an apparently healthy subset.
+     */
+    constructor(inventories) {
+        this.data = InventoryMerge_1.InventoryMerge.combine(structuredClone((() => {
+            const _ip0 = input => "string" === typeof input["id"];
+            const _ip1 = 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 _ip2 = input => "object" === typeof input["range"] && null !== input["range"] && _io4(input["range"]);
+            const _ip3 = input => "object" === typeof input["location"] && null !== input["location"] && _io3(input["location"]);
+            const _ip4 = input => "string" === typeof input["hostId"];
+            const _ip5 = input => "string" === typeof input["target"];
+            const _ap0 = (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 _ap1 = (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 _ap2 = (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)) && _ao4(input["range"], _path + ".range", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".range",
+                expected: "IEvidenceSourceRange",
+                value: input["range"]
+            }, _errorFactory);
+            const _ap3 = (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)) && _ao3(input["location"], _path + ".location", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".location",
+                expected: "IEvidenceSourceLocation",
+                value: input["location"]
+            }, _errorFactory);
+            const _ap4 = (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 _ap5 = (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 _ao0 = (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, _index20) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".sources[" + _index20 + "]",
+                expected: "IEvidenceSourceFile",
+                value: elem
+            }, _errorFactory)) && _ao1(elem, _path + ".sources[" + _index20 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".sources[" + _index20 + "]",
+                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, _index21) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".annotationRanges[" + _index21 + "]",
+                expected: "IEvidenceSourceLocation",
+                value: elem
+            }, _errorFactory)) && _ao3(elem, _path + ".annotationRanges[" + _index21 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".annotationRanges[" + _index21 + "]",
+                expected: "IEvidenceSourceLocation",
+                value: elem
+            }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".annotationRanges",
+                expected: "Array<IEvidenceSourceLocation>",
+                value: input.annotationRanges
+            }, _errorFactory)) && ((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, _index22) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".units[" + _index22 + "]",
+                expected: "IEvidenceUnit",
+                value: elem
+            }, _errorFactory)) && _ao6(elem, _path + ".units[" + _index22 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".units[" + _index22 + "]",
+                expected: "IEvidenceUnit",
+                value: elem
+            }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".units",
+                expected: "Array<IEvidenceUnit>",
+                value: input.units
+            }, _errorFactory)) && ((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, _index23) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".addresses[" + _index23 + "]",
+                expected: "IEvidencePublicAddress",
+                value: elem
+            }, _errorFactory)) && _ao9(elem, _path + ".addresses[" + _index23 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".addresses[" + _index23 + "]",
+                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, _index24) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".hosts[" + _index24 + "]",
+                expected: "IEvidenceHost",
+                value: elem
+            }, _errorFactory)) && _ao10(elem, _path + ".hosts[" + _index24 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".hosts[" + _index24 + "]",
+                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, _index25) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".declarations[" + _index25 + "]",
+                expected: "IEvidenceDeclaration",
+                value: elem
+            }, _errorFactory)) && _ao11(elem, _path + ".declarations[" + _index25 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".declarations[" + _index25 + "]",
+                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, _index26) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".reviews[" + _index26 + "]",
+                expected: "IEvidenceReview",
+                value: elem
+            }, _errorFactory)) && _ao12(elem, _path + ".reviews[" + _index26 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".reviews[" + _index26 + "]",
+                expected: "IEvidenceReview",
+                value: elem
+            }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".reviews",
+                expected: "Array<IEvidenceReview>",
+                value: input.reviews
+            }, _errorFactory)) && ((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, _index27) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".diagnostics[" + _index27 + "]",
+                expected: "IEvidenceDiagnostic",
+                value: elem
+            }, _errorFactory)) && _ao13(elem, _path + ".diagnostics[" + _index27 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".diagnostics[" + _index27 + "]",
+                expected: "IEvidenceDiagnostic",
+                value: elem
+            }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".diagnostics",
+                expected: "Array<IEvidenceDiagnostic>",
+                value: input.diagnostics
+            }, _errorFactory)) && ((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, _index28) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".dependencies[" + _index28 + "]",
+                expected: "IEvidenceSourceDependency",
+                value: elem
+            }, _errorFactory)) && _ao14(elem, _path + ".dependencies[" + _index28 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".dependencies[" + _index28 + "]",
+                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 _ao1 = (input, _path, _exceptionable = true) => _ap0(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, _index29) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".addresses[" + _index29 + "]",
+                expected: "IEvidenceSourceAddress",
+                value: elem
+            }, _errorFactory)) && _ao2(elem, _path + ".addresses[" + _index29 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".addresses[" + _index29 + "]",
+                expected: "IEvidenceSourceAddress",
+                value: elem
+            }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".addresses",
+                expected: "Array<IEvidenceSourceAddress>",
+                value: input.addresses
+            }, _errorFactory));
+            const _ao10 = (input, _path, _exceptionable = true) => _ap0(input, _path, true && _exceptionable) && _ap1(input, _path, true && _exceptionable) && _ap2(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, _index35) => "string" === typeof elem || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".origins[" + _index35 + "]",
+                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)) && ((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, _index36) => "string" === typeof elem || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".unitIds[" + _index36 + "]",
+                expected: "string",
+                value: elem
+            }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".unitIds",
+                expected: "Array<string>",
+                value: input.unitIds
+            }, _errorFactory)) && ("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 _ao11 = (input, _path, _exceptionable = true) => _ap4(input, _path, true && _exceptionable) && _ap5(input, _path, true && _exceptionable) && _ap3(input, _path, true && _exceptionable) && _ap0(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 _ao12 = (input, _path, _exceptionable = true) => _ap4(input, _path, true && _exceptionable) && _ap5(input, _path, true && _exceptionable) && _ap3(input, _path, true && _exceptionable) && _ap0(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 _ao13 = (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)) && _ao3(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 _ao14 = (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 _ao2 = (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 _ao3 = (input, _path, _exceptionable = true) => _ap1(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)) && _ao4(input.range, _path + ".range", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".range",
+                expected: "(IEvidenceSourceRange | undefined)",
+                value: input.range
+            }, _errorFactory));
+            const _ao4 = (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)) && _ao5(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)) && _ao5(input.end, _path + ".end", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".end",
+                expected: "IEvidenceSourcePosition",
+                value: input.end
+            }, _errorFactory));
+            const _ao5 = (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 _ao6 = (input, _path, _exceptionable = true) => _ap0(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, _index30) => "string" === typeof elem || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".identity[" + _index30 + "]",
+                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, _index31) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".sites[" + _index31 + "]",
+                expected: "IEvidenceUnitSite",
+                value: elem
+            }, _errorFactory)) && _ao7(elem, _path + ".sites[" + _index31 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".sites[" + _index31 + "]",
+                expected: "IEvidenceUnitSite",
+                value: elem
+            }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".sites",
+                expected: "Array<IEvidenceUnitSite>",
+                value: input.sites
+            }, _errorFactory)) && ((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, _index32) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".withdrawals[" + _index32 + "]",
+                expected: "IEvidenceWithdrawal",
+                value: elem
+            }, _errorFactory)) && _ao8(elem, _path + ".withdrawals[" + _index32 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".withdrawals[" + _index32 + "]",
+                expected: "IEvidenceWithdrawal",
+                value: elem
+            }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".withdrawals",
+                expected: "Array<IEvidenceWithdrawal>",
+                value: input.withdrawals
+            }, _errorFactory));
+            const _ao7 = (input, _path, _exceptionable = true) => _ap0(input, _path, true && _exceptionable) && _ap1(input, _path, true && _exceptionable) && _ap2(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, _index33) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".content[" + _index33 + "]",
+                expected: "IEvidenceSourceRange",
+                value: elem
+            }, _errorFactory)) && _ao4(elem, _path + ".content[" + _index33 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".content[" + _index33 + "]",
+                expected: "IEvidenceSourceRange",
+                value: elem
+            }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".content",
+                expected: "Array<IEvidenceSourceRange>",
+                value: input.content
+            }, _errorFactory));
+            const _ao8 = (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)) && _ap3(input, _path, true && _exceptionable);
+            const _ao9 = (input, _path, _exceptionable = true) => _ap1(input, _path, true && _exceptionable) && ((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, _index34) => "string" === typeof elem || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".segments[" + _index34 + "]",
+                expected: "string",
+                value: elem
+            }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".segments",
+                expected: "Array<string>",
+                value: input.segments
+            }, _errorFactory)) && ("string" === typeof input.unitId || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".unitId",
+                expected: "string",
+                value: input.unitId
+            }, _errorFactory));
+            const _io0 = input => 1 === input.schemaVersion && (Array.isArray(input.sources) && input.sources.every(elem => "object" === typeof elem && null !== elem && _io1(elem))) && (Array.isArray(input.annotationRanges) && input.annotationRanges.every(elem => "object" === typeof elem && null !== elem && _io3(elem))) && (Array.isArray(input.units) && input.units.every(elem => "object" === typeof elem && null !== elem && _io6(elem))) && (Array.isArray(input.addresses) && input.addresses.every(elem => "object" === typeof elem && null !== elem && _io9(elem))) && (Array.isArray(input.hosts) && input.hosts.every(elem => "object" === typeof elem && null !== elem && _io10(elem))) && (Array.isArray(input.declarations) && input.declarations.every(elem => "object" === typeof elem && null !== elem && _io11(elem))) && (Array.isArray(input.reviews) && input.reviews.every(elem => "object" === typeof elem && null !== elem && _io12(elem))) && (Array.isArray(input.diagnostics) && input.diagnostics.every(elem => "object" === typeof elem && null !== elem && _io13(elem))) && (Array.isArray(input.dependencies) && input.dependencies.every(elem => "object" === typeof elem && null !== elem && _io14(elem))) && "boolean" === typeof input.complete;
+            const _io1 = input => _ip0(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 && _io2(elem)));
+            const _io10 = input => _ip0(input) && _ip1(input) && _ip2(input) && (undefined === input.origins || Array.isArray(input.origins) && input.origins.every(elem => "string" === typeof elem)) && (undefined === input.siteId || "string" === typeof input.siteId) && (Array.isArray(input.unitIds) && input.unitIds.every(elem => "string" === typeof elem)) && ("attached" === input.attachment || "unattached" === input.attachment || "unsupported" === input.attachment) && (undefined === input.problem || "string" === typeof input.problem);
+            const _io11 = input => _ip4(input) && _ip5(input) && _ip3(input) && _ip0(input) && ("evidence" === input.kind || "evidenceExclude" === input.kind) && "string" === typeof input.reason;
+            const _io12 = input => _ip4(input) && _ip5(input) && _ip3(input) && _ip0(input) && ("evidence" === input.reviews || "evidenceExclude" === input.reviews) && (undefined === input.fingerprint || "string" === typeof input.fingerprint) && "string" === typeof input.description;
+            const _io13 = 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 && _io3(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 _io14 = input => "string" === typeof input.path && "boolean" === typeof input.recursive;
+            const _io2 = input => "string" === typeof input.absolute && "string" === typeof input.relative && "string" === typeof input.display && (undefined === input.selected || "boolean" === typeof input.selected);
+            const _io3 = input => _ip1(input) && (undefined === input.range || "object" === typeof input.range && null !== input.range && _io4(input.range));
+            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 => _ip0(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 && _io7(elem))) && (Array.isArray(input.withdrawals) && input.withdrawals.every(elem => "object" === typeof elem && null !== elem && _io8(elem)));
+            const _io7 = input => _ip0(input) && _ip1(input) && _ip2(input) && (Array.isArray(input.content) && input.content.every(elem => "object" === typeof elem && null !== elem && _io4(elem)));
+            const _io8 = input => ("hidden" === input.tag || "ignore" === input.tag || "internal" === input.tag) && _ip3(input);
+            const _io9 = input => _ip1(input) && (Array.isArray(input.segments) && input.segments.every(elem => "string" === typeof elem)) && "string" === typeof input.unitId;
+            const __is = input => Array.isArray(input) && input.every(elem => "object" === typeof elem && null !== elem && _io0(elem));
+            let _errorFactory;
+            return (input, errorFactory) => {
+                if (false === __is(input)) {
+                    _errorFactory = errorFactory;
+                    ((input, _path, _exceptionable = true) => (Array.isArray(input) || _assertGuard_1._assertGuard(true, {
+                        method: "typia.assert",
+                        path: _path + "",
+                        expected: "Array<IEvidenceInventory>",
+                        value: input
+                    }, _errorFactory)) && input.every((elem, _index19) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(true, {
+                        method: "typia.assert",
+                        path: _path + "[" + _index19 + "]",
+                        expected: "IEvidenceInventory",
+                        value: elem
+                    }, _errorFactory)) && _ao0(elem, _path + "[" + _index19 + "]", true) || _assertGuard_1._assertGuard(true, {
+                        method: "typia.assert",
+                        path: _path + "[" + _index19 + "]",
+                        expected: "IEvidenceInventory",
+                        value: elem
+                    }, _errorFactory)) || _assertGuard_1._assertGuard(true, {
+                        method: "typia.assert",
+                        path: _path + "",
+                        expected: "Array<IEvidenceInventory>",
+                        value: input
+                    }, _errorFactory))(input, "$input", true);
+                }
+                return input;
+            };
+        })()(inventories)));
+        for (const unit of this.data.units)
+            this.units.set(unit.id, unit);
+        this.validate();
+        this.normalize();
+    }
+    /**
+     * Returns a serializable copy of the reconciled inventory.
+     *
+     * The copy includes diagnostics and incomplete records. Callers may inspect or
+     * mutate it without changing future selections or resolutions on this index.
+     */
+    snapshot() {
+        return structuredClone(this.data);
+    }
+    /**
+     * Serializes the normalized inventory in stable schema order.
+     *
+     * Construction has already reconciled and sorted the collections. Serializing
+     * therefore preserves deterministic output without changing selection state or
+     * requiring callers to normalize a snapshot themselves.
+     */
+    serialize() {
+        return (() => {
+            const _ip0 = input => "string" === typeof input["id"];
+            const _ip1 = 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 _ip2 = input => "object" === typeof input["range"] && null !== input["range"] && _io4(input["range"]);
+            const _ip3 = input => "object" === typeof input["location"] && null !== input["location"] && _io3(input["location"]);
+            const _ip4 = input => "string" === typeof input["hostId"];
+            const _ip5 = input => "string" === typeof input["target"];
+            const _so0 = input => `{"schemaVersion":${String(_jsonStringifyNumber_1._jsonStringifyNumber(input.schemaVersion))},"sources":${`[${_jsonStringifyArray_1._jsonStringifyArray(input.sources, elem => _so1(elem))}]`},"annotationRanges":${`[${_jsonStringifyArray_1._jsonStringifyArray(input.annotationRanges, elem => _so3(elem))}]`},"units":${`[${_jsonStringifyArray_1._jsonStringifyArray(input.units, elem => _so6(elem))}]`},"addresses":${`[${_jsonStringifyArray_1._jsonStringifyArray(input.addresses, elem => _so9(elem))}]`},"hosts":${`[${_jsonStringifyArray_1._jsonStringifyArray(input.hosts, elem => _so10(elem))}]`},"declarations":${`[${_jsonStringifyArray_1._jsonStringifyArray(input.declarations, elem => _so11(elem))}]`},"reviews":${`[${_jsonStringifyArray_1._jsonStringifyArray(input.reviews, elem => _so12(elem))}]`},"diagnostics":${`[${_jsonStringifyArray_1._jsonStringifyArray(input.diagnostics, elem => _so13(elem))}]`},"dependencies":${`[${_jsonStringifyArray_1._jsonStringifyArray(input.dependencies, elem => _so14(elem))}]`},"complete":${String(input.complete)}}`;
+            const _so1 = input => `{"id":${_jsonStringifyString_1._jsonStringifyString(input.id)},"physicalPath":${_jsonStringifyString_1._jsonStringifyString(input.physicalPath)},"content":${_jsonStringifyString_1._jsonStringifyString(input.content)},"digest":${_jsonStringifyString_1._jsonStringifyString(input.digest)},"addresses":${`[${_jsonStringifyArray_1._jsonStringifyArray(input.addresses, elem => _so2(elem))}]`}}`;
+            const _so10 = input => `{${_jsonStringifyTail_1._jsonStringifyTail(`"id":${_jsonStringifyString_1._jsonStringifyString(input.id)},"file":${_jsonStringifyString_1._jsonStringifyString(input.file)},"range":${_so4(input.range)},${undefined === input.origins ? "" : `"origins":${undefined !== input.origins ? `[${_jsonStringifyArray_1._jsonStringifyArray(input.origins, elem => _jsonStringifyString_1._jsonStringifyString(elem))}]` : undefined},`}${undefined === input.siteId ? "" : `"siteId":${undefined !== input.siteId ? _jsonStringifyString_1._jsonStringifyString(input.siteId) : undefined},`}"unitIds":${`[${_jsonStringifyArray_1._jsonStringifyArray(input.unitIds, elem => _jsonStringifyString_1._jsonStringifyString(elem))}]`},"attachment":${"\"" + input.attachment + "\""},${undefined === input.problem ? "" : `"problem":${undefined !== input.problem ? _jsonStringifyString_1._jsonStringifyString(input.problem) : undefined}`}`)}}`;
+            const _so11 = input => `{"hostId":${_jsonStringifyString_1._jsonStringifyString(input.hostId)},"target":${_jsonStringifyString_1._jsonStringifyString(input.target)},"location":${_so3(input.location)},"id":${_jsonStringifyString_1._jsonStringifyString(input.id)},"kind":${"\"" + input.kind + "\""},"reason":${_jsonStringifyString_1._jsonStringifyString(input.reason)}}`;
+            const _so12 = input => `{"hostId":${_jsonStringifyString_1._jsonStringifyString(input.hostId)},"target":${_jsonStringifyString_1._jsonStringifyString(input.target)},"location":${_so3(input.location)},"id":${_jsonStringifyString_1._jsonStringifyString(input.id)},"reviews":${"\"" + input.reviews + "\""},${undefined === input.fingerprint ? "" : `"fingerprint":${undefined !== input.fingerprint ? _jsonStringifyString_1._jsonStringifyString(input.fingerprint) : undefined},`}"description":${_jsonStringifyString_1._jsonStringifyString(input.description)}}`;
+            const _so13 = 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 ? _so3(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 _so14 = input => `{"path":${_jsonStringifyString_1._jsonStringifyString(input.path)},"recursive":${String(input.recursive)}}`;
+            const _so2 = input => `{${_jsonStringifyTail_1._jsonStringifyTail(`"absolute":${_jsonStringifyString_1._jsonStringifyString(input.absolute)},"relative":${_jsonStringifyString_1._jsonStringifyString(input.relative)},"display":${_jsonStringifyString_1._jsonStringifyString(input.display)},${undefined === input.selected ? "" : `"selected":${undefined !== input.selected ? String(input.selected) : undefined}`}`)}}`;
+            const _so3 = input => `{${_jsonStringifyTail_1._jsonStringifyTail(`"file":${_jsonStringifyString_1._jsonStringifyString(input.file)},${undefined === input.range ? "" : `"range":${undefined !== input.range ? _so4(input.range) : undefined}`}`)}}`;
+            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 => `{"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 => _so7(elem))}]`},"withdrawals":${`[${_jsonStringifyArray_1._jsonStringifyArray(input.withdrawals, elem => _so8(elem))}]`}}`;
+            const _so7 = 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 _so8 = input => `{"tag":${"\"" + input.tag + "\""},"location":${_so3(input.location)}}`;
+            const _so9 = input => `{"file":${_jsonStringifyString_1._jsonStringifyString(input.file)},"segments":${`[${_jsonStringifyArray_1._jsonStringifyArray(input.segments, elem => _jsonStringifyString_1._jsonStringifyString(elem))}]`},"unitId":${_jsonStringifyString_1._jsonStringifyString(input.unitId)}}`;
+            const _io1 = input => _ip0(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 && _io2(elem)));
+            const _io2 = input => "string" === typeof input.absolute && "string" === typeof input.relative && "string" === typeof input.display && (undefined === input.selected || "boolean" === typeof input.selected);
+            const _io3 = input => _ip1(input) && (undefined === input.range || "object" === typeof input.range && null !== input.range && _io4(input.range));
+            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 => _ip0(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 && _io7(elem))) && (Array.isArray(input.withdrawals) && input.withdrawals.every(elem => "object" === typeof elem && null !== elem && _io8(elem)));
+            const _io7 = input => _ip0(input) && _ip1(input) && _ip2(input) && (Array.isArray(input.content) && input.content.every(elem => "object" === typeof elem && null !== elem && _io4(elem)));
+            const _io8 = input => ("hidden" === input.tag || "ignore" === input.tag || "internal" === input.tag) && _ip3(input);
+            const _io9 = input => _ip1(input) && (Array.isArray(input.segments) && input.segments.every(elem => "string" === typeof elem)) && "string" === typeof input.unitId;
+            const _io10 = input => _ip0(input) && _ip1(input) && _ip2(input) && (undefined === input.origins || Array.isArray(input.origins) && input.origins.every(elem => "string" === typeof elem)) && (undefined === input.siteId || "string" === typeof input.siteId) && (Array.isArray(input.unitIds) && input.unitIds.every(elem => "string" === typeof elem)) && ("attached" === input.attachment || "unattached" === input.attachment || "unsupported" === input.attachment) && (undefined === input.problem || "string" === typeof input.problem);
+            const _io11 = input => _ip4(input) && _ip5(input) && _ip3(input) && _ip0(input) && ("evidence" === input.kind || "evidenceExclude" === input.kind) && "string" === typeof input.reason;
+            const _io12 = input => _ip4(input) && _ip5(input) && _ip3(input) && _ip0(input) && ("evidence" === input.reviews || "evidenceExclude" === input.reviews) && (undefined === input.fingerprint || "string" === typeof input.fingerprint) && "string" === typeof input.description;
+            const _io13 = 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 && _io3(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 _io14 = input => "string" === typeof input.path && "boolean" === typeof input.recursive;
+            return input => _so0(input);
+        })()(this.data);
+    }
+    /**
+     * Projects selected identities and the structural context needed to resolve them.
+     *
+     * Required units exclude effective withdrawals, while scopes include their real
+     * ancestors. Hosts are narrowed to selected semantic owners, including hosts
+     * without tags. Unknown requested IDs throw because they indicate an invalid
+     * selection, rather than an empty configured population.
+     *
+     * @example
+     * // Selecting a method retains its class as a resolvable aggregate scope.
+     * // The class does not become an extra required unit unless its ID is selected.
+     */
+    select(ids) {
+        const requested = new Set(ids);
+        const scopes = new Set();
+        // Keep the original closure for hidden-target explanations, even when a
+        // requested unit is later removed by an inherited withdrawal.
+        for (const id of requested) {
+            if (!this.units.has(id))
+                throw new Error(`Unknown selected semantic identity: ${id}`);
+            for (const ancestor of this.ancestors(id))
+                scopes.add(ancestor.id);
+        }
+        const visible = this.data.units.filter((unit) => requested.has(unit.id) && !this.hidden(unit.id));
+        const selected = new Set(visible.map((unit) => unit.id));
+        // Only ancestors of surviving requirements remain visible scopes. An owner
+        // of exclusively withdrawn units must not re-enter through aggregate lookup.
+        const visibleScopes = new Set(visible.flatMap((unit) => this.ancestors(unit.id).map((ancestor) => ancestor.id)));
+        return structuredClone({
+            units: visible,
+            scopes: this.data.units.filter((unit) => visibleScopes.has(unit.id)),
+            hidden: this.data.units.filter((unit) => scopes.has(unit.id) && this.hidden(unit.id)),
+            hosts: this.data.hosts
+                .filter((host) => host.attachment === "attached" &&
+                host.unitIds.some((id) => selected.has(id)))
+                .map((host) => ({
+                ...host,
+                unitIds: host.unitIds.filter((id) => selected.has(id)),
+            })),
+            complete: this.data.complete,
+            diagnostics: this.data.diagnostics,
+        });
+    }
+    /**
+     * Resolves an exact public address inside a selected population's structural scope.
+     *
+     * Aliases resolving to one unit are deduplicated by identity; distinct matching
+     * units remain ambiguous. A withdrawn match carries its withdrawal locations.
+     * Incomplete inventory takes precedence over all apparent matches because
+     * missing extraction may hide another candidate or invalidate the population.
+     */
+    resolve(address, ids) {
+        const population = this.select(ids);
+        const visible = new Set(population.scopes.map((unit) => unit.id));
+        const hidden = new Set(population.hidden.map((unit) => unit.id));
+        const matching = new Set(this.data.addresses
+            .filter((candidate) => candidate.file === address.file &&
+            JSON.stringify(candidate.segments) ===
+                JSON.stringify(address.segments))
+            .map((candidate) => candidate.unitId));
+        const found = this.data.units.filter((unit) => matching.has(unit.id) && visible.has(unit.id));
+        const withdrawn = this.data.units.filter((unit) => matching.has(unit.id) && hidden.has(unit.id));
+        // A partial inventory cannot prove uniqueness or absence. Preserve that
+        // uncertainty before choosing resolved, ambiguous, hidden, or missing.
+        return structuredClone({
+            status: !this.data.complete
+                ? "incomplete"
+                : found.length > 1
+                    ? "ambiguous"
+                    : found.length === 1
+                        ? "resolved"
+                        : withdrawn.length > 0
+                            ? "hidden"
+                            : "missing",
+            units: found.length === 0 ? withdrawn : found,
+            withdrawals: InventoryMerge_1.InventoryMerge.unique(withdrawn.flatMap((unit) => this.withdrawals.get(unit.id) ?? []), (value) => (() => {
+                const _so0 = input => `{"tag":${"\"" + input.tag + "\""},"location":${_so1(input.location)}}`;
+                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);
+            })()(value)),
+        });
+    }
+    /**
+     * Tests whether a semantic identity is removed by its own or an inherited withdrawal.
+     *
+     * The map is populated during validation from the explicit parent chain. Consumers
+     * use this predicate after retaining structural closure, so a hidden ancestor can
+     * still be named in a diagnostic without returning it as a visible requirement.
+     */
+    hidden(id) {
+        return (this.withdrawals.get(id)?.length ?? 0) !== 0;
+    }
+    /**
+     * Returns an identity and its reachable structural ancestors in child-to-root order.
+     *
+     * Selection uses this closure for aggregate addresses and inherited withdrawals.
+     * The visited set bounds malformed parent cycles; validation reports the cycle
+     * separately rather than letting a lookup or diagnostic construction loop forever.
+     */
+    ancestors(id) {
+        const output = [];
+        const seen = new Set();
+        let current = this.units.get(id);
+        while (current !== undefined && !seen.has(current.id)) {
+            output.push(current);
+            seen.add(current.id);
+            current =
+                current.parentId === undefined
+                    ? undefined
+                    : this.units.get(current.parentId);
+        }
+        return output;
+    }
+    /**
+     * Checks that merged records still describe a coherent source and ownership graph.
+     *
+     * Validation is deliberately non-throwing for semantic contradictions. Each
+     * finding marks the inventory incomplete and remains available to graph reporting,
+     * while malformed runtime input has already failed shape validation at construction.
+     */
+    validate() {
+        const sources = new Map();
+        for (const source of this.data.sources) {
+            const text = new SourceText_1.SourceText(source.content);
+            for (const file of [
+                source.physicalPath,
+                ...source.addresses.map((address) => address.absolute),
+            ]) {
+                const previous = sources.get(file);
+                if (previous !== undefined && previous.content !== source.content)
+                    this.problem("inventory-source", "One source path names different source contents.", { file });
+                sources.set(file, text);
+            }
+        }
+        // Source-coordinate checks run before cross-record ownership checks so every
+        // later site, host, declaration, and review can use the same original text map.
+        const sites = new Map();
+        for (const annotation of this.data.annotationRanges)
+            this.checkLocation(annotation, sources);
+        for (const unit of this.data.units) {
+            if (unit.sites.length === 0)
+                this.problem("inventory-site", `Identity ${unit.id} has no declaration site.`);
+            const ownSites = new Map();
+            for (const site of unit.sites) {
+                const ownPrevious = ownSites.get(site.id);
+                if (ownPrevious !== undefined &&
+                    (InventoryMerge_1.InventoryMerge.siteKey(ownPrevious) !==
+                        InventoryMerge_1.InventoryMerge.siteKey(site) ||
+                        InventoryMerge_1.InventoryMerge.contentKey(ownPrevious) !==
+                            InventoryMerge_1.InventoryMerge.contentKey(site)))
+                    this.problem("inventory-content", `Identity ${unit.id} assigns conflicting content to site ${site.id}.`, site);
+                ownSites.set(site.id, site);
+                const previous = sites.get(site.id);
+                if (previous !== undefined &&
+                    InventoryMerge_1.InventoryMerge.siteKey(previous) !== InventoryMerge_1.InventoryMerge.siteKey(site))
+                    this.problem("inventory-site", `Declaration site ${site.id} has conflicting locations.`, site);
+                sites.set(site.id, site);
+                this.checkLocation(site, sources);
+                for (const range of site.content) {
+                    this.checkLocation({ file: site.file, range }, sources);
+                    if (range.start.offset < site.range.start.offset ||
+                        range.end.offset > site.range.end.offset)
+                        this.problem("inventory-content", `Content of ${unit.id} lies outside its declaration site.`, site);
+                }
+            }
+            if (unit.parentId !== undefined && !this.units.has(unit.parentId))
+                this.problem("inventory-parent", `Identity ${unit.id} names missing parent ${unit.parentId}.`);
+            const ancestors = this.ancestors(unit.id);
+            const last = ancestors.at(-1);
+            if (last !== undefined &&
+                last.parentId !== undefined &&
+                this.units.has(last.parentId))
+                this.problem("inventory-cycle", `The parent chain of ${unit.id} contains a cycle.`);
+            // Cache inherited directives per identity. Applying only local withdrawals
+            // would expose a child that an enclosing symbol explicitly withdrew.
+            this.withdrawals.set(unit.id, ancestors.flatMap((ancestor) => ancestor.withdrawals));
+            for (const withdrawal of unit.withdrawals)
+                this.checkLocation(withdrawal.location, sources);
+        }
+        for (const address of this.data.addresses)
+            if (!this.units.has(address.unitId))
+                this.problem("inventory-address", `Public address names missing identity ${address.unitId}.`, { file: address.file });
+        // Annotation attachment is valid only when a host belongs to a declaration
+        // site. A matching file name alone is insufficient for generated or repeated text.
+        const hosts = new Map(this.data.hosts.map((host) => [host.id, host]));
+        for (const host of this.data.hosts) {
+            this.checkLocation(host, sources);
+            if (host.attachment === "attached") {
+                if (host.unitIds.length === 0 && host.siteId !== undefined)
+                    this.problem("inventory-host", `Attached semantic host ${host.id} has no semantic owner.`, host);
+                if (host.unitIds.length !== 0 && host.siteId === undefined)
+                    this.problem("inventory-host", `Attached semantic host ${host.id} has no declaration site.`, host);
+                for (const id of host.unitIds) {
+                    const unit = this.units.get(id);
+                    if (unit === undefined ||
+                        !unit.sites.some((site) => site.id === host.siteId && site.file === host.file))
+                        this.problem("inventory-host", `Host ${host.id} is not attached to a declaration owned by ${id}.`, host);
+                }
+            }
+            else if (host.unitIds.length !== 0 || host.siteId !== undefined)
+                this.problem("inventory-host", `Unattached or unsupported host ${host.id} claims a semantic owner.`, host);
+        }
+        for (const entry of this.data.declarations) {
+            this.checkLocation(entry.location, sources);
+            const host = hosts.get(entry.hostId);
+            const range = entry.location.range;
+            if (host === undefined ||
+                host.attachment !== "attached" ||
+                range === undefined ||
+                host.file !== entry.location.file ||
+                range.start.offset < host.range.start.offset ||
+                range.end.offset > host.range.end.offset)
+                this.problem("inventory-host", `Annotation ${entry.id} does not belong to an eligible documentation host.`, entry.location);
+        }
+        for (const entry of this.data.reviews) {
+            this.checkLocation(entry.location, sources);
+            const host = hosts.get(entry.hostId);
+            const range = entry.location.range;
+            if (host === undefined ||
+                host.attachment !== "attached" ||
+                range === undefined ||
+                host.file !== entry.location.file ||
+                range.start.offset < host.range.start.offset ||
+                range.end.offset > host.range.end.offset)
+                this.problem("inventory-host", `Review ${entry.id} does not belong to an eligible documentation host.`, entry.location);
+        }
+    }
+    /**
+     * Verifies that an optional source range belongs to the recorded source snapshot.
+     *
+     * Adapter records must point into the exact original content, not merely to a
+     * path that happens to exist. Missing source text, absent ranges, and out-of-bounds
+     * coordinates all make later diagnostics and fingerprints unreliable.
+     */
+    checkLocation(location, sources) {
+        const text = sources.get(location.file);
+        if (text === undefined ||
+            location.range === undefined ||
+            !text.contains(location.range))
+            this.problem("inventory-location", "A declaration location does not match its original source snapshot.", location);
+    }
+    /**
+     * Appends one inventory diagnostic and permanently marks this snapshot incomplete.
+     *
+     * This central path keeps all validation failures visible to the graph evaluator.
+     * An optional location is reduced to the portable file/range form accepted by the
+     * report schema, preserving a specific repair site when the source record supplied one.
+     */
+    problem(code, message, location) {
+        this.data.complete = false;
+        this.data.diagnostics.push({
+            code,
+            severity: "error",
+            message,
+            repair: "Correct the adapter's source, identity, or ownership records before evaluating coverage.",
+            ...(location === undefined
+                ? {}
+                : {
+                    location: {
+                        file: location.file,
+                        ...(location.range === undefined
+                            ? {}
+                            : { range: location.range }),
+                    },
+                }),
+        });
+    }
+    /**
+     * Deduplicates and canonically orders merged records after validation.
+     *
+     * Normalization does not repair contradictions already reported. It only gives
+     * snapshots, serialized output, and diagnostic ordering a stable representation
+     * when equivalent adapter records arrived from independent scan inputs.
+     */
+    normalize() {
+        this.data.sources = InventoryMerge_1.InventoryMerge.unique(this.data.sources, (source) => source.id);
+        for (const source of this.data.sources)
+            source.addresses = InventoryMerge_1.InventoryMerge.sourceAddresses(source.addresses);
+        this.data.annotationRanges = InventoryMerge_1.InventoryMerge.unique(this.data.annotationRanges, (location) => (() => {
+            const _so0 = input => `{${_jsonStringifyTail_1._jsonStringifyTail(`"file":${_jsonStringifyString_1._jsonStringifyString(input.file)},${undefined === input.range ? "" : `"range":${undefined !== input.range ? _so1(input.range) : undefined}`}`)}}`;
+            const _so1 = input => `{"start":${_so2(input.start)},"end":${_so2(input.end)}}`;
+            const _so2 = 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 => "object" === typeof input.start && null !== input.start && _io2(input.start) && ("object" === typeof input.end && null !== input.end && _io2(input.end));
+            const _io2 = input => "number" === typeof input.offset && "number" === typeof input.line && "number" === typeof input.column;
+            return input => _so0(input);
+        })()(location));
+        this.data.units = InventoryMerge_1.InventoryMerge.unique(this.data.units, (unit) => unit.id);
+        for (const unit of this.data.units) {
+            unit.sites = InventoryMerge_1.InventoryMerge.unique(unit.sites, (site) => site.id);
+            for (const site of unit.sites)
+                site.content = InventoryMerge_1.InventoryMerge.unique(site.content, (range) => JSON.stringify([range.start.offset, range.end.offset])).sort((x, y) => {
+                    const start = x.start.offset - y.start.offset;
+                    return start !== 0 ? start : x.end.offset - y.end.offset;
+                });
+            unit.withdrawals = InventoryMerge_1.InventoryMerge.unique(unit.withdrawals, (withdrawal) => (() => {
+                const _so0 = input => `{"tag":${"\"" + input.tag + "\""},"location":${_so1(input.location)}}`;
+                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);
+            })()(withdrawal));
+        }
+        this.data.addresses = InventoryMerge_1.InventoryMerge.unique(this.data.addresses, (address) => JSON.stringify([address.file, address.segments, address.unitId]));
+        this.data.hosts = InventoryMerge_1.InventoryMerge.unique(this.data.hosts, (host) => host.id);
+        for (const host of this.data.hosts) {
+            host.unitIds = InventoryMerge_1.InventoryMerge.unique(host.unitIds, (id) => id);
+            host.origins = InventoryMerge_1.InventoryMerge.unique(host.origins ?? [host.file], (file) => file);
+            // Citation origin is required to explain generated or shared hosts. Keep the
+            // host record for diagnostics instead of silently deleting an invalid entry.
+            if (host.origins.length === 0)
+                this.problem("inventory-host", `Host ${host.id} has no citation origin.`, host);
+        }
+        this.data.declarations = InventoryMerge_1.InventoryMerge.unique(this.data.declarations, (entry) => entry.id);
+        this.data.reviews = InventoryMerge_1.InventoryMerge.unique(this.data.reviews, (entry) => entry.id);
+        this.data.dependencies = InventoryMerge_1.InventoryMerge.unique(this.data.dependencies, (dependency) => JSON.stringify([dependency.path, dependency.recursive]));
+        this.data.diagnostics = InventoryMerge_1.InventoryMerge.unique(this.data.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));
+    }
+}
+exports.EvidenceInventory = EvidenceInventory;