@wrtnlabs/evidence 0.0.0

package/lib/contexts/EvidenceQueryPopulationContext.d.ts

@@ -0,0 +1,102 @@
+import type { IEvidenceQueryPopulation } from "../internal/IEvidenceQueryPopulation";
+import type { IEvidencePublicAddress } from "../structures/IEvidencePublicAddress";
+import type { IEvidenceUnit } from "../structures/IEvidenceUnit";
+/**
+ * Indexes one configured population for repeated structural and coverage queries.
+ *
+ * The containing facade owns the analysis snapshot. This context borrows its
+ * records, distinguishes explicit selection from ancestor closure and visibility,
+ * and caches descendant traversal without rebuilding indexes for each operation.
+ */
+export declare class EvidenceQueryPopulationContext {
+    /**
+     * Claim or reference coordinates identifying the configured population.
+     *
+     * Query rows qualify semantic identities with this scope to retain independent obligations.
+     */
+    readonly scope: IEvidenceQueryPopulation["scope"];
+    /**
+     * Inventory borrowed from the containing facade's isolated analysis snapshot.
+     *
+     * It supplies full structural context, including units outside explicit selection.
+     */
+    readonly inventory: IEvidenceQueryPopulation["inventory"];
+    /**
+     * Configured semantic selection in its original order.
+     *
+     * Descendant results preserve this order rather than adopting map traversal order.
+     */
+    readonly unitIds: IEvidenceQueryPopulation["unitIds"];
+    /**
+     * Effective graph input when the population represents a reference.
+     *
+     * Claim populations leave this undefined because they do not own a reference policy.
+     */
+    readonly reference: IEvidenceQueryPopulation["reference"];
+    /**
+     * Evaluated obligation ledger for a reference population.
+     *
+     * Coverage inspection uses this alongside structural selection; claim entries omit it.
+     */
+    readonly obligation: IEvidenceQueryPopulation["obligation"];
+    /**
+     * Full inventory indexed by semantic unit identity.
+     *
+     * Parent traversal follows these explicit links instead of inferring ownership
+     * from public accessor prefixes.
+     */
+    readonly units: Map<string, IEvidenceUnit>;
+    /**
+     * Explicitly selected identities used for direct membership checks.
+     *
+     * Structural ancestors belong to configured closure separately and do not
+     * increase this population's selected denominator.
+     */
+    readonly selected: Set<string>;
+    /**
+     * Selected identities together with their existing structural ancestors.
+     *
+     * Withdrawn identities remain in this set for exact target applicability even
+     * though visible discovery output excludes them.
+     */
+    readonly configured: Set<string>;
+    /**
+     * Configured identities with neither an own withdrawal nor a withdrawn ancestor.
+     *
+     * List queries use this set to avoid advertising hidden public targets as visible API.
+     */
+    readonly visible: Set<string>;
+    /**
+     * Public addresses grouped by semantic identity in inventory order.
+     *
+     * Formatting later sorts and deduplicates target spellings for each query row.
+     */
+    readonly addresses: Map<string, IEvidencePublicAddress[]>;
+    /**
+     * Cached selected-descendant lists keyed by queried ancestor identity.
+     *
+     * The immutable snapshot boundary lets repeated coverage queries reuse traversal results.
+     */
+    private readonly descendants;
+    /**
+     * Builds selection, visibility, and address indexes over an owned analysis population.
+     *
+     * This constructor does not clone records itself; the containing facade supplies
+     * isolated data. Parent walks stop at cycles or missing units so inspection cannot loop.
+     */
+    constructor(population: IEvidenceQueryPopulation);
+    /**
+     * Returns selected descendants in configured order, including a selected ancestor itself.
+     *
+     * The cached result follows explicit parent relationships. Callers receive a
+     * readonly view because mutating it would corrupt subsequent coverage summaries.
+     */
+    selectedDescendants(ancestorId: string): readonly string[];
+    /**
+     * Tests whether an identity belongs to an ancestor's explicit structural subtree.
+     *
+     * A unit descends from itself. Missing parents and cycles terminate the walk,
+     * and literal dots in names never invent another ownership edge.
+     */
+    descends(unitId: string, ancestorId: string): boolean;
+}

package/lib/contexts/EvidenceQueryPopulationContext.js

@@ -0,0 +1,166 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EvidenceQueryPopulationContext = void 0;
+/**
+ * Indexes one configured population for repeated structural and coverage queries.
+ *
+ * The containing facade owns the analysis snapshot. This context borrows its
+ * records, distinguishes explicit selection from ancestor closure and visibility,
+ * and caches descendant traversal without rebuilding indexes for each operation.
+ */
+class EvidenceQueryPopulationContext {
+    /**
+     * Claim or reference coordinates identifying the configured population.
+     *
+     * Query rows qualify semantic identities with this scope to retain independent obligations.
+     */
+    scope;
+    /**
+     * Inventory borrowed from the containing facade's isolated analysis snapshot.
+     *
+     * It supplies full structural context, including units outside explicit selection.
+     */
+    inventory;
+    /**
+     * Configured semantic selection in its original order.
+     *
+     * Descendant results preserve this order rather than adopting map traversal order.
+     */
+    unitIds;
+    /**
+     * Effective graph input when the population represents a reference.
+     *
+     * Claim populations leave this undefined because they do not own a reference policy.
+     */
+    reference;
+    /**
+     * Evaluated obligation ledger for a reference population.
+     *
+     * Coverage inspection uses this alongside structural selection; claim entries omit it.
+     */
+    obligation;
+    /**
+     * Full inventory indexed by semantic unit identity.
+     *
+     * Parent traversal follows these explicit links instead of inferring ownership
+     * from public accessor prefixes.
+     */
+    units;
+    /**
+     * Explicitly selected identities used for direct membership checks.
+     *
+     * Structural ancestors belong to configured closure separately and do not
+     * increase this population's selected denominator.
+     */
+    selected;
+    /**
+     * Selected identities together with their existing structural ancestors.
+     *
+     * Withdrawn identities remain in this set for exact target applicability even
+     * though visible discovery output excludes them.
+     */
+    configured = new Set();
+    /**
+     * Configured identities with neither an own withdrawal nor a withdrawn ancestor.
+     *
+     * List queries use this set to avoid advertising hidden public targets as visible API.
+     */
+    visible = new Set();
+    /**
+     * Public addresses grouped by semantic identity in inventory order.
+     *
+     * Formatting later sorts and deduplicates target spellings for each query row.
+     */
+    addresses = new Map();
+    /**
+     * Cached selected-descendant lists keyed by queried ancestor identity.
+     *
+     * The immutable snapshot boundary lets repeated coverage queries reuse traversal results.
+     */
+    descendants = new Map();
+    /**
+     * Builds selection, visibility, and address indexes over an owned analysis population.
+     *
+     * This constructor does not clone records itself; the containing facade supplies
+     * isolated data. Parent walks stop at cycles or missing units so inspection cannot loop.
+     */
+    constructor(population) {
+        this.scope = population.scope;
+        this.inventory = population.inventory;
+        this.unitIds = population.unitIds;
+        this.reference = population.reference;
+        this.obligation = population.obligation;
+        this.units = new Map(this.inventory.units.map((unit) => [unit.id, unit]));
+        this.selected = new Set(this.unitIds);
+        for (const id of this.unitIds) {
+            let current = this.units.get(id);
+            const visited = new Set();
+            while (current !== undefined && !visited.has(current.id)) {
+                this.configured.add(current.id);
+                visited.add(current.id);
+                current =
+                    current.parentId === undefined
+                        ? undefined
+                        : this.units.get(current.parentId);
+            }
+        }
+        // Preserve structural closure before applying withdrawal. Exact inspection
+        // still needs to recognize a configured target and explain why it is hidden.
+        for (const id of this.configured) {
+            let current = this.units.get(id);
+            const visited = new Set();
+            let withdrawn = false;
+            while (current !== undefined && !visited.has(current.id)) {
+                if (current.withdrawals.length !== 0) {
+                    withdrawn = true;
+                    break;
+                }
+                visited.add(current.id);
+                current =
+                    current.parentId === undefined
+                        ? undefined
+                        : this.units.get(current.parentId);
+            }
+            if (!withdrawn)
+                this.visible.add(id);
+        }
+        for (const address of this.inventory.addresses) {
+            const entries = this.addresses.get(address.unitId) ?? [];
+            entries.push(address);
+            this.addresses.set(address.unitId, entries);
+        }
+    }
+    /**
+     * Returns selected descendants in configured order, including a selected ancestor itself.
+     *
+     * The cached result follows explicit parent relationships. Callers receive a
+     * readonly view because mutating it would corrupt subsequent coverage summaries.
+     */
+    selectedDescendants(ancestorId) {
+        const remembered = this.descendants.get(ancestorId);
+        if (remembered !== undefined)
+            return remembered;
+        const descendants = this.unitIds.filter((unitId) => this.descends(unitId, ancestorId));
+        this.descendants.set(ancestorId, descendants);
+        return descendants;
+    }
+    /**
+     * Tests whether an identity belongs to an ancestor's explicit structural subtree.
+     *
+     * A unit descends from itself. Missing parents and cycles terminate the walk,
+     * and literal dots in names never invent another ownership edge.
+     */
+    descends(unitId, ancestorId) {
+        const visited = new Set();
+        let unit = this.units.get(unitId);
+        while (unit !== undefined && !visited.has(unit.id)) {
+            if (unit.id === ancestorId)
+                return true;
+            visited.add(unit.id);
+            unit =
+                unit.parentId === undefined ? undefined : this.units.get(unit.parentId);
+        }
+        return false;
+    }
+}
+exports.EvidenceQueryPopulationContext = EvidenceQueryPopulationContext;

package/lib/contexts/IEvidenceCheckContext.d.ts

@@ -0,0 +1,26 @@
+import type { IEvidenceMaterializedClaim } from "../internal/IEvidenceMaterializedClaim";
+import type { IEvidenceConfigPlan } from "../structures/IEvidenceConfigPlan";
+/**
+ * Captures configuration and adapter output for one checker execution.
+ *
+ * The checker builds this context after configuration resolution and source
+ * materialization. Downstream graph preparation uses both fields together so
+ * plan coordinates, selected roots, and parsed declarations refer to one stable
+ * run rather than to a mix of later configuration or filesystem state.
+ */
+export interface IEvidenceCheckContext {
+    /**
+     * Resolved configuration plan used throughout this checker execution.
+     *
+     * It retains effective activation and original configuration coordinates, which
+     * graph diagnostics use to identify the declaration that created an obligation.
+     */
+    readonly plan: IEvidenceConfigPlan;
+    /**
+     * Claim adapter results materialized from the same configuration snapshot.
+     *
+     * Each entry retains claim and reference inventories before graph evaluation so
+     * incomplete scans remain visible instead of being removed during preparation.
+     */
+    readonly claims: IEvidenceMaterializedClaim[];
+}

package/lib/contexts/IEvidenceCheckContext.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/contexts/IEvidenceClaimContext.d.ts

@@ -0,0 +1,48 @@
+import type { IEvidenceMaterializedClaim } from "../internal/IEvidenceMaterializedClaim";
+import type { IEvidenceHost } from "../structures/IEvidenceHost";
+import type { IEvidenceInventory } from "../structures/IEvidenceInventory";
+/**
+ * Holds claim-local indexes while materializing graph reference obligations.
+ *
+ * Preparation reconciles the claim inventory once, maps declarations to the
+ * references where they apply, and keeps review applicability separate. Graph
+ * construction consumes this context before it creates per-reference resolution
+ * state, preserving independent obligations under one claim.
+ */
+export interface IEvidenceClaimContext {
+    /**
+     * Materialized claim input before graph-specific contexts are produced.
+     *
+     * It contains the configuration-plan coordinates and adapter inventories from
+     * the same checker execution, which keeps declaration locations aligned.
+     */
+    readonly materialized: IEvidenceMaterializedClaim;
+    /**
+     * Reconciled claim inventory that receives preparation diagnostics.
+     *
+     * Invalid hosts or participation targets make this inventory incomplete so
+     * later graph evaluation can preserve the failure instead of dropping records.
+     */
+    readonly inventory: IEvidenceInventory;
+    /**
+     * Claim hosts indexed by the semantic identity that owns their annotations.
+     *
+     * Multiple physical sites can describe one host identity; the map provides the
+     * canonical semantic attachment point used during acknowledgement matching.
+     */
+    readonly hosts: Map<string, IEvidenceHost>;
+    /**
+     * Reference positions to which each acknowledgement applies for coverage.
+     *
+     * The set preserves repeated reference boundaries. An absent entry means the
+     * declaration is not eligible to satisfy any reference under this claim.
+     */
+    readonly declarations: Map<string, Set<number>>;
+    /**
+     * Reference positions to which each review applies, independent of coverage.
+     *
+     * A review can target a reference without being an acknowledgement. Keeping its
+     * index separately prevents review metadata from changing coverage counts.
+     */
+    readonly reviews: Map<string, Set<number>>;
+}

package/lib/contexts/IEvidenceClaimContext.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/contexts/IEvidenceGraphClaimContext.d.ts

@@ -0,0 +1,40 @@
+import type { IEvidenceGraphClaim } from "../structures/IEvidenceGraphClaim";
+import type { IEvidenceInventory } from "../structures/IEvidenceInventory";
+import type { IEvidencePopulation } from "../structures/IEvidencePopulation";
+/**
+ * Captures the claim-side state required to evaluate its reference obligations.
+ *
+ * The graph creates this context after materialized claim targets are reconciled.
+ * Every reference beneath the claim reuses its host population, but resolves and
+ * evaluates reference-side units independently through its own context.
+ */
+export interface IEvidenceGraphClaimContext {
+    /**
+     * Materialized claim configuration, declarations, hosts, and references.
+     *
+     * This preserves the configuration boundary that owns reference indexes, even
+     * when another claim selects the same source host or semantic identity.
+     */
+    readonly claim: IEvidenceGraphClaim;
+    /**
+     * Reconciled claim inventory used for diagnostics and host lookup.
+     *
+     * Semantic validation failures are retained here so graph evaluation can report
+     * an incomplete claim instead of evaluating only the records that survived.
+     */
+    readonly inventory: IEvidenceInventory;
+    /**
+     * Selected claim units, structural scopes, and eligible documentation hosts.
+     *
+     * Structural ancestors make aggregate addresses resolvable, whereas the selected
+     * set determines required claim membership and the available attachment hosts.
+     */
+    readonly population: IEvidencePopulation;
+    /**
+     * Zero-based position of this claim in the captured graph input.
+     *
+     * Diagnostics and exported boundaries preserve this coordinate so duplicate
+     * claims remain distinguishable rather than collapsing by target identity.
+     */
+    readonly index: number;
+}

package/lib/contexts/IEvidenceGraphClaimContext.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/contexts/IEvidenceGraphReferenceContext.d.ts

@@ -0,0 +1,65 @@
+import type { IEvidenceGraphReference } from "../structures/IEvidenceGraphReference";
+import type { IEvidenceGraphResolution } from "../structures/IEvidenceGraphResolution";
+import type { IEvidenceGraphReviewResolution } from "../structures/IEvidenceGraphReviewResolution";
+import type { IEvidenceInventory } from "../structures/IEvidenceInventory";
+import type { IEvidencePopulation } from "../structures/IEvidencePopulation";
+import type { IEvidenceGraphClaimContext } from "./IEvidenceGraphClaimContext";
+/**
+ * Collects resolved state for one reference obligation beneath a graph claim.
+ *
+ * A claim can contain several references to overlapping semantic units, but each
+ * reference owns its policy, selected population, coverage ledger, and review
+ * resolution. Evaluators use this context to preserve that independence while
+ * sharing only the claim-side host and declaration information.
+ */
+export interface IEvidenceGraphReferenceContext {
+    /**
+     * Claim-side context shared by this claim's independent reference obligations.
+     *
+     * It supplies the selected hosts and declaration participation table; it does
+     * not merge this reference's policy or coverage outcome with a sibling's.
+     */
+    readonly claim: IEvidenceGraphClaimContext;
+    /**
+     * Materialized reference selection and graph policy being evaluated.
+     *
+     * Its target IDs define this obligation's reference population. Cardinality,
+     * exclusions, checklist, and review requirements all apply at this boundary.
+     */
+    readonly reference: IEvidenceGraphReference;
+    /**
+     * Reconciled reference inventory used for target coverage and review fingerprints.
+     *
+     * An incomplete inventory prevents the evaluator from treating an apparent
+     * match or absence as conclusive because extraction may have omitted a unit.
+     */
+    readonly inventory: IEvidenceInventory;
+    /**
+     * Reference units and structural owners selected for this obligation.
+     *
+     * The selected denominator and aggregate target scopes differ: an ancestor can
+     * be addressable for resolution without becoming a separately required unit.
+     */
+    readonly population: IEvidencePopulation;
+    /**
+     * Zero-based position of this reference within its owning claim.
+     *
+     * Participation indexes use this value to determine which acknowledgements and
+     * reviews apply without confusing duplicate references in the same claim.
+     */
+    readonly index: number;
+    /**
+     * Acknowledgement targets resolved against this reference population.
+     *
+     * These results feed coverage, exclusions, cardinality, and checklist handling.
+     * They deliberately exclude review targets, which have a separate lifecycle.
+     */
+    readonly resolutions: IEvidenceGraphResolution[];
+    /**
+     * Review targets resolved independently from coverage acknowledgements.
+     *
+     * A review validates relationship and fingerprint freshness; it never creates
+     * coverage merely because it points at the same semantic target.
+     */
+    readonly reviewResolutions: IEvidenceGraphReviewResolution[];
+}

package/lib/contexts/IEvidenceGraphReferenceContext.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/contexts/IEvidenceQueryContext.d.ts

@@ -0,0 +1,32 @@
+import type { IEvidenceCheckAnalysis } from "../structures/IEvidenceCheckAnalysis";
+import type { EvidenceQueryPopulationContext } from "./EvidenceQueryPopulationContext";
+/**
+ * Owned query state shared by list, inspect, and graph programmers.
+ *
+ * The EvidenceQuery facade clones analysis before constructing this context and
+ * clones reports before returning them. Population indexes can therefore cache
+ * traversal results without depending on caller-owned mutable inventory data.
+ */
+export interface IEvidenceQueryContext {
+    /**
+     * Complete analysis bundle captured by the query facade.
+     *
+     * Its plan, inventories, graph input, and report remain aligned throughout the
+     * lifetime of the population indexes.
+     */
+    readonly analysis: IEvidenceCheckAnalysis;
+    /**
+     * Absolute directory anchoring file-qualified query targets.
+     *
+     * Capturing it once prevents later cwd changes from altering target formatting
+     * or inspection within the same facade.
+     */
+    readonly cwd: string;
+    /**
+     * Claim and reference indexes belonging to the captured analysis.
+     *
+     * Each index keeps independent selection and obligation state despite shared
+     * semantic identities across configuration boundaries.
+     */
+    readonly populations: EvidenceQueryPopulationContext[];
+}

package/lib/contexts/IEvidenceQueryContext.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/contexts/IEvidenceTagContext.d.ts

@@ -0,0 +1,64 @@
+import type { IPendingEvidenceTag } from "../internal/IPendingEvidenceTag";
+import type { SourceText } from "../internal/SourceText";
+import type { IEvidenceDocumentation } from "../structures/IEvidenceDocumentation";
+import type { IEvidenceHost } from "../structures/IEvidenceHost";
+import type { IEvidenceTagParseResult } from "../structures/IEvidenceTagParseResult";
+/**
+ * Holds the mutable state used while one adapter parses an annotation block.
+ *
+ * The parser supplies immutable source, host, and documentation boundaries, then
+ * advances the pending tag and Markdown-fence state line by line. Keeping this
+ * state per invocation prevents an unterminated tag or code fence in one file
+ * from changing how another file is interpreted.
+ */
+export interface IEvidenceTagContext {
+    /**
+     * Original source text used to translate documentation offsets into locations.
+     *
+     * Diagnostics and parsed declarations use these coordinates to point back into
+     * the physical file rather than reporting offsets relative to a copied comment.
+     */
+    readonly source: SourceText;
+    /**
+     * Adapter-established declaration that owns every annotation parsed here.
+     *
+     * The tag parser never derives ownership from prose. Its consumer relies on
+     * this host identity when it later connects acknowledgements to graph claims.
+     */
+    readonly host: IEvidenceHost;
+    /**
+     * Normalized documentation text and its language-specific source boundaries.
+     *
+     * It determines which lines count as annotation content and maps each retained
+     * character to the original source position after comment syntax is removed.
+     */
+    readonly documentation: IEvidenceDocumentation;
+    /**
+     * Parsed annotations and diagnostics accumulated for this documentation block.
+     *
+     * The caller receives this shared result after end-of-input finalization, so a
+     * malformed tag can coexist with annotations that were parsed successfully.
+     */
+    readonly result: IEvidenceTagParseResult;
+    /**
+     * Tag whose value may still accept continuation lines.
+     *
+     * An empty boundary or a new tag finalizes this pending record. `undefined`
+     * means the next content line must begin a tag rather than extend one.
+     */
+    pending: IPendingEvidenceTag | undefined;
+    /**
+     * Opening marker for the active fenced code region.
+     *
+     * An empty string means ordinary tag parsing is active. While nonempty, lines
+     * are treated as literal code until a compatible closing marker is found.
+     */
+    fence: string;
+    /**
+     * Minimum run length required for the active fence's closing marker.
+     *
+     * A shorter run of the same marker remains code content. This preserves nested
+     * fence text instead of terminating the outer annotation value prematurely.
+     */
+    fenceLength: number;
+}

package/lib/contexts/IEvidenceTagContext.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/executable/evidence.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/lib/executable/evidence.js

@@ -0,0 +1,14 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const EvidenceCommand_js_1 = require("../commands/EvidenceCommand.js");
+// Keep process termination outside the reusable command module. Assigning the
+// exit code lets pending stream writes and watcher cleanup complete naturally.
+EvidenceCommand_js_1.EvidenceCommand.main(process.argv.slice(2))
+    .then((exitCode) => {
+    process.exitCode = exitCode;
+})
+    .catch((error) => {
+    console.error(error);
+    process.exitCode = 2;
+});

package/lib/graph/EvidenceFingerprint.d.ts

@@ -0,0 +1,27 @@
+import type { IEvidenceFingerprint } from "../structures/IEvidenceFingerprint";
+import type { IEvidenceInventory } from "../structures/IEvidenceInventory";
+/**
+ * Computes review fingerprints from reconciled semantic content.
+ *
+ * Review freshness must change when a declaration or its structural scope changes,
+ * not when an adapter cache key, scan order, or caller-owned object changes. This
+ * namespace first rebuilds the supplied inventory through the normal validation
+ * boundary and delegates the versioned digest algorithm to the shared index.
+ */
+export declare namespace EvidenceFingerprint {
+    /**
+     * Returns one unit's own digest and versioned structural-scope fingerprint.
+     *
+     * The result includes content accepted for review as well as the explicit parent
+     * chain required to detect moves between owners. It rejects incomplete inventory
+     * because a missing unit would make a stable-looking fingerprint untrustworthy.
+     *
+     * @example
+     * const fingerprint: IEvidenceFingerprint = EvidenceFingerprint.inspect(
+     *   inventory,
+     *   unitId,
+     * );
+     * // Persist fingerprint.value with a review of this semantic unit.
+     */
+    function inspect(inventory: IEvidenceInventory, unitId: string): IEvidenceFingerprint;
+}

package/lib/graph/EvidenceFingerprint.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EvidenceFingerprint = void 0;
+const EvidenceInventory_1 = require("./EvidenceInventory");
+const EvidenceFingerprintIndex_1 = require("../internal/EvidenceFingerprintIndex");
+/**
+ * Computes review fingerprints from reconciled semantic content.
+ *
+ * Review freshness must change when a declaration or its structural scope changes,
+ * not when an adapter cache key, scan order, or caller-owned object changes. This
+ * namespace first rebuilds the supplied inventory through the normal validation
+ * boundary and delegates the versioned digest algorithm to the shared index.
+ */
+var EvidenceFingerprint;
+(function (EvidenceFingerprint) {
+    /**
+     * Returns one unit's own digest and versioned structural-scope fingerprint.
+     *
+     * The result includes content accepted for review as well as the explicit parent
+     * chain required to detect moves between owners. It rejects incomplete inventory
+     * because a missing unit would make a stable-looking fingerprint untrustworthy.
+     *
+     * @example
+     * const fingerprint: IEvidenceFingerprint = EvidenceFingerprint.inspect(
+     *   inventory,
+     *   unitId,
+     * );
+     * // Persist fingerprint.value with a review of this semantic unit.
+     */
+    function inspect(inventory, unitId) {
+        const snapshot = new EvidenceInventory_1.EvidenceInventory([inventory]).snapshot();
+        if (!snapshot.complete)
+            throw new Error("Cannot fingerprint an incomplete evidence inventory.");
+        return new EvidenceFingerprintIndex_1.EvidenceFingerprintIndex(snapshot).inspect(unitId);
+    }
+    EvidenceFingerprint.inspect = inspect;
+})(EvidenceFingerprint || (exports.EvidenceFingerprint = EvidenceFingerprint = {}));