@wrtnlabs/evidence 0.0.0 → 0.1.0

package/lib/adapters/dbml/EvidenceDbmlAdapter.js

@@ -40,40 +40,46 @@ 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 EvidenceInventoryMerge_1 = require("../../internal/EvidenceInventoryMerge");
 const EvidenceInventory_1 = require("../../graph/EvidenceInventory");
-const DbmlDocumentation_1 = require("./DbmlDocumentation");
+const EvidenceDbmlDocumentation_1 = require("./EvidenceDbmlDocumentation");
 const EvidenceParser_1 = require("../../parsers/EvidenceParser");
 const EvidenceParserError_1 = require("../../parsers/EvidenceParserError");
 const EvidenceTagParser_1 = require("../../parsers/EvidenceTagParser");
-const DbmlFileScanner_1 = require("./DbmlFileScanner");
+const EvidenceDbmlFileScanner_1 = require("./EvidenceDbmlFileScanner");
 /**
  * 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.
+ * 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.
+     * Claims and references use this value to apply the adapter's database
+     * selectors.
      */
-    type = "dbml";
+    get type() {
+        return "dbml";
+    }
     /**
-     * Builds a normalized DBML inventory from a validated, cloned source snapshot.
+     * 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.
+     * 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 _ip2 = input => "string" === typeof input["physicalPath"];
+            const _ip3 = input => "string" === typeof input["fingerprintPath"];
+            const _ip4 = 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",
@@ -86,7 +92,19 @@ class EvidenceDbmlAdapter {
                 expected: "string",
                 value: input["display"]
             }, _errorFactory);
-            const _ap2 = (input, _path, _exceptionable = true) => "string" === typeof input["path"] || _assertGuard_1._assertGuard(_exceptionable, {
+            const _ap2 = (input, _path, _exceptionable = true) => "string" === typeof input["physicalPath"] || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".physicalPath",
+                expected: "string",
+                value: input["physicalPath"]
+            }, _errorFactory);
+            const _ap3 = (input, _path, _exceptionable = true) => "string" === typeof input["fingerprintPath"] || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".fingerprintPath",
+                expected: "string",
+                value: input["fingerprintPath"]
+            }, _errorFactory);
+            const _ap4 = (input, _path, _exceptionable = true) => "string" === typeof input["path"] || _assertGuard_1._assertGuard(_exceptionable, {
                 method: "typia.assert",
                 path: _path + ".path",
                 expected: "string",
@@ -133,7 +151,7 @@ class EvidenceDbmlAdapter {
                 path: _path + ".dependencies[" + _index6 + "]",
                 expected: "IEvidenceSourceDependency",
                 value: elem
-            }, _errorFactory)) && _ao4(elem, _path + ".dependencies[" + _index6 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+            }, _errorFactory)) && _ao5(elem, _path + ".dependencies[" + _index6 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
                 method: "typia.assert",
                 path: _path + ".dependencies[" + _index6 + "]",
                 expected: "IEvidenceSourceDependency",
@@ -153,7 +171,7 @@ class EvidenceDbmlAdapter {
                 path: _path + ".diagnostics[" + _index7 + "]",
                 expected: "IEvidenceSourceDiagnostic",
                 value: elem
-            }, _errorFactory)) && _ao5(elem, _path + ".diagnostics[" + _index7 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+            }, _errorFactory)) && _ao6(elem, _path + ".diagnostics[" + _index7 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
                 method: "typia.assert",
                 path: _path + ".diagnostics[" + _index7 + "]",
                 expected: "IEvidenceSourceDiagnostic",
@@ -185,11 +203,16 @@ class EvidenceDbmlAdapter {
                 path: _path + ".id",
                 expected: "string",
                 value: input.id
-            }, _errorFactory)) && ("string" === typeof input.physicalPath || _assertGuard_1._assertGuard(_exceptionable, {
+            }, _errorFactory)) && _ap2(input, _path, true && _exceptionable) && _ap3(input, _path, true && _exceptionable) && (undefined === input.fingerprintRoot || ("object" === typeof input.fingerprintRoot && null !== input.fingerprintRoot || _assertGuard_1._assertGuard(_exceptionable, {
                 method: "typia.assert",
-                path: _path + ".physicalPath",
-                expected: "string",
-                value: input.physicalPath
+                path: _path + ".fingerprintRoot",
+                expected: "(IEvidenceSourceFingerprintRoot | undefined)",
+                value: input.fingerprintRoot
+            }, _errorFactory)) && _ao3(input.fingerprintRoot, _path + ".fingerprintRoot", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+                method: "typia.assert",
+                path: _path + ".fingerprintRoot",
+                expected: "(IEvidenceSourceFingerprintRoot | undefined)",
+                value: input.fingerprintRoot
             }, _errorFactory)) && ("string" === typeof input.content || _assertGuard_1._assertGuard(_exceptionable, {
                 method: "typia.assert",
                 path: _path + ".content",
@@ -210,7 +233,7 @@ class EvidenceDbmlAdapter {
                 path: _path + ".addresses[" + _index8 + "]",
                 expected: "IEvidenceSourceAddress",
                 value: elem
-            }, _errorFactory)) && _ao3(elem, _path + ".addresses[" + _index8 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+            }, _errorFactory)) && _ao4(elem, _path + ".addresses[" + _index8 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
                 method: "typia.assert",
                 path: _path + ".addresses[" + _index8 + "]",
                 expected: "IEvidenceSourceAddress",
@@ -221,7 +244,8 @@ class EvidenceDbmlAdapter {
                 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, {
+            const _ao3 = (input, _path, _exceptionable = true) => _ap2(input, _path, true && _exceptionable) && _ap3(input, _path, true && _exceptionable);
+            const _ao4 = (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",
@@ -232,29 +256,30 @@ class EvidenceDbmlAdapter {
                 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, {
+            const _ao5 = (input, _path, _exceptionable = true) => _ap4(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, {
+            const _ao6 = (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, {
+            }, _errorFactory)) && _ap4(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 _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 && _io5(elem))) && (Array.isArray(input.diagnostics) && input.diagnostics.every(elem => "object" === typeof elem && null !== elem && _io6(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 _io2 = input => "string" === typeof input.id && _ip2(input) && _ip3(input) && (undefined === input.fingerprintRoot || "object" === typeof input.fingerprintRoot && null !== input.fingerprintRoot && _io3(input.fingerprintRoot)) && "string" === typeof input.content && "string" === typeof input.digest && (Array.isArray(input.addresses) && input.addresses.every(elem => "object" === typeof elem && null !== elem && _io4(elem)));
+            const _io3 = input => _ip2(input) && _ip3(input);
+            const _io4 = input => _ip0(input) && "string" === typeof input.relative && _ip1(input) && (undefined === input.selected || "boolean" === typeof input.selected);
+            const _io5 = input => _ip4(input) && "boolean" === typeof input.recursive;
+            const _io6 = 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) && _ip4(input) && "string" === typeof input.message;
             const __is = input => "object" === typeof input && null !== input && _io0(input);
             let _errorFactory;
             return (input, errorFactory) => {
@@ -302,7 +327,7 @@ class EvidenceDbmlAdapter {
                 if (previous === undefined)
                     records.set(source.id, source);
                 else
-                    previous.addresses = InventoryMerge_1.InventoryMerge.sourceAddresses([
+                    previous.addresses = EvidenceInventoryMerge_1.EvidenceInventoryMerge.sourceAddresses([
                         ...previous.addresses,
                         ...source.addresses,
                     ]);
@@ -332,8 +357,9 @@ class EvidenceDbmlAdapter {
     /**
      * 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.
+     * 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 {
@@ -341,7 +367,7 @@ class EvidenceDbmlAdapter {
                 type: "dbml",
                 file: source.addresses[0]?.relative ?? source.physicalPath,
                 content: source.content,
-            }, (session) => new DbmlFileScanner_1.DbmlFileScanner(session, source).scan());
+            }, (session) => new EvidenceDbmlFileScanner_1.EvidenceDbmlFileScanner(session, source).scan());
         }
         catch (cause) {
             const error = cause instanceof EvidenceParserError_1.EvidenceParserError ? cause : undefined;
@@ -368,9 +394,11 @@ class EvidenceDbmlAdapter {
         }
     }
     /**
-     * Establishes file-independent tables and detects conflicting schema declarations or aliases.
+     * Establishes file-independent tables and detects conflicting schema
+     * declarations or aliases.
      *
-     * Relation resolution uses this map after every selected DBML file has been scanned.
+     * Relation resolution uses this map after every selected DBML file has been
+     * scanned.
      */
     aliases(inventory, analyses) {
         const aliases = new Map();
@@ -400,9 +428,11 @@ class EvidenceDbmlAdapter {
         return aliases;
     }
     /**
-     * Resolves endpoint existence, ordered composite arity, direction, and owning model.
+     * Resolves endpoint existence, ordered composite arity, direction, and owning
+     * model.
      *
-     * Resolved relations become semantic declarations before units and hosts are materialized.
+     * Resolved relations become semantic declarations before units and hosts are
+     * materialized.
      */
     relations(inventory, analyses, aliases) {
         const columns = new Set(analyses.flatMap((analysis) => analysis.declarations
@@ -438,7 +468,8 @@ class EvidenceDbmlAdapter {
             }
     }
     /**
-     * Rejects missing or ambiguous semantic endpoints instead of dropping a relation obligation.
+     * Rejects missing or ambiguous semantic endpoints instead of dropping a
+     * relation obligation.
      *
      * Returning no endpoint preserves the failure in inventory completeness.
      */
@@ -456,15 +487,17 @@ class EvidenceDbmlAdapter {
         return { table, columns: endpoint.columns };
     }
     /**
-     * Publishes one semantic identity and each declaration's physical file address.
+     * Publishes one semantic identity and each declaration's physical file
+     * address.
      *
-     * Aliased schema declarations can therefore share a unit while retaining their source sites.
+     * 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)
+            .sort(EvidenceInventoryMerge_1.EvidenceInventoryMerge.compare)
             .join("\n");
         for (const analysis of analyses)
             for (const declaration of analysis.declarations) {
@@ -541,7 +574,8 @@ class EvidenceDbmlAdapter {
             }
     }
     /**
-     * Hashes semantic declaration text and enum dependencies without documentation syntax.
+     * Hashes semantic declaration text and enum dependencies without
+     * documentation syntax.
      *
      * Review fingerprints change for schema behavior, not annotation prose.
      */
@@ -551,9 +585,11 @@ class EvidenceDbmlAdapter {
             .digest("hex");
     }
     /**
-     * Applies withdrawals first, then retains every visible documented or undocumented host.
+     * Applies withdrawals first, then retains every visible documented or
+     * undocumented host.
      *
-     * Hidden declarations must not create hosts that can satisfy graph obligations.
+     * 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]));
@@ -613,9 +649,11 @@ class EvidenceDbmlAdapter {
                     });
     }
     /**
-     * Creates a source-mapped carrier sharing one declaration site for inline column relations.
+     * 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.
+     * The shared site lets one DBML note acknowledge the column and its inline
+     * relation.
      */
     host(analysis, documentation, units) {
         const owners = documentation.owners
@@ -642,15 +680,18 @@ class EvidenceDbmlAdapter {
     /**
      * Parses notes and comments only after structural ownership is known.
      *
-     * Tag parsing needs the resolved unit IDs and attachment status of each carrier.
+     * 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));
+        return EvidenceTagParser_1.EvidenceTagParser.parse(analysis.source.content, host, EvidenceDbmlDocumentation_1.EvidenceDbmlDocumentation.read(analysis.source.content, host.id, documentation));
     }
     /**
-     * Encodes literal schema segments without conflating punctuation or file placement.
+     * Encodes literal schema segments without conflating punctuation or file
+     * placement.
      *
-     * JSON serialization preserves a stable unit key for segments containing dots or separators.
+     * JSON serialization preserves a stable unit key for segments containing dots
+     * or separators.
      */
     id(identity) {
         return `dbml:${JSON.stringify(identity)}`;
@@ -658,7 +699,8 @@ class EvidenceDbmlAdapter {
     /**
      * Preserves missing schema facts as actionable incomplete analysis.
      *
-     * The diagnostic prevents unresolved DBML declarations from silently shrinking coverage.
+     * The diagnostic prevents unresolved DBML declarations from silently
+     * shrinking coverage.
      */
     problem(inventory, analysis, message) {
         inventory.complete = false;

package/lib/adapters/dbml/EvidenceDbmlDocumentation.d.ts

@@ -0,0 +1,19 @@
+import type { IEvidenceDocumentation } from "../../structures/IEvidenceDocumentation";
+import type { IEvidenceDbmlDocumentation } from "./IEvidenceDbmlDocumentation";
+/**
+ * Decodes DBML note escapes without losing original UTF-16 annotation
+ * positions.
+ *
+ * The adapter uses mapped positions to attach Evidence tags to original source
+ * text.
+ */
+export declare namespace EvidenceDbmlDocumentation {
+    /**
+     * Reads established comment or note ownership and preserves mapped decoded
+     * characters.
+     *
+     * Callers provide a scanner-created carrier after structural ownership is
+     * known.
+     */
+    function read(content: string, hostId: string, documentation: IEvidenceDbmlDocumentation): IEvidenceDocumentation;
+}

package/lib/adapters/dbml/EvidenceDbmlDocumentation.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EvidenceDbmlDocumentation = void 0;
+const EvidenceDocumentation_1 = require("../../parsers/EvidenceDocumentation");
+/**
+ * Decodes DBML note escapes without losing original UTF-16 annotation
+ * positions.
+ *
+ * The adapter uses mapped positions to attach Evidence tags to original source
+ * text.
+ */
+var EvidenceDbmlDocumentation;
+(function (EvidenceDbmlDocumentation) {
+    /**
+     * Reads established comment or note ownership and preserves mapped decoded
+     * characters.
+     *
+     * Callers provide a scanner-created carrier after structural ownership is
+     * known.
+     */
+    function read(content, hostId, documentation) {
+        const parsed = EvidenceDocumentation_1.EvidenceDocumentation.read(content, hostId, documentation.range, documentation.syntax);
+        if (!documentation.syntax.opening.startsWith("'"))
+            return parsed;
+        const offsets = [];
+        const ends = [];
+        let text = "";
+        for (let index = 0; index < parsed.text.length; ++index) {
+            let character = parsed.text[index] ?? "";
+            const start = parsed.offsets[index];
+            if (character === "\\" && index + 1 < parsed.text.length) {
+                character = parsed.text[++index] ?? "";
+                character =
+                    character === "n"
+                        ? "\n"
+                        : character === "r"
+                            ? "\r"
+                            : character === "t"
+                                ? "\t"
+                                : character;
+            }
+            const end = parsed.ends[index];
+            if (start === undefined || end === undefined)
+                throw new Error("A DBML note lost its original source mapping.");
+            text += character;
+            offsets.push(start);
+            ends.push(end);
+        }
+        offsets.push(parsed.offsets.at(-1) ?? documentation.range.end.offset);
+        return { ...parsed, text, offsets, ends };
+    }
+    EvidenceDbmlDocumentation.read = read;
+})(EvidenceDbmlDocumentation || (exports.EvidenceDbmlDocumentation = EvidenceDbmlDocumentation = {}));

package/lib/adapters/dbml/EvidenceDbmlFileScanner.d.ts

@@ -0,0 +1,131 @@
+import type { EvidenceParseSession } from "../../parsers/EvidenceParseSession";
+import type { IEvidenceSourceFile } from "../../structures/IEvidenceSourceFile";
+import type { IEvidenceDbmlFileAnalysis } from "./IEvidenceDbmlFileAnalysis";
+/**
+ * Extracts DBML schema facts from audited structural parser nodes.
+ *
+ * It records unsupported syntax as incomplete so selection cannot silently omit
+ * declarations the adapter does not understand.
+ */
+export declare class EvidenceDbmlFileScanner {
+    private readonly session;
+    /**
+     * Accumulates the serializable analysis for this source file.
+     *
+     * Later adapter stages resolve its relations, enum dependencies, and
+     * documentation carriers.
+     */
+    private readonly output;
+    /**
+     * Maps parser-node offsets to declaration identities they own.
+     *
+     * Notes and comments use this map to attach only at the matching syntax
+     * level.
+     */
+    private readonly owners;
+    /**
+     * Tracks line comments already included in a contiguous documentation
+     * carrier.
+     *
+     * Each comment can contribute to at most one attachment run.
+     */
+    private readonly comments;
+    /**
+     * Binds the parsed DBML session and its immutable source snapshot.
+     *
+     * Parser nodes are used only during extraction; the returned result contains
+     * serializable facts.
+     */
+    constructor(session: EvidenceParseSession, source: IEvidenceSourceFile);
+    /**
+     * Extracts top-level DBML constructs and their documentation attachments.
+     *
+     * A complete result contains every recognized declaration and explicit
+     * unsupported-syntax diagnostic.
+     */
+    scan(): IEvidenceDbmlFileAnalysis;
+    /**
+     * Retains enum semantic dependencies and validates their members.
+     *
+     * Duplicate values make the declared schema ambiguous for dependent
+     * fingerprints.
+     */
+    private enumeration;
+    /**
+     * Publishes a table and scalar columns directly owned by it.
+     *
+     * Nested constructs are handled separately so each declaration has an
+     * unambiguous owner.
+     */
+    private table;
+    /**
+     * Retains relation endpoints until selected-schema declarations are
+     * available.
+     *
+     * Cross-file resolution occurs after every DBML source has been scanned.
+     */
+    private relation;
+    /**
+     * Reads literal endpoint segments without resolving semantic existence.
+     *
+     * Deferring lookup permits relations between declarations in separate source
+     * files.
+     */
+    private endpoint;
+    /**
+     * Builds a table identity while applying DBML's implicit public schema.
+     *
+     * Literal identifier dots remain part of their quoted segments rather than
+     * path separators.
+     */
+    private tableName;
+    /**
+     * Decodes quoted identifiers without altering their case or punctuation.
+     *
+     * Literal spelling is required to preserve the DBML identity used by
+     * resolution.
+     */
+    private identifier;
+    /**
+     * Attaches adjacent comments only to a recognized declaration at the same
+     * level.
+     *
+     * This prevents comments inside nested syntax from documenting an enclosing
+     * declaration.
+     */
+    private comment;
+    /**
+     * Distinguishes trailing comments from leading documentation runs.
+     *
+     * A comment must start on otherwise blank text before it can attach forward.
+     */
+    private standalone;
+    /**
+     * Checks that a documentation run reaches its next declaration without a
+     * blank line.
+     *
+     * Separation means the comment has no unambiguous declaration owner.
+     */
+    private adjacent;
+    /**
+     * Attaches supported table and column notes to their owners.
+     *
+     * Notes on enums, indexes, and projects remain explicit unsupported
+     * annotation carriers.
+     */
+    private note;
+    /**
+     * Serializes enum semantics without including annotations.
+     *
+     * Documentation acknowledges declarations but does not change the enum
+     * fingerprint.
+     */
+    private semantic;
+    /**
+     * Marks unsupported source as incomplete and records a repairable diagnostic.
+     *
+     * The failure protects coverage from passing against a reduced obligation
+     * set.
+     */
+    private problem;
+}