@wrtnlabs/evidence 0.0.0

package/lib/loaders/EvidenceConfigLoader.js

@@ -0,0 +1,557 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EvidenceConfigLoader = void 0;
+const _assertGuard_1 = __importStar(require("typia/lib/internal/_assertGuard"));
+const promises_1 = require("node:fs/promises");
+const node_path_1 = require("node:path");
+const typia_1 = __importDefault(require("typia"));
+const createEvidenceConfigPlan_1 = require("../internal/createEvidenceConfigPlan");
+const EvidenceConfigFormat_1 = require("../internal/EvidenceConfigFormat");
+const EvidenceArtifactTypes_1 = require("../internal/EvidenceArtifactTypes");
+const evaluateTypeScriptConfig_1 = require("../internal/evaluateTypeScriptConfig");
+const validateEvidenceConfig_1 = require("../internal/validateEvidenceConfig");
+/**
+ * Loads and validates Evidence configuration before artifact I/O begins.
+ *
+ * JSON is read as data; TypeScript is evaluated through the consumer's ttsx with
+ * output isolated from report stdout. Validation covers disabled declarations too.
+ * Call load to retain authored configuration or plan to resolve inherited policy
+ * and remove inactive populations before source discovery.
+ *
+ * @example
+ * const plan: IEvidenceConfigPlan = await EvidenceConfigLoader.plan(
+ *   "./config/evidence.config.ts",
+ * );
+ * // Population roots are anchored to the resolved configuration file.
+ */
+var EvidenceConfigLoader;
+(function (EvidenceConfigLoader) {
+    /**
+     * Loads authored configuration and validates every claim and reference.
+     *
+     * JSON data and TypeScript default exports share artifact and shape validation.
+     * Evaluation output goes to stderr, and failures reject rather than returning
+     * partially validated configuration. Inactive declarations are still checked.
+     *
+     * @param file Configuration path, relative to the current working directory.
+     */
+    async function load(file = "evidence.config.ts") {
+        const filename = await resolveConfigFile(file);
+        const config = await evaluateResolvedConfig(filename);
+        (0, validateEvidenceConfig_1.validateEvidenceConfig)(config, filename);
+        return config;
+    }
+    EvidenceConfigLoader.load = load;
+    /**
+     * Loads configuration into a plan with resolved policy and selector defaults.
+     *
+     * Validation precedes filtering, so malformed disabled settings still fail.
+     * Disabled and off populations are omitted before artifact I/O while active
+     * entries retain their authored indices and configuration-relative roots.
+     */
+    async function plan(file = "evidence.config.ts") {
+        const filename = await resolveConfigFile(file);
+        return (0, createEvidenceConfigPlan_1.createEvidenceConfigPlan)(await evaluateResolvedConfig(filename), filename);
+    }
+    EvidenceConfigLoader.plan = plan;
+})(EvidenceConfigLoader || (exports.EvidenceConfigLoader = EvidenceConfigLoader = {}));
+/**
+ * Resolves a supported configuration path to an existing physical file.
+ *
+ * Both logical and resolved spellings must use a supported format. Evaluation
+ * follows the resolved filename, and a symlink to an unsupported target is rejected.
+ */
+async function resolveConfigFile(file) {
+    EvidenceConfigFormat_1.EvidenceConfigFormat.get(file);
+    const filename = await (0, promises_1.realpath)((0, node_path_1.resolve)(file));
+    EvidenceConfigFormat_1.EvidenceConfigFormat.get(filename);
+    if (!(await (0, promises_1.stat)(filename)).isFile())
+        throw new Error(`Evidence configuration must be a file: ${filename}`);
+    return filename;
+}
+/**
+ * Evaluates an already resolved file and validates its configuration shape.
+ *
+ * Artifact identifiers receive a focused certification diagnostic before the
+ * generated shape validator handles the remaining contract. JSON BOM removal
+ * permits ordinary UTF-8 files without treating their strings as executable imports.
+ */
+async function evaluateResolvedConfig(filename) {
+    const value = EvidenceConfigFormat_1.EvidenceConfigFormat.get(filename) === "json"
+        ? JSON.parse((await (0, promises_1.readFile)(filename, "utf8")).replace(/^\uFEFF/u, ""))
+        : await (0, evaluateTypeScriptConfig_1.evaluateTypeScriptConfig)(filename);
+    validateArtifactTypes(value);
+    return (() => {
+        const _ip0 = input => undefined === input["severity"] || "error" === input["severity"] || "off" === input["severity"] || "warning" === input["severity"];
+        const _ip1 = input => "bigquery" === input["type"] || "dbml" === input["type"] || "mysql" === input["type"] || "postgresql" === input["type"] || "prisma" === input["type"] || "sql" === input["type"] || "sqlite" === input["type"];
+        const _ip2 = input => undefined === input["name"] || "string" === typeof input["name"];
+        const _ip3 = input => undefined === input["disabled"] || "boolean" === typeof input["disabled"];
+        const _ip4 = input => undefined === input["root"] || "string" === typeof input["root"];
+        const _ip5 = input => Array.isArray(input["files"]) && input["files"].every(elem => "string" === typeof elem);
+        const _ip6 = input => null !== input["symbol"] && (undefined === input["symbol"] || "column" === input["symbol"] || "model" === input["symbol"] || "relation" === input["symbol"] || Array.isArray(input["symbol"]) && input["symbol"].every(elem => "column" === elem || "model" === elem || "relation" === elem));
+        const _ip7 = input => undefined === input["evidenceExcludeCarriers"] || Array.isArray(input["evidenceExcludeCarriers"]) && input["evidenceExcludeCarriers"].every(elem => "string" === typeof elem);
+        const _ip8 = input => null !== input["reference"] && undefined !== input["reference"] && (Array.isArray(input["reference"]) && input["reference"].every(elem => "object" === typeof elem && null !== elem && _iu1(elem)) || "object" === typeof input["reference"] && null !== input["reference"] && _iu1(input["reference"]));
+        const _ip9 = input => undefined === input["noEvidenceExclude"] || "boolean" === typeof input["noEvidenceExclude"];
+        const _ip10 = input => undefined === input["uniqueEvidence"] || "boolean" === typeof input["uniqueEvidence"];
+        const _ip11 = input => undefined === input["singleEvidencePerSymbol"] || "boolean" === typeof input["singleEvidencePerSymbol"];
+        const _ip12 = input => undefined === input["requireReview"] || "boolean" === typeof input["requireReview"];
+        const _ip13 = input => "markdown" === input["type"];
+        const _ip14 = input => null !== input["symbol"] && (undefined === input["symbol"] || "file" === input["symbol"] || "h1" === input["symbol"] || "h2" === input["symbol"] || "h3" === input["symbol"] || "h4" === input["symbol"] || Array.isArray(input["symbol"]) && input["symbol"].every(elem => "file" === elem || "h1" === elem || "h2" === elem || "h3" === elem || "h4" === elem));
+        const _ip15 = input => true === _iv0.has(input["type"]);
+        const _iv0 = new Set(["c", "cpp", "csharp", "dart", "go", "java", "javascript", "kotlin", "lua", "matlab", "objc", "php", "python", "ruby", "rust", "scala", "swift", "typescript", "zig"]);
+        const _ip16 = input => null !== input["symbol"] && (undefined === input["symbol"] || "function" === input["symbol"] || "property" === input["symbol"] || "type" === input["symbol"] || Array.isArray(input["symbol"]) && input["symbol"].every(elem => "function" === elem || "property" === elem || "type" === elem));
+        const _ip17 = input => "swagger" === input["type"];
+        const _ip18 = input => null !== input["symbol"] && (undefined === input["symbol"] || "operation" === input["symbol"] || Array.isArray(input["symbol"]) && input["symbol"].every(elem => "operation" === elem));
+        const _ap0 = (input, _path, _exceptionable = true) => undefined === input["severity"] || "error" === input["severity"] || "off" === input["severity"] || "warning" === input["severity"] || _assertGuard_1._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".severity",
+            expected: "(\"error\" | \"off\" | \"warning\" | undefined)",
+            value: input["severity"]
+        }, _errorFactory);
+        const _ap1 = (input, _path, _exceptionable = true) => "bigquery" === input["type"] || "dbml" === input["type"] || "mysql" === input["type"] || "postgresql" === input["type"] || "prisma" === input["type"] || "sql" === input["type"] || "sqlite" === input["type"] || _assertGuard_1._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".type",
+            expected: "(\"bigquery\" | \"dbml\" | \"mysql\" | \"postgresql\" | \"prisma\" | \"sql\" | \"sqlite\")",
+            value: input["type"]
+        }, _errorFactory);
+        const _ap2 = (input, _path, _exceptionable = true) => undefined === input["name"] || "string" === typeof input["name"] || _assertGuard_1._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".name",
+            expected: "(string | undefined)",
+            value: input["name"]
+        }, _errorFactory);
+        const _ap3 = (input, _path, _exceptionable = true) => undefined === input["disabled"] || "boolean" === typeof input["disabled"] || _assertGuard_1._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".disabled",
+            expected: "(boolean | undefined)",
+            value: input["disabled"]
+        }, _errorFactory);
+        const _ap4 = (input, _path, _exceptionable = true) => undefined === input["root"] || "string" === typeof input["root"] || _assertGuard_1._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".root",
+            expected: "(string | undefined)",
+            value: input["root"]
+        }, _errorFactory);
+        const _ap5 = (input, _path, _exceptionable = true) => (Array.isArray(input["files"]) || _assertGuard_1._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".files",
+            expected: "Array<string>",
+            value: input["files"]
+        }, _errorFactory)) && input["files"].every((elem, _index10) => "string" === typeof elem || _assertGuard_1._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".files[" + _index10 + "]",
+            expected: "string",
+            value: elem
+        }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".files",
+            expected: "Array<string>",
+            value: input["files"]
+        }, _errorFactory);
+        const _ap6 = (input, _path, _exceptionable = true) => (null !== input["symbol"] || _assertGuard_1._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".symbol",
+            expected: "(\"column\" | \"model\" | \"relation\" | Array<EvidenceDatabaseSymbol> | undefined)",
+            value: input["symbol"]
+        }, _errorFactory)) && (undefined === input["symbol"] || "column" === input["symbol"] || "model" === input["symbol"] || "relation" === input["symbol"] || (Array.isArray(input["symbol"]) || _assertGuard_1._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".symbol",
+            expected: "(\"column\" | \"model\" | \"relation\" | Array<EvidenceDatabaseSymbol> | undefined)",
+            value: input["symbol"]
+        }, _errorFactory)) && input["symbol"].every((elem, _index11) => "column" === elem || "model" === elem || "relation" === elem || _assertGuard_1._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".symbol[" + _index11 + "]",
+            expected: "(\"column\" | \"model\" | \"relation\")",
+            value: elem
+        }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".symbol",
+            expected: "(\"column\" | \"model\" | \"relation\" | Array<EvidenceDatabaseSymbol> | undefined)",
+            value: input["symbol"]
+        }, _errorFactory));
+        const _ap7 = (input, _path, _exceptionable = true) => undefined === input["evidenceExcludeCarriers"] || (Array.isArray(input["evidenceExcludeCarriers"]) || _assertGuard_1._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".evidenceExcludeCarriers",
+            expected: "(Array<string> | undefined)",
+            value: input["evidenceExcludeCarriers"]
+        }, _errorFactory)) && input["evidenceExcludeCarriers"].every((elem, _index12) => "string" === typeof elem || _assertGuard_1._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".evidenceExcludeCarriers[" + _index12 + "]",
+            expected: "string",
+            value: elem
+        }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".evidenceExcludeCarriers",
+            expected: "(Array<string> | undefined)",
+            value: input["evidenceExcludeCarriers"]
+        }, _errorFactory);
+        const _ap8 = (input, _path, _exceptionable = true) => (null !== input["reference"] || _assertGuard_1._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".reference",
+            expected: _ae0,
+            value: input["reference"]
+        }, _errorFactory)) && (undefined !== input["reference"] || _assertGuard_1._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".reference",
+            expected: _ae0,
+            value: input["reference"]
+        }, _errorFactory)) && (Array.isArray(input["reference"]) && input["reference"].every((elem, _index13) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".reference[" + _index13 + "]",
+            expected: "(IEvidenceDatabaseReference | IEvidenceMarkdownReference | IEvidenceProgrammingReference | IEvidenceSwaggerReference)",
+            value: elem
+        }, _errorFactory)) && _au1(elem, _path + ".reference[" + _index13 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".reference[" + _index13 + "]",
+            expected: "(IEvidenceDatabaseReference | IEvidenceMarkdownReference | IEvidenceProgrammingReference | IEvidenceSwaggerReference)",
+            value: elem
+        }, _errorFactory)) || "object" === typeof input["reference"] && null !== input["reference"] && _au1(input["reference"], _path + ".reference", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".reference",
+            expected: _ae0,
+            value: input["reference"]
+        }, _errorFactory) || _assertGuard_1._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".reference",
+            expected: _ae0,
+            value: input["reference"]
+        }, _errorFactory));
+        const _ae0 = "(Array<IEvidenceReference> | IEvidenceDatabaseReference | IEvidenceMarkdownReference | IEvidenceProgrammingReference | IEvidenceSwaggerReference)";
+        const _ap9 = (input, _path, _exceptionable = true) => undefined === input["noEvidenceExclude"] || "boolean" === typeof input["noEvidenceExclude"] || _assertGuard_1._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".noEvidenceExclude",
+            expected: "(boolean | undefined)",
+            value: input["noEvidenceExclude"]
+        }, _errorFactory);
+        const _ap10 = (input, _path, _exceptionable = true) => undefined === input["uniqueEvidence"] || "boolean" === typeof input["uniqueEvidence"] || _assertGuard_1._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".uniqueEvidence",
+            expected: "(boolean | undefined)",
+            value: input["uniqueEvidence"]
+        }, _errorFactory);
+        const _ap11 = (input, _path, _exceptionable = true) => undefined === input["singleEvidencePerSymbol"] || "boolean" === typeof input["singleEvidencePerSymbol"] || _assertGuard_1._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".singleEvidencePerSymbol",
+            expected: "(boolean | undefined)",
+            value: input["singleEvidencePerSymbol"]
+        }, _errorFactory);
+        const _ap12 = (input, _path, _exceptionable = true) => undefined === input["requireReview"] || "boolean" === typeof input["requireReview"] || _assertGuard_1._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".requireReview",
+            expected: "(boolean | undefined)",
+            value: input["requireReview"]
+        }, _errorFactory);
+        const _ap13 = (input, _path, _exceptionable = true) => "markdown" === input["type"] || _assertGuard_1._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".type",
+            expected: "\"markdown\"",
+            value: input["type"]
+        }, _errorFactory);
+        const _ap14 = (input, _path, _exceptionable = true) => (null !== input["symbol"] || _assertGuard_1._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".symbol",
+            expected: "(\"file\" | \"h1\" | \"h2\" | \"h3\" | \"h4\" | Array<EvidenceMarkdownSymbol> | undefined)",
+            value: input["symbol"]
+        }, _errorFactory)) && (undefined === input["symbol"] || "file" === input["symbol"] || "h1" === input["symbol"] || "h2" === input["symbol"] || "h3" === input["symbol"] || "h4" === input["symbol"] || (Array.isArray(input["symbol"]) || _assertGuard_1._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".symbol",
+            expected: "(\"file\" | \"h1\" | \"h2\" | \"h3\" | \"h4\" | Array<EvidenceMarkdownSymbol> | undefined)",
+            value: input["symbol"]
+        }, _errorFactory)) && input["symbol"].every((elem, _index14) => "file" === elem || "h1" === elem || "h2" === elem || "h3" === elem || "h4" === elem || _assertGuard_1._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".symbol[" + _index14 + "]",
+            expected: "(\"file\" | \"h1\" | \"h2\" | \"h3\" | \"h4\")",
+            value: elem
+        }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".symbol",
+            expected: "(\"file\" | \"h1\" | \"h2\" | \"h3\" | \"h4\" | Array<EvidenceMarkdownSymbol> | undefined)",
+            value: input["symbol"]
+        }, _errorFactory));
+        const _ap15 = (input, _path, _exceptionable = true) => true === _av0.has(input["type"]) || _assertGuard_1._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".type",
+            expected: _ae1,
+            value: input["type"]
+        }, _errorFactory);
+        const _av0 = new Set(["c", "cpp", "csharp", "dart", "go", "java", "javascript", "kotlin", "lua", "matlab", "objc", "php", "python", "ruby", "rust", "scala", "swift", "typescript", "zig"]);
+        const _ae1 = "(\"c\" | \"cpp\" | \"csharp\" | \"dart\" | \"go\" | \"java\" | \"javascript\" | \"kotlin\" | \"lua\" | \"matlab\" | \"objc\" | \"php\" | \"python\" | \"ruby\" | \"rust\" | \"scala\" | \"swift\" | \"typescript\" | \"zig\")";
+        const _ap16 = (input, _path, _exceptionable = true) => (null !== input["symbol"] || _assertGuard_1._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".symbol",
+            expected: "(\"function\" | \"property\" | \"type\" | Array<EvidenceProgrammingSymbol> | undefined)",
+            value: input["symbol"]
+        }, _errorFactory)) && (undefined === input["symbol"] || "function" === input["symbol"] || "property" === input["symbol"] || "type" === input["symbol"] || (Array.isArray(input["symbol"]) || _assertGuard_1._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".symbol",
+            expected: "(\"function\" | \"property\" | \"type\" | Array<EvidenceProgrammingSymbol> | undefined)",
+            value: input["symbol"]
+        }, _errorFactory)) && input["symbol"].every((elem, _index15) => "function" === elem || "property" === elem || "type" === elem || _assertGuard_1._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".symbol[" + _index15 + "]",
+            expected: "(\"function\" | \"property\" | \"type\")",
+            value: elem
+        }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".symbol",
+            expected: "(\"function\" | \"property\" | \"type\" | Array<EvidenceProgrammingSymbol> | undefined)",
+            value: input["symbol"]
+        }, _errorFactory));
+        const _ap17 = (input, _path, _exceptionable = true) => "swagger" === input["type"] || _assertGuard_1._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".type",
+            expected: "\"swagger\"",
+            value: input["type"]
+        }, _errorFactory);
+        const _ap18 = (input, _path, _exceptionable = true) => (null !== input["symbol"] || _assertGuard_1._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".symbol",
+            expected: "(\"operation\" | Array<\"operation\"> | undefined)",
+            value: input["symbol"]
+        }, _errorFactory)) && (undefined === input["symbol"] || "operation" === input["symbol"] || (Array.isArray(input["symbol"]) || _assertGuard_1._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".symbol",
+            expected: "(\"operation\" | Array<\"operation\"> | undefined)",
+            value: input["symbol"]
+        }, _errorFactory)) && input["symbol"].every((elem, _index16) => "operation" === elem || _assertGuard_1._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".symbol[" + _index16 + "]",
+            expected: "\"operation\"",
+            value: elem
+        }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".symbol",
+            expected: "(\"operation\" | Array<\"operation\"> | undefined)",
+            value: input["symbol"]
+        }, _errorFactory));
+        const _ao0 = (input, _path, _exceptionable = true) => _ap0(input, _path, true && _exceptionable) && ((Array.isArray(input.claims) || _assertGuard_1._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".claims",
+            expected: "Array<IEvidenceClaim>",
+            value: input.claims
+        }, _errorFactory)) && input.claims.every((elem, _index9) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".claims[" + _index9 + "]",
+            expected: "(IEvidenceDatabaseClaim | IEvidenceMarkdownClaim | IEvidenceProgrammingClaim | IEvidenceSwaggerClaim)",
+            value: elem
+        }, _errorFactory)) && _au0(elem, _path + ".claims[" + _index9 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".claims[" + _index9 + "]",
+            expected: "(IEvidenceDatabaseClaim | IEvidenceMarkdownClaim | IEvidenceProgrammingClaim | IEvidenceSwaggerClaim)",
+            value: elem
+        }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".claims",
+            expected: "Array<IEvidenceClaim>",
+            value: input.claims
+        }, _errorFactory));
+        const _ao1 = (input, _path, _exceptionable = true) => _ap1(input, _path, true && _exceptionable) && _ap2(input, _path, true && _exceptionable) && _ap0(input, _path, true && _exceptionable) && _ap3(input, _path, true && _exceptionable) && _ap4(input, _path, true && _exceptionable) && _ap5(input, _path, true && _exceptionable) && _ap6(input, _path, true && _exceptionable) && _ap7(input, _path, true && _exceptionable) && _ap8(input, _path, true && _exceptionable);
+        const _ao2 = (input, _path, _exceptionable = true) => _ap1(input, _path, true && _exceptionable) && _ap4(input, _path, true && _exceptionable) && _ap6(input, _path, true && _exceptionable) && _ap0(input, _path, true && _exceptionable) && _ap9(input, _path, true && _exceptionable) && _ap10(input, _path, true && _exceptionable) && _ap11(input, _path, true && _exceptionable) && _ap12(input, _path, true && _exceptionable) && _ap5(input, _path, true && _exceptionable);
+        const _ao3 = (input, _path, _exceptionable = true) => _ap13(input, _path, true && _exceptionable) && _ap4(input, _path, true && _exceptionable) && _ap14(input, _path, true && _exceptionable) && _ap0(input, _path, true && _exceptionable) && _ap9(input, _path, true && _exceptionable) && _ap10(input, _path, true && _exceptionable) && _ap11(input, _path, true && _exceptionable) && _ap12(input, _path, true && _exceptionable) && _ap5(input, _path, true && _exceptionable) && (undefined === input.checklist || "boolean" === typeof input.checklist || _assertGuard_1._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".checklist",
+            expected: "(boolean | undefined)",
+            value: input.checklist
+        }, _errorFactory));
+        const _ao4 = (input, _path, _exceptionable = true) => _ap15(input, _path, true && _exceptionable) && _ap4(input, _path, true && _exceptionable) && _ap16(input, _path, true && _exceptionable) && _ap0(input, _path, true && _exceptionable) && _ap9(input, _path, true && _exceptionable) && _ap10(input, _path, true && _exceptionable) && _ap11(input, _path, true && _exceptionable) && _ap12(input, _path, true && _exceptionable) && _ap5(input, _path, true && _exceptionable);
+        const _ao5 = (input, _path, _exceptionable = true) => _ap17(input, _path, true && _exceptionable) && _ap4(input, _path, true && _exceptionable) && _ap18(input, _path, true && _exceptionable) && _ap0(input, _path, true && _exceptionable) && _ap9(input, _path, true && _exceptionable) && _ap10(input, _path, true && _exceptionable) && _ap11(input, _path, true && _exceptionable) && _ap12(input, _path, true && _exceptionable) && ("string" === typeof input.file || _assertGuard_1._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + ".file",
+            expected: "string",
+            value: input.file
+        }, _errorFactory));
+        const _ao6 = (input, _path, _exceptionable = true) => _ap13(input, _path, true && _exceptionable) && _ap2(input, _path, true && _exceptionable) && _ap0(input, _path, true && _exceptionable) && _ap3(input, _path, true && _exceptionable) && _ap4(input, _path, true && _exceptionable) && _ap5(input, _path, true && _exceptionable) && _ap14(input, _path, true && _exceptionable) && _ap7(input, _path, true && _exceptionable) && _ap8(input, _path, true && _exceptionable);
+        const _ao7 = (input, _path, _exceptionable = true) => _ap15(input, _path, true && _exceptionable) && _ap2(input, _path, true && _exceptionable) && _ap0(input, _path, true && _exceptionable) && _ap3(input, _path, true && _exceptionable) && _ap4(input, _path, true && _exceptionable) && _ap5(input, _path, true && _exceptionable) && _ap16(input, _path, true && _exceptionable) && _ap7(input, _path, true && _exceptionable) && _ap8(input, _path, true && _exceptionable);
+        const _ao8 = (input, _path, _exceptionable = true) => _ap17(input, _path, true && _exceptionable) && _ap2(input, _path, true && _exceptionable) && _ap0(input, _path, true && _exceptionable) && _ap3(input, _path, true && _exceptionable) && _ap4(input, _path, true && _exceptionable) && _ap5(input, _path, true && _exceptionable) && _ap18(input, _path, true && _exceptionable) && _ap7(input, _path, true && _exceptionable) && _ap8(input, _path, true && _exceptionable);
+        const _au0 = (input, _path, _exceptionable = true) => (() => {
+            if ("swagger" === input.type)
+                return _ao8(input, _path, true && _exceptionable);
+            else if (true === _av0.has(input.type))
+                return _ao7(input, _path, true && _exceptionable);
+            else if ("markdown" === input.type)
+                return _ao6(input, _path, true && _exceptionable);
+            else if ("bigquery" === input.type || "dbml" === input.type || "mysql" === input.type || "postgresql" === input.type || "prisma" === input.type || "sql" === input.type || "sqlite" === input.type)
+                return _ao1(input, _path, true && _exceptionable);
+            else
+                return _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path,
+                    expected: "(IEvidenceSwaggerClaim | IEvidenceProgrammingClaim | IEvidenceMarkdownClaim | IEvidenceDatabaseClaim)",
+                    value: input
+                }, _errorFactory);
+        })();
+        const _au1 = (input, _path, _exceptionable = true) => (() => {
+            if ("bigquery" === input.type || "dbml" === input.type || "mysql" === input.type || "postgresql" === input.type || "prisma" === input.type || "sql" === input.type || "sqlite" === input.type)
+                return _ao2(input, _path, true && _exceptionable);
+            else if ("markdown" === input.type)
+                return _ao3(input, _path, true && _exceptionable);
+            else if (true === _av0.has(input.type))
+                return _ao4(input, _path, true && _exceptionable);
+            else if ("swagger" === input.type)
+                return _ao5(input, _path, true && _exceptionable);
+            else
+                return _assertGuard_1._assertGuard(_exceptionable, {
+                    method: "typia.assert",
+                    path: _path,
+                    expected: "(IEvidenceDatabaseReference | IEvidenceMarkdownReference | IEvidenceProgrammingReference | IEvidenceSwaggerReference)",
+                    value: input
+                }, _errorFactory);
+        })();
+        const _io0 = input => _ip0(input) && (Array.isArray(input.claims) && input.claims.every(elem => "object" === typeof elem && null !== elem && _iu0(elem)));
+        const _io1 = input => _ip1(input) && _ip2(input) && _ip0(input) && _ip3(input) && _ip4(input) && _ip5(input) && _ip6(input) && _ip7(input) && _ip8(input);
+        const _io2 = input => _ip1(input) && _ip4(input) && _ip6(input) && _ip0(input) && _ip9(input) && _ip10(input) && _ip11(input) && _ip12(input) && _ip5(input);
+        const _io3 = input => _ip13(input) && _ip4(input) && _ip14(input) && _ip0(input) && _ip9(input) && _ip10(input) && _ip11(input) && _ip12(input) && _ip5(input) && (undefined === input.checklist || "boolean" === typeof input.checklist);
+        const _io4 = input => _ip15(input) && _ip4(input) && _ip16(input) && _ip0(input) && _ip9(input) && _ip10(input) && _ip11(input) && _ip12(input) && _ip5(input);
+        const _io5 = input => _ip17(input) && _ip4(input) && _ip18(input) && _ip0(input) && _ip9(input) && _ip10(input) && _ip11(input) && _ip12(input) && "string" === typeof input.file;
+        const _io6 = input => _ip13(input) && _ip2(input) && _ip0(input) && _ip3(input) && _ip4(input) && _ip5(input) && _ip14(input) && _ip7(input) && _ip8(input);
+        const _io7 = input => _ip15(input) && _ip2(input) && _ip0(input) && _ip3(input) && _ip4(input) && _ip5(input) && _ip16(input) && _ip7(input) && _ip8(input);
+        const _io8 = input => _ip17(input) && _ip2(input) && _ip0(input) && _ip3(input) && _ip4(input) && _ip5(input) && _ip18(input) && _ip7(input) && _ip8(input);
+        const _iu0 = input => (() => {
+            if ("swagger" === input.type)
+                return _io8(input);
+            else if (true === _iv0.has(input.type))
+                return _io7(input);
+            else if ("markdown" === input.type)
+                return _io6(input);
+            else if ("bigquery" === input.type || "dbml" === input.type || "mysql" === input.type || "postgresql" === input.type || "prisma" === input.type || "sql" === input.type || "sqlite" === input.type)
+                return _io1(input);
+            else
+                return false;
+        })();
+        const _iu1 = input => (() => {
+            if ("bigquery" === input.type || "dbml" === input.type || "mysql" === input.type || "postgresql" === input.type || "prisma" === input.type || "sql" === input.type || "sqlite" === input.type)
+                return _io2(input);
+            else if ("markdown" === input.type)
+                return _io3(input);
+            else if (true === _iv0.has(input.type))
+                return _io4(input);
+            else if ("swagger" === input.type)
+                return _io5(input);
+            else
+                return false;
+        })();
+        const __is = input => "object" === typeof input && null !== input && _io0(input);
+        let _errorFactory;
+        return (input, errorFactory) => {
+            if (false === __is(input)) {
+                _errorFactory = errorFactory;
+                ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input || _assertGuard_1._assertGuard(true, {
+                    method: "typia.assert",
+                    path: _path + "",
+                    expected: "IEvidenceConfig",
+                    value: input
+                }, _errorFactory)) && _ao0(input, _path + "", true) || _assertGuard_1._assertGuard(true, {
+                    method: "typia.assert",
+                    path: _path + "",
+                    expected: "IEvidenceConfig",
+                    value: input
+                }, _errorFactory))(input, "$input", true);
+            }
+            return input;
+        };
+    })()(value, configurationShapeError);
+}
+/**
+ * Attributes unsupported artifact identifiers to exact claim/reference paths.
+ *
+ * This preflight only traverses recognizable containers. General malformed shapes
+ * remain the generated validator's responsibility rather than being accepted here.
+ */
+function validateArtifactTypes(value) {
+    if (!isRecord(value))
+        return;
+    const claims = unknownArray(value["claims"]);
+    if (claims === undefined)
+        return;
+    claims.forEach((claim, claimIndex) => {
+        if (!isRecord(claim))
+            return;
+        validateArtifactType(claim["type"], `claims[${claimIndex}].type`);
+        const references = unknownArray(claim["reference"]);
+        if (references !== undefined)
+            references.forEach((reference, referenceIndex) => {
+                if (isRecord(reference))
+                    validateArtifactType(reference["type"], `claims[${claimIndex}].reference[${referenceIndex}].type`);
+            });
+        else if (isRecord(claim["reference"]))
+            validateArtifactType(claim["reference"]["type"], `claims[${claimIndex}].reference.type`);
+    });
+}
+/**
+ * Rejects a string discriminator with no shipped certified adapter.
+ *
+ * Non-string values are left for shape validation so this check reports only the
+ * artifact-availability problem it can diagnose with a precise configuration path.
+ */
+function validateArtifactType(value, path) {
+    if (typeof value !== "string" || EvidenceArtifactTypes_1.EvidenceArtifactTypes.isSupported(value))
+        return;
+    throw new Error(`Invalid Evidence configuration at ${path}: artifact type '${value}' has no certified Evidence adapter. Supported types: ${EvidenceArtifactTypes_1.EvidenceArtifactTypes.supported().join(", ")}.`);
+}
+/**
+ * Narrows a value enough to inspect named configuration fields during preflight.
+ *
+ * This only establishes safe object access; full shape validity is checked by typia.
+ */
+function isRecord(value) {
+    return typeof value === "object" && value !== null;
+}
+/**
+ * Exposes array entries for artifact preflight without assuming their element shape.
+ *
+ * Non-arrays return undefined so single-reference handling or shape validation
+ * can decide the appropriate interpretation.
+ */
+function unknownArray(value) {
+    return Array.isArray(value) ? value : undefined;
+}
+/**
+ * Converts generated shape-validation details into an author-facing configuration error.
+ *
+ * The message removes the validator's synthetic root name and distinguishes a
+ * missing value from a wrong type without serializing arbitrary configuration data.
+ */
+function configurationShapeError(props) {
+    const path = (props.path ?? "$input").replace(/^\$input\.?/u, "");
+    const location = path === "" ? "configuration" : path;
+    const received = props.value === undefined
+        ? "the value is missing"
+        : "the value has another type";
+    return new Error(`Invalid Evidence configuration at ${location}: expected ${props.expected}; ${received}.`);
+}

package/lib/loaders/EvidenceSourceLoader.d.ts

@@ -0,0 +1,35 @@
+import type { IEvidenceSourceSelection } from "../structures/IEvidenceSourceSelection";
+import type { IEvidenceSourceSnapshot } from "../structures/IEvidenceSourceSnapshot";
+/**
+ * Loads source snapshots that adapter analysis can classify and parse.
+ *
+ * Configuration planning supplies a selection, then the checker uses this boundary
+ * to preserve both discovered files and recoverable filesystem failures. The
+ * loader does not decide language support: selected unsupported files remain in
+ * the snapshot so the applicable adapter can produce its own diagnostic.
+ *
+ * @example
+ * const snapshot: IEvidenceSourceSnapshot = await EvidenceSourceLoader.glob(
+ *   "evidence.config.ts",
+ *   { files: ["src/*.ts"] },
+ * );
+ */
+export declare namespace EvidenceSourceLoader {
+    /**
+     * Discovers every path selected by one enabled population.
+     *
+     * Relative patterns and the optional root are anchored to `configFile`. Invalid
+     * selector syntax rejects before scanning, while read, traversal, and snapshot
+     * failures are collected in an incomplete result. This distinction lets graph
+     * evaluation fail safely without losing paths needed for watch recovery.
+     */
+    function glob(configFile: string, selection: IEvidenceSourceSelection): Promise<IEvidenceSourceSnapshot>;
+    /**
+     * Captures one exact local file for an operation that names a path directly.
+     *
+     * The file may be outside `root`, unlike a glob population. Its resolved root
+     * still supplies configuration-relative identity and location context, and any
+     * filesystem failure is retained in the returned incomplete snapshot.
+     */
+    function file(configFile: string, file: string, root?: string): Promise<IEvidenceSourceSnapshot>;
+}