@wrtnlabs/evidence 0.0.0

package/lib/internal/ConfigDependencyScanner.js

@@ -0,0 +1,330 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigDependencyScanner = void 0;
+const promises_1 = require("node:fs/promises");
+const node_module_1 = require("node:module");
+const node_path_1 = __importDefault(require("node:path"));
+const node_url_1 = require("node:url");
+const EvidenceParser_1 = require("../parsers/EvidenceParser");
+const EcmaScriptSyntax_1 = require("../adapters/ecmascript/EcmaScriptSyntax");
+const SourcePath_1 = require("./SourcePath");
+/**
+ * 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.
+ */
+class ConfigDependencyScanner {
+    configFile;
+    dependencies = new Map();
+    scanned = new Set();
+    parser = new EvidenceParser_1.EvidenceParser({ concurrency: 1 });
+    /** 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) {
+        this.configFile = configFile;
+    }
+    /** 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.
+     */
+    async scan() {
+        try {
+            if (programmingType(this.configFile) !== undefined)
+                await this.watchModuleScope(node_path_1.default.resolve(this.configFile));
+            await this.scanFile(node_path_1.default.resolve(this.configFile));
+            return this.list();
+        }
+        finally {
+            await this.parser.close();
+        }
+    }
+    /** 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() {
+        return Array.from(this.dependencies.values()).sort((left, right) => left.path < right.path ? -1 : left.path > right.path ? 1 : 0);
+    }
+    /** Watches and parses one physical module once, then follows its static specifiers.
+     *
+     * Logical and real paths are both retained because symlink changes can alter resolution even when the parsed physical file is unchanged.
+     */
+    async scanFile(file) {
+        const logical = SourcePath_1.SourcePath.slash(node_path_1.default.resolve(file));
+        this.watch(logical, false);
+        this.watch(SourcePath_1.SourcePath.slash(node_path_1.default.dirname(logical)), true);
+        const physical = SourcePath_1.SourcePath.slash(await (0, promises_1.realpath)(logical));
+        this.watch(physical, false);
+        this.watch(SourcePath_1.SourcePath.slash(node_path_1.default.dirname(physical)), true);
+        if (logical === SourcePath_1.SourcePath.slash(node_path_1.default.resolve(this.configFile)) &&
+            programmingType(physical) !== undefined)
+            await this.watchModuleScope(physical);
+        if (this.scanned.has(physical))
+            return;
+        this.scanned.add(physical);
+        const type = programmingType(physical);
+        if (type === undefined)
+            return;
+        const content = await (0, promises_1.readFile)(physical, "utf8");
+        const specifiers = await this.parser.parse({ type, file: physical, content }, collectSpecifiers);
+        for (const specifier of specifiers)
+            for (const resolved of await this.resolve(physical, specifier))
+                await this.scanFile(resolved);
+    }
+    /** Resolves one static specifier while recording paths that can alter its resolution.
+     *
+     * Local, file URL, and package forms use their respective Node-compatible lookup paths before recursive scanning continues.
+     */
+    async resolve(owner, specifier) {
+        if (specifier.startsWith("node:") || (0, node_module_1.isBuiltin)(specifier))
+            return [];
+        if (specifier.startsWith("file:"))
+            return this.resolveExact((0, node_url_1.fileURLToPath)(specifier));
+        if (specifier.startsWith(".") || node_path_1.default.isAbsolute(specifier)) {
+            const base = node_path_1.default.resolve(node_path_1.default.dirname(owner), specifier);
+            try {
+                return await this.resolvePath(base);
+            }
+            catch (cause) {
+                try {
+                    return await this.resolveExact((0, node_module_1.createRequire)(owner).resolve(specifier));
+                }
+                catch {
+                    throw cause;
+                }
+            }
+        }
+        await this.watchPackageResolution(owner, packageSpecifier(specifier));
+        try {
+            return this.resolveExact((0, node_module_1.createRequire)(owner).resolve(specifier));
+        }
+        catch (cause) {
+            await this.watchMissingPackage(owner, specifier);
+            throw new Error(`Could not resolve configuration import '${specifier}' from ${owner}.`, { cause });
+        }
+    }
+    /** Watches package boundaries whose module mode changes temporary config evaluation.
+     *
+     * The nearest `package.json` controls Node module kind, so its appearance or replacement must invalidate the configuration dependency set.
+     */
+    async watchModuleScope(file) {
+        let directory = node_path_1.default.dirname(file);
+        for (;;) {
+            const manifest = SourcePath_1.SourcePath.slash(node_path_1.default.join(directory, "package.json"));
+            this.watch(manifest, false);
+            try {
+                if ((await (0, promises_1.stat)(manifest)).isFile())
+                    return;
+            }
+            catch (cause) {
+                if (!absent(cause))
+                    throw cause;
+            }
+            const parent = node_path_1.default.dirname(directory);
+            if (parent === directory)
+                return;
+            directory = parent;
+        }
+    }
+    /** Watches each `node_modules` candidate searched by Node package resolution.
+     *
+     * A package installed higher in the directory tree can make a previously unresolved configuration import valid.
+     */
+    async watchPackageResolution(owner, packageName) {
+        let directory = node_path_1.default.dirname(owner);
+        for (;;) {
+            const nodeModules = SourcePath_1.SourcePath.slash(node_path_1.default.join(directory, "node_modules"));
+            const packageDirectory = SourcePath_1.SourcePath.slash(node_path_1.default.join(nodeModules, packageName));
+            this.watch(packageDirectory, false);
+            this.watch(SourcePath_1.SourcePath.slash(node_path_1.default.join(packageDirectory, "package.json")), false);
+            const parent = node_path_1.default.dirname(directory);
+            if (parent === directory)
+                return;
+            directory = parent;
+        }
+    }
+    /** Validates an exact resolved module and watches its parent for deletion or replacement.
+     *
+     * The parent dependency lets watch mode notice a module that disappears after resolution has succeeded.
+     */
+    async resolveExact(file) {
+        const location = SourcePath_1.SourcePath.slash(node_path_1.default.resolve(file));
+        this.watch(location, false);
+        this.watch(SourcePath_1.SourcePath.slash(node_path_1.default.dirname(location)), true);
+        if ((await (0, promises_1.stat)(location)).isFile())
+            return [location];
+        throw new Error(`Configuration module '${location}' is not a file.`);
+    }
+    /** Tries TypeScript-aware local extension candidates in deterministic order.
+     *
+     * The ordered candidates mirror supported config imports so a newly created higher-precedence file can restart resolution.
+     */
+    async resolvePath(base) {
+        const candidates = moduleCandidates(base);
+        for (const candidate of candidates) {
+            this.watch(SourcePath_1.SourcePath.slash(candidate), false);
+            try {
+                if ((await (0, promises_1.stat)(candidate)).isFile())
+                    return [candidate];
+            }
+            catch (cause) {
+                if (!absent(cause))
+                    throw cause;
+            }
+        }
+        this.watch(SourcePath_1.SourcePath.slash(node_path_1.default.dirname(base)), true);
+        throw new Error(`Could not resolve local configuration module '${base}'.`);
+    }
+    /** Retains recursive missing package paths so installation or repair restarts the watch cycle.
+     *
+     * Failed package resolution still establishes dependencies on every searched package root instead of becoming a terminal blind spot.
+     */
+    async watchMissingPackage(owner, specifier) {
+        const packageName = packageSpecifier(specifier);
+        let directory = node_path_1.default.dirname(owner);
+        for (;;) {
+            const nodeModules = SourcePath_1.SourcePath.slash(node_path_1.default.join(directory, "node_modules"));
+            this.watch(nodeModules, true);
+            this.watch(SourcePath_1.SourcePath.slash(node_path_1.default.join(nodeModules, packageName)), true);
+            const parent = node_path_1.default.dirname(directory);
+            if (parent === directory)
+                return;
+            directory = parent;
+        }
+    }
+    /** 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.
+     */
+    watch(location, recursive) {
+        const previous = this.dependencies.get(location);
+        this.dependencies.set(location, {
+            path: location,
+            recursive: recursive || previous?.recursive === true,
+        });
+    }
+}
+exports.ConfigDependencyScanner = ConfigDependencyScanner;
+/** Extracts only statically knowable imports and rejects dynamic dependency expressions.
+ *
+ * Configuration watching can follow a fixed dependency graph, but dynamic `import` or `require` arguments require runtime execution and therefore fail visibly.
+ */
+function collectSpecifiers(session) {
+    const output = new Set();
+    for (const statement of session.root.namedChildren) {
+        if (statement.type !== "import_statement" &&
+            statement.type !== "export_statement")
+            continue;
+        if (EcmaScriptSyntax_1.EcmaScriptSyntax.token(statement, "type"))
+            continue;
+        const direct = EcmaScriptSyntax_1.EcmaScriptSyntax.module(statement.childForFieldName("source"));
+        if (direct !== undefined)
+            output.add(direct);
+        else if (statement.type === "import_statement") {
+            const literal = statement.descendantsOfType("string").at(-1);
+            const nested = EcmaScriptSyntax_1.EcmaScriptSyntax.module(literal ?? null);
+            if (nested !== undefined)
+                output.add(nested);
+        }
+    }
+    for (const call of session.root.descendantsOfType("call_expression")) {
+        const callee = call.childForFieldName("function");
+        if (callee?.text !== "import" && callee?.text !== "require")
+            continue;
+        const argumentsNode = call.childForFieldName("arguments");
+        const argument = argumentsNode === null
+            ? undefined
+            : argumentsNode.namedChildren.find((child) => child.type === "string");
+        const specifier = EcmaScriptSyntax_1.EcmaScriptSyntax.module(argument ?? null);
+        if (specifier === undefined)
+            throw new Error(`Configuration ${callee.text}() dependencies require one static string literal.`);
+        output.add(specifier);
+    }
+    return Array.from(output);
+}
+/** Chooses a parser only for JavaScript-family modules relevant to configuration imports.
+ *
+ * Non-code files can be resolved as dependencies but are not recursively parsed for module specifiers.
+ */
+function programmingType(file) {
+    const extension = node_path_1.default.extname(file).toLowerCase();
+    if ([".ts", ".tsx", ".cts", ".mts"].includes(extension))
+        return "typescript";
+    if ([".js", ".jsx", ".cjs", ".mjs"].includes(extension))
+        return "javascript";
+    return undefined;
+}
+/** Produces the supported local TypeScript and JavaScript extension fallback order.
+ *
+ * Local import resolution uses this ordered list to match configuration evaluation and register each candidate for watch recovery.
+ */
+function moduleCandidates(base) {
+    const extension = node_path_1.default.extname(base).toLowerCase();
+    if (extension === ".js" || extension === ".jsx")
+        return unique([
+            replaceExtension(base, ".ts"),
+            replaceExtension(base, ".tsx"),
+            base,
+        ]);
+    if (extension === ".mjs")
+        return unique([replaceExtension(base, ".mts"), base]);
+    if (extension === ".cjs")
+        return unique([replaceExtension(base, ".cts"), base]);
+    if (extension !== "")
+        return [base];
+    const extensions = [
+        ".ts",
+        ".tsx",
+        ".mts",
+        ".cts",
+        ".js",
+        ".jsx",
+        ".mjs",
+        ".cjs",
+        ".json",
+    ];
+    return unique([
+        base,
+        ...extensions.map((value) => base + value),
+        ...extensions.map((value) => node_path_1.default.join(base, "index" + value)),
+    ]);
+}
+/** Replaces an existing extension without applying path normalization.
+ *
+ * Candidate generation preserves the authored base path while trying TypeScript counterparts for JavaScript spellings.
+ */
+function replaceExtension(file, extension) {
+    return file.slice(0, -node_path_1.default.extname(file).length) + extension;
+}
+/** Retains each candidate's first occurrence while eliminating fallback duplicates.
+ *
+ * This preserves deterministic resolution precedence when extension substitution produces the same path twice.
+ */
+function unique(values) {
+    return Array.from(new Set(values));
+}
+/** Extracts the package root so subpath resolution watches the owning package boundary.
+ *
+ * Scoped specifiers retain their first two segments; ordinary packages retain only the first segment.
+ */
+function packageSpecifier(specifier) {
+    const segments = specifier.split("/");
+    return specifier.startsWith("@")
+        ? segments.slice(0, 2).join("/")
+        : (segments[0] ?? specifier);
+}
+/** Identifies expected missing-path errors that resolution can continue past.
+ *
+ * Resolution probes may skip absent candidates, whereas permission and other filesystem failures must remain diagnostic.
+ */
+function absent(cause) {
+    return (cause instanceof Error &&
+        "code" in cause &&
+        (cause.code === "ENOENT" || cause.code === "ENOTDIR"));
+}

package/lib/internal/EvidenceAdapterFactory.d.ts

@@ -0,0 +1,15 @@
+import type { IEvidenceAdapter } from "../structures/IEvidenceAdapter";
+import type { EvidenceArtifactType } from "../typings/EvidenceArtifactType";
+/**
+ * Constructs the adapter implementing one certified artifact contract.
+ *
+ * A fresh instance isolates parser/session state between analyses; unsupported
+ * additions fail here instead of producing a partial inventory downstream.
+ */
+export declare namespace EvidenceAdapterFactory {
+    /** Creates the dedicated adapter for a validated artifact discriminator.
+     *
+     * Each call returns a fresh instance so parser and scan state cannot cross an inventory boundary.
+     */
+    function create(type: EvidenceArtifactType): IEvidenceAdapter;
+}

package/lib/internal/EvidenceAdapterFactory.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EvidenceAdapterFactory = void 0;
+const EvidenceObjcAdapter_1 = require("../adapters/objc/EvidenceObjcAdapter");
+const EvidenceDartAdapter_1 = require("../adapters/dart/EvidenceDartAdapter");
+const EvidenceCAdapter_1 = require("../adapters/c/EvidenceCAdapter");
+const EvidenceBigQueryAdapter_1 = require("../adapters/bigquery/EvidenceBigQueryAdapter");
+const EvidenceCppAdapter_1 = require("../adapters/cpp/EvidenceCppAdapter");
+const EvidenceCSharpAdapter_1 = require("../adapters/csharp/EvidenceCSharpAdapter");
+const EvidenceDbmlAdapter_1 = require("../adapters/dbml/EvidenceDbmlAdapter");
+const EvidenceGoAdapter_1 = require("../adapters/go/EvidenceGoAdapter");
+const EvidenceJavaAdapter_1 = require("../adapters/java/EvidenceJavaAdapter");
+const EvidenceJavaScriptAdapter_1 = require("../adapters/javascript/EvidenceJavaScriptAdapter");
+const EvidenceKotlinAdapter_1 = require("../adapters/kotlin/EvidenceKotlinAdapter");
+const EvidenceLuaAdapter_1 = require("../adapters/lua/EvidenceLuaAdapter");
+const EvidenceMarkdownAdapter_1 = require("../adapters/markdown/EvidenceMarkdownAdapter");
+const EvidenceMatlabAdapter_1 = require("../adapters/matlab/EvidenceMatlabAdapter");
+const EvidencePhpAdapter_1 = require("../adapters/php/EvidencePhpAdapter");
+const EvidenceMysqlAdapter_1 = require("../adapters/mysql/EvidenceMysqlAdapter");
+const EvidencePrismaAdapter_1 = require("../adapters/prisma/EvidencePrismaAdapter");
+const EvidencePostgresqlAdapter_1 = require("../adapters/postgresql/EvidencePostgresqlAdapter");
+const EvidencePythonAdapter_1 = require("../adapters/python/EvidencePythonAdapter");
+const EvidenceRubyAdapter_1 = require("../adapters/ruby/EvidenceRubyAdapter");
+const EvidenceScalaAdapter_1 = require("../adapters/scala/EvidenceScalaAdapter");
+const EvidenceRustAdapter_1 = require("../adapters/rust/EvidenceRustAdapter");
+const EvidenceSqlAdapter_1 = require("../adapters/sql/EvidenceSqlAdapter");
+const EvidenceSqliteAdapter_1 = require("../adapters/sqlite/EvidenceSqliteAdapter");
+const EvidenceSwiftAdapter_1 = require("../adapters/swift/EvidenceSwiftAdapter");
+const EvidenceSwaggerAdapter_1 = require("../adapters/swagger/EvidenceSwaggerAdapter");
+const EvidenceTypeScriptAdapter_1 = require("../adapters/typescript/EvidenceTypeScriptAdapter");
+const EvidenceZigAdapter_1 = require("../adapters/zig/EvidenceZigAdapter");
+/**
+ * Constructs the adapter implementing one certified artifact contract.
+ *
+ * A fresh instance isolates parser/session state between analyses; unsupported
+ * additions fail here instead of producing a partial inventory downstream.
+ */
+var EvidenceAdapterFactory;
+(function (EvidenceAdapterFactory) {
+    /** Creates the dedicated adapter for a validated artifact discriminator.
+     *
+     * Each call returns a fresh instance so parser and scan state cannot cross an inventory boundary.
+     */
+    function create(type) {
+        if (type === "objc")
+            return new EvidenceObjcAdapter_1.EvidenceObjcAdapter();
+        if (type === "dart")
+            return new EvidenceDartAdapter_1.EvidenceDartAdapter();
+        if (type === "c")
+            return new EvidenceCAdapter_1.EvidenceCAdapter();
+        if (type === "bigquery")
+            return new EvidenceBigQueryAdapter_1.EvidenceBigQueryAdapter();
+        if (type === "cpp")
+            return new EvidenceCppAdapter_1.EvidenceCppAdapter();
+        if (type === "csharp")
+            return new EvidenceCSharpAdapter_1.EvidenceCSharpAdapter();
+        if (type === "dbml")
+            return new EvidenceDbmlAdapter_1.EvidenceDbmlAdapter();
+        if (type === "go")
+            return new EvidenceGoAdapter_1.EvidenceGoAdapter();
+        if (type === "java")
+            return new EvidenceJavaAdapter_1.EvidenceJavaAdapter();
+        if (type === "javascript")
+            return new EvidenceJavaScriptAdapter_1.EvidenceJavaScriptAdapter();
+        if (type === "kotlin")
+            return new EvidenceKotlinAdapter_1.EvidenceKotlinAdapter();
+        if (type === "lua")
+            return new EvidenceLuaAdapter_1.EvidenceLuaAdapter();
+        if (type === "markdown")
+            return new EvidenceMarkdownAdapter_1.EvidenceMarkdownAdapter();
+        if (type === "matlab")
+            return new EvidenceMatlabAdapter_1.EvidenceMatlabAdapter();
+        if (type === "php")
+            return new EvidencePhpAdapter_1.EvidencePhpAdapter();
+        if (type === "mysql")
+            return new EvidenceMysqlAdapter_1.EvidenceMysqlAdapter();
+        if (type === "prisma")
+            return new EvidencePrismaAdapter_1.EvidencePrismaAdapter();
+        if (type === "postgresql")
+            return new EvidencePostgresqlAdapter_1.EvidencePostgresqlAdapter();
+        if (type === "python")
+            return new EvidencePythonAdapter_1.EvidencePythonAdapter();
+        if (type === "ruby")
+            return new EvidenceRubyAdapter_1.EvidenceRubyAdapter();
+        if (type === "scala")
+            return new EvidenceScalaAdapter_1.EvidenceScalaAdapter();
+        if (type === "rust")
+            return new EvidenceRustAdapter_1.EvidenceRustAdapter();
+        if (type === "sql")
+            return new EvidenceSqlAdapter_1.EvidenceSqlAdapter();
+        if (type === "sqlite")
+            return new EvidenceSqliteAdapter_1.EvidenceSqliteAdapter();
+        if (type === "swift")
+            return new EvidenceSwiftAdapter_1.EvidenceSwiftAdapter();
+        if (type === "swagger")
+            return new EvidenceSwaggerAdapter_1.EvidenceSwaggerAdapter();
+        if (type === "typescript")
+            return new EvidenceTypeScriptAdapter_1.EvidenceTypeScriptAdapter();
+        if (type === "zig")
+            return new EvidenceZigAdapter_1.EvidenceZigAdapter();
+        throw new Error(`Artifact type '${type}' has no certified Evidence adapter.`);
+    }
+    EvidenceAdapterFactory.create = create;
+})(EvidenceAdapterFactory || (exports.EvidenceAdapterFactory = EvidenceAdapterFactory = {}));

package/lib/internal/EvidenceArtifactTypes.d.ts

@@ -0,0 +1,20 @@
+import type { EvidenceArtifactType } from "../typings/EvidenceArtifactType";
+/**
+ * Provides the runtime set of artifact types with certified adapters.
+ *
+ * Configuration validation uses this boundary instead of language identifier
+ * unions, since a grammar candidate must not become selectable before its
+ * extraction and target behavior are complete.
+ */
+export declare namespace EvidenceArtifactTypes {
+    /** Narrows a configuration discriminator to a certified artifact type.
+     *
+     * Configuration validation uses this guard before adapter construction, keeping grammar-only candidates outside the supported product surface.
+     */
+    function isSupported(type: string): type is EvidenceArtifactType;
+    /** Returns the certified artifact types in a defensive copy.
+     *
+     * Callers can inspect or sort their result without mutating the module-level support baseline used by validation.
+     */
+    function supported(): EvidenceArtifactType[];
+}

package/lib/internal/EvidenceArtifactTypes.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EvidenceArtifactTypes = void 0;
+const EvidenceLanguageRegistry_1 = require("../parsers/EvidenceLanguageRegistry");
+/**
+ * Provides the runtime set of artifact types with certified adapters.
+ *
+ * Configuration validation uses this boundary instead of language identifier
+ * unions, since a grammar candidate must not become selectable before its
+ * extraction and target behavior are complete.
+ */
+var EvidenceArtifactTypes;
+(function (EvidenceArtifactTypes) {
+    /** Narrows a configuration discriminator to a certified artifact type.
+     *
+     * Configuration validation uses this guard before adapter construction, keeping grammar-only candidates outside the supported product surface.
+     */
+    function isSupported(type) {
+        return SUPPORTED.some((supported) => supported === type);
+    }
+    EvidenceArtifactTypes.isSupported = isSupported;
+    /** Returns the certified artifact types in a defensive copy.
+     *
+     * Callers can inspect or sort their result without mutating the module-level support baseline used by validation.
+     */
+    function supported() {
+        return [...SUPPORTED];
+    }
+    EvidenceArtifactTypes.supported = supported;
+})(EvidenceArtifactTypes || (exports.EvidenceArtifactTypes = EvidenceArtifactTypes = {}));
+const SUPPORTED = [
+    "markdown",
+    "prisma",
+    "swagger",
+    ...[
+        ...EvidenceLanguageRegistry_1.EvidenceLanguageRegistry.list(),
+        ...EvidenceLanguageRegistry_1.EvidenceLanguageRegistry.databases(),
+    ]
+        .filter((language) => language.adapter !== undefined)
+        .map((language) => language.type),
+];

package/lib/internal/EvidenceConfigFormat.d.ts

@@ -0,0 +1,11 @@
+/** Selects the evaluator supported by a configuration filename's explicit extension.
+ *
+ * Config loading calls this boundary before parsing so file content never changes the evaluator selected for a path.
+ */
+export declare namespace EvidenceConfigFormat {
+    /** Returns the evaluator selected by an explicit supported filename extension.
+     *
+     * Unsupported spellings fail here instead of causing configuration loading to guess a parser from file content.
+     */
+    function get(file: string): "json" | "typescript";
+}

package/lib/internal/EvidenceConfigFormat.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EvidenceConfigFormat = void 0;
+const node_path_1 = require("node:path");
+/** Selects the evaluator supported by a configuration filename's explicit extension.
+ *
+ * Config loading calls this boundary before parsing so file content never changes the evaluator selected for a path.
+ */
+var EvidenceConfigFormat;
+(function (EvidenceConfigFormat) {
+    /** Returns the evaluator selected by an explicit supported filename extension.
+     *
+     * Unsupported spellings fail here instead of causing configuration loading to guess a parser from file content.
+     */
+    function get(file) {
+        const extension = (0, node_path_1.extname)(file);
+        if (extension === ".json")
+            return "json";
+        if ([".ts", ".cts", ".mts"].includes(extension))
+            return "typescript";
+        throw new Error(`Unsupported evidence configuration extension: ${file}. Use .json, .ts, .cts, or .mts.`);
+    }
+    EvidenceConfigFormat.get = get;
+})(EvidenceConfigFormat || (exports.EvidenceConfigFormat = EvidenceConfigFormat = {}));

package/lib/internal/EvidenceFingerprintIndex.d.ts

@@ -0,0 +1,49 @@
+import type { IEvidenceFingerprint } from "../structures/IEvidenceFingerprint";
+import type { IEvidenceInventory } from "../structures/IEvidenceInventory";
+/**
+ * Computes and memoizes stable fingerprints for inventory units and descendants.
+ *
+ * Fingerprints exclude annotation text and presentation-only whitespace so an
+ * acknowledgement edit does not look like a specification change. The index
+ * owns only references to the immutable analysis inventory.
+ */
+export declare class EvidenceFingerprintIndex {
+    private readonly annotations;
+    private readonly children;
+    private readonly contentDigests;
+    private readonly fingerprints;
+    private readonly sources;
+    private readonly units;
+    /** Builds source, annotation, and parent indexes once for one inventory snapshot.
+     *
+     * Fingerprint generation reuses these indexes to connect units to their physical content without repeatedly scanning inventory collections.
+     */
+    constructor(inventory: IEvidenceInventory);
+    /**
+     * Returns the root content digest and subtree scope digest for one semantic identity.
+     *
+     * Unknown identities fail rather than producing an empty fingerprint, because
+     * absence would make a stale graph appear unchanged.
+     */
+    inspect(unitId: string): IEvidenceFingerprint;
+    /** Collects a cycle-safe structural subtree for one unit.
+     *
+     * The visited set prevents malformed parent links from looping fingerprint generation while preserving each reachable child once.
+     */
+    private collect;
+    /** Adds withdrawal tags to the content contribution because they alter effective scope.
+     *
+     * A unit's fingerprint must change when a withdrawal changes which declarations remain active, even if its source range is unchanged.
+     */
+    private contribution;
+    /** Hashes source sites after stripping mapped annotations and normalizing presentation differences.
+     *
+     * Annotation edits are tracked separately, while substantive source changes remain stable across line-ending and trailing-space differences.
+     */
+    private contentDigest;
+    /** Removes only overlapping annotation spans while retaining surrounding source exactly for semantic hashing.
+     *
+     * Ranges are ordered before removal so adjacent or overlapping tags cannot duplicate or erase unrelated source fragments.
+     */
+    private withoutAnnotations;
+}