@wrtnlabs/evidence 0.0.0 → 0.1.0

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

@@ -0,0 +1,25 @@
+import type { Node as EvidenceNode } from "web-tree-sitter";
+/**
+ * Defines the portable subset independently of the broad SQL parser grammar.
+ *
+ * `EvidenceSqlFileScanner` uses this policy to reject syntax whose meaning
+ * varies by dialect.
+ */
+export declare namespace EvidenceSqlPolicy {
+    /**
+     * Folds regular identifiers to upper case and preserves standard quoted
+     * identifiers.
+     *
+     * This yields portable semantic identity while retaining literal quoted
+     * spelling.
+     */
+    function identifier(raw: string): string | undefined;
+    /**
+     * Rejects every statement or extension outside explicit portable CREATE
+     * TABLE.
+     *
+     * The scanner reports the returned reason so unsupported syntax cannot shrink
+     * the population.
+     */
+    function validate(node: EvidenceNode): string | undefined;
+}

package/lib/adapters/sql/EvidenceSqlPolicy.js

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EvidenceSqlPolicy = void 0;
+/**
+ * Defines the portable subset independently of the broad SQL parser grammar.
+ *
+ * `EvidenceSqlFileScanner` uses this policy to reject syntax whose meaning
+ * varies by dialect.
+ */
+var EvidenceSqlPolicy;
+(function (EvidenceSqlPolicy) {
+    /**
+     * Folds regular identifiers to upper case and preserves standard quoted
+     * identifiers.
+     *
+     * This yields portable semantic identity while retaining literal quoted
+     * spelling.
+     */
+    function identifier(raw) {
+        if (/^"(?:[^"]|"")+"$/u.test(raw))
+            return raw.slice(1, -1).replaceAll('""', '"');
+        return /^[A-Za-z_][A-Za-z_0-9]*$/u.test(raw)
+            ? raw.toUpperCase()
+            : undefined;
+    }
+    EvidenceSqlPolicy.identifier = identifier;
+    /**
+     * Rejects every statement or extension outside explicit portable CREATE
+     * TABLE.
+     *
+     * The scanner reports the returned reason so unsupported syntax cannot shrink
+     * the population.
+     */
+    function validate(node) {
+        if (node.type === "comment" || node.type === "marginalia")
+            return undefined;
+        if (node.type !== "create_table")
+            return "Portable SQL accepts only explicit CREATE TABLE declarations; select a dialect adapter or add support for this statement.";
+        const allowed = new Set([
+            "keyword_create",
+            "keyword_table",
+            "object_reference",
+            "column_definitions",
+            "comment",
+            "marginalia",
+        ]);
+        if (node.namedChildren.some((child) => !allowed.has(child.type)))
+            return "Portable SQL does not infer conditional, temporary, query-derived, or dialect-specific tables.";
+        const forbidden = new Set([
+            "keyword_index",
+            "keyword_auto_increment",
+            "keyword_generated",
+            "keyword_as",
+            "keyword_stored",
+            "keyword_virtual",
+            "keyword_comment",
+            "keyword_unsigned",
+            "keyword_zerofill",
+            "keyword_collate",
+            "keyword_nulls",
+            "direction",
+            "array_size",
+            "array_size_definition",
+            "array_type",
+        ]);
+        const stack = [...node.namedChildren];
+        while (stack.length !== 0) {
+            const child = stack.pop();
+            if (child === undefined)
+                continue;
+            if (child.type === "identifier" && identifier(child.text) === undefined)
+                return "Portable SQL accepts regular ASCII and standard double-quoted identifiers only.";
+            if (forbidden.has(child.type))
+                return `Portable SQL does not support '${child.text}' in table declarations.`;
+            if (child.type === "constraint") {
+                const forms = new Set(child.namedChildren.map((entry) => entry.type));
+                if (![
+                    "keyword_foreign",
+                    "keyword_primary",
+                    "keyword_unique",
+                    "keyword_check",
+                ].some((type) => forms.has(type)))
+                    return "Portable SQL supports only PRIMARY KEY, UNIQUE, CHECK, and FOREIGN KEY table constraints.";
+                if (forms.has("keyword_unique") && forms.has("keyword_key"))
+                    return "Portable SQL uses UNIQUE, not the dialect-specific UNIQUE KEY spelling.";
+                if (child.childForFieldName("name") !== null &&
+                    !forms.has("keyword_constraint"))
+                    return "Portable SQL names constraints with CONSTRAINT; dialect-specific index names are unsupported.";
+                if (forms.has("keyword_foreign") &&
+                    child.childForFieldName("name") !== null)
+                    return "Named foreign-key syntax is not supported by the portable SQL grammar; use an anonymous FOREIGN KEY or a certified dialect.";
+            }
+            if (child.type === "column_definition") {
+                const named = child.namedChildren.filter((entry) => entry.type !== "comment" && entry.type !== "marginalia");
+                for (let index = 0; index < named.length; ++index) {
+                    if (named[index]?.type !== "keyword_default")
+                        continue;
+                    const expression = named[index + 1];
+                    if (expression === undefined ||
+                        !/^(?:[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?|'(?:[^']|'')*'|TRUE|FALSE|NULL|CURRENT_TIMESTAMP)$/iu.test(expression.text.trim()))
+                        return "Portable SQL defaults require a scalar literal or CURRENT_TIMESTAMP; dialect function defaults are unsupported.";
+                }
+                if (named.some((entry) => entry.type === "keyword_constraint"))
+                    return "Named column constraints are outside the documented portable grammar subset.";
+                const type = child.childForFieldName("type");
+                if (child.childrenForFieldName("type").length !== 1 ||
+                    type === null ||
+                    !/^(?:SMALLINT|INTEGER|INT|BIGINT|DECIMAL|NUMERIC|REAL|DOUBLE\s+PRECISION|FLOAT|BOOLEAN|CHAR(?:ACTER)?|VARCHAR|CHARACTER\s+VARYING|DATE|TIME|TIMESTAMP)(?:\s*\(\s*\d+\s*(?:,\s*\d+\s*)?\))?$/iu.test(type.text))
+                    return "Portable SQL columns require a documented standard scalar data type.";
+            }
+            stack.push(...child.namedChildren);
+        }
+        return undefined;
+    }
+    EvidenceSqlPolicy.validate = validate;
+})(EvidenceSqlPolicy || (exports.EvidenceSqlPolicy = EvidenceSqlPolicy = {}));

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

@@ -0,0 +1,38 @@
+import type { EvidenceParseSession } from "../../parsers/EvidenceParseSession";
+import type { IEvidenceSourceFile } from "../../structures/IEvidenceSourceFile";
+import type { EvidenceDatabaseType } from "../../typings/EvidenceDatabaseType";
+import type { IEvidenceSqlFileAnalysis } from "./IEvidenceSqlFileAnalysis";
+/**
+ * Dialect-specific hooks consumed by the shared SQL inventory materializer.
+ *
+ * Scanning owns syntax and declaration interpretation; an optional resolver can
+ * connect ownership across files. The materializer runs these phases before
+ * materializing units and documentation under a single parser lifecycle.
+ */
+export interface IEvidenceSqlAdapterOptions {
+    /**
+     * 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) => IEvidenceSqlFileAnalysis;
+    /**
+     * 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: IEvidenceSqlFileAnalysis[]) => void;
+}

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

@@ -0,0 +1,78 @@
+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 IEvidenceSqlDeclaration {
+    /**
+     * 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/IEvidenceSqlDocumentation.d.ts

@@ -0,0 +1,46 @@
+import type { IEvidenceDocumentation } from "../../structures/IEvidenceDocumentation";
+import type { IEvidenceCommentSyntax } from "../../structures/IEvidenceCommentSyntax";
+import type { IEvidenceSourceRange } from "../../structures/IEvidenceSourceRange";
+import type { IEvidenceSqlDocumentationAttachment } from "./IEvidenceSqlDocumentationAttachment";
+/**
+ * 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 IEvidenceSqlDocumentation {
+    /**
+     * 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: IEvidenceSqlDocumentationAttachment[];
+}

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

@@ -0,0 +1,21 @@
+/**
+ * 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 IEvidenceSqlDocumentationAttachment {
+    /**
+     * 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/IEvidenceSqlFileAnalysis.d.ts

@@ -0,0 +1,47 @@
+import type { IEvidenceDiagnostic } from "../../structures/IEvidenceDiagnostic";
+import type { IEvidenceSourceFile } from "../../structures/IEvidenceSourceFile";
+import type { IEvidenceSqlDeclaration } from "./IEvidenceSqlDeclaration";
+import type { IEvidenceSqlDocumentation } from "./IEvidenceSqlDocumentation";
+/**
+ * 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 IEvidenceSqlFileAnalysis {
+    /**
+     * 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: IEvidenceSqlDeclaration[];
+    /**
+     * 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: IEvidenceSqlDocumentation[];
+    /**
+     * 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/IEvidenceSqlPolicy.d.ts

@@ -0,0 +1,50 @@
+import type { Node as EvidenceNode } 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 IEvidenceSqlPolicy {
+    /**
+     * 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: EvidenceNode) => 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";
+}

package/lib/adapters/sqlite/EvidenceSqliteAdapter.d.ts

@@ -1,4 +1,6 @@
-import { SqlAdapter } from "../sql/SqlAdapter";
+import type { IEvidenceAdapter } from "../../structures/IEvidenceAdapter";
+import type { IEvidenceInventory } from "../../structures/IEvidenceInventory";
+import type { IEvidenceSourceSnapshot } from "../../structures/IEvidenceSourceSnapshot";
 /**
  * Extracts SQLite's explicitly declared tables, columns, and foreign keys.
  *
@@ -6,11 +8,26 @@ import { SqlAdapter } from "../sql/SqlAdapter";
  * the shared SQL materializer. Analysis uses captured DDL source and does not
  * open a database or infer schema by executing statements.
  */
-export declare class EvidenceSqliteAdapter extends SqlAdapter {
+export declare class EvidenceSqliteAdapter implements IEvidenceAdapter<"sqlite"> {
     /**
-     * Selects SQLite grammar and declaration scanning for the shared adapter lifecycle.
+     * SQLite grammar selected for this adapter.
      *
-     * Parser allocation and source analysis wait until analyze receives a snapshot.
+     * The explicit dialect keeps SQLite's ownership and identifier rules stable
+     * for source files with a shared `.sql` extension.
      */
-    constructor();
+    get type(): "sqlite";
+    /**
+     * Materializes SQLite scanner records into graph-facing inventory records.
+     *
+     * SQLite syntax stays with the scanner; this collaborator owns only parser
+     * lifetime and syntax-independent SQL record publication.
+     */
+    private readonly materializer;
+    /**
+     * Extracts SQLite declarations from one captured source snapshot.
+     *
+     * Parser allocation and source analysis wait until this method receives the
+     * snapshot.
+     */
+    analyze(snapshot: IEvidenceSourceSnapshot): Promise<IEvidenceInventory>;
 }

package/lib/adapters/sqlite/EvidenceSqliteAdapter.js

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EvidenceSqliteAdapter = void 0;
-const SqlAdapter_1 = require("../sql/SqlAdapter");
-const SqliteFileScanner_1 = require("./SqliteFileScanner");
+const EvidenceSqlInventoryMaterializer_1 = require("../sql/EvidenceSqlInventoryMaterializer");
+const EvidenceSqliteFileScanner_1 = require("./EvidenceSqliteFileScanner");
+const EVID_SQLITE_TYPE = "sqlite";
 /**
  * Extracts SQLite's explicitly declared tables, columns, and foreign keys.
  *
@@ -10,17 +11,34 @@ const SqliteFileScanner_1 = require("./SqliteFileScanner");
  * the shared SQL materializer. Analysis uses captured DDL source and does not
  * open a database or infer schema by executing statements.
  */
-class EvidenceSqliteAdapter extends SqlAdapter_1.SqlAdapter {
+class EvidenceSqliteAdapter {
     /**
-     * Selects SQLite grammar and declaration scanning for the shared adapter lifecycle.
+     * SQLite grammar selected for this adapter.
      *
-     * Parser allocation and source analysis wait until analyze receives a snapshot.
+     * The explicit dialect keeps SQLite's ownership and identifier rules stable
+     * for source files with a shared `.sql` extension.
      */
-    constructor() {
-        super({
-            type: "sqlite",
-            scan: (session, source) => new SqliteFileScanner_1.SqliteFileScanner(session, source).scan(),
-        });
+    get type() {
+        return "sqlite";
+    }
+    /**
+     * Materializes SQLite scanner records into graph-facing inventory records.
+     *
+     * SQLite syntax stays with the scanner; this collaborator owns only parser
+     * lifetime and syntax-independent SQL record publication.
+     */
+    materializer = new EvidenceSqlInventoryMaterializer_1.EvidenceSqlInventoryMaterializer({
+        type: EVID_SQLITE_TYPE,
+        scan: (session, source) => new EvidenceSqliteFileScanner_1.EvidenceSqliteFileScanner(session, source).scan(),
+    });
+    /**
+     * Extracts SQLite declarations from one captured source snapshot.
+     *
+     * Parser allocation and source analysis wait until this method receives the
+     * snapshot.
+     */
+    analyze(snapshot) {
+        return this.materializer.analyze(snapshot);
     }
 }
 exports.EvidenceSqliteAdapter = EvidenceSqliteAdapter;

package/lib/adapters/sqlite/EvidenceSqliteFileScanner.d.ts

@@ -0,0 +1,96 @@
+import type { EvidenceParseSession } from "../../parsers/EvidenceParseSession";
+import type { IEvidenceSourceFile } from "../../structures/IEvidenceSourceFile";
+import type { IEvidenceSqlFileAnalysis } from "../sql/IEvidenceSqlFileAnalysis";
+/**
+ * Extracts a static SQLite schema from declarative grammar nodes.
+ *
+ * The scanner does not execute migrations or queries. It records only syntax
+ * that establishes a stable schema and reports other constructs so they cannot
+ * make a partial inventory appear complete.
+ */
+export declare class EvidenceSqliteFileScanner {
+    private readonly session;
+    private readonly source;
+    /**
+     * Collects declarations established by recognized SQLite grammar positions.
+     *
+     * The array remains private until `scan` returns its node-free analysis.
+     */
+    private readonly declarations;
+    /**
+     * Collects findings that prevent a smaller schema from appearing complete.
+     *
+     * Each diagnostic identifies syntax requiring runtime interpretation or a
+     * scanner capability that SQLite extraction does not support.
+     */
+    private readonly diagnostics;
+    /**
+     * Maps SQLite node offsets into original UTF-16 source coordinates.
+     *
+     * Documentation and declaration sites share this coordinate authority.
+     */
+    private readonly text;
+    /**
+     * Initializes one scanner over a borrowed session and immutable source.
+     *
+     * The session supplies grammar nodes only during the scan; the returned
+     * analysis contains no node references after this object finishes.
+     */
+    constructor(session: EvidenceParseSession, source: IEvidenceSourceFile);
+    /**
+     * Returns declarations, documentation carriers, and truthful completeness.
+     *
+     * Every unsupported statement records a diagnostic before the result reports
+     * completion, preventing a reduced schema from passing coverage checks.
+     */
+    scan(): IEvidenceSqlFileAnalysis;
+    /**
+     * Creates one model and its explicitly declared columns and relations.
+     *
+     * The method rejects query-derived tables and ambiguous names because static
+     * identity must come from explicit SQLite schema syntax.
+     */
+    private table;
+    /**
+     * Creates a relation from a foreign-key clause with explicit endpoints.
+     *
+     * Relations use a namespace below their model so a constraint does not
+     * collide with a column, and endpoint arity must remain verifiable.
+     */
+    private relation;
+    /**
+     * Creates a physical declaration record distinct from normalized identity.
+     *
+     * SQLite case-folds semantic identity while preserving source spelling and
+     * ranges for public addresses, documentation, and review fingerprints.
+     */
+    private declare;
+    /**
+     * Attaches adjacent leading comments while retaining detached carriers.
+     *
+     * Grouping is limited to standalone adjacent line comments so trailing text
+     * cannot accidentally document the declaration on the following line.
+     */
+    private documentation;
+    /**
+     * Checks whether a comment begins before other content on its source line.
+     *
+     * Trailing comments fail this check and therefore cannot absorb the next
+     * declaration's leading documentation role.
+     */
+    private leading;
+    /**
+     * Checks whether only one optional line break separates two source ranges.
+     *
+     * Blank lines and intervening syntax detach comments from declarations and
+     * from preceding line-comment fragments.
+     */
+    private adjacent;
+    /**
+     * Reports unsupported SQLite syntax without inferring runtime database state.
+     *
+     * The repair tells authors how to restore a declarative complete inventory
+     * while the diagnostic keeps the partial result from passing as complete.
+     */
+    private incomplete;
+}