@wrtnlabs/evidence 0.0.0 → 0.1.0

package/lib/structures/IEvidenceUnitSite.d.ts

@@ -3,8 +3,9 @@ import type { IEvidenceSourceRange } from "./IEvidenceSourceRange";
  * A physical declaration occurrence and its contribution to a unit's content.
  *
  * A merged unit can own several sites, while a statement declaring several
- * variables can share one site ID across units. The site identifies the physical
- * occurrence without deciding whether its declarations share semantic identity.
+ * variables can share one site ID across units. The site identifies the
+ * physical occurrence without deciding whether its declarations share semantic
+ * identity.
  *
  * The declaration range establishes ownership and diagnostic location. Content
  * ranges identify the portions belonging to this unit's own fingerprint and may
@@ -15,8 +16,9 @@ export interface IEvidenceUnitSite {
     /**
      * Adapter identity of the physical declaration occurrence.
      *
-     * Multi-variable statements may share this ID. Its source location must remain
-     * consistent across those records even when their content contributions differ.
+     * Multi-variable statements may share this ID. Its source location must
+     * remain consistent across those records even when their content
+     * contributions differ.
      */
     id: string;
     /**
@@ -37,8 +39,9 @@ export interface IEvidenceUnitSite {
      * Source portions contributing to this unit's own content digest.
      *
      * Sibling declarators need not contribute to one another's fingerprints.
-     * Accepted annotation spans are removed before the remaining text is normalized
-     * and hashed; structural descendants are combined separately afterward.
+     * Accepted annotation spans are removed before the remaining text is
+     * normalized and hashed; structural descendants are combined separately
+     * afterward.
      */
     content: IEvidenceSourceRange[];
 }

package/lib/structures/IEvidenceWatchCheckCycle.d.ts

@@ -1,16 +1,18 @@
 import type { IEvidenceCheckReport } from "./IEvidenceCheckReport";
 /**
- * Published watch cycle containing a fresh, stable Evidence check report.
+ * Published watch cycle containing a fresh, stable Evidence Graph check report.
  *
  * The envelope identifies its place in the watch stream while mirroring the
  * report's completeness, success, and exit status. A stable incomplete analysis
- * is still publishable; operational exceptions use the separate failure envelope.
+ * is still publishable; operational exceptions use the separate failure
+ * envelope.
  */
 export interface IEvidenceWatchCheckCycle {
     /**
      * Version of the watch envelope's serialization contract.
      *
-     * Readers can validate it before interpreting the nested report and cycle fields.
+     * Readers can validate it before interpreting the nested report and cycle
+     * fields.
      */
     schemaVersion: 1;
     /**
@@ -22,20 +24,22 @@ export interface IEvidenceWatchCheckCycle {
     /**
      * Discriminator marking this result as part of a watch stream.
      *
-     * Consumers use cycle numbers to distinguish repeated evaluations of one command.
+     * Consumers use cycle numbers to distinguish repeated evaluations of one
+     * command.
      */
     watch: true;
     /**
      * One-based sequence number of the published result.
      *
-     * Stable failures and successful analyses share the same publication sequence;
-     * discarded unstable attempts do not consume another number.
+     * Stable failures and successful analyses share the same publication
+     * sequence; discarded unstable attempts do not consume another number.
      */
     cycle: number;
     /**
      * Completeness state copied from the fresh check report.
      *
-     * Complete describes analysis availability, not whether coverage errors were found.
+     * Complete describes analysis availability, not whether coverage errors were
+     * found.
      */
     status: "complete" | "incomplete";
     /**
@@ -47,14 +51,15 @@ export interface IEvidenceWatchCheckCycle {
     /**
      * Check outcome copied into the watch envelope.
      *
-     * Zero passes, one reports completed errors, and two reports incomplete analysis;
-     * publication itself does not end the watcher.
+     * Zero passes, one reports completed errors, and two reports incomplete
+     * analysis; publication itself does not end the watcher.
      */
     exitCode: 0 | 1 | 2;
     /**
      * Full check result underlying the envelope's outcome fields.
      *
-     * It retains independent claims, counts, and actionable diagnostics for this cycle.
+     * It retains independent claims, counts, and actionable diagnostics for this
+     * cycle.
      */
     report: IEvidenceCheckReport;
 }

package/lib/structures/IEvidenceWatchFailureCycle.d.ts

@@ -1,9 +1,10 @@
 /**
  * Published watch cycle for a stable configuration or operational exception.
  *
- * The watcher cannot provide a normal check report for this attempt, but retains
- * dependencies so a later repair can trigger another cycle. Parser acquisition
- * failures also retry on a timer because recovery may require no source edit.
+ * The watcher cannot provide a normal check report for this attempt, but
+ * retains dependencies so a later repair can trigger another cycle. Parser
+ * acquisition failures also retry on a timer because recovery may require no
+ * source edit.
  */
 export interface IEvidenceWatchFailureCycle {
     /**
@@ -15,13 +16,14 @@ export interface IEvidenceWatchFailureCycle {
     /**
      * Check operation that the watcher attempted.
      *
-     * The failure belongs to reevaluation of the configured Evidence check.
+     * The failure belongs to reevaluation of the configured Evidence Graph check.
      */
     command: "check";
     /**
      * Discriminator marking an ongoing watch-stream result.
      *
-     * A failed cycle does not imply that the watcher has stopped observing repairs.
+     * A failed cycle does not imply that the watcher has stopped observing
+     * repairs.
      */
     watch: true;
     /**
@@ -39,32 +41,36 @@ export interface IEvidenceWatchFailureCycle {
     /**
      * Failed outcome for consumers inspecting the common success field.
      *
-     * An exception cannot certify complete coverage, even if an earlier cycle passed.
+     * An exception cannot certify complete coverage, even if an earlier cycle
+     * passed.
      */
     success: false;
     /**
      * Outcome code for unavailable analysis in this cycle.
      *
-     * This is published as data and does not itself terminate ongoing observation.
+     * This is published as data and does not itself terminate ongoing
+     * observation.
      */
     exitCode: 2;
     /**
      * Resolved configuration path associated with the failed attempt.
      *
-     * The path remains available even when configuration evaluation itself failed.
+     * The path remains available even when configuration evaluation itself
+     * failed.
      */
     configFile: string;
     /**
      * Explanation derived from the configuration or operational exception.
      *
-     * It identifies the current failure rather than repeating the previous cycle's report.
+     * It identifies the current failure rather than repeating the previous
+     * cycle's report.
      */
     message: string;
     /**
      * Corrective guidance and the applicable retry behavior.
      *
-     * Parser acquisition can retry automatically; other failures wait for a watched
-     * filesystem change that permits another complete attempt.
+     * Parser acquisition can retry automatically; other failures wait for a
+     * watched filesystem change that permits another complete attempt.
      */
     repair: string;
 }

package/lib/structures/IEvidenceWatchOptions.d.ts

@@ -3,15 +3,15 @@ import type { tags } from "typia";
  * Timing controls for dependency polling, edit settling, and parser recovery.
  *
  * The watcher compares dependency snapshots and waits for a quiet period before
- * reevaluation. Parser acquisition has a separate retry clock because network or
- * cache recovery may happen without any watched filesystem change.
+ * reevaluation. Parser acquisition has a separate retry clock because network
+ * or cache recovery may happen without any watched filesystem change.
  */
 export interface IEvidenceWatchOptions {
     /**
      * Positive delay between dependency snapshots, in milliseconds.
      *
-     * Shorter intervals detect changes sooner while performing filesystem inspection
-     * more often. Omission uses 250 milliseconds.
+     * Shorter intervals detect changes sooner while performing filesystem
+     * inspection more often. Omission uses 250 milliseconds.
      *
      * @default 250
      */

package/lib/structures/IEvidenceWithdrawal.d.ts

@@ -2,9 +2,10 @@ import type { IEvidenceSourceLocation } from "./IEvidenceSourceLocation";
 /**
  * Source annotation withdrawing a declaration from the public population.
  *
- * Inventory selection propagates withdrawal through structural descendants while
- * retaining the original location. A citation can then explain why a declaration
- * is hidden instead of presenting an excluded API as an unknown name.
+ * Inventory selection propagates withdrawal through structural descendants
+ * while retaining the original location. A citation can then explain why a
+ * declaration is hidden instead of presenting an excluded API as an unknown
+ * name.
  */
 export interface IEvidenceWithdrawal {
     /**
@@ -17,8 +18,8 @@ export interface IEvidenceWithdrawal {
     /**
      * Source location of the directive causing withdrawal.
      *
-     * Descendant exclusions keep this origin so diagnostics point to the authoring
-     * decision rather than an arbitrary child declaration.
+     * Descendant exclusions keep this origin so diagnostics point to the
+     * authoring decision rather than an arbitrary child declaration.
      */
     location: IEvidenceSourceLocation;
 }

package/lib/structures/index.d.ts

@@ -63,6 +63,7 @@ export type * from "./IEvidenceSourceAddress";
 export type * from "./IEvidenceSourceDependency";
 export type * from "./IEvidenceSourceDiagnostic";
 export type * from "./IEvidenceSourceFile";
+export type * from "./IEvidenceSourceFingerprintRoot";
 export type * from "./IEvidenceSourcePosition";
 export type * from "./IEvidenceSourceRange";
 export type * from "./IEvidenceSourceRoot";

package/lib/targets/EvidenceAccessor.d.ts

@@ -1,22 +1,25 @@
 /**
- * Converts the accessor portion of a file-qualified target between text and segments.
+ * Converts the accessor portion of a file-qualified target between text and
+ * segments.
  *
- * Target resolution uses segments to distinguish lexical ownership from a literal
- * dot in a member name. This namespace accepts the portable baseline syntax only:
- * identifiers after dots, JSON strings in brackets, and non-negative integer
- * bracket members. It neither resolves symbols nor interprets a segment as code.
+ * Target resolution uses segments to distinguish lexical ownership from a
+ * literal dot in a member name. This namespace accepts the portable baseline
+ * syntax only: identifiers after dots, JSON strings in brackets, and
+ * non-negative integer bracket members. It neither resolves symbols nor
+ * interprets a segment as code.
  *
  * @example
- * EvidenceAccessor.parse('Client.prototype["send.request"]');
- * // ["Client", "prototype", "send.request"]
+ *   EvidenceAccessor.parse('Client.prototype["send.request"]');
+ *   // ["Client", "prototype", "send.request"]
  */
 export declare namespace EvidenceAccessor {
     /**
      * Parses one accessor spelling into the literal segments used by an address.
      *
-     * A bracket string preserves characters that have structural meaning in dotted
-     * syntax. Invalid separators, unterminated brackets, and unsupported bracket
-     * content reject before a resolver can look up a different declaration.
+     * A bracket string preserves characters that have structural meaning in
+     * dotted syntax. Invalid separators, unterminated brackets, and unsupported
+     * bracket content reject before a resolver can look up a different
+     * declaration.
      */
     function parse(value: string): string[];
     /**

package/lib/targets/EvidenceAccessor.js

@@ -40,25 +40,28 @@ exports.EvidenceAccessor = void 0;
 const _assertGuard_1 = __importStar(require("typia/lib/internal/_assertGuard"));
 const typia_1 = __importDefault(require("typia"));
 /**
- * Converts the accessor portion of a file-qualified target between text and segments.
+ * Converts the accessor portion of a file-qualified target between text and
+ * segments.
  *
- * Target resolution uses segments to distinguish lexical ownership from a literal
- * dot in a member name. This namespace accepts the portable baseline syntax only:
- * identifiers after dots, JSON strings in brackets, and non-negative integer
- * bracket members. It neither resolves symbols nor interprets a segment as code.
+ * Target resolution uses segments to distinguish lexical ownership from a
+ * literal dot in a member name. This namespace accepts the portable baseline
+ * syntax only: identifiers after dots, JSON strings in brackets, and
+ * non-negative integer bracket members. It neither resolves symbols nor
+ * interprets a segment as code.
  *
  * @example
- * EvidenceAccessor.parse('Client.prototype["send.request"]');
- * // ["Client", "prototype", "send.request"]
+ *   EvidenceAccessor.parse('Client.prototype["send.request"]');
+ *   // ["Client", "prototype", "send.request"]
  */
 var EvidenceAccessor;
 (function (EvidenceAccessor) {
     /**
      * Parses one accessor spelling into the literal segments used by an address.
      *
-     * A bracket string preserves characters that have structural meaning in dotted
-     * syntax. Invalid separators, unterminated brackets, and unsupported bracket
-     * content reject before a resolver can look up a different declaration.
+     * A bracket string preserves characters that have structural meaning in
+     * dotted syntax. Invalid separators, unterminated brackets, and unsupported
+     * bracket content reject before a resolver can look up a different
+     * declaration.
      */
     function parse(value) {
         const segments = [];

package/lib/targets/EvidenceFileTarget.d.ts

@@ -9,33 +9,37 @@ import type { IEvidenceAddress } from "../structures/IEvidenceAddress";
  * text without changing literal accessor segments.
  *
  * @example
- * EvidenceFileTarget.parse("../api/client.ts#Client.prototype.send", "/repo/docs/guide.md");
+ *   EvidenceFileTarget.parse(
+ *     "../api/client.ts#Client.prototype.send",
+ *     "/repo/docs/guide.md",
+ *   );
  */
 export declare namespace EvidenceFileTarget {
     /**
      * Parses an authored file target relative to the documentation host's file.
      *
-     * A missing hash selects the file unit; a hash must be followed by an accessor.
-     * The file component permits percent encoding for reserved path characters,
-     * whereas accessor parsing remains delegated to `EvidenceAccessor`. The origin
-     * must be absolute so the same citation cannot resolve differently by process
-     * working directory.
+     * A missing hash selects the file unit; a hash must be followed by an
+     * accessor. The file component permits percent encoding for reserved path
+     * characters, whereas accessor parsing remains delegated to
+     * `EvidenceAccessor`. The origin must be absolute so the same citation cannot
+     * resolve differently by process working directory.
      */
     function parse(target: string, origin: string): IEvidenceAddress;
     /**
      * Formats a normalized address as canonical file-target text.
      *
      * Reserved path characters are percent-encoded, but directory separators and
-     * Windows drive separators stay readable. The accessor is formatted separately
-     * so literal segment characters cannot change the file/path boundary.
+     * Windows drive separators stay readable. The accessor is formatted
+     * separately so literal segment characters cannot change the file/path
+     * boundary.
      */
     function format(address: IEvidenceAddress): string;
     /**
      * Normalizes separators and dot segments without consulting the filesystem.
      *
-     * This is lexical normalization only: symlinks, case rules, and file existence
-     * remain the scanner's responsibility. The UNC guard preserves a leading pair
-     * of slashes only when the author actually supplied a UNC path.
+     * This is lexical normalization only: symlinks, case rules, and file
+     * existence remain the scanner's responsibility. The UNC guard preserves a
+     * leading pair of slashes only when the author actually supplied a UNC path.
      */
     function normalize(file: string): string;
 }

package/lib/targets/EvidenceFileTarget.js

@@ -16,18 +16,21 @@ const EvidenceAccessor_1 = require("./EvidenceAccessor");
  * text without changing literal accessor segments.
  *
  * @example
- * EvidenceFileTarget.parse("../api/client.ts#Client.prototype.send", "/repo/docs/guide.md");
+ *   EvidenceFileTarget.parse(
+ *     "../api/client.ts#Client.prototype.send",
+ *     "/repo/docs/guide.md",
+ *   );
  */
 var EvidenceFileTarget;
 (function (EvidenceFileTarget) {
     /**
      * Parses an authored file target relative to the documentation host's file.
      *
-     * A missing hash selects the file unit; a hash must be followed by an accessor.
-     * The file component permits percent encoding for reserved path characters,
-     * whereas accessor parsing remains delegated to `EvidenceAccessor`. The origin
-     * must be absolute so the same citation cannot resolve differently by process
-     * working directory.
+     * A missing hash selects the file unit; a hash must be followed by an
+     * accessor. The file component permits percent encoding for reserved path
+     * characters, whereas accessor parsing remains delegated to
+     * `EvidenceAccessor`. The origin must be absolute so the same citation cannot
+     * resolve differently by process working directory.
      */
     function parse(target, origin) {
         const hash = target.indexOf("#");
@@ -57,8 +60,9 @@ var EvidenceFileTarget;
      * Formats a normalized address as canonical file-target text.
      *
      * Reserved path characters are percent-encoded, but directory separators and
-     * Windows drive separators stay readable. The accessor is formatted separately
-     * so literal segment characters cannot change the file/path boundary.
+     * Windows drive separators stay readable. The accessor is formatted
+     * separately so literal segment characters cannot change the file/path
+     * boundary.
      */
     function format(address) {
         const encoded = encodeURIComponent(normalize(address.file))
@@ -72,9 +76,9 @@ var EvidenceFileTarget;
     /**
      * Normalizes separators and dot segments without consulting the filesystem.
      *
-     * This is lexical normalization only: symlinks, case rules, and file existence
-     * remain the scanner's responsibility. The UNC guard preserves a leading pair
-     * of slashes only when the author actually supplied a UNC path.
+     * This is lexical normalization only: symlinks, case rules, and file
+     * existence remain the scanner's responsibility. The UNC guard preserves a
+     * leading pair of slashes only when the author actually supplied a UNC path.
      */
     function normalize(file) {
         const slash = file.replaceAll("\\", "/");
@@ -88,9 +92,10 @@ var EvidenceFileTarget;
     /**
      * Resolves a decoded file request using the host file's path flavor.
      *
-     * Drive-relative requests are rejected because Windows interprets them against
-     * a process-local drive directory. Selecting POSIX or Windows semantics from
-     * either input keeps cross-platform inventories deterministic.
+     * Drive-relative requests are rejected because Windows interprets them
+     * against a process-local drive directory. Selecting POSIX or Windows
+     * semantics from either input keeps cross-platform inventories
+     * deterministic.
      */
     function resolve(origin, file) {
         const base = normalize(origin);
@@ -114,7 +119,8 @@ var EvidenceFileTarget;
     /**
      * Detects Windows drive and UNC spellings after separators are normalized.
      *
-     * This selects `path.win32` even when an inventory is inspected on a POSIX host.
+     * This selects `path.win32` even when an inventory is inspected on a POSIX
+     * host.
      */
     function windows(file) {
         return /^[A-Za-z]:\//u.test(file) || file.startsWith("//");

package/lib/targets/EvidenceTargetResolver.d.ts

@@ -17,12 +17,14 @@ import type { EvidenceArtifactType } from "../typings/EvidenceArtifactType";
  * multi-origin documentation silently select an arbitrary declaration.
  *
  * @example
- * const resolver: EvidenceTargetResolver = new EvidenceTargetResolver([inventory]);
- * const result: IEvidenceTargetResolution = await resolver.resolve(
- *   statement,
- *   host,
- *   selectedIds,
- * );
+ *   const resolver: EvidenceTargetResolver = new EvidenceTargetResolver([
+ *     inventory,
+ *   ]);
+ *   const result: IEvidenceTargetResolution = await resolver.resolve(
+ *     statement,
+ *     host,
+ *     selectedIds,
+ *   );
  */
 export declare class EvidenceTargetResolver {
     /**
@@ -49,8 +51,8 @@ export declare class EvidenceTargetResolver {
     /**
      * Normalized public addresses admitted by the reference's selected sources.
      *
-     * Ordinary targets may resolve only in this set; physical file existence alone
-     * never makes an unselected source part of the coverage denominator.
+     * Ordinary targets may resolve only in this set; physical file existence
+     * alone never makes an unselected source part of the coverage denominator.
      */
     private readonly selectedFiles;
     /**
@@ -63,16 +65,16 @@ export declare class EvidenceTargetResolver {
     /**
      * Authored public file spellings grouped by their normalized file identity.
      *
-     * A target must be tested through every public spelling because address lookup
-     * preserves authored paths as part of the public identity contract.
+     * A target must be tested through every public spelling because address
+     * lookup preserves authored paths as part of the public identity contract.
      */
     private readonly publicFiles;
     /**
      * Selected Markdown roots grouped by Markdown's root-relative path spelling.
      *
-     * Markdown targets are intentionally resolved from reference roots rather than
-     * relative to the documentation host, so one logical target may map to several
-     * physical selected files before ambiguity is decided.
+     * Markdown targets are intentionally resolved from reference roots rather
+     * than relative to the documentation host, so one logical target may map to
+     * several physical selected files before ambiguity is decided.
      */
     private readonly markdownFiles;
     /**
@@ -88,44 +90,47 @@ export declare class EvidenceTargetResolver {
      *
      * The host must match the statement because diagnostics and relative origins
      * belong to that attachment. Specialized Markdown, Prisma, and Swagger target
-     * forms are parsed only for a uniquely identified artifact type. Ordinary file
-     * targets are attempted for each declared host origin, then deduplicated before
-     * index lookup and filesystem classification.
+     * forms are parsed only for a uniquely identified artifact type. Ordinary
+     * file targets are attempted for each declared host origin, then deduplicated
+     * before index lookup and filesystem classification.
      *
      * Incomplete inventories win before an empty or missing-member result. A scan
-     * that omitted declarations cannot prove coverage merely because the remaining
-     * selected population has no match.
+     * that omitted declarations cannot prove coverage merely because the
+     * remaining selected population has no match.
      */
     resolve(statement: IEvidenceTargetStatement, host: IEvidenceHost, ids: string[]): Promise<IEvidenceTargetResolution>;
     /**
      * Converts address-index lookups into one semantic target resolution.
      *
-     * Multiple candidates may be aliases of one unit, which resolves successfully.
-     * Multiple unit IDs or an index-level ambiguity remain ambiguous. A withdrawal
-     * shadows an otherwise found unit, because a citation cannot acknowledge a
-     * declaration that has been explicitly removed from public coverage.
+     * Multiple candidates may be aliases of one unit, which resolves
+     * successfully. Multiple unit IDs or an index-level ambiguity remain
+     * ambiguous. A withdrawal shadows an otherwise found unit, because a citation
+     * cannot acknowledge a declaration that has been explicitly removed from
+     * public coverage.
      */
     private resolveCandidates;
     /**
      * Creates a failed resolution with its one explanatory diagnostic.
      *
-     * Callers receive candidate addresses, units, and withdrawals even for failure
-     * states so reports can explain the evidence considered without reconstructing
-     * this resolver's normalization and alias work.
+     * Callers receive candidate addresses, units, and withdrawals even for
+     * failure states so reports can explain the evidence considered without
+     * reconstructing this resolver's normalization and alias work.
      */
     private failure;
     /**
      * Creates the conservative result required when inventory acquisition failed.
      *
-     * Existing inventory diagnostics are retained with the target-specific error so
-     * authors see both the acquisition cause and why this citation was not trusted.
+     * Existing inventory diagnostics are retained with the target-specific error
+     * so authors see both the acquisition cause and why this citation was not
+     * trusted.
      */
     private incomplete;
     /**
      * Attaches target-resolution details to the statement's original source span.
      *
      * Keeping this construction centralized ensures every failure points to the
-     * authored target and owning host, rather than an internal normalized address.
+     * authored target and owning host, rather than an internal normalized
+     * address.
      */
     private diagnostic;
     private exists;
@@ -138,10 +143,12 @@ export declare class EvidenceTargetResolver {
      */
     private referenceType;
     /**
-     * Extracts a Node-style error code without assuming an arbitrary thrown value.
+     * Extracts a EvidenceNode-style error code without assuming an arbitrary
+     * thrown value.
      *
      * Filesystem APIs may reject with non-Error values, which must remain an
-     * incomplete inspection rather than cause the resolver's classifier to throw.
+     * incomplete inspection rather than cause the resolver's classifier to
+     * throw.
      */
     private errorCode;
     /**
@@ -165,10 +172,11 @@ export declare class EvidenceTargetResolver {
      */
     private files;
     /**
-     * Formats the representative accessor after candidate paths share its segments.
+     * Formats the representative accessor after candidate paths share its
+     * segments.
      *
-     * An empty array occurs only in defensive failure construction and deliberately
-     * produces an empty display rather than inventing an accessor.
+     * An empty array occurs only in defensive failure construction and
+     * deliberately produces an empty display rather than inventing an accessor.
      */
     private accessor;
 }