@wrtnlabs/evidence 0.0.0

package/lib/graph/EvidenceQuery.d.ts

@@ -0,0 +1,86 @@
+import type { IEvidenceCheckAnalysis } from "../structures/IEvidenceCheckAnalysis";
+import type { IEvidenceGraphReport } from "../structures/IEvidenceGraphReport";
+import type { IEvidenceInspectReport } from "../structures/IEvidenceInspectReport";
+import type { IEvidenceLanguagesReport } from "../structures/IEvidenceLanguagesReport";
+import type { IEvidenceListReport } from "../structures/IEvidenceListReport";
+import type { EvidenceArtifactType } from "../typings/EvidenceArtifactType";
+import type { EvidenceSymbol } from "../typings/EvidenceSymbol";
+/**
+ * Provides queries over one owned analysis snapshot.
+ *
+ * Construction clones the supplied check analysis and captures an absolute base
+ * directory for file-qualified target formatting. List, inspect, and graph queries
+ * reuse population indexes without reevaluating configuration or extraction.
+ * Returned reports are cloned so caller mutation cannot invalidate later queries.
+ *
+ * @example
+ * const query: EvidenceQuery = new EvidenceQuery(analysis, process.cwd());
+ * const list: IEvidenceListReport = query.list("typescript", "function");
+ * const first: IEvidenceListReport["items"][number] | undefined = list.items[0];
+ * if (first !== undefined) await query.inspect(first.target);
+ */
+export declare class EvidenceQuery {
+    /**
+     * Analysis snapshot, target base directory, and reusable population indexes.
+     *
+     * This context owns its input data; programmer results are cloned before leaving the facade.
+     */
+    private readonly context;
+    /**
+     * Captures an analysis snapshot and builds indexes for subsequent queries.
+     *
+     * The base directory is resolved immediately so later process cwd changes do
+     * not redirect file-qualified inspection or target formatting.
+     */
+    constructor(analysis: IEvidenceCheckAnalysis, cwd: string);
+    /**
+     * Lists selected identities and addressable ancestors with optional display filters.
+     *
+     * Language and kind restrict returned rows without changing the check's diagnostic
+     * or success state. Aliases remain grouped under each population-qualified identity.
+     */
+    list(language?: EvidenceArtifactType, kind?: EvidenceSymbol): IEvidenceListReport;
+    /**
+     * Lists targets through a newly owned query snapshot.
+     *
+     * Use an instance when several queries should share population indexes; this
+     * convenience call captures and indexes the supplied analysis for one operation.
+     */
+    static list(analysis: IEvidenceCheckAnalysis, cwd: string, language?: EvidenceArtifactType, kind?: EvidenceSymbol): IEvidenceListReport;
+    /**
+     * Resolves a target and gathers its evidence context in applicable populations.
+     *
+     * File-qualified targets use the captured base directory. Artifact-specific
+     * grammars retain their own addressing rules, and each population keeps an
+     * independent resolution, obligation state, acknowledgements, and reviews.
+     */
+    inspect(target: string): Promise<IEvidenceInspectReport>;
+    /**
+     * Inspects one target through a newly captured analysis context.
+     *
+     * Input data is isolated before asynchronous resolution begins. Reuse an instance
+     * when subsequent inspections should share its population indexes.
+     */
+    static inspect(analysis: IEvidenceCheckAnalysis, cwd: string, target: string): Promise<IEvidenceInspectReport>;
+    /**
+     * Exports independent obligation boundaries, nodes, acknowledgements, and reviews.
+     *
+     * Node identities include their boundary so repeated populations retain separate
+     * coverage. Reviews remain distinct relations and never become acknowledgement edges.
+     */
+    graph(): IEvidenceGraphReport;
+    /**
+     * Exports a graph through a newly owned query snapshot.
+     *
+     * The supplied base directory controls file-qualified target display; extraction
+     * and evaluation results come entirely from the provided analysis.
+     */
+    static graph(analysis: IEvidenceCheckAnalysis, cwd: string): IEvidenceGraphReport;
+    /**
+     * Lists certified programming and database adapter capabilities.
+     *
+     * This metadata query requires no configuration, source scan, or grammar load and
+     * excludes candidates that only have parsing metadata.
+     */
+    static languages(): IEvidenceLanguagesReport;
+}

package/lib/graph/EvidenceQuery.js

@@ -0,0 +1,109 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EvidenceQuery = void 0;
+const node_path_1 = __importDefault(require("node:path"));
+const EvidenceQueryProgrammer_1 = require("../programmers/EvidenceQueryProgrammer");
+/**
+ * Provides queries over one owned analysis snapshot.
+ *
+ * Construction clones the supplied check analysis and captures an absolute base
+ * directory for file-qualified target formatting. List, inspect, and graph queries
+ * reuse population indexes without reevaluating configuration or extraction.
+ * Returned reports are cloned so caller mutation cannot invalidate later queries.
+ *
+ * @example
+ * const query: EvidenceQuery = new EvidenceQuery(analysis, process.cwd());
+ * const list: IEvidenceListReport = query.list("typescript", "function");
+ * const first: IEvidenceListReport["items"][number] | undefined = list.items[0];
+ * if (first !== undefined) await query.inspect(first.target);
+ */
+class EvidenceQuery {
+    /**
+     * Analysis snapshot, target base directory, and reusable population indexes.
+     *
+     * This context owns its input data; programmer results are cloned before leaving the facade.
+     */
+    context;
+    /**
+     * Captures an analysis snapshot and builds indexes for subsequent queries.
+     *
+     * The base directory is resolved immediately so later process cwd changes do
+     * not redirect file-qualified inspection or target formatting.
+     */
+    constructor(analysis, cwd) {
+        const snapshot = structuredClone(analysis);
+        this.context = {
+            analysis: snapshot,
+            cwd: node_path_1.default.resolve(cwd),
+            populations: EvidenceQueryProgrammer_1.EvidenceQueryProgrammer.populations(snapshot),
+        };
+    }
+    /**
+     * Lists selected identities and addressable ancestors with optional display filters.
+     *
+     * Language and kind restrict returned rows without changing the check's diagnostic
+     * or success state. Aliases remain grouped under each population-qualified identity.
+     */
+    list(language, kind) {
+        return structuredClone(EvidenceQueryProgrammer_1.EvidenceQueryProgrammer.list(this.context, language, kind));
+    }
+    /**
+     * Lists targets through a newly owned query snapshot.
+     *
+     * Use an instance when several queries should share population indexes; this
+     * convenience call captures and indexes the supplied analysis for one operation.
+     */
+    static list(analysis, cwd, language, kind) {
+        return new EvidenceQuery(analysis, cwd).list(language, kind);
+    }
+    /**
+     * Resolves a target and gathers its evidence context in applicable populations.
+     *
+     * File-qualified targets use the captured base directory. Artifact-specific
+     * grammars retain their own addressing rules, and each population keeps an
+     * independent resolution, obligation state, acknowledgements, and reviews.
+     */
+    async inspect(target) {
+        return structuredClone(await EvidenceQueryProgrammer_1.EvidenceQueryProgrammer.inspect(this.context, target));
+    }
+    /**
+     * Inspects one target through a newly captured analysis context.
+     *
+     * Input data is isolated before asynchronous resolution begins. Reuse an instance
+     * when subsequent inspections should share its population indexes.
+     */
+    static async inspect(analysis, cwd, target) {
+        return new EvidenceQuery(analysis, cwd).inspect(target);
+    }
+    /**
+     * Exports independent obligation boundaries, nodes, acknowledgements, and reviews.
+     *
+     * Node identities include their boundary so repeated populations retain separate
+     * coverage. Reviews remain distinct relations and never become acknowledgement edges.
+     */
+    graph() {
+        return structuredClone(EvidenceQueryProgrammer_1.EvidenceQueryProgrammer.graph(this.context));
+    }
+    /**
+     * Exports a graph through a newly owned query snapshot.
+     *
+     * The supplied base directory controls file-qualified target display; extraction
+     * and evaluation results come entirely from the provided analysis.
+     */
+    static graph(analysis, cwd) {
+        return new EvidenceQuery(analysis, cwd).graph();
+    }
+    /**
+     * Lists certified programming and database adapter capabilities.
+     *
+     * This metadata query requires no configuration, source scan, or grammar load and
+     * excludes candidates that only have parsing metadata.
+     */
+    static languages() {
+        return EvidenceQueryProgrammer_1.EvidenceQueryProgrammer.languages();
+    }
+}
+exports.EvidenceQuery = EvidenceQuery;

package/lib/index.d.ts

@@ -0,0 +1,110 @@
+/**
+ * Public package API.
+ *
+ * Importing this entry point registers no parser work, configuration loading, or
+ * command execution. Consumers choose explicit checker, command, loader, and
+ * adapter entry points for their own execution boundary.
+ */
+export { EvidenceDartAdapter } from "./adapters/dart/EvidenceDartAdapter";
+export { EvidenceScalaAdapter } from "./adapters/scala/EvidenceScalaAdapter";
+export { EvidenceChecker } from "./EvidenceChecker";
+/**
+ * Exports certified adapters for supported programming and database artifacts.
+ *
+ * Consumers select these adapters when constructing an explicit parsing boundary;
+ * configuration-driven checks use the package registry to select them by artifact
+ * type instead.
+ */
+export { EvidenceCAdapter } from "./adapters/c/EvidenceCAdapter";
+export { EvidenceBigQueryAdapter } from "./adapters/bigquery/EvidenceBigQueryAdapter";
+export { EvidenceCppAdapter } from "./adapters/cpp/EvidenceCppAdapter";
+export { EvidenceCSharpAdapter } from "./adapters/csharp/EvidenceCSharpAdapter";
+export { EvidenceDbmlAdapter } from "./adapters/dbml/EvidenceDbmlAdapter";
+export { EvidenceGoAdapter } from "./adapters/go/EvidenceGoAdapter";
+export { EvidenceJavaAdapter } from "./adapters/java/EvidenceJavaAdapter";
+export { EvidenceJavaScriptAdapter } from "./adapters/javascript/EvidenceJavaScriptAdapter";
+export { EvidenceKotlinAdapter } from "./adapters/kotlin/EvidenceKotlinAdapter";
+export { EvidenceLuaAdapter } from "./adapters/lua/EvidenceLuaAdapter";
+export { EvidenceSqliteAdapter } from "./adapters/sqlite/EvidenceSqliteAdapter";
+export { EvidenceMarkdownAdapter } from "./adapters/markdown/EvidenceMarkdownAdapter";
+export { EvidenceMatlabAdapter } from "./adapters/matlab/EvidenceMatlabAdapter";
+export { EvidencePhpAdapter } from "./adapters/php/EvidencePhpAdapter";
+export { EvidenceMysqlAdapter } from "./adapters/mysql/EvidenceMysqlAdapter";
+export { EvidencePrismaAdapter } from "./adapters/prisma/EvidencePrismaAdapter";
+export { EvidencePostgresqlAdapter } from "./adapters/postgresql/EvidencePostgresqlAdapter";
+export { EvidencePythonAdapter } from "./adapters/python/EvidencePythonAdapter";
+export { EvidenceRubyAdapter } from "./adapters/ruby/EvidenceRubyAdapter";
+export { EvidenceRustAdapter } from "./adapters/rust/EvidenceRustAdapter";
+export { EvidenceSqlAdapter } from "./adapters/sql/EvidenceSqlAdapter";
+export { EvidenceSwiftAdapter } from "./adapters/swift/EvidenceSwiftAdapter";
+export { EvidenceSwaggerAdapter } from "./adapters/swagger/EvidenceSwaggerAdapter";
+export { EvidenceTypeScriptAdapter } from "./adapters/typescript/EvidenceTypeScriptAdapter";
+export { EvidenceZigAdapter } from "./adapters/zig/EvidenceZigAdapter";
+/**
+ * Exports 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 { EvidenceCommand } from "./commands/EvidenceCommand";
+export { EvidenceCommandError } from "./commands/EvidenceCommandError";
+export { EvidenceWatcher } from "./commands/EvidenceWatcher";
+/**
+ * Exports graph construction, semantic inventory, and query projections.
+ *
+ * These APIs consume a captured check analysis to resolve semantic identities,
+ * coverage, reviews, and human- or machine-facing query results consistently.
+ */
+export { EvidenceFingerprint } from "./graph/EvidenceFingerprint";
+export { EvidenceGraph } from "./graph/EvidenceGraph";
+export { EvidenceInventory } from "./graph/EvidenceInventory";
+export { EvidenceQuery } from "./graph/EvidenceQuery";
+/**
+ * Exports configuration and local-source loading boundaries.
+ *
+ * EvidenceChecker composes these loaders for normal checks, while integrations
+ * can call them directly when they need validated configuration or snapshots.
+ */
+export { EvidenceConfigLoader } from "./loaders/EvidenceConfigLoader";
+export { EvidenceSourceLoader } from "./loaders/EvidenceSourceLoader";
+/**
+ * Exports parser sessions, documentation tags, and certified language registry access.
+ *
+ * Adapter implementations use these boundaries to parse supported artifacts and
+ * interpret evidence annotations without importing the command execution layer.
+ */
+export { EvidenceDocumentation } from "./parsers/EvidenceDocumentation";
+export { EvidenceLanguageRegistry } from "./parsers/EvidenceLanguageRegistry";
+export { EvidenceParser } from "./parsers/EvidenceParser";
+export { EvidenceParserError } from "./parsers/EvidenceParserError";
+export type { EvidenceParseSession } from "./parsers/EvidenceParseSession";
+export { EvidenceTagParser } from "./parsers/EvidenceTagParser";
+/**
+ * Exports serializers for check, query, graph, and watch reports.
+ *
+ * They project already evaluated report objects into text, JSON, or graph formats
+ * without changing the underlying inventory, diagnostics, or exit semantics.
+ */
+export { EvidenceGraphReporter } from "./reporters/EvidenceGraphReporter";
+export { EvidenceQueryReporter } from "./reporters/EvidenceQueryReporter";
+export { EvidenceReporter } from "./reporters/EvidenceReporter";
+export { EvidenceWatchReporter } from "./reporters/EvidenceWatchReporter";
+/**
+ * Exports target parsing and resolution utilities.
+ *
+ * Query and annotation consumers use them to preserve literal accessor spelling,
+ * normalize file addresses, and resolve targets within selected populations.
+ */
+export { EvidenceAccessor } from "./targets/EvidenceAccessor";
+export { EvidenceFileTarget } from "./targets/EvidenceFileTarget";
+export { EvidenceTargetResolver } from "./targets/EvidenceTargetResolver";
+/**
+ * Re-exports public configuration, report, source, and semantic contract types.
+ *
+ * These type-only exports define the values exchanged by checker, command, loader,
+ * and query APIs without adding runtime work to a package import.
+ */
+export type * from "./structures";
+export type * from "./typings";
+export { EvidenceObjcAdapter } from "./adapters/objc/EvidenceObjcAdapter";

package/lib/index.js

@@ -0,0 +1,154 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EvidenceObjcAdapter = exports.EvidenceTargetResolver = exports.EvidenceFileTarget = exports.EvidenceAccessor = exports.EvidenceWatchReporter = exports.EvidenceReporter = exports.EvidenceQueryReporter = exports.EvidenceGraphReporter = exports.EvidenceTagParser = exports.EvidenceParserError = exports.EvidenceParser = exports.EvidenceLanguageRegistry = exports.EvidenceDocumentation = exports.EvidenceSourceLoader = exports.EvidenceConfigLoader = exports.EvidenceQuery = exports.EvidenceInventory = exports.EvidenceGraph = exports.EvidenceFingerprint = exports.EvidenceWatcher = exports.EvidenceCommandError = exports.EvidenceCommand = exports.EvidenceZigAdapter = exports.EvidenceTypeScriptAdapter = exports.EvidenceSwaggerAdapter = exports.EvidenceSwiftAdapter = exports.EvidenceSqlAdapter = exports.EvidenceRustAdapter = exports.EvidenceRubyAdapter = exports.EvidencePythonAdapter = exports.EvidencePostgresqlAdapter = exports.EvidencePrismaAdapter = exports.EvidenceMysqlAdapter = exports.EvidencePhpAdapter = exports.EvidenceMatlabAdapter = exports.EvidenceMarkdownAdapter = exports.EvidenceSqliteAdapter = exports.EvidenceLuaAdapter = exports.EvidenceKotlinAdapter = exports.EvidenceJavaScriptAdapter = exports.EvidenceJavaAdapter = exports.EvidenceGoAdapter = exports.EvidenceDbmlAdapter = exports.EvidenceCSharpAdapter = exports.EvidenceCppAdapter = exports.EvidenceBigQueryAdapter = exports.EvidenceCAdapter = exports.EvidenceChecker = exports.EvidenceScalaAdapter = exports.EvidenceDartAdapter = void 0;
+/**
+ * Public package API.
+ *
+ * Importing this entry point registers no parser work, configuration loading, or
+ * command execution. Consumers choose explicit checker, command, loader, and
+ * adapter entry points for their own execution boundary.
+ */
+var EvidenceDartAdapter_1 = require("./adapters/dart/EvidenceDartAdapter");
+Object.defineProperty(exports, "EvidenceDartAdapter", { enumerable: true, get: function () { return EvidenceDartAdapter_1.EvidenceDartAdapter; } });
+var EvidenceScalaAdapter_1 = require("./adapters/scala/EvidenceScalaAdapter");
+Object.defineProperty(exports, "EvidenceScalaAdapter", { enumerable: true, get: function () { return EvidenceScalaAdapter_1.EvidenceScalaAdapter; } });
+var EvidenceChecker_1 = require("./EvidenceChecker");
+Object.defineProperty(exports, "EvidenceChecker", { enumerable: true, get: function () { return EvidenceChecker_1.EvidenceChecker; } });
+/**
+ * Exports certified adapters for supported programming and database artifacts.
+ *
+ * Consumers select these adapters when constructing an explicit parsing boundary;
+ * configuration-driven checks use the package registry to select them by artifact
+ * type instead.
+ */
+var EvidenceCAdapter_1 = require("./adapters/c/EvidenceCAdapter");
+Object.defineProperty(exports, "EvidenceCAdapter", { enumerable: true, get: function () { return EvidenceCAdapter_1.EvidenceCAdapter; } });
+var EvidenceBigQueryAdapter_1 = require("./adapters/bigquery/EvidenceBigQueryAdapter");
+Object.defineProperty(exports, "EvidenceBigQueryAdapter", { enumerable: true, get: function () { return EvidenceBigQueryAdapter_1.EvidenceBigQueryAdapter; } });
+var EvidenceCppAdapter_1 = require("./adapters/cpp/EvidenceCppAdapter");
+Object.defineProperty(exports, "EvidenceCppAdapter", { enumerable: true, get: function () { return EvidenceCppAdapter_1.EvidenceCppAdapter; } });
+var EvidenceCSharpAdapter_1 = require("./adapters/csharp/EvidenceCSharpAdapter");
+Object.defineProperty(exports, "EvidenceCSharpAdapter", { enumerable: true, get: function () { return EvidenceCSharpAdapter_1.EvidenceCSharpAdapter; } });
+var EvidenceDbmlAdapter_1 = require("./adapters/dbml/EvidenceDbmlAdapter");
+Object.defineProperty(exports, "EvidenceDbmlAdapter", { enumerable: true, get: function () { return EvidenceDbmlAdapter_1.EvidenceDbmlAdapter; } });
+var EvidenceGoAdapter_1 = require("./adapters/go/EvidenceGoAdapter");
+Object.defineProperty(exports, "EvidenceGoAdapter", { enumerable: true, get: function () { return EvidenceGoAdapter_1.EvidenceGoAdapter; } });
+var EvidenceJavaAdapter_1 = require("./adapters/java/EvidenceJavaAdapter");
+Object.defineProperty(exports, "EvidenceJavaAdapter", { enumerable: true, get: function () { return EvidenceJavaAdapter_1.EvidenceJavaAdapter; } });
+var EvidenceJavaScriptAdapter_1 = require("./adapters/javascript/EvidenceJavaScriptAdapter");
+Object.defineProperty(exports, "EvidenceJavaScriptAdapter", { enumerable: true, get: function () { return EvidenceJavaScriptAdapter_1.EvidenceJavaScriptAdapter; } });
+var EvidenceKotlinAdapter_1 = require("./adapters/kotlin/EvidenceKotlinAdapter");
+Object.defineProperty(exports, "EvidenceKotlinAdapter", { enumerable: true, get: function () { return EvidenceKotlinAdapter_1.EvidenceKotlinAdapter; } });
+var EvidenceLuaAdapter_1 = require("./adapters/lua/EvidenceLuaAdapter");
+Object.defineProperty(exports, "EvidenceLuaAdapter", { enumerable: true, get: function () { return EvidenceLuaAdapter_1.EvidenceLuaAdapter; } });
+var EvidenceSqliteAdapter_1 = require("./adapters/sqlite/EvidenceSqliteAdapter");
+Object.defineProperty(exports, "EvidenceSqliteAdapter", { enumerable: true, get: function () { return EvidenceSqliteAdapter_1.EvidenceSqliteAdapter; } });
+var EvidenceMarkdownAdapter_1 = require("./adapters/markdown/EvidenceMarkdownAdapter");
+Object.defineProperty(exports, "EvidenceMarkdownAdapter", { enumerable: true, get: function () { return EvidenceMarkdownAdapter_1.EvidenceMarkdownAdapter; } });
+var EvidenceMatlabAdapter_1 = require("./adapters/matlab/EvidenceMatlabAdapter");
+Object.defineProperty(exports, "EvidenceMatlabAdapter", { enumerable: true, get: function () { return EvidenceMatlabAdapter_1.EvidenceMatlabAdapter; } });
+var EvidencePhpAdapter_1 = require("./adapters/php/EvidencePhpAdapter");
+Object.defineProperty(exports, "EvidencePhpAdapter", { enumerable: true, get: function () { return EvidencePhpAdapter_1.EvidencePhpAdapter; } });
+var EvidenceMysqlAdapter_1 = require("./adapters/mysql/EvidenceMysqlAdapter");
+Object.defineProperty(exports, "EvidenceMysqlAdapter", { enumerable: true, get: function () { return EvidenceMysqlAdapter_1.EvidenceMysqlAdapter; } });
+var EvidencePrismaAdapter_1 = require("./adapters/prisma/EvidencePrismaAdapter");
+Object.defineProperty(exports, "EvidencePrismaAdapter", { enumerable: true, get: function () { return EvidencePrismaAdapter_1.EvidencePrismaAdapter; } });
+var EvidencePostgresqlAdapter_1 = require("./adapters/postgresql/EvidencePostgresqlAdapter");
+Object.defineProperty(exports, "EvidencePostgresqlAdapter", { enumerable: true, get: function () { return EvidencePostgresqlAdapter_1.EvidencePostgresqlAdapter; } });
+var EvidencePythonAdapter_1 = require("./adapters/python/EvidencePythonAdapter");
+Object.defineProperty(exports, "EvidencePythonAdapter", { enumerable: true, get: function () { return EvidencePythonAdapter_1.EvidencePythonAdapter; } });
+var EvidenceRubyAdapter_1 = require("./adapters/ruby/EvidenceRubyAdapter");
+Object.defineProperty(exports, "EvidenceRubyAdapter", { enumerable: true, get: function () { return EvidenceRubyAdapter_1.EvidenceRubyAdapter; } });
+var EvidenceRustAdapter_1 = require("./adapters/rust/EvidenceRustAdapter");
+Object.defineProperty(exports, "EvidenceRustAdapter", { enumerable: true, get: function () { return EvidenceRustAdapter_1.EvidenceRustAdapter; } });
+var EvidenceSqlAdapter_1 = require("./adapters/sql/EvidenceSqlAdapter");
+Object.defineProperty(exports, "EvidenceSqlAdapter", { enumerable: true, get: function () { return EvidenceSqlAdapter_1.EvidenceSqlAdapter; } });
+var EvidenceSwiftAdapter_1 = require("./adapters/swift/EvidenceSwiftAdapter");
+Object.defineProperty(exports, "EvidenceSwiftAdapter", { enumerable: true, get: function () { return EvidenceSwiftAdapter_1.EvidenceSwiftAdapter; } });
+var EvidenceSwaggerAdapter_1 = require("./adapters/swagger/EvidenceSwaggerAdapter");
+Object.defineProperty(exports, "EvidenceSwaggerAdapter", { enumerable: true, get: function () { return EvidenceSwaggerAdapter_1.EvidenceSwaggerAdapter; } });
+var EvidenceTypeScriptAdapter_1 = require("./adapters/typescript/EvidenceTypeScriptAdapter");
+Object.defineProperty(exports, "EvidenceTypeScriptAdapter", { enumerable: true, get: function () { return EvidenceTypeScriptAdapter_1.EvidenceTypeScriptAdapter; } });
+var EvidenceZigAdapter_1 = require("./adapters/zig/EvidenceZigAdapter");
+Object.defineProperty(exports, "EvidenceZigAdapter", { enumerable: true, get: function () { return EvidenceZigAdapter_1.EvidenceZigAdapter; } });
+/**
+ * Exports 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.
+ */
+var EvidenceCommand_1 = require("./commands/EvidenceCommand");
+Object.defineProperty(exports, "EvidenceCommand", { enumerable: true, get: function () { return EvidenceCommand_1.EvidenceCommand; } });
+var EvidenceCommandError_1 = require("./commands/EvidenceCommandError");
+Object.defineProperty(exports, "EvidenceCommandError", { enumerable: true, get: function () { return EvidenceCommandError_1.EvidenceCommandError; } });
+var EvidenceWatcher_1 = require("./commands/EvidenceWatcher");
+Object.defineProperty(exports, "EvidenceWatcher", { enumerable: true, get: function () { return EvidenceWatcher_1.EvidenceWatcher; } });
+/**
+ * Exports graph construction, semantic inventory, and query projections.
+ *
+ * These APIs consume a captured check analysis to resolve semantic identities,
+ * coverage, reviews, and human- or machine-facing query results consistently.
+ */
+var EvidenceFingerprint_1 = require("./graph/EvidenceFingerprint");
+Object.defineProperty(exports, "EvidenceFingerprint", { enumerable: true, get: function () { return EvidenceFingerprint_1.EvidenceFingerprint; } });
+var EvidenceGraph_1 = require("./graph/EvidenceGraph");
+Object.defineProperty(exports, "EvidenceGraph", { enumerable: true, get: function () { return EvidenceGraph_1.EvidenceGraph; } });
+var EvidenceInventory_1 = require("./graph/EvidenceInventory");
+Object.defineProperty(exports, "EvidenceInventory", { enumerable: true, get: function () { return EvidenceInventory_1.EvidenceInventory; } });
+var EvidenceQuery_1 = require("./graph/EvidenceQuery");
+Object.defineProperty(exports, "EvidenceQuery", { enumerable: true, get: function () { return EvidenceQuery_1.EvidenceQuery; } });
+/**
+ * Exports configuration and local-source loading boundaries.
+ *
+ * EvidenceChecker composes these loaders for normal checks, while integrations
+ * can call them directly when they need validated configuration or snapshots.
+ */
+var EvidenceConfigLoader_1 = require("./loaders/EvidenceConfigLoader");
+Object.defineProperty(exports, "EvidenceConfigLoader", { enumerable: true, get: function () { return EvidenceConfigLoader_1.EvidenceConfigLoader; } });
+var EvidenceSourceLoader_1 = require("./loaders/EvidenceSourceLoader");
+Object.defineProperty(exports, "EvidenceSourceLoader", { enumerable: true, get: function () { return EvidenceSourceLoader_1.EvidenceSourceLoader; } });
+/**
+ * Exports parser sessions, documentation tags, and certified language registry access.
+ *
+ * Adapter implementations use these boundaries to parse supported artifacts and
+ * interpret evidence annotations without importing the command execution layer.
+ */
+var EvidenceDocumentation_1 = require("./parsers/EvidenceDocumentation");
+Object.defineProperty(exports, "EvidenceDocumentation", { enumerable: true, get: function () { return EvidenceDocumentation_1.EvidenceDocumentation; } });
+var EvidenceLanguageRegistry_1 = require("./parsers/EvidenceLanguageRegistry");
+Object.defineProperty(exports, "EvidenceLanguageRegistry", { enumerable: true, get: function () { return EvidenceLanguageRegistry_1.EvidenceLanguageRegistry; } });
+var EvidenceParser_1 = require("./parsers/EvidenceParser");
+Object.defineProperty(exports, "EvidenceParser", { enumerable: true, get: function () { return EvidenceParser_1.EvidenceParser; } });
+var EvidenceParserError_1 = require("./parsers/EvidenceParserError");
+Object.defineProperty(exports, "EvidenceParserError", { enumerable: true, get: function () { return EvidenceParserError_1.EvidenceParserError; } });
+var EvidenceTagParser_1 = require("./parsers/EvidenceTagParser");
+Object.defineProperty(exports, "EvidenceTagParser", { enumerable: true, get: function () { return EvidenceTagParser_1.EvidenceTagParser; } });
+/**
+ * Exports serializers for check, query, graph, and watch reports.
+ *
+ * They project already evaluated report objects into text, JSON, or graph formats
+ * without changing the underlying inventory, diagnostics, or exit semantics.
+ */
+var EvidenceGraphReporter_1 = require("./reporters/EvidenceGraphReporter");
+Object.defineProperty(exports, "EvidenceGraphReporter", { enumerable: true, get: function () { return EvidenceGraphReporter_1.EvidenceGraphReporter; } });
+var EvidenceQueryReporter_1 = require("./reporters/EvidenceQueryReporter");
+Object.defineProperty(exports, "EvidenceQueryReporter", { enumerable: true, get: function () { return EvidenceQueryReporter_1.EvidenceQueryReporter; } });
+var EvidenceReporter_1 = require("./reporters/EvidenceReporter");
+Object.defineProperty(exports, "EvidenceReporter", { enumerable: true, get: function () { return EvidenceReporter_1.EvidenceReporter; } });
+var EvidenceWatchReporter_1 = require("./reporters/EvidenceWatchReporter");
+Object.defineProperty(exports, "EvidenceWatchReporter", { enumerable: true, get: function () { return EvidenceWatchReporter_1.EvidenceWatchReporter; } });
+/**
+ * Exports target parsing and resolution utilities.
+ *
+ * Query and annotation consumers use them to preserve literal accessor spelling,
+ * normalize file addresses, and resolve targets within selected populations.
+ */
+var EvidenceAccessor_1 = require("./targets/EvidenceAccessor");
+Object.defineProperty(exports, "EvidenceAccessor", { enumerable: true, get: function () { return EvidenceAccessor_1.EvidenceAccessor; } });
+var EvidenceFileTarget_1 = require("./targets/EvidenceFileTarget");
+Object.defineProperty(exports, "EvidenceFileTarget", { enumerable: true, get: function () { return EvidenceFileTarget_1.EvidenceFileTarget; } });
+var EvidenceTargetResolver_1 = require("./targets/EvidenceTargetResolver");
+Object.defineProperty(exports, "EvidenceTargetResolver", { enumerable: true, get: function () { return EvidenceTargetResolver_1.EvidenceTargetResolver; } });
+var EvidenceObjcAdapter_1 = require("./adapters/objc/EvidenceObjcAdapter");
+Object.defineProperty(exports, "EvidenceObjcAdapter", { enumerable: true, get: function () { return EvidenceObjcAdapter_1.EvidenceObjcAdapter; } });

package/lib/internal/CanonicalJson.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Produces canonical JSON-derived values for semantic identity calculations.
+ *
+ * The renderer normalizes object order and cyclic references so equivalent
+ * extracted structures have stable hashes across process runs.
+ */
+export declare namespace CanonicalJson {
+    /** Hashes a canonical representation with SHA-256 for persisted semantic comparison.
+     *
+     * Fingerprint consumers use the digest to compare semantic records whose ordinary object enumeration order may differ.
+     */
+    function digest(value: unknown): string;
+    /**
+     * Copies enumerable fields except caller-named non-semantic metadata.
+     *
+     * This is non-mutating because adapters may reuse the source record for
+     * diagnostics after computing an identity-specific view.
+     */
+    function without(value: object, keys: string[]): Record<string, unknown>;
+}

package/lib/internal/CanonicalJson.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CanonicalJson = void 0;
+const node_crypto_1 = require("node:crypto");
+/**
+ * Produces canonical JSON-derived values for semantic identity calculations.
+ *
+ * The renderer normalizes object order and cyclic references so equivalent
+ * extracted structures have stable hashes across process runs.
+ */
+var CanonicalJson;
+(function (CanonicalJson) {
+    /** Hashes a canonical representation with SHA-256 for persisted semantic comparison.
+     *
+     * Fingerprint consumers use the digest to compare semantic records whose ordinary object enumeration order may differ.
+     */
+    function digest(value) {
+        return (0, node_crypto_1.createHash)("sha256").update(render(value, new Set())).digest("hex");
+    }
+    CanonicalJson.digest = digest;
+    /**
+     * Copies enumerable fields except caller-named non-semantic metadata.
+     *
+     * This is non-mutating because adapters may reuse the source record for
+     * diagnostics after computing an identity-specific view.
+     */
+    function without(value, keys) {
+        const excluded = new Set(keys);
+        return Object.fromEntries(Object.entries(value).filter(([key]) => !excluded.has(key)));
+    }
+    CanonicalJson.without = without;
+    /** Serializes values recursively while replacing an active cycle with a stable sentinel.
+     *
+     * Tracking only the active ancestry permits shared acyclic values while preventing recursive structures from making fingerprint rendering diverge.
+     */
+    function render(value, seen) {
+        if (value === null || typeof value !== "object")
+            return stringify(value);
+        if (seen.has(value))
+            return '"[circular]"';
+        seen.add(value);
+        try {
+            if (Array.isArray(value)) {
+                const elements = value;
+                return `[${elements
+                    .map((element) => render(element ?? null, seen))
+                    .join(",")}]`;
+            }
+            const raw = Object.entries(value);
+            const entries = raw.filter(([, element]) => element !== undefined);
+            entries.sort(([x], [y]) => (x < y ? -1 : x > y ? 1 : 0));
+            return `{${entries
+                .map(([key, element]) => `${JSON.stringify(key)}:${render(element, seen)}`)
+                .join(",")}}`;
+        }
+        finally {
+            seen.delete(value);
+        }
+    }
+    /** Serializes JSON primitives while representing unsupported values as `null`.
+     *
+     * This follows `JSON.stringify` for representable primitives and keeps the canonical renderer total for arbitrary input.
+     */
+    function stringify(value) {
+        return JSON.stringify(value) ?? "null";
+    }
+})(CanonicalJson || (exports.CanonicalJson = CanonicalJson = {}));

package/lib/internal/ConfigDependencyScanner.d.ts

@@ -0,0 +1,40 @@
+import type { IEvidenceSourceDependency } from "../structures/IEvidenceSourceDependency";
+/**
+ * Finds static local and package-resolution dependencies of one evaluated config.
+ *
+ * It records dependencies before reads and resolution complete, allowing watch
+ * mode to observe a repaired import rather than remaining stuck on a failed scan.
+ */
+export declare class ConfigDependencyScanner {
+    private readonly configFile;
+    private readonly dependencies;
+    private readonly scanned;
+    private readonly parser;
+    /** Creates a dependency scanner for one configuration entry file.
+     *
+     * The scanner owns a private parser and closes it after `scan` completes, so callers receive only serializable watch dependencies.
+     */
+    constructor(configFile: string);
+    /** Scans the configuration and every statically reachable local module.
+     *
+     * Parser resources close on both success and failure, while already discovered dependencies remain available through `list` for watch recovery.
+     */
+    scan(): Promise<IEvidenceSourceDependency[]>;
+    /** Returns ordered dependencies discovered before a failed read or parse.
+     *
+     * Watch setup uses this partial result so a repaired module or package boundary can restart a failed configuration cycle.
+     */
+    list(): IEvidenceSourceDependency[];
+    private scanFile;
+    private resolve;
+    private watchModuleScope;
+    private watchPackageResolution;
+    private resolveExact;
+    private resolvePath;
+    private watchMissingPackage;
+    /** Merges duplicate dependencies and upgrades them to recursive observation when needed.
+     *
+     * A path reached through several import routes retains the strongest watch requirement without duplicate entries.
+     */
+    private watch;
+}