@wrtnlabs/evidence 0.0.0

package/lib/adapters/dbml/EvidenceDbmlAdapter.js

@@ -0,0 +1,674 @@
+"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.EvidenceDbmlAdapter = void 0;
+const _assertGuard_1 = __importStar(require("typia/lib/internal/_assertGuard"));
+const node_crypto_1 = require("node:crypto");
+const typia_1 = __importDefault(require("typia"));
+const InventoryMerge_1 = require("../../internal/InventoryMerge");
+const EvidenceInventory_1 = require("../../graph/EvidenceInventory");
+const DbmlDocumentation_1 = require("./DbmlDocumentation");
+const EvidenceParser_1 = require("../../parsers/EvidenceParser");
+const EvidenceParserError_1 = require("../../parsers/EvidenceParserError");
+const EvidenceTagParser_1 = require("../../parsers/EvidenceTagParser");
+const DbmlFileScanner_1 = require("./DbmlFileScanner");
+/**
+ * Extracts DBML tables, columns, relations, and supported documentation hosts.
+ *
+ * Physical source aliases are deduplicated before parsing. Schema aliases and
+ * relation endpoints are resolved across file analyses before public units and
+ * annotation carriers are materialized, preserving semantic ownership and explicit
+ * failures instead of guessing unresolved schema links.
+ */
+class EvidenceDbmlAdapter {
+    /**
+     * Database family discriminator selecting DBML parsing and schema rules.
+     *
+     * Claims and references use this value to apply the adapter's database selectors.
+     */
+    type = "dbml";
+    /**
+     * Builds a normalized DBML inventory from a validated, cloned source snapshot.
+     *
+     * Failed scans preserve located diagnostics and incomplete state. Successfully
+     * scanned files contribute dependencies, aliases, relation ownership, and
+     * documentation before the parser runtime closes in cleanup.
+     */
+    async analyze(snapshot) {
+        const input = structuredClone((() => {
+            const _ip0 = input => "string" === typeof input["absolute"];
+            const _ip1 = input => "string" === typeof input["display"];
+            const _ip2 = input => "string" === typeof input["path"];
+            const _ap0 = (input, _path, _exceptionable = true) => "string" === typeof input["absolute"] || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".absolute",
+                expected: "string",
+                value: input["absolute"]
+            }, _errorFactory);
+            const _ap1 = (input, _path, _exceptionable = true) => "string" === typeof input["display"] || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".display",
+                expected: "string",
+                value: input["display"]
+            }, _errorFactory);
+            const _ap2 = (input, _path, _exceptionable = true) => "string" === typeof input["path"] || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".path",
+                expected: "string",
+                value: input["path"]
+            }, _errorFactory);
+            const _ae0 = "(\"case-mismatch\" | \"invalid-encoding\" | \"not-file\" | \"path-unreadable\" | \"root-unreadable\" | \"source-changed\" | \"symlink-cycle\")";
+            const _ao0 = (input, _path, _exceptionable = true) => (("object" === typeof input.root && null !== input.root || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".root",
+                expected: "IEvidenceSourceRoot",
+                value: input.root
+            }, _errorFactory)) && _ao1(input.root, _path + ".root", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".root",
+                expected: "IEvidenceSourceRoot",
+                value: input.root
+            }, _errorFactory)) && ((Array.isArray(input.files) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".files",
+                expected: "Array<IEvidenceSourceFile>",
+                value: input.files
+            }, _errorFactory)) && input.files.every((elem, _index5) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".files[" + _index5 + "]",
+                expected: "IEvidenceSourceFile",
+                value: elem
+            }, _errorFactory)) && _ao2(elem, _path + ".files[" + _index5 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".files[" + _index5 + "]",
+                expected: "IEvidenceSourceFile",
+                value: elem
+            }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".files",
+                expected: "Array<IEvidenceSourceFile>",
+                value: input.files
+            }, _errorFactory)) && ((Array.isArray(input.dependencies) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".dependencies",
+                expected: "Array<IEvidenceSourceDependency>",
+                value: input.dependencies
+            }, _errorFactory)) && input.dependencies.every((elem, _index6) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".dependencies[" + _index6 + "]",
+                expected: "IEvidenceSourceDependency",
+                value: elem
+            }, _errorFactory)) && _ao4(elem, _path + ".dependencies[" + _index6 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".dependencies[" + _index6 + "]",
+                expected: "IEvidenceSourceDependency",
+                value: elem
+            }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".dependencies",
+                expected: "Array<IEvidenceSourceDependency>",
+                value: input.dependencies
+            }, _errorFactory)) && ((Array.isArray(input.diagnostics) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".diagnostics",
+                expected: "Array<IEvidenceSourceDiagnostic>",
+                value: input.diagnostics
+            }, _errorFactory)) && input.diagnostics.every((elem, _index7) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".diagnostics[" + _index7 + "]",
+                expected: "IEvidenceSourceDiagnostic",
+                value: elem
+            }, _errorFactory)) && _ao5(elem, _path + ".diagnostics[" + _index7 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".diagnostics[" + _index7 + "]",
+                expected: "IEvidenceSourceDiagnostic",
+                value: elem
+            }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".diagnostics",
+                expected: "Array<IEvidenceSourceDiagnostic>",
+                value: input.diagnostics
+            }, _errorFactory)) && ("boolean" === typeof input.complete || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".complete",
+                expected: "boolean",
+                value: input.complete
+            }, _errorFactory));
+            const _ao1 = (input, _path, _exceptionable = true) => ("string" === typeof input.declared || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".declared",
+                expected: "string",
+                value: input.declared
+            }, _errorFactory)) && _ap0(input, _path, true && _exceptionable) && (undefined === input.physical || "string" === typeof input.physical || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".physical",
+                expected: "(string | undefined)",
+                value: input.physical
+            }, _errorFactory)) && _ap1(input, _path, true && _exceptionable);
+            const _ao2 = (input, _path, _exceptionable = true) => ("string" === typeof input.id || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".id",
+                expected: "string",
+                value: input.id
+            }, _errorFactory)) && ("string" === typeof input.physicalPath || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".physicalPath",
+                expected: "string",
+                value: input.physicalPath
+            }, _errorFactory)) && ("string" === typeof input.content || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".content",
+                expected: "string",
+                value: input.content
+            }, _errorFactory)) && ("string" === typeof input.digest || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".digest",
+                expected: "string",
+                value: input.digest
+            }, _errorFactory)) && ((Array.isArray(input.addresses) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".addresses",
+                expected: "Array<IEvidenceSourceAddress>",
+                value: input.addresses
+            }, _errorFactory)) && input.addresses.every((elem, _index8) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".addresses[" + _index8 + "]",
+                expected: "IEvidenceSourceAddress",
+                value: elem
+            }, _errorFactory)) && _ao3(elem, _path + ".addresses[" + _index8 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".addresses[" + _index8 + "]",
+                expected: "IEvidenceSourceAddress",
+                value: elem
+            }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".addresses",
+                expected: "Array<IEvidenceSourceAddress>",
+                value: input.addresses
+            }, _errorFactory));
+            const _ao3 = (input, _path, _exceptionable = true) => _ap0(input, _path, true && _exceptionable) && ("string" === typeof input.relative || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".relative",
+                expected: "string",
+                value: input.relative
+            }, _errorFactory)) && _ap1(input, _path, true && _exceptionable) && (undefined === input.selected || "boolean" === typeof input.selected || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".selected",
+                expected: "(boolean | undefined)",
+                value: input.selected
+            }, _errorFactory));
+            const _ao4 = (input, _path, _exceptionable = true) => _ap2(input, _path, true && _exceptionable) && ("boolean" === typeof input.recursive || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".recursive",
+                expected: "boolean",
+                value: input.recursive
+            }, _errorFactory));
+            const _ao5 = (input, _path, _exceptionable = true) => ("case-mismatch" === input.code || "invalid-encoding" === input.code || "not-file" === input.code || "path-unreadable" === input.code || "root-unreadable" === input.code || "source-changed" === input.code || "symlink-cycle" === input.code || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".code",
+                expected: _ae0,
+                value: input.code
+            }, _errorFactory)) && _ap2(input, _path, true && _exceptionable) && ("string" === typeof input.message || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".message",
+                expected: "string",
+                value: input.message
+            }, _errorFactory));
+            const _io0 = input => "object" === typeof input.root && null !== input.root && _io1(input.root) && (Array.isArray(input.files) && input.files.every(elem => "object" === typeof elem && null !== elem && _io2(elem))) && (Array.isArray(input.dependencies) && input.dependencies.every(elem => "object" === typeof elem && null !== elem && _io4(elem))) && (Array.isArray(input.diagnostics) && input.diagnostics.every(elem => "object" === typeof elem && null !== elem && _io5(elem))) && "boolean" === typeof input.complete;
+            const _io1 = input => "string" === typeof input.declared && _ip0(input) && (undefined === input.physical || "string" === typeof input.physical) && _ip1(input);
+            const _io2 = input => "string" === typeof input.id && "string" === typeof input.physicalPath && "string" === typeof input.content && "string" === typeof input.digest && (Array.isArray(input.addresses) && input.addresses.every(elem => "object" === typeof elem && null !== elem && _io3(elem)));
+            const _io3 = input => _ip0(input) && "string" === typeof input.relative && _ip1(input) && (undefined === input.selected || "boolean" === typeof input.selected);
+            const _io4 = input => _ip2(input) && "boolean" === typeof input.recursive;
+            const _io5 = input => ("case-mismatch" === input.code || "invalid-encoding" === input.code || "not-file" === input.code || "path-unreadable" === input.code || "root-unreadable" === input.code || "source-changed" === input.code || "symlink-cycle" === input.code) && _ip2(input) && "string" === typeof input.message;
+            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: "IEvidenceSourceSnapshot",
+                        value: input
+                    }, _errorFactory)) && _ao0(input, _path + "", true) || _assertGuard_1._assertGuard(true, {
+                        method: "typia.assert",
+                        path: _path + "",
+                        expected: "IEvidenceSourceSnapshot",
+                        value: input
+                    }, _errorFactory))(input, "$input", true);
+                }
+                return input;
+            };
+        })()(snapshot));
+        const inventory = {
+            schemaVersion: 1,
+            sources: input.files,
+            annotationRanges: [],
+            units: [],
+            addresses: [],
+            hosts: [],
+            declarations: [],
+            reviews: [],
+            dependencies: input.dependencies,
+            complete: input.complete,
+            diagnostics: input.diagnostics.map((diagnostic) => ({
+                code: `source-${diagnostic.code}`,
+                severity: "error",
+                message: diagnostic.message,
+                repair: "Restore every selected DBML source before checking coverage.",
+                location: { file: diagnostic.path },
+            })),
+        };
+        const parser = new EvidenceParser_1.EvidenceParser();
+        try {
+            const records = new Map();
+            for (const source of input.files) {
+                const previous = records.get(source.id);
+                if (previous === undefined)
+                    records.set(source.id, source);
+                else
+                    previous.addresses = InventoryMerge_1.InventoryMerge.sourceAddresses([
+                        ...previous.addresses,
+                        ...source.addresses,
+                    ]);
+            }
+            const sources = Array.from(records.values());
+            const analyses = await Promise.all(sources.map((source) => this.scan(parser, source)));
+            for (const analysis of analyses) {
+                inventory.complete &&= analysis.complete;
+                inventory.diagnostics.push(...analysis.diagnostics);
+                inventory.dependencies.push({
+                    path: analysis.source.physicalPath,
+                    recursive: false,
+                });
+            }
+            // Relation endpoints may use table aliases from another selected file.
+            // Resolve those names before units and their documentation acquire owners.
+            const aliases = this.aliases(inventory, analyses);
+            this.relations(inventory, analyses, aliases);
+            this.units(inventory, analyses, aliases);
+            this.documentation(inventory, analyses);
+            return new EvidenceInventory_1.EvidenceInventory([inventory]).snapshot();
+        }
+        finally {
+            await parser.close();
+        }
+    }
+    /**
+     * Extracts DBML declaration records inside one borrowed parse session.
+     *
+     * Syntax and acquisition failures retain their source range when available and
+     * mark analysis incomplete, rather than contributing a successful empty schema.
+     */
+    async scan(parser, source) {
+        try {
+            return await parser.parse({
+                type: "dbml",
+                file: source.addresses[0]?.relative ?? source.physicalPath,
+                content: source.content,
+            }, (session) => new DbmlFileScanner_1.DbmlFileScanner(session, source).scan());
+        }
+        catch (cause) {
+            const error = cause instanceof EvidenceParserError_1.EvidenceParserError ? cause : undefined;
+            return {
+                source,
+                declarations: [],
+                relations: [],
+                documentation: [],
+                enums: [],
+                complete: false,
+                diagnostics: [
+                    {
+                        code: `dbml-${error?.code ?? "parse-failed"}`,
+                        severity: "error",
+                        message: error?.message ?? String(cause),
+                        repair: "Correct the selected DBML source or add grammar/adapter support before checking coverage.",
+                        location: {
+                            file: source.physicalPath,
+                            ...(error?.range === undefined ? {} : { range: error.range }),
+                        },
+                    },
+                ],
+            };
+        }
+    }
+    /**
+     * Establishes file-independent tables and detects conflicting schema declarations or aliases.
+     *
+     * Relation resolution uses this map after every selected DBML file has been scanned.
+     */
+    aliases(inventory, analyses) {
+        const aliases = new Map();
+        const enums = new Set();
+        for (const analysis of analyses)
+            for (const enumeration of analysis.enums) {
+                const key = JSON.stringify(enumeration.identity);
+                if (enums.has(key))
+                    this.problem(inventory, analysis, "A DBML enum identity has multiple declarations. Select one declaration per schema enum.");
+                enums.add(key);
+            }
+        for (const analysis of analyses)
+            for (const declaration of analysis.declarations.filter((entry) => entry.symbol === "model")) {
+                for (const name of [
+                    declaration.identity,
+                    ...(declaration.alias === undefined
+                        ? []
+                        : [["public", declaration.alias]]),
+                ]) {
+                    const key = JSON.stringify(name);
+                    if (aliases.has(key))
+                        this.problem(inventory, analysis, `DBML table or alias '${name.join(".")}' is declared more than once. Select one unambiguous schema declaration.`);
+                    else
+                        aliases.set(key, declaration.identity);
+                }
+            }
+        return aliases;
+    }
+    /**
+     * Resolves endpoint existence, ordered composite arity, direction, and owning model.
+     *
+     * Resolved relations become semantic declarations before units and hosts are materialized.
+     */
+    relations(inventory, analyses, aliases) {
+        const columns = new Set(analyses.flatMap((analysis) => analysis.declarations
+            .filter((entry) => entry.symbol === "column")
+            .map((entry) => JSON.stringify(entry.identity))));
+        for (const analysis of analyses)
+            for (const relation of analysis.relations) {
+                const from = this.endpoint(inventory, analysis, relation.from, aliases, columns);
+                const to = this.endpoint(inventory, analysis, relation.to, aliases, columns);
+                if (from === undefined || to === undefined)
+                    continue;
+                if (from.columns.length !== to.columns.length) {
+                    this.problem(inventory, analysis, "DBML composite relation endpoints have different column counts. Use corresponding ordered columns on both sides.");
+                    continue;
+                }
+                const owner = relation.cardinality === "<" ||
+                    (relation.cardinality === "-" && !relation.inline)
+                    ? to.table
+                    : from.table;
+                const name = relation.name === undefined
+                    ? `$ref:${JSON.stringify([from.table, from.columns, relation.cardinality, to.table, to.columns])}`
+                    : `$ref:${relation.name}`;
+                const identity = [...owner, name];
+                const key = JSON.stringify(relation.identity);
+                for (const documentation of analysis.documentation)
+                    documentation.owners = documentation.owners.map((entry) => JSON.stringify(entry) === key ? identity : entry);
+                analysis.declarations.push({
+                    identity,
+                    symbol: "relation",
+                    content: relation.content,
+                    range: relation.range,
+                });
+            }
+    }
+    /**
+     * Rejects missing or ambiguous semantic endpoints instead of dropping a relation obligation.
+     *
+     * Returning no endpoint preserves the failure in inventory completeness.
+     */
+    endpoint(inventory, analysis, endpoint, aliases, columns) {
+        const table = aliases.get(JSON.stringify(endpoint.table));
+        if (table === undefined ||
+            endpoint.columns.some((column) => !columns.has(JSON.stringify([...table, column])))) {
+            this.problem(inventory, analysis, `DBML relation endpoint '${[...endpoint.table, ...endpoint.columns].join(".")}' does not resolve to selected table columns. Include its schema source and correct the endpoint.`);
+            return undefined;
+        }
+        if (new Set(endpoint.columns).size !== endpoint.columns.length) {
+            this.problem(inventory, analysis, "A DBML composite relation endpoint repeats a column. Use each endpoint column once.");
+            return undefined;
+        }
+        return { table, columns: endpoint.columns };
+    }
+    /**
+     * Publishes one semantic identity and each declaration's physical file address.
+     *
+     * Aliased schema declarations can therefore share a unit while retaining their source sites.
+     */
+    units(inventory, analyses, aliases) {
+        const seen = new Set();
+        const enums = analyses
+            .flatMap((analysis) => analysis.enums.map((enumeration) => enumeration.content))
+            .sort(InventoryMerge_1.InventoryMerge.compare)
+            .join("\n");
+        for (const analysis of analyses)
+            for (const declaration of analysis.declarations) {
+                const id = this.id(declaration.identity);
+                if (seen.has(id)) {
+                    this.problem(inventory, analysis, `DBML identity '${declaration.identity.join(".")}' has multiple declarations. Rename duplicate columns/relations or select one schema declaration.`);
+                    continue;
+                }
+                seen.add(id);
+                const siteId = `dbml:site:${analysis.source.id}:${declaration.range.start.offset}`;
+                inventory.units.push({
+                    id,
+                    type: "dbml",
+                    symbol: declaration.symbol,
+                    identity: declaration.identity,
+                    name: declaration.identity.join("."),
+                    ...(declaration.symbol === "model"
+                        ? {}
+                        : { parentId: this.id(declaration.identity.slice(0, 2)) }),
+                    contentDigest: this.digest(declaration, enums),
+                    sites: [
+                        {
+                            id: siteId,
+                            file: analysis.source.physicalPath,
+                            range: declaration.range,
+                            content: [declaration.range],
+                        },
+                    ],
+                    withdrawals: [],
+                });
+                const table = declaration.identity.slice(0, 2);
+                const names = [declaration.identity];
+                if (table[0] === "public")
+                    names.push(declaration.identity.slice(1));
+                for (const [key, target] of aliases)
+                    if (JSON.stringify(target) === JSON.stringify(table)) {
+                        const name = (() => {
+                            const __is = input => Array.isArray(input) && input.every(elem => "string" === typeof elem);
+                            let _errorFactory;
+                            const __assert = (input, errorFactory) => {
+                                if (false === __is(input)) {
+                                    _errorFactory = errorFactory;
+                                    ((input, _path, _exceptionable = true) => (Array.isArray(input) || _assertGuard_1._assertGuard(true, {
+                                        method: "typia.json.assertParse",
+                                        path: _path + "",
+                                        expected: "Array<string>",
+                                        value: input
+                                    }, _errorFactory)) && input.every((elem, _index2) => "string" === typeof elem || _assertGuard_1._assertGuard(true, {
+                                        method: "typia.json.assertParse",
+                                        path: _path + "[" + _index2 + "]",
+                                        expected: "string",
+                                        value: elem
+                                    }, _errorFactory)) || _assertGuard_1._assertGuard(true, {
+                                        method: "typia.json.assertParse",
+                                        path: _path + "",
+                                        expected: "Array<string>",
+                                        value: input
+                                    }, _errorFactory))(input, "$input", true);
+                                }
+                                return input;
+                            };
+                            return (input, errorFactory) => __assert(JSON.parse(input), errorFactory);
+                        })()(key);
+                        if (JSON.stringify(name) !== JSON.stringify(table))
+                            names.push([name[1] ?? "", ...declaration.identity.slice(2)]);
+                    }
+                for (const address of analysis.source.addresses)
+                    for (const segments of names)
+                        inventory.addresses.push({
+                            unitId: id,
+                            file: address.absolute,
+                            segments,
+                        });
+            }
+    }
+    /**
+     * Hashes semantic declaration text and enum dependencies without documentation syntax.
+     *
+     * Review fingerprints change for schema behavior, not annotation prose.
+     */
+    digest(declaration, enums) {
+        return (0, node_crypto_1.createHash)("sha256")
+            .update((declaration.content + "\n" + enums).replace(/\r\n/gu, "\n"))
+            .digest("hex");
+    }
+    /**
+     * Applies withdrawals first, then retains every visible documented or undocumented host.
+     *
+     * Hidden declarations must not create hosts that can satisfy graph obligations.
+     */
+    documentation(inventory, analyses) {
+        const units = new Map(inventory.units.map((unit) => [unit.id, unit]));
+        for (const analysis of analyses)
+            for (const documentation of analysis.documentation) {
+                const host = this.host(analysis, documentation, units);
+                const parsed = this.parse(analysis, documentation, host);
+                inventory.annotationRanges.push({
+                    file: analysis.source.physicalPath,
+                    range: documentation.annotationRange,
+                });
+                for (const id of host.unitIds) {
+                    const unit = units.get(id);
+                    if (unit !== undefined)
+                        unit.withdrawals.push(...parsed.withdrawals);
+                }
+            }
+        const hidden = new Set(inventory.units
+            .filter((unit) => unit.withdrawals.length !== 0 ||
+            (unit.parentId !== undefined &&
+                (units.get(unit.parentId)?.withdrawals?.length ?? 0) !== 0))
+            .map((unit) => unit.id));
+        const documented = new Set();
+        for (const analysis of analyses)
+            for (const documentation of analysis.documentation) {
+                const host = this.host(analysis, documentation, units);
+                host.unitIds = host.unitIds.filter((id) => !hidden.has(id));
+                if (host.unitIds.length === 0) {
+                    host.attachment = "unsupported";
+                    delete host.siteId;
+                    host.problem =
+                        "Move the annotation to a visible DBML table, column or relation documentation host.";
+                }
+                const parsed = this.parse(analysis, documentation, host);
+                if (host.unitIds.length === 0 &&
+                    parsed.declarations.length === 0 &&
+                    parsed.reviews.length === 0 &&
+                    parsed.diagnostics.length === 0)
+                    continue;
+                inventory.hosts.push(host);
+                for (const id of host.unitIds)
+                    documented.add(`${id}:${host.siteId ?? ""}`);
+                inventory.declarations.push(...parsed.declarations);
+                inventory.reviews.push(...parsed.reviews);
+                inventory.diagnostics.push(...parsed.diagnostics);
+            }
+        for (const unit of inventory.units)
+            for (const site of unit.sites)
+                if (!hidden.has(unit.id) && !documented.has(`${unit.id}:${site.id}`))
+                    inventory.hosts.push({
+                        id: `${site.id}:host`,
+                        file: site.file,
+                        range: site.range,
+                        siteId: site.id,
+                        unitIds: [unit.id],
+                        attachment: "attached",
+                    });
+    }
+    /**
+     * Creates a source-mapped carrier sharing one declaration site for inline column relations.
+     *
+     * The shared site lets one DBML note acknowledge the column and its inline relation.
+     */
+    host(analysis, documentation, units) {
+        const owners = documentation.owners
+            .map((identity) => units.get(this.id(identity)))
+            .filter((unit) => unit !== undefined);
+        const first = owners[0];
+        const site = first === undefined
+            ? undefined
+            : first.sites.find((candidate) => candidate.file === analysis.source.physicalPath);
+        return {
+            id: `dbml:${analysis.source.id}:documentation:${documentation.range.start.offset}`,
+            file: analysis.source.physicalPath,
+            range: documentation.range,
+            origins: analysis.source.addresses.map((address) => address.absolute),
+            unitIds: owners.map((unit) => unit.id),
+            attachment: site === undefined ? "unsupported" : "attached",
+            ...(site === undefined
+                ? {
+                    problem: "Attach DBML annotations to supported table, column or relation documentation.",
+                }
+                : { siteId: site.id }),
+        };
+    }
+    /**
+     * Parses notes and comments only after structural ownership is known.
+     *
+     * Tag parsing needs the resolved unit IDs and attachment status of each carrier.
+     */
+    parse(analysis, documentation, host) {
+        return EvidenceTagParser_1.EvidenceTagParser.parse(analysis.source.content, host, DbmlDocumentation_1.DbmlDocumentation.read(analysis.source.content, host.id, documentation));
+    }
+    /**
+     * Encodes literal schema segments without conflating punctuation or file placement.
+     *
+     * JSON serialization preserves a stable unit key for segments containing dots or separators.
+     */
+    id(identity) {
+        return `dbml:${JSON.stringify(identity)}`;
+    }
+    /**
+     * Preserves missing schema facts as actionable incomplete analysis.
+     *
+     * The diagnostic prevents unresolved DBML declarations from silently shrinking coverage.
+     */
+    problem(inventory, analysis, message) {
+        inventory.complete = false;
+        inventory.diagnostics.push({
+            code: "dbml-schema-incomplete",
+            severity: "error",
+            message,
+            repair: "Correct conflicting declarations or include every referenced DBML schema source.",
+            location: { file: analysis.source.physicalPath },
+        });
+    }
+}
+exports.EvidenceDbmlAdapter = EvidenceDbmlAdapter;