@wrtnlabs/evidence 0.0.0

package/lib/adapters/scala/ScalaFileScanner.js

@@ -0,0 +1,434 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScalaFileScanner = void 0;
+/**
+ * Extracts explicit Scala 2/3 declarations while retaining unsupported surface boundaries.
+ *
+ * The scanner records lexical declarations and explicit exports separately so
+ * a later snapshot-wide pass can resolve singleton forwarding without inventing aliases.
+ */
+class ScalaFileScanner {
+    session;
+    source;
+    /**
+     * Collects declaration records that remain valid after parsing closes.
+     *
+     * Each record retains source ranges and lexical ownership without holding a Tree-sitter node.
+     */
+    declarations = [];
+    /**
+     * Indexes Scaladoc and unsupported tag carriers by their original source offset.
+     *
+     * The offset permits adjacent declaration attachment without reparsing the carrier text.
+     */
+    documentation = new Map();
+    /**
+     * Collects explicit exports for resolution after every selected file is scanned.
+     *
+     * Deferring resolution lets a forwarding file find declarations from other selected sources.
+     */
+    exports = [];
+    /**
+     * Collects public-surface failures that prevent a passing smaller inventory.
+     *
+     * The returned analysis uses these diagnostics to mark extraction incomplete.
+     */
+    diagnostics = [];
+    /**
+     * Borrows syntax only during the common parser callback.
+     *
+     * Source identity and ranges are copied into the returned analysis because
+     * export resolution begins only after parser sessions have closed.
+     */
+    constructor(session, source) {
+        this.session = session;
+        this.source = source;
+    }
+    /**
+     * Produces a serializable inventory fragment.
+     *
+     * Documentation is collected first, then scopes are traversed without entering
+     * executable bodies, preserving source attachment and public-boundary semantics.
+     */
+    scan() {
+        this.collectDocumentation();
+        this.scope(this.session.root.namedChildren, [], undefined);
+        return {
+            source: this.source,
+            declarations: this.declarations,
+            documentation: [...this.documentation.values()],
+            exports: this.exports,
+            diagnostics: this.diagnostics,
+            complete: this.diagnostics.length === 0,
+        };
+    }
+    /**
+     * Walks declaration scopes without descending into executable bodies or local definitions.
+     *
+     * Package clauses extend the current namespace, while nested declaration bodies establish lexical owners.
+     */
+    scope(nodes, namespace, owner) {
+        let current = namespace;
+        for (const node of nodes) {
+            if (node.type === "package_clause") {
+                const name = node.childForFieldName("name");
+                const parts = name === null
+                    ? []
+                    : name.namedChildren.map((part) => this.name(part));
+                const body = node.childForFieldName("body");
+                if (body === null)
+                    current = [...current, ...parts];
+                else
+                    this.scope(body.namedChildren, [...current, ...parts], owner);
+            }
+            else
+                this.visit(node, current, owner);
+        }
+    }
+    /**
+     * Selects supported source declarations and their explicit lexical children.
+     *
+     * Unsupported public declaration forms are reported as incomplete instead of being guessed from syntax.
+     */
+    visit(node, namespace, owner) {
+        if ([
+            "class_definition",
+            "trait_definition",
+            "object_definition",
+            "enum_definition",
+            "package_object",
+        ].includes(node.type)) {
+            const declaration = this.declare(node, node.childForFieldName("name"), "type", namespace, owner);
+            if (declaration === undefined)
+                return;
+            if (node.childForFieldName("derive") !== null && declaration.public)
+                this.problem("derived-members", "Derives and uses clauses require generated-member resolution.", node);
+            const parameterLists = node.childrenForFieldName("class_parameters");
+            for (const [index, list] of parameterLists.entries())
+                for (const parameter of list.namedChildren.filter((child) => child.type === "class_parameter"))
+                    if (parameter.children.some((child) => child.text === "val" || child.text === "var") ||
+                        (index === 0 &&
+                            node.children.some((child) => child.text === "case")))
+                        this.declare(parameter, parameter.childForFieldName("name"), "property", namespace, declaration);
+                    else
+                        this.declare(parameter, parameter.childForFieldName("name"), "property", namespace, { ...declaration, public: false });
+            for (const body of node.childrenForFieldName("body"))
+                this.scope(body.namedChildren, namespace, declaration);
+            return;
+        }
+        if (["function_definition", "function_declaration"].includes(node.type)) {
+            const name = node.childForFieldName("name");
+            if (name?.text === "this")
+                return;
+            this.declare(node, name, "function", namespace, owner);
+            return;
+        }
+        if (node.type === "type_definition") {
+            this.declare(node, node.childForFieldName("name"), "type", namespace, owner);
+            return;
+        }
+        if ([
+            "val_definition",
+            "var_definition",
+            "val_declaration",
+            "var_declaration",
+        ].includes(node.type)) {
+            const pattern = node.childForFieldName("pattern") ?? node.childForFieldName("name");
+            if (pattern === null)
+                this.problem("binding-pattern", "A value declaration has no static binding name.", node);
+            else
+                for (const name of this.bindings(pattern, node, owner))
+                    this.declare(node, name, "property", namespace, owner);
+            return;
+        }
+        if (node.type === "given_definition") {
+            const declaration = this.declare(node, node.childForFieldName("name"), "property", namespace, owner);
+            if (declaration === undefined)
+                return;
+            for (const body of node.childrenForFieldName("body"))
+                if (["template_body", "with_template_body"].includes(body.type))
+                    this.scope(body.namedChildren, namespace, declaration);
+            return;
+        }
+        if (node.type === "extension_definition") {
+            const before = this.declarations.length;
+            this.scope(node.childrenForFieldName("body").filter((child) => child.isNamed), namespace, owner);
+            for (const declaration of this.declarations.slice(before)) {
+                if (declaration.ownerDeclarationId !== owner?.id)
+                    continue;
+                const header = {
+                    start: this.session.range(node).start,
+                    end: this.session.range(node.childrenForFieldName("body")[0] ?? node)
+                        .start,
+                };
+                declaration.site.range = {
+                    start: header.start,
+                    end: declaration.site.range.end,
+                };
+                declaration.site.content = [header, ...declaration.site.content];
+                this.attach(node, declaration);
+            }
+            return;
+        }
+        if (node.type === "enum_case_definitions") {
+            for (const child of node.namedChildren.filter((part) => ["simple_enum_case", "full_enum_case"].includes(part.type))) {
+                const name = child.childForFieldName("name") ??
+                    child.namedChildren.find((part) => part.type === "identifier") ??
+                    null;
+                const full = child.namedChildren.some((part) => part.type === "class_parameters");
+                const declaration = this.declare(child, name, full ? "type" : "property", namespace, owner);
+                if (declaration === undefined)
+                    continue;
+                this.attach(node, declaration);
+                if (full)
+                    for (const list of child.namedChildren.filter((part) => part.type === "class_parameters"))
+                        for (const parameter of list.namedChildren.filter((part) => part.type === "class_parameter"))
+                            this.declare(parameter, parameter.childForFieldName("name"), "property", namespace, declaration);
+            }
+            return;
+        }
+        if (node.type === "export_declaration") {
+            this.export(node, namespace, owner);
+            return;
+        }
+        if ([
+            "comment",
+            "block_comment",
+            "import_declaration",
+            "end_marker",
+            "self_type",
+        ].includes(node.type))
+            return;
+        if (owner?.public !== false &&
+            (node.type.endsWith("_definition") || node.type.endsWith("_declaration")))
+            this.problem("unsupported-declaration", `Unsupported public Scala declaration '${node.type}'.`, node);
+    }
+    /**
+     * Retains only statically bound value names from a Scala binding pattern.
+     *
+     * Identifiers, tuple patterns, and multi-name patterns expand into declarations; visible extractor or typed patterns report a boundary.
+     */
+    bindings(pattern, node, owner) {
+        if (["identifier", "operator_identifier"].includes(pattern.type))
+            return pattern.text === "_" ? [] : [pattern];
+        if (["identifiers", "tuple_pattern"].includes(pattern.type))
+            return pattern.namedChildren.flatMap((child) => this.bindings(child, node, owner));
+        if (pattern.type === "wildcard")
+            return [];
+        if (this.visible(node, owner))
+            this.problem("binding-pattern", "Extractor and typed binding patterns require binding and stable-name resolution.", node);
+        return [];
+    }
+    /**
+     * Creates one lexical declaration without synthesizing runtime or compiler members.
+     *
+     * The record captures visibility, address, lookup path, source site, and unsupported semantic boundaries for later publication.
+     */
+    declare(node, nameNode, symbol, namespace, owner, rename) {
+        const visible = this.visible(node, owner);
+        if (nameNode === null) {
+            if (visible)
+                this.problem("anonymous-given", "Anonymous givens require compiler-assigned names. Give the instance an explicit source name before addressing it.", node);
+            return undefined;
+        }
+        const name = rename ?? this.name(nameNode);
+        const object = node.type === "object_definition";
+        const segment = object
+            ? `object ${name}`
+            : node.type === "package_object"
+                ? `package object ${name}`
+                : name;
+        const address = [...(owner?.address ?? namespace), segment];
+        const range = this.session.range(node);
+        const siteId = `scala:${this.source.id}:site:${node.startIndex}:${node.endIndex}`;
+        const declaration = {
+            id: `${siteId}:${symbol}:${name}`,
+            name,
+            symbol,
+            identity: address,
+            address,
+            lookup: [...(owner?.lookup ?? namespace), name],
+            public: visible,
+            object,
+            syntax: node.type,
+            site: {
+                id: siteId,
+                file: this.source.physicalPath,
+                range,
+                content: [range],
+            },
+            ...(owner === undefined ? {} : { ownerDeclarationId: owner.id }),
+        };
+        if (visible && node.descendantsOfType("macro_body").length !== 0)
+            this.problem("macro", "Macro expansion is outside the explicit Scala source surface.", node);
+        if (visible &&
+            ["type", "return_type"].some((field) => {
+                const type = node.childForFieldName(field);
+                return (type !== null &&
+                    (type.type === "structural_type" ||
+                        type.descendantsOfType("structural_type").length !== 0));
+            }))
+            this.problem("structural-type", "Structural member types require explicit member ownership resolution.", node);
+        const value = node.childForFieldName("value");
+        if (visible &&
+            value !== null &&
+            value.descendantsOfType("template_body").length !== 0)
+            this.problem("anonymous-members", "Anonymous initializer members require inferred public type resolution.", node);
+        this.declarations.push(declaration);
+        this.attach(node, declaration);
+        return declaration;
+    }
+    /**
+     * Determines whether a declaration is publicly visible through its lexical chain.
+     *
+     * Any private or protected modifier, or a restricted owner, excludes the declaration from the public population.
+     */
+    visible(node, owner) {
+        const modifiers = node.namedChildren.find((child) => child.type === "modifiers");
+        return (owner?.public !== false &&
+            (modifiers === undefined ||
+                modifiers.descendantsOfType("access_modifier").length === 0));
+    }
+    /**
+     * Records supported named exports from selected singleton objects.
+     *
+     * Imports, wildcard selectors, givens, unqualified paths, and dynamic selectors report incomplete resolution rather than creating aliases.
+     */
+    export(node, namespace, owner) {
+        if (owner?.public === false)
+            return;
+        if (this.session.root.descendantsOfType("import_declaration").length !== 0) {
+            this.problem("export-resolution", "Exports in files with imports require import and shadowing resolution.", node);
+            return;
+        }
+        const path = node
+            .childrenForFieldName("path")
+            .filter((child) => child.isNamed);
+        const selectors = node.namedChildren.find((child) => child.type === "namespace_selectors");
+        const renamed = node.namedChildren.find((child) => child.type === "as_renamed_identifier");
+        const names = selectors?.namedChildren ??
+            (renamed === undefined ? path.slice(-1) : [renamed]);
+        const qualifier = (selectors === undefined && renamed === undefined
+            ? path.slice(0, -1)
+            : path).map((part) => this.name(part));
+        if (qualifier.length === 0 ||
+            node.descendantsOfType(["namespace_wildcard", "wildcard"]).length !== 0 ||
+            node.children.some((child) => child.text === "given")) {
+            this.problem("export-resolution", "Only explicit named exports from selected singleton objects are supported; wildcard, given, and unqualified exports require member resolution.", node);
+            return;
+        }
+        for (const selected of names) {
+            const parts = [
+                "as_renamed_identifier",
+                "arrow_renamed_identifier",
+            ].includes(selected.type)
+                ? selected.namedChildren
+                : [selected];
+            const member = parts[0];
+            const alias = parts.at(-1);
+            if (member === undefined ||
+                alias === undefined ||
+                !["identifier", "operator_identifier"].includes(member.type) ||
+                alias.text === "_") {
+                this.problem("export-resolution", "This export selector requires unsupported name or given resolution.", node);
+                continue;
+            }
+            const declaration = this.declare(node, member, "property", namespace, owner, this.name(alias));
+            if (declaration === undefined)
+                continue;
+            declaration.public = false;
+            const scope = owner?.lookup ?? namespace;
+            const paths = [];
+            for (let length = scope.length; length >= 0; --length)
+                paths.push([...scope.slice(0, length), ...qualifier]);
+            this.exports.push({ declaration, paths, member: this.name(member) });
+        }
+    }
+    /**
+     * Decodes a backticked Scala name into its literal accessor segment.
+     *
+     * Unquoted names retain their source text, while only the surrounding backticks are removed.
+     */
+    name(node) {
+        return node.text.startsWith("`") ? node.text.slice(1, -1) : node.text;
+    }
+    /**
+     * Attaches a Scaladoc carrier only when it immediately precedes a declaration through whitespace.
+     *
+     * Other comments, intervening syntax, and non-Scaladoc blocks remain unattached for unsupported-host handling.
+     */
+    attach(node, declaration) {
+        const previous = node.previousNamedSibling;
+        if (previous === null ||
+            previous.type !== "block_comment" ||
+            !previous.text.startsWith("/**") ||
+            !/^\s*$/u.test(this.source.content.slice(previous.endIndex, node.startIndex)))
+            return;
+        const documentation = this.documentation.get(previous.startIndex);
+        if (documentation !== undefined)
+            documentation.attachments.push({
+                declarationId: declaration.id,
+                siteId: declaration.site.id,
+            });
+    }
+    /**
+     * Classifies comments and tag-bearing literal strings without treating them as declarations.
+     *
+     * Scaladoc may attach to a declaration; other tag-shaped carriers remain available for diagnostics.
+     */
+    collectDocumentation() {
+        for (const node of this.session.root.descendantsOfType([
+            "block_comment",
+            "comment",
+            "string",
+        ])) {
+            const scaladoc = node.type === "block_comment" && node.text.startsWith("/**");
+            if (!scaladoc &&
+                !/@(?:evidenceExcludeReview|evidenceReview|evidenceExclude|evidence|link|internal|hidden|ignore)\b/u.test(node.text))
+                continue;
+            const opening = node.type === "block_comment"
+                ? scaladoc
+                    ? "/**"
+                    : "/*"
+                : node.type === "comment"
+                    ? "//"
+                    : node.text.startsWith('"""')
+                        ? '"""'
+                        : '"';
+            this.documentation.set(node.startIndex, {
+                id: `scala:${this.source.id}:documentation:${node.startIndex}`,
+                range: this.session.range(node),
+                syntax: {
+                    opening,
+                    closing: node.type === "block_comment"
+                        ? "*/"
+                        : node.type === "comment"
+                            ? ""
+                            : opening,
+                    ...(node.type === "block_comment" ? { linePrefix: "*" } : {}),
+                    tagBoundaries: true,
+                    allowWithdrawal: scaladoc,
+                },
+                attachments: [],
+            });
+        }
+    }
+    /**
+     * Reports an actionable incomplete-analysis boundary at the original syntax range.
+     *
+     * The repair directs authors toward supported explicit declarations before graph evaluation can use the inventory.
+     */
+    problem(code, message, node) {
+        this.diagnostics.push({
+            code: `scala-${code}`,
+            severity: "error",
+            message,
+            repair: "Use supported explicit Scala declarations or implement the reported source-resolution boundary before evaluating coverage.",
+            location: {
+                file: this.source.physicalPath,
+                range: this.session.range(node),
+            },
+        });
+    }
+}
+exports.ScalaFileScanner = ScalaFileScanner;

package/lib/adapters/sql/EvidenceSqlAdapter.d.ts

@@ -0,0 +1,13 @@
+import { SqlAdapter } from "./SqlAdapter";
+/** Extracts the explicitly configured portable SQL CREATE TABLE surface.
+ *
+ * This entry fixes interpretation to the portable grammar; shared `.sql` files
+ * never trigger dialect probing that could change the selected population.
+ */
+export declare class EvidenceSqlAdapter extends SqlAdapter {
+    /** Selects the portable grammar policy without probing another dialect.
+     *
+     * Parser lifetime and inventory materialization remain owned by `SqlAdapter`.
+     */
+    constructor();
+}

package/lib/adapters/sql/EvidenceSqlAdapter.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EvidenceSqlAdapter = void 0;
+const SqlAdapter_1 = require("./SqlAdapter");
+const SqlFileScanner_1 = require("./SqlFileScanner");
+/** Extracts the explicitly configured portable SQL CREATE TABLE surface.
+ *
+ * This entry fixes interpretation to the portable grammar; shared `.sql` files
+ * never trigger dialect probing that could change the selected population.
+ */
+class EvidenceSqlAdapter extends SqlAdapter_1.SqlAdapter {
+    /** Selects the portable grammar policy without probing another dialect.
+     *
+     * Parser lifetime and inventory materialization remain owned by `SqlAdapter`.
+     */
+    constructor() {
+        super({ type: "sql", scan: scan });
+    }
+}
+exports.EvidenceSqlAdapter = EvidenceSqlAdapter;
+/** Copies portable declarations while the parser session is borrowed.
+ *
+ * The scanner returns node-free records so no native Tree-sitter value escapes
+ * the callback that owns the parse session.
+ */
+function scan(...args) {
+    return new SqlFileScanner_1.SqlFileScanner(...args).scan();
+}

package/lib/adapters/sql/ISqlAdapterOptions.d.ts

@@ -0,0 +1,33 @@
+import type { EvidenceParseSession } from "../../parsers/EvidenceParseSession";
+import type { IEvidenceSourceFile } from "../../structures/IEvidenceSourceFile";
+import type { EvidenceDatabaseType } from "../../typings/EvidenceDatabaseType";
+import type { ISqlFileAnalysis } from "./ISqlFileAnalysis";
+/**
+ * Dialect-specific hooks consumed by the shared SQL inventory adapter.
+ *
+ * Scanning owns syntax and declaration interpretation; an optional resolver can
+ * connect ownership across files. The shared adapter runs these phases before
+ * materializing units and documentation under a single parser lifecycle.
+ */
+export interface ISqlAdapterOptions {
+    /**
+     * Explicit database family used for grammar selection and inventory type.
+     *
+     * Shared .sql extensions do not permit falling back to another dialect on failure.
+     */
+    type: EvidenceDatabaseType;
+    /**
+     * Copies one borrowed syntax tree into serializable declaration and host records.
+     *
+     * Returned analysis must not retain native nodes after the parse callback ends;
+     * unsupported extraction should preserve diagnostics and incomplete state.
+     */
+    scan: (session: EvidenceParseSession, source: IEvidenceSourceFile) => ISqlFileAnalysis;
+    /**
+     * Reconciles cross-file declaration and documentation ownership before publication.
+     *
+     * The hook mutates copied file analyses after every scan has completed. Omission
+     * means the dialect scanner already established the ownership needed for materialization.
+     */
+    resolve?: (analyses: ISqlFileAnalysis[]) => void;
+}

package/lib/adapters/sql/ISqlAdapterOptions.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/adapters/sql/ISqlDeclaration.d.ts

@@ -0,0 +1,67 @@
+import type { IEvidenceUnitSite } from "../../structures/IEvidenceUnitSite";
+import type { EvidenceDatabaseSymbol } from "../../typings/EvidenceDatabaseSymbol";
+/** Represents one database declaration copied from a dialect syntax tree.
+ *
+ * SQL scanners retain this node-free record after their parser session closes.
+ * Inventory construction uses its identity and public address to reconcile
+ * semantic units, while `site` preserves the physical declaration that owns
+ * documentation and review fingerprints.
+ */
+export interface ISqlDeclaration {
+    /** Identifies this extraction record within one source snapshot.
+     *
+     * Documentation attachments use this value to name their declared owner.
+     */
+    id: string;
+    /** Names the final address segment for diagnostics and inventory display.
+     *
+     * Relation records may use a generated segment when the SQL syntax has no
+     * explicit constraint name.
+     */
+    name: string;
+    /** Classifies the declaration for the shared database selector contract.
+     *
+     * The scanner emits `model`, `column`, and `relation` records only when the
+     * dialect syntax establishes their respective schema boundary.
+     */
+    symbol: EvidenceDatabaseSymbol;
+    /** Stores the file-independent segments that identify the semantic unit.
+     *
+     * A dialect may normalize these segments without changing the public source
+     * spelling retained in `address`.
+     */
+    identity: string[];
+    /** Stores the public accessor segments at this physical declaration site.
+     *
+     * Each segment remains distinct so quoted identifiers containing dots do not
+     * become different nested paths.
+     */
+    address: string[];
+    /** Lists additional dialect-established public paths for this declaration.
+     *
+     * Omission means the primary `address` is the only supported public path.
+     */
+    aliases?: string[][];
+    /** Locates the declaration and the content used for its review fingerprint.
+     *
+     * This is a physical site, even when several sites reconcile to one semantic
+     * identity.
+     */
+    site: IEvidenceUnitSite;
+    /** Marks whether this extracted declaration belongs to the selected surface.
+     *
+     * Non-public boundaries remain available to the scanner so it can preserve a
+     * truthful inventory without exposing them as selectable units.
+     */
+    public: boolean;
+    /** Names the model extraction record that physically owns this member.
+     *
+     * Omission denotes a model declaration, which is its own structural owner.
+     */
+    ownerDeclarationId?: string;
+    /** Marks an additional physical site for an identity established elsewhere.
+     *
+     * Omission means this record introduces its semantic identity in the scan.
+     */
+    merge?: boolean;
+}

package/lib/adapters/sql/ISqlDeclaration.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/adapters/sql/ISqlDocumentation.d.ts

@@ -0,0 +1,40 @@
+import type { IEvidenceDocumentation } from "../../structures/IEvidenceDocumentation";
+import type { IEvidenceCommentSyntax } from "../../structures/IEvidenceCommentSyntax";
+import type { IEvidenceSourceRange } from "../../structures/IEvidenceSourceRange";
+import type { ISqlDocumentationAttachment } from "./ISqlDocumentationAttachment";
+/** Represents one SQL comment carrier considered for documentation attachment.
+ *
+ * The scanner keeps every relevant carrier, including one that cannot attach,
+ * so the documentation parser can diagnose annotations without silently
+ * dropping their source range.
+ */
+export interface ISqlDocumentation {
+    /** Identifies this documentation record within the source snapshot.
+     *
+     * Attachment records refer to declarations rather than this value, which
+     * keeps comment ownership directional.
+     */
+    id: string;
+    /** Locates the complete carrier in original half-open UTF-16 coordinates.
+     *
+     * Adjacent line comments can share one range when the scanner forms a run.
+     */
+    range: IEvidenceSourceRange;
+    /** Describes delimiters and tag rules when the carrier has usable syntax.
+     *
+     * Omission leaves the carrier available for unsupported-annotation handling
+     * without pretending that it has a parseable documentation form.
+     */
+    syntax?: IEvidenceCommentSyntax;
+    /** Maps dialect-provided documentation text back to original coordinates.
+     *
+     * Omission means this carrier is represented only by its raw source range.
+     */
+    mapped?: IEvidenceDocumentation;
+    /** Lists every physical declaration site documented by this carrier.
+     *
+     * An empty list preserves detached or trailing annotation carriers for later
+     * diagnostics.
+     */
+    attachments: ISqlDocumentationAttachment[];
+}

package/lib/adapters/sql/ISqlDocumentation.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/adapters/sql/ISqlDocumentationAttachment.d.ts

@@ -0,0 +1,18 @@
+/** Connects one SQL documentation carrier to a physical declaration site.
+ *
+ * This separate record lets a single leading comment acknowledge declarations
+ * that share a source location, such as an inline relation and its column.
+ */
+export interface ISqlDocumentationAttachment {
+    /** Names the extraction record for the documented declaration.
+     *
+     * The value resolves within the file analysis that owns this attachment.
+     */
+    declarationId: string;
+    /** Names the physical site through which the semantic unit is documented.
+     *
+     * This remains distinct from `declarationId` when identities merge across
+     * more than one site.
+     */
+    siteId: string;
+}

package/lib/adapters/sql/ISqlDocumentationAttachment.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });