@wrtnlabs/evidence 0.0.0 → 0.1.0

package/lib/commands/EvidenceWatcher.d.ts

@@ -4,37 +4,42 @@ import type { EvidenceWatchPublisher } from "../typings/EvidenceWatchPublisher";
 /**
  * Rechecks active dependencies and publishes stable results in sequence.
  *
- * Start one watch loop per instance and supply an awaited publisher. Each attempt
- * reevaluates configuration and source dependencies, then verifies that its input
- * snapshots stayed stable before publishing. Failed attempts retain dependencies
- * needed to observe repairs; parser acquisition also retries without a file edit.
+ * Start one watch loop per instance and supply an awaited publisher. Each
+ * attempt reevaluates configuration and source dependencies, then verifies that
+ * its input snapshots stayed stable before publishing. Failed attempts retain
+ * dependencies needed to observe repairs; parser acquisition also retries
+ * without a file edit.
  *
  * Close stops future publication, interrupts pending delays, and cancels this
  * watcher's asset subscriptions. Await the watch promise to observe completion
  * of any analysis or publisher already in progress.
  *
  * @example
- * const watcher: EvidenceWatcher = new EvidenceWatcher("evidence.config.ts");
- * const watching: Promise<void> = watcher.watch(
- *   async (cycle: EvidenceWatchCycle): Promise<void> => {
- *     console.log(cycle.cycle, cycle.status);
- *   },
- * );
- * // When the application shuts down:
- * await watcher.close();
- * await watching;
+ *   const watcher: EvidenceWatcher = new EvidenceWatcher(
+ *     "evidence.config.ts",
+ *   );
+ *   const watching: Promise<void> = watcher.watch(
+ *     async (cycle: EvidenceWatchCycle): Promise<void> => {
+ *       console.log(cycle.cycle, cycle.status);
+ *     },
+ *   );
+ *   // When the application shuts down:
+ *   await watcher.close();
+ *   await watching;
  */
 export declare class EvidenceWatcher {
     /**
      * Absolute configuration anchor captured before observation begins.
      *
-     * Later changes to process cwd cannot redirect configuration or dependency scans.
+     * Later changes to process cwd cannot redirect configuration or dependency
+     * scans.
      */
     private readonly configFile;
     /**
      * Interval between dependency snapshots during idle observation.
      *
-     * Close can interrupt the pending delay rather than waiting out this interval.
+     * Close can interrupt the pending delay rather than waiting out this
+     * interval.
      */
     private readonly pollIntervalMilliseconds;
     /**
@@ -44,10 +49,11 @@ export declare class EvidenceWatcher {
      */
     private readonly debounceMilliseconds;
     /**
-     * Retry interval for parser assets that may recover without a filesystem edit.
+     * Retry interval for parser assets that may recover without a filesystem
+     * edit.
      *
-     * Only acquisition-related failures activate this timer; other stable failures
-     * wait for a dependency change.
+     * Only acquisition-related failures activate this timer; other stable
+     * failures wait for a dependency change.
      */
     private readonly parserRetryMilliseconds;
     /**
@@ -67,13 +73,16 @@ export declare class EvidenceWatcher {
     /**
      * Whether the instance has already entered its single allowed watch loop.
      *
-     * The guard prevents concurrent loops from sharing cycle and dependency state.
+     * The guard prevents concurrent loops from sharing cycle and dependency
+     * state.
      */
     private started;
     /**
-     * Shutdown state checked between asynchronous analysis and publication phases.
+     * Shutdown state checked between asynchronous analysis and publication
+     * phases.
      *
-     * A completed attempt is discarded if shutdown was requested before publication.
+     * A completed attempt is discarded if shutdown was requested before
+     * publication.
      */
     private closed;
     /**
@@ -93,8 +102,9 @@ export declare class EvidenceWatcher {
     /**
      * Captures the configuration anchor and validates observation timing.
      *
-     * Construction prepares fallback dependencies but does not evaluate configuration
-     * or start polling. Omitted timing options use the documented watch defaults.
+     * Construction prepares fallback dependencies but does not evaluate
+     * configuration or start polling. Omitted timing options use the documented
+     * watch defaults.
      */
     constructor(configFile?: string, options?: IEvidenceWatchOptions);
     /**
@@ -105,7 +115,8 @@ export declare class EvidenceWatcher {
      */
     dependencies(): IEvidenceSourceDependency[];
     /**
-     * Publishes an initial check and subsequent stable reevaluations until shutdown.
+     * Publishes an initial check and subsequent stable reevaluations until
+     * shutdown.
      *
      * The publisher is awaited, preserving cycle order and applying backpressure.
      * Starting twice or after close rejects. Analysis failures become cycle data;
@@ -115,9 +126,9 @@ export declare class EvidenceWatcher {
     /**
      * Requests shutdown and wakes any polling or settling delay immediately.
      *
-     * Asset subscriptions owned by this watcher are cancelled. This method does not
-     * join the active watch loop; await its watch promise to finish outstanding
-     * analysis or publication work.
+     * Asset subscriptions owned by this watcher are cancelled. This method does
+     * not join the active watch loop; await its watch promise to finish
+     * outstanding analysis or publication work.
      */
     close(): Promise<void>;
     private evaluate;
@@ -127,8 +138,9 @@ export declare class EvidenceWatcher {
     /**
      * Reads shutdown state after asynchronous boundaries.
      *
-     * The loop checks this before starting another phase or publishing a completed
-     * attempt, since close can run while an awaited operation is pending.
+     * The loop checks this before starting another phase or publishing a
+     * completed attempt, since close can run while an awaited operation is
+     * pending.
      */
     private isClosed;
 }

package/lib/commands/EvidenceWatcher.js

@@ -41,47 +41,52 @@ const _isTypeUint32_1 = __importStar(require("typia/lib/internal/_isTypeUint32")
 const _assertGuard_1 = __importStar(require("typia/lib/internal/_assertGuard"));
 const node_path_1 = __importDefault(require("node:path"));
 const typia_1 = __importDefault(require("typia"));
-const ConfigDependencyScanner_1 = require("../internal/ConfigDependencyScanner");
-const TreeSitterAssetScope_1 = require("../internal/TreeSitterAssetScope");
+const EvidenceConfigDependencyScanner_1 = require("../internal/EvidenceConfigDependencyScanner");
+const EvidenceTreeSitterAssetScope_1 = require("../internal/EvidenceTreeSitterAssetScope");
 const EvidenceParserError_1 = require("../parsers/EvidenceParserError");
-const SourcePath_1 = require("../internal/SourcePath");
-const WatchDependencySet_1 = require("../internal/WatchDependencySet");
-const WatchDependencySnapshot_1 = require("../internal/WatchDependencySnapshot");
+const EvidenceSourcePath_1 = require("../internal/EvidenceSourcePath");
+const EvidenceWatchDependencySet_1 = require("../internal/EvidenceWatchDependencySet");
+const EvidenceWatchDependencySnapshot_1 = require("../internal/EvidenceWatchDependencySnapshot");
 const EvidenceChecker_1 = require("../EvidenceChecker");
 /**
  * Rechecks active dependencies and publishes stable results in sequence.
  *
- * Start one watch loop per instance and supply an awaited publisher. Each attempt
- * reevaluates configuration and source dependencies, then verifies that its input
- * snapshots stayed stable before publishing. Failed attempts retain dependencies
- * needed to observe repairs; parser acquisition also retries without a file edit.
+ * Start one watch loop per instance and supply an awaited publisher. Each
+ * attempt reevaluates configuration and source dependencies, then verifies that
+ * its input snapshots stayed stable before publishing. Failed attempts retain
+ * dependencies needed to observe repairs; parser acquisition also retries
+ * without a file edit.
  *
  * Close stops future publication, interrupts pending delays, and cancels this
  * watcher's asset subscriptions. Await the watch promise to observe completion
  * of any analysis or publisher already in progress.
  *
  * @example
- * const watcher: EvidenceWatcher = new EvidenceWatcher("evidence.config.ts");
- * const watching: Promise<void> = watcher.watch(
- *   async (cycle: EvidenceWatchCycle): Promise<void> => {
- *     console.log(cycle.cycle, cycle.status);
- *   },
- * );
- * // When the application shuts down:
- * await watcher.close();
- * await watching;
+ *   const watcher: EvidenceWatcher = new EvidenceWatcher(
+ *     "evidence.config.ts",
+ *   );
+ *   const watching: Promise<void> = watcher.watch(
+ *     async (cycle: EvidenceWatchCycle): Promise<void> => {
+ *       console.log(cycle.cycle, cycle.status);
+ *     },
+ *   );
+ *   // When the application shuts down:
+ *   await watcher.close();
+ *   await watching;
  */
 class EvidenceWatcher {
     /**
      * Absolute configuration anchor captured before observation begins.
      *
-     * Later changes to process cwd cannot redirect configuration or dependency scans.
+     * Later changes to process cwd cannot redirect configuration or dependency
+     * scans.
      */
     configFile;
     /**
      * Interval between dependency snapshots during idle observation.
      *
-     * Close can interrupt the pending delay rather than waiting out this interval.
+     * Close can interrupt the pending delay rather than waiting out this
+     * interval.
      */
     pollIntervalMilliseconds;
     /**
@@ -91,10 +96,11 @@ class EvidenceWatcher {
      */
     debounceMilliseconds;
     /**
-     * Retry interval for parser assets that may recover without a filesystem edit.
+     * Retry interval for parser assets that may recover without a filesystem
+     * edit.
      *
-     * Only acquisition-related failures activate this timer; other stable failures
-     * wait for a dependency change.
+     * Only acquisition-related failures activate this timer; other stable
+     * failures wait for a dependency change.
      */
     parserRetryMilliseconds;
     /**
@@ -114,13 +120,16 @@ class EvidenceWatcher {
     /**
      * Whether the instance has already entered its single allowed watch loop.
      *
-     * The guard prevents concurrent loops from sharing cycle and dependency state.
+     * The guard prevents concurrent loops from sharing cycle and dependency
+     * state.
      */
     started = false;
     /**
-     * Shutdown state checked between asynchronous analysis and publication phases.
+     * Shutdown state checked between asynchronous analysis and publication
+     * phases.
      *
-     * A completed attempt is discarded if shutdown was requested before publication.
+     * A completed attempt is discarded if shutdown was requested before
+     * publication.
      */
     closed = false;
     /**
@@ -140,8 +149,9 @@ class EvidenceWatcher {
     /**
      * Captures the configuration anchor and validates observation timing.
      *
-     * Construction prepares fallback dependencies but does not evaluate configuration
-     * or start polling. Omitted timing options use the documented watch defaults.
+     * Construction prepares fallback dependencies but does not evaluate
+     * configuration or start polling. Omitted timing options use the documented
+     * watch defaults.
      */
     constructor(configFile = "evidence.config.ts", options = {}) {
         const checked = (() => {
@@ -223,7 +233,8 @@ class EvidenceWatcher {
         return structuredClone(this.active);
     }
     /**
-     * Publishes an initial check and subsequent stable reevaluations until shutdown.
+     * Publishes an initial check and subsequent stable reevaluations until
+     * shutdown.
      *
      * The publisher is awaited, preserving cycle order and applying backpressure.
      * Starting twice or after close rejects. Analysis failures become cycle data;
@@ -231,9 +242,9 @@ class EvidenceWatcher {
      */
     async watch(publish) {
         if (this.started)
-            throw new Error("An Evidence watcher can be started only once.");
+            throw new Error("An Evidence Graph watcher can be started only once.");
         if (this.closed)
-            throw new Error("A closed Evidence watcher cannot be started.");
+            throw new Error("A closed Evidence Graph watcher cannot be started.");
         this.started = true;
         try {
             let attempt = await this.evaluate();
@@ -252,7 +263,7 @@ class EvidenceWatcher {
                 await this.pause(this.pollIntervalMilliseconds);
                 if (this.isClosed())
                     break;
-                const changed = await WatchDependencySnapshot_1.WatchDependencySnapshot.capture(this.active);
+                const changed = await EvidenceWatchDependencySnapshot_1.EvidenceWatchDependencySnapshot.capture(this.active);
                 if (changed.equals(baseline) && Date.now() < retryAt)
                     continue;
                 await this.settle(changed);
@@ -278,9 +289,9 @@ class EvidenceWatcher {
     /**
      * Requests shutdown and wakes any polling or settling delay immediately.
      *
-     * Asset subscriptions owned by this watcher are cancelled. This method does not
-     * join the active watch loop; await its watch promise to finish outstanding
-     * analysis or publication work.
+     * Asset subscriptions owned by this watcher are cancelled. This method does
+     * not join the active watch loop; await its watch promise to finish
+     * outstanding analysis or publication work.
      */
     async close() {
         this.closed = true;
@@ -290,37 +301,39 @@ class EvidenceWatcher {
     /**
      * Runs an attempt under this watcher's execution-local asset cancellation.
      *
-     * An inherited caller signal remains effective alongside watcher shutdown, and
-     * the scope reaches parsers created by configuration scanning as well as analysis.
+     * An inherited caller signal remains effective alongside watcher shutdown,
+     * and the scope reaches parsers created by configuration scanning as well as
+     * analysis.
      */
     async evaluate() {
-        const inherited = TreeSitterAssetScope_1.TreeSitterAssetScope.current().signal;
+        const inherited = EvidenceTreeSitterAssetScope_1.EvidenceTreeSitterAssetScope.current().signal;
         const signal = inherited === undefined
             ? this.cancellation.signal
             : AbortSignal.any([inherited, this.cancellation.signal]);
-        return TreeSitterAssetScope_1.TreeSitterAssetScope.run({ signal }, () => this.evaluateStable());
+        return EvidenceTreeSitterAssetScope_1.EvidenceTreeSitterAssetScope.run({ signal }, () => this.evaluateStable());
     }
     /**
      * Repeats analysis until dependency discovery and source snapshots agree.
      *
-     * Newly discovered paths enlarge the observed boundary before acceptance. Input
-     * changes during evaluation cause another attempt, while stable failures retain
-     * enough dependency state for a later repair to trigger reevaluation.
+     * Newly discovered paths enlarge the observed boundary before acceptance.
+     * Input changes during evaluation cause another attempt, while stable
+     * failures retain enough dependency state for a later repair to trigger
+     * reevaluation.
      */
     async evaluateStable() {
         for (;;) {
             if (this.isClosed()) {
-                const snapshot = await WatchDependencySnapshot_1.WatchDependencySnapshot.capture(this.active);
+                const snapshot = await EvidenceWatchDependencySnapshot_1.EvidenceWatchDependencySnapshot.capture(this.active);
                 return {
-                    cycle: failureCycle(this.cycles + 1, this.configFile, new Error("The Evidence watcher was closed.")),
+                    cycle: failureCycle(this.cycles + 1, this.configFile, new Error("The Evidence Graph watcher was closed.")),
                     dependencies: this.active,
                     snapshot,
                     retryParser: false,
                 };
             }
             const beforeConfig = await scanConfiguration(this.configFile);
-            const candidates = WatchDependencySet_1.WatchDependencySet.merge(this.active, beforeConfig.dependencies);
-            const before = await WatchDependencySnapshot_1.WatchDependencySnapshot.capture(candidates);
+            const candidates = EvidenceWatchDependencySet_1.EvidenceWatchDependencySet.merge(this.active, beforeConfig.dependencies);
+            const before = await EvidenceWatchDependencySnapshot_1.EvidenceWatchDependencySnapshot.capture(candidates);
             let analysis;
             let analysisCause;
             try {
@@ -335,21 +348,21 @@ class EvidenceWatcher {
             // A failed evaluation cannot replace the previous dependency set with a
             // smaller partial discovery, or repairing a lost input might never wake us.
             const active = analysis === undefined
-                ? WatchDependencySet_1.WatchDependencySet.merge(this.active, afterConfig.dependencies)
+                ? EvidenceWatchDependencySet_1.EvidenceWatchDependencySet.merge(this.active, afterConfig.dependencies)
                 : cause === undefined
-                    ? WatchDependencySet_1.WatchDependencySet.analysis(analysis, afterConfig.dependencies)
-                    : WatchDependencySet_1.WatchDependencySet.merge(this.active, afterConfig.dependencies, WatchDependencySet_1.WatchDependencySet.analysis(analysis, []));
+                    ? EvidenceWatchDependencySet_1.EvidenceWatchDependencySet.analysis(analysis, afterConfig.dependencies)
+                    : EvidenceWatchDependencySet_1.EvidenceWatchDependencySet.merge(this.active, afterConfig.dependencies, EvidenceWatchDependencySet_1.EvidenceWatchDependencySet.analysis(analysis, []));
             const retryParser = parserFailure(cause) ||
                 (analysis !== undefined &&
                     analysis.report.diagnostics.some((diagnostic) => /(?:^|-)asset-(?:download|cache|corrupt)$/u.test(diagnostic.code)));
-            if (!WatchDependencySet_1.WatchDependencySet.contains(candidates, active)) {
+            if (!EvidenceWatchDependencySet_1.EvidenceWatchDependencySet.contains(candidates, active)) {
                 this.active = active;
                 // A preparation failure already proves this cycle incomplete. Publish it
                 // before retrying, while still recording every newly discovered dependency.
                 if (!retryParser)
                     continue;
             }
-            const after = await WatchDependencySnapshot_1.WatchDependencySnapshot.capture(WatchDependencySet_1.WatchDependencySet.merge(candidates, active));
+            const after = await EvidenceWatchDependencySnapshot_1.EvidenceWatchDependencySnapshot.capture(EvidenceWatchDependencySet_1.EvidenceWatchDependencySet.merge(candidates, active));
             // Compare the same pre-analysis boundary. A report built across two source
             // versions must be retried rather than published as a stable cycle.
             if (!before.equals(after.select(candidates))) {
@@ -371,8 +384,9 @@ class EvidenceWatcher {
     /**
      * Waits until watched inputs remain unchanged for one quiet interval.
      *
-     * Further edits restart the interval. Shutdown and zero debounce skip additional
-     * waiting so the outer loop can handle cancellation or evaluate immediately.
+     * Further edits restart the interval. Shutdown and zero debounce skip
+     * additional waiting so the outer loop can handle cancellation or evaluate
+     * immediately.
      */
     async settle(initial) {
         let previous = initial;
@@ -380,7 +394,7 @@ class EvidenceWatcher {
             await this.pause(this.debounceMilliseconds);
             if (this.isClosed())
                 return previous;
-            const current = await WatchDependencySnapshot_1.WatchDependencySnapshot.capture(this.active);
+            const current = await EvidenceWatchDependencySnapshot_1.EvidenceWatchDependencySnapshot.capture(this.active);
             if (current.equals(previous))
                 return current;
             previous = current;
@@ -414,8 +428,9 @@ class EvidenceWatcher {
     /**
      * Reads shutdown state after asynchronous boundaries.
      *
-     * The loop checks this before starting another phase or publishing a completed
-     * attempt, since close can run while an awaited operation is pending.
+     * The loop checks this before starting another phase or publishing a
+     * completed attempt, since close can run while an awaited operation is
+     * pending.
      */
     isClosed() {
         return this.closed;
@@ -429,7 +444,7 @@ exports.EvidenceWatcher = EvidenceWatcher;
  * only the exception would discard the scanner's partial dependency knowledge.
  */
 async function scanConfiguration(configFile) {
-    const scanner = new ConfigDependencyScanner_1.ConfigDependencyScanner(configFile);
+    const scanner = new EvidenceConfigDependencyScanner_1.EvidenceConfigDependencyScanner(configFile);
     try {
         return { dependencies: await scanner.scan() };
     }
@@ -492,9 +507,12 @@ function parserFailure(cause) {
  * file or a nearby imported input is initially missing or cannot be evaluated.
  */
 function configurationFallback(configFile) {
-    const normalized = SourcePath_1.SourcePath.slash(configFile);
+    const normalized = EvidenceSourcePath_1.EvidenceSourcePath.slash(configFile);
     return [
         { path: normalized, recursive: false },
-        { path: SourcePath_1.SourcePath.slash(node_path_1.default.dirname(normalized)), recursive: true },
+        {
+            path: EvidenceSourcePath_1.EvidenceSourcePath.slash(node_path_1.default.dirname(normalized)),
+            recursive: true,
+        },
     ];
 }

package/lib/commands/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Command execution, watch lifecycle, and command syntax boundaries.
+ *
+ * Use EvidenceCommand for CLI-compatible finite execution, EvidenceWatcher for
+ * long-lived publication, and EvidenceCommandError to distinguish invalid
+ * syntax before a project configuration is loaded.
+ */
+export * from "./EvidenceCommand";
+export * from "./EvidenceCommandError";
+export * from "./EvidenceWatcher";

package/lib/commands/index.js

@@ -0,0 +1,26 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Command execution, watch lifecycle, and command syntax boundaries.
+ *
+ * Use EvidenceCommand for CLI-compatible finite execution, EvidenceWatcher for
+ * long-lived publication, and EvidenceCommandError to distinguish invalid
+ * syntax before a project configuration is loaded.
+ */
+__exportStar(require("./EvidenceCommand"), exports);
+__exportStar(require("./EvidenceCommandError"), exports);
+__exportStar(require("./EvidenceWatcher"), exports);

package/lib/contexts/EvidenceQueryPopulationContext.d.ts

@@ -2,48 +2,55 @@ import type { IEvidenceQueryPopulation } from "../internal/IEvidenceQueryPopulat
 import type { IEvidencePublicAddress } from "../structures/IEvidencePublicAddress";
 import type { IEvidenceUnit } from "../structures/IEvidenceUnit";
 /**
- * Indexes one configured population for repeated structural and coverage queries.
+ * 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.
+ * 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.
+     * 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.
+     * 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.
+     * 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.
+     * 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.
+     * 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.
+     * Parent traversal follows these explicit links instead of inferring
+     * ownership from public accessor prefixes.
      */
     readonly units: Map<string, IEvidenceUnit>;
     /**
@@ -61,39 +68,48 @@ export declare class EvidenceQueryPopulationContext {
      */
     readonly configured: Set<string>;
     /**
-     * Configured identities with neither an own withdrawal nor a withdrawn ancestor.
+     * 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.
+     * 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.
+     * 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.
+     * 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.
+     * 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.
+     * 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.
+     * 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.
+     * 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.
+     * 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.