@wrtnlabs/evidence 0.0.0 → 0.1.0

package/lib/adapters/dart/EvidenceDartLibraries.js

@@ -0,0 +1,235 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EvidenceDartLibraries = void 0;
+const node_path_1 = __importDefault(require("node:path"));
+/**
+ * Resolves selected Dart library ownership and export aliases without executing
+ * package tooling.
+ *
+ * Physical scans cannot decide whether a part belongs to a library or whether
+ * an exported spelling denotes an existing unit, so this pass establishes those
+ * relationships before inventory publication and documentation attachment.
+ */
+var EvidenceDartLibraries;
+(function (EvidenceDartLibraries) {
+    /**
+     * Validates reciprocal part ownership and retains missing URI paths for watch
+     * invalidation.
+     *
+     * A missing or conflicting part makes the analysis incomplete because
+     * treating it as absent could remove public declarations from the coverage
+     * denominator.
+     */
+    function resolve(analyses, inventory) {
+        const files = new Map();
+        for (const analysis of analyses)
+            for (const name of [
+                analysis.source.physicalPath,
+                ...analysis.source.addresses.map((address) => address.absolute),
+            ])
+                files.set(normalize(name), analysis);
+        for (const analysis of analyses)
+            for (const directive of analysis.directives) {
+                if (directive.named) {
+                    const matches = analyses.filter((candidate) => candidate.libraryName === directive.target &&
+                        !candidate.directives.some((item) => item.kind === "part-of"));
+                    if (matches.length === 1 && matches[0] !== undefined)
+                        directive.resolved = matches[0].source.physicalPath;
+                    else
+                        problem(analysis, "part-owner", `Named part library '${directive.target}' is missing or ambiguous in the selected snapshot.`);
+                    continue;
+                }
+                if (/^[A-Za-z][A-Za-z0-9+.-]*:|[?#%\\]/u.test(directive.target) ||
+                    directive.target.startsWith("/")) {
+                    problem(analysis, "external-uri", `Library URI '${directive.target}' requires package, SDK, or non-relative URI resolution. Use selected relative library source or implement URI resolution.`);
+                    continue;
+                }
+                const locations = [
+                    ...new Set([
+                        analysis.source.physicalPath,
+                        ...analysis.source.addresses.map((address) => address.absolute),
+                    ].map((file) => node_path_1.default.posix.join(node_path_1.default.posix.dirname(normalize(file)), directive.target))),
+                ];
+                for (const location of locations)
+                    if (!inventory.dependencies.some((dependency) => dependency.path === location && !dependency.recursive))
+                        inventory.dependencies.push({ path: location, recursive: false });
+                const matches = [
+                    ...new Set(locations.flatMap((location) => {
+                        const match = files.get(location);
+                        return match === undefined ? [] : [match];
+                    })),
+                ];
+                if (matches.length === 1 && matches[0] !== undefined)
+                    directive.resolved = matches[0].source.physicalPath;
+                else
+                    problem(analysis, "unresolved-library", `Library URI '${directive.target}' is missing or ambiguous in the selected snapshot. Include the referenced Dart file in this population.`);
+            }
+        for (const analysis of analyses) {
+            const owners = analysis.directives.filter((directive) => directive.kind === "part-of");
+            if (owners.length === 0)
+                continue;
+            const owner = analyses.find((candidate) => candidate.source.physicalPath === owners[0]?.resolved);
+            if (owners.length !== 1 ||
+                owner === undefined ||
+                owner === analysis ||
+                owner.directives.some((directive) => directive.kind === "part-of") ||
+                !owner.directives.some((directive) => directive.kind === "part" &&
+                    directive.resolved === analysis.source.physicalPath)) {
+                problem(analysis, "part-owner", "A part must name exactly one selected defining library whose part directive includes this file.");
+                continue;
+            }
+            if (analysis.libraryName !== undefined ||
+                analysis.directives.some((directive) => directive.kind !== "part-of"))
+                problem(analysis, "part-directives", "A part cannot define a library, export another library, or include parts.");
+            analysis.library = owner.source.physicalPath;
+        }
+        for (const analysis of analyses)
+            for (const directive of analysis.directives) {
+                const target = analyses.find((candidate) => candidate.source.physicalPath === directive.resolved);
+                if (target === undefined)
+                    continue;
+                if (directive.kind === "part" &&
+                    (target === analysis ||
+                        target.library !== analysis.source.physicalPath ||
+                        !target.directives.some((item) => item.kind === "part-of")))
+                    problem(analysis, "part-owner", `Part '${directive.target}' does not reciprocally belong to this defining library.`);
+                if (directive.kind === "export" &&
+                    target.directives.some((item) => item.kind === "part-of"))
+                    problem(analysis, "export-part", "A part file cannot be exported as a standalone library; export its defining library.");
+            }
+        const declarations = new Map();
+        for (const analysis of analyses)
+            for (const declaration of analysis.declarations) {
+                declaration.library = analysis.library;
+                const key = JSON.stringify([analysis.library, declaration.address]);
+                const previous = declarations.get(key) ?? [];
+                if (previous.length !== 0 &&
+                    !(previous.length === 1 &&
+                        previous[0]?.symbol === "property" &&
+                        declaration.symbol === "property" &&
+                        ((previous[0].role === "getter" && declaration.role === "setter") ||
+                            (previous[0].role === "setter" && declaration.role === "getter"))))
+                    problem(analysis, "declaration-conflict", `Library declaration '${declaration.address.join(".")}' has conflicting selected definitions.`);
+                previous.push(declaration);
+                declarations.set(key, previous);
+            }
+    }
+    EvidenceDartLibraries.resolve = resolve;
+    /**
+     * Projects library and transitive show or hide export addresses without
+     * duplicating semantic units.
+     *
+     * One declaration can have several public paths while retaining a single unit
+     * identity.
+     */
+    function publish(analyses, inventory, published) {
+        const surfaces = new Map();
+        const localNames = new Map();
+        for (const analysis of analyses) {
+            const surface = surfaces.get(analysis.library) ?? new Set();
+            const names = localNames.get(analysis.library) ?? new Set();
+            for (const declaration of analysis.declarations) {
+                const id = published.get(declaration.id);
+                if (id !== undefined)
+                    surface.add(id);
+                if (declaration.address.length === 1)
+                    names.add(declaration.name);
+            }
+            surfaces.set(analysis.library, surface);
+            localNames.set(analysis.library, names);
+        }
+        const units = new Map(inventory.units.map((unit) => [unit.id, unit]));
+        let changed = true;
+        while (changed) {
+            changed = false;
+            for (const analysis of analyses)
+                for (const directive of analysis.directives.filter((item) => item.kind === "export")) {
+                    const target = analyses.find((candidate) => candidate.source.physicalPath === directive.resolved);
+                    const destination = surfaces.get(analysis.library);
+                    if (target === undefined || destination === undefined)
+                        continue;
+                    for (const id of surfaces.get(target.library) ?? []) {
+                        const name = units.get(id)?.identity?.[0];
+                        const locals = localNames.get(analysis.library);
+                        if (name === undefined ||
+                            (locals !== undefined && locals.has(name)) ||
+                            !allowed(directive, name) ||
+                            destination.has(id))
+                            continue;
+                        destination.add(id);
+                        changed = true;
+                    }
+                }
+        }
+        const addresses = new Set(inventory.addresses.map((address) => JSON.stringify(address)));
+        for (const analysis of analyses) {
+            const roots = new Map();
+            for (const id of surfaces.get(analysis.library) ?? []) {
+                const unit = units.get(id);
+                if (unit === undefined)
+                    continue;
+                if (unit.identity.length === 1) {
+                    const ids = roots.get(unit.name) ?? new Set();
+                    ids.add(unit.id);
+                    roots.set(unit.name, ids);
+                }
+                for (const file of analysis.source.addresses) {
+                    const address = {
+                        unitId: id,
+                        file: file.absolute,
+                        segments: unit.identity,
+                    };
+                    const key = JSON.stringify(address);
+                    if (addresses.has(key))
+                        continue;
+                    addresses.add(key);
+                    inventory.addresses.push(address);
+                }
+            }
+            if ([...roots.values()].some((ids) => ids.size > 1)) {
+                problem(analysis, "export-conflict", "Multiple exported libraries expose distinct declarations with the same name. Resolve the ambiguity with show/hide combinators.");
+                inventory.complete = false;
+                inventory.diagnostics.push(...analysis.diagnostics.filter((diagnostic) => diagnostic.code === "dart-export-conflict"));
+            }
+        }
+    }
+    EvidenceDartLibraries.publish = publish;
+    /**
+     * Applies sequential Dart combinators to one root name.
+     *
+     * Source order determines whether a later show or hide filter keeps the
+     * export.
+     */
+    function allowed(directive, name) {
+        return directive.filters.every((filter) => filter.kind === "show"
+            ? filter.names.includes(name)
+            : !filter.names.includes(name));
+    }
+    /**
+     * Makes source path separators portable without filesystem access.
+     *
+     * Static URI topology must compare the same way on Windows and POSIX hosts.
+     */
+    function normalize(file) {
+        return node_path_1.default.posix.normalize(file.replaceAll("\\", "/"));
+    }
+    /**
+     * Records a library topology failure on its source analysis.
+     *
+     * The affected analysis remains incomplete until its URI relationship is
+     * repaired.
+     */
+    function problem(analysis, code, message) {
+        analysis.complete = false;
+        analysis.diagnostics.push({
+            code: `dart-${code}`,
+            severity: "error",
+            message,
+            repair: "Select an unambiguous complete Dart library graph or implement the reported URI boundary before checking coverage.",
+            location: { file: analysis.source.physicalPath },
+        });
+    }
+})(EvidenceDartLibraries || (exports.EvidenceDartLibraries = EvidenceDartLibraries = {}));

package/lib/adapters/dart/IEvidenceDartDeclaration.d.ts

@@ -0,0 +1,86 @@
+import type { IEvidenceUnitSite } from "../../structures/IEvidenceUnitSite";
+import type { EvidenceProgrammingSymbol } from "../../typings/EvidenceProgrammingSymbol";
+/**
+ * Represents one physical Dart declaration before library identity
+ * reconciliation.
+ *
+ * The scanner deliberately retains private and part-file declarations here: the
+ * library resolver needs their lexical ownership before it can decide which
+ * declarations form the selected public surface.
+ */
+export interface IEvidenceDartDeclaration {
+    /**
+     * Identifies this physical extraction record within its source snapshot.
+     *
+     * This is not a public address: one semantic unit can collect several such
+     * records through parts and complementary accessors.
+     */
+    id: string;
+    /**
+     * Gives the declared name or explicit constructor or operator segment.
+     *
+     * The scanner combines this with `identity` and `address`; it is unqualified
+     * so diagnostics can retain the source spelling.
+     */
+    name: string;
+    /**
+     * Classifies the declaration in Evidence's language-independent selector
+     * vocabulary.
+     *
+     * Materialization preserves this category while it reconciles declarations
+     * with the same Dart name.
+     */
+    symbol: EvidenceProgrammingSymbol;
+    /**
+     * Distinguishes declaration forms that share a Dart name.
+     *
+     * In particular, getter and setter roles must remain separate until unit
+     * materialization can merge their complementary public accessors.
+     */
+    role: string;
+    /**
+     * Names the defining library after `part` ownership is resolved.
+     *
+     * Unit identity uses this path so a declaration from a part cannot be
+     * mistaken for an independent declaration in the part's physical file.
+     */
+    library: string;
+    /**
+     * Lists the lexical segments that establish the declaration's semantic
+     * identity.
+     *
+     * Library reconciliation prefixes this path with the defining library so
+     * parts share their owner's identity.
+     */
+    identity: string[];
+    /**
+     * Lists the public accessor segments used in a selected source address.
+     *
+     * This may differ from `identity` after library exports project a declaration
+     * through another file.
+     */
+    address: string[];
+    /**
+     * Retains the physical declaration range and content used by hosts and
+     * fingerprints.
+     *
+     * A reconciled unit can collect multiple sites from parts or complementary
+     * accessors.
+     */
+    site: IEvidenceUnitSite;
+    /**
+     * States whether this declaration and every lexical owner are publicly
+     * visible.
+     *
+     * The adapter excludes private declarations from publication while retaining
+     * them for ownership and boundary diagnostics.
+     */
+    public: boolean;
+    /**
+     * Identifies the physical lexical owner when this is a member.
+     *
+     * The adapter maps this record to the owner's published unit only after it
+     * knows whether both declarations are public.
+     */
+    ownerDeclarationId?: string;
+}

package/lib/adapters/dart/IEvidenceDartDirective.d.ts

@@ -0,0 +1,56 @@
+import type { IEvidenceDartExportFilter } from "./IEvidenceDartExportFilter";
+import type { IEvidenceSourceRange } from "../../structures/IEvidenceSourceRange";
+/**
+ * Records one static Dart library-topology directive.
+ *
+ * EvidenceDartFileScanner retains this source-level relationship for
+ * EvidenceDartLibraries, which resolves selected files, validates part
+ * ownership, and projects exports into the public inventory without evaluating
+ * Dart.
+ */
+export interface IEvidenceDartDirective {
+    /**
+     * Identifies the library relationship expressed by this directive.
+     *
+     * EvidenceDartLibraries uses `part` and `part-of` to establish a shared
+     * library and applies export projection only for `export`.
+     */
+    kind: "part" | "part-of" | "export";
+    /**
+     * Names the decoded URI target or named `part of` library.
+     *
+     * Its interpretation depends on {@link named}: URI targets are resolved
+     * against selected source locations, while named libraries match
+     * declarations.
+     */
+    target: string;
+    /**
+     * Distinguishes a named `part of` library from a URI target.
+     *
+     * This preserves the grammar-level target form so resolution does not treat a
+     * dotted library name as a physical file address.
+     */
+    named: boolean;
+    /**
+     * Gives the selected physical file resolved from a URI target.
+     *
+     * Omission means the target is named or URI resolution did not produce one
+     * unambiguous selected file; the library pass reports the latter condition.
+     */
+    resolved?: string;
+    /**
+     * Retains export combinators in their source order.
+     *
+     * EvidenceDartLibraries applies each filter to a candidate exported
+     * declaration, so a `show` intersects the population and a `hide` subtracts
+     * from it.
+     */
+    filters: IEvidenceDartExportFilter[];
+    /**
+     * Locates the complete directive in the original source.
+     *
+     * Resolution and topology diagnostics cite this half-open UTF-16 range rather
+     * than a synthesized library relationship.
+     */
+    range: IEvidenceSourceRange;
+}

package/lib/adapters/dart/IEvidenceDartDocumentation.d.ts

@@ -0,0 +1,41 @@
+import type { IEvidenceCommentSyntax } from "../../structures/IEvidenceCommentSyntax";
+import type { IEvidenceSourceRange } from "../../structures/IEvidenceSourceRange";
+import type { IEvidenceDartDocumentationAttachment } from "./IEvidenceDartDocumentationAttachment";
+/**
+ * Represents a Dart documentation carrier or tag-bearing unsupported carrier.
+ *
+ * The scanner preserves unsupported tagged text as well as attached DartDoc so
+ * the adapter can report a misplaced annotation instead of silently ignoring
+ * it.
+ */
+export interface IEvidenceDartDocumentation {
+    /**
+     * Identifies this physical documentation carrier within the scanned source.
+     *
+     * Attachments and generated hosts use this scanner-local identity; it does
+     * not name a semantic declaration.
+     */
+    id: string;
+    /**
+     * Locates the carrier's original half-open UTF-16 source span.
+     *
+     * The adapter preserves this position for diagnostics and annotation-range
+     * exclusion.
+     */
+    range: IEvidenceSourceRange;
+    /**
+     * Defines the delimiters and annotation-reading rules for this carrier.
+     *
+     * Documentation parsing uses this syntax instead of reinterpreting raw Dart
+     * source text.
+     */
+    syntax: IEvidenceCommentSyntax;
+    /**
+     * Lists supported declaration sites that accept this carrier as
+     * documentation.
+     *
+     * Attachments are established by source adjacency before library and unit
+     * reconciliation.
+     */
+    attachments: IEvidenceDartDocumentationAttachment[];
+}

package/lib/adapters/dart/IEvidenceDartDocumentationAttachment.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Connects a DartDoc carrier to one extracted declaration site.
+ *
+ * EvidenceDartFileScanner records source-adjacent attachments here, allowing
+ * the documentation pass to evaluate one carrier against each declaration site
+ * it governs without making the comment itself own a semantic unit.
+ */
+export interface IEvidenceDartDocumentationAttachment {
+    /**
+     * Identifies the declaration extraction record that receives the DartDoc.
+     *
+     * Consumers use this stable scanner-local ID to find the declaration before
+     * evaluating its annotation against the declaration's semantic unit.
+     */
+    declarationId: string;
+    /**
+     * Identifies the physical declaration site covered by the DartDoc.
+     *
+     * A semantic unit can have multiple sites, so this keeps attachment scoped to
+     * the adjacent source occurrence instead of every site with the same unit
+     * ID.
+     */
+    siteId: string;
+}

package/lib/adapters/dart/IEvidenceDartExportFilter.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Represents one Dart export combinator retained from source order.
+ *
+ * An {@link IEvidenceDartDirective} owns these filters, and
+ * EvidenceDartLibraries applies them in sequence while deciding whether each
+ * exported top-level name is public.
+ */
+export interface IEvidenceDartExportFilter {
+    /**
+     * Selects whether this combinator keeps or removes its listed names.
+     *
+     * A `show` filter admits only listed candidates at its position, while a
+     * `hide` filter removes listed candidates that earlier filters permitted.
+     */
+    kind: "show" | "hide";
+    /**
+     * Lists literal top-level declaration names affected by this combinator.
+     *
+     * The names preserve source spelling and are compared with the candidate
+     * export name; they are not paths or resolved declaration identities.
+     */
+    names: string[];
+}

package/lib/adapters/dart/IEvidenceDartFileAnalysis.d.ts

@@ -0,0 +1,70 @@
+import type { IEvidenceDiagnostic } from "../../structures/IEvidenceDiagnostic";
+import type { IEvidenceSourceFile } from "../../structures/IEvidenceSourceFile";
+import type { IEvidenceDartDirective } from "./IEvidenceDartDirective";
+import type { IEvidenceDartDeclaration } from "./IEvidenceDartDeclaration";
+import type { IEvidenceDartDocumentation } from "./IEvidenceDartDocumentation";
+/**
+ * Holds the node-free Dart extraction retained after a parse session closes.
+ *
+ * Library resolution consumes this intermediate record across every selected
+ * file, so parser nodes cannot be retained and physical source remains
+ * explicit.
+ */
+export interface IEvidenceDartFileAnalysis {
+    /**
+     * Gives the selected physical path of the defining library.
+     *
+     * Part files adopt this owner during topology resolution instead of becoming
+     * independent public files.
+     */
+    library: string;
+    /**
+     * Gives the optional named library declaration or `part of` name.
+     *
+     * Omission denotes an unnamed library; named values let topology resolution
+     * match named part owners.
+     */
+    libraryName?: string;
+    /**
+     * Lists library topology directives retained for snapshot-wide resolution.
+     *
+     * `EvidenceDartLibraries` consumes parts and exports to establish ownership
+     * and projected public addresses.
+     */
+    directives: IEvidenceDartDirective[];
+    /**
+     * Retains the selected source file that produced this analysis.
+     *
+     * Its physical identity and configured addresses are used when units and
+     * documentation hosts are materialized.
+     */
+    source: IEvidenceSourceFile;
+    /**
+     * Lists extracted declarations, including non-public ownership boundaries.
+     *
+     * Topology resolution consumes these physical records before selecting public
+     * units.
+     */
+    declarations: IEvidenceDartDeclaration[];
+    /**
+     * Lists classified DartDoc and unsupported annotation carriers in this file.
+     *
+     * The adapter keeps tagged unsupported carriers so they can produce
+     * diagnostics rather than disappear.
+     */
+    documentation: IEvidenceDartDocumentation[];
+    /**
+     * Lists failures encountered while establishing this file's public surface.
+     *
+     * The adapter forwards them into the inventory alongside the `complete`
+     * boundary.
+     */
+    diagnostics: IEvidenceDiagnostic[];
+    /**
+     * States whether scanning classified every surface-affecting form.
+     *
+     * A false value survives topology resolution and prevents missing syntax from
+     * reducing the population used to evaluate coverage.
+     */
+    complete: boolean;
+}

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

@@ -6,83 +6,101 @@ import type { IEvidenceSourceSnapshot } from "../../structures/IEvidenceSourceSn
  *
  * 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.
  */
-export declare class EvidenceDbmlAdapter implements IEvidenceAdapter {
+export declare class EvidenceDbmlAdapter implements IEvidenceAdapter<"dbml"> {
     /**
      * 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.
      */
-    readonly type = "dbml";
+    get type(): "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.
      */
     analyze(snapshot: IEvidenceSourceSnapshot): Promise<IEvidenceInventory>;
     private scan;
     /**
-     * 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.
      */
     private 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.
      */
     private relations;
     /**
-     * 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.
      */
     private endpoint;
     /**
-     * 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.
      */
     private units;
     /**
-     * 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.
      */
     private digest;
     /**
-     * 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.
      */
     private documentation;
     /**
-     * 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.
      */
     private host;
     /**
      * 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.
      */
     private parse;
     /**
-     * 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.
      */
     private id;
     /**
      * 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.
      */
     private problem;
 }