@wrtnlabs/evidence 0.0.0 → 0.1.0

package/lib/adapters/scala/ScalaFileScanner.js

@@ -1,434 +0,0 @@
-"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/ISqlAdapterOptions.d.ts

@@ -1,33 +0,0 @@
-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/ISqlDeclaration.d.ts

@@ -1,67 +0,0 @@
-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/ISqlDocumentation.d.ts

@@ -1,40 +0,0 @@
-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/ISqlDocumentationAttachment.d.ts

@@ -1,18 +0,0 @@
-/** 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/ISqlFileAnalysis.d.ts

@@ -1,41 +0,0 @@
-import type { IEvidenceDiagnostic } from "../../structures/IEvidenceDiagnostic";
-import type { IEvidenceSourceFile } from "../../structures/IEvidenceSourceFile";
-import type { ISqlDeclaration } from "./ISqlDeclaration";
-import type { ISqlDocumentation } from "./ISqlDocumentation";
-/** Retains a node-free SQL extraction after its parse session closes.
- *
- * SQL adapters transfer this serializable analysis to later inventory and
- * documentation phases without retaining Tree-sitter nodes or session state.
- */
-export interface ISqlFileAnalysis {
-    /** Preserves the selected source snapshot whose coordinates records use.
-     *
-     * Consumers use this source to retain the physical file boundary of every
-     * declaration, comment, and diagnostic.
-     */
-    source: IEvidenceSourceFile;
-    /** Contains declarations extracted from recognized schema syntax.
-     *
-     * The collection includes non-public structural boundaries needed to build a
-     * faithful inventory before public selection is projected.
-     */
-    declarations: ISqlDeclaration[];
-    /** Contains classified comments and unsupported annotation carriers.
-     *
-     * Detached carriers remain here so later phases can report their annotations
-     * instead of treating absence of an attachment as absence of evidence.
-     */
-    documentation: ISqlDocumentation[];
-    /** Records failures encountered while establishing the schema surface.
-     *
-     * These diagnostics explain why callers must not trust a partial extraction
-     * as a complete selected population.
-     */
-    diagnostics: IEvidenceDiagnostic[];
-    /** States whether every relevant declaration form was understood.
-     *
-     * A false value prevents unsupported source from making coverage pass by
-     * shrinking the discovered inventory.
-     */
-    complete: boolean;
-}

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

@@ -1,43 +0,0 @@
-import type { Node } from "web-tree-sitter";
-import type { EvidenceDatabaseSymbol } from "../../typings/EvidenceDatabaseSymbol";
-/** Defines dialect-specific decisions for the shared SQL table scanner.
- *
- * The scanner owns common declaration extraction; a policy supplies only the
- * syntax and namespace choices that vary by SQL dialect.
- */
-export interface ISqlPolicy {
-    /** Decodes one grammar identifier under this dialect's quoting rules.
-     *
-     * Returning `undefined` rejects the spelling and makes the containing scan
-     * incomplete rather than inventing an address.
-     */
-    identifier: (raw: string) => string | undefined;
-    /** Validates a complete grammar statement or comment for this dialect.
-     *
-     * Returning a message marks the analysis incomplete and provides the
-     * diagnostic reason; returning `undefined` permits common extraction.
-     */
-    validate: (node: Node) => string | undefined;
-    /** Projects a decoded public address into its dialect-specific identity.
-     *
-     * Omission preserves the address as the semantic identity.
-     */
-    identity?: (address: string[], symbol: EvidenceDatabaseSymbol) => string[];
-    /** Resolves a referenced table name within its declared owner scope.
-     *
-     * Omission leaves the decoded reference unchanged when building relation
-     * endpoint identity.
-     */
-    reference?: (reference: string[], owner: string[]) => string[];
-    /** States whether a grammar constraint name is a relation's public name.
-     *
-     * Omission treats explicit table constraint names as relation names.
-     */
-    constraintNames?: boolean;
-    /** Selects how column-level `REFERENCES` syntax contributes relations.
-     *
-     * Omission uses the scanner's normal relation behavior; `ignore` omits it
-     * and `reject` records dialect incompleteness.
-     */
-    inlineReferences?: "ignore" | "relation" | "reject";
-}