@wrtnlabs/evidence 0.0.0 → 0.1.0

package/lib/adapters/swagger/EvidenceSwaggerRemoteReader.d.ts

@@ -0,0 +1,45 @@
+import type { IEvidenceRemoteSwaggerSource } from "./IEvidenceRemoteSwaggerSource";
+/**
+ * Validates and reads explicitly configured HTTP(S) Swagger sources.
+ *
+ * Remote input is intentionally bounded before parsing so a configured URL
+ * cannot turn schema discovery into an unbounded memory or time consumer.
+ */
+export declare namespace EvidenceSwaggerRemoteReader {
+    /**
+     * Parses a configured remote source only when it has a URL scheme.
+     *
+     * Returning `undefined` leaves ordinary paths to the local-source loader;
+     * explicit remote URLs must be HTTP(S) and cannot use fragments.
+     */
+    function parse(source: string): URL | undefined;
+    /**
+     * Reads one remote document and fingerprints the exact accepted bytes.
+     *
+     * The content-length preflight and streamed byte count enforce the same limit
+     * when a server omits or lies about its response header.
+     */
+    function read(url: URL): Promise<IEvidenceRemoteSwaggerSource>;
+    /**
+     * Renders a safe source label for diagnostics.
+     *
+     * Query values may carry credentials or arbitrary user data, so their
+     * presence is retained while their contents are never exposed.
+     */
+    function display(url: URL): string;
+    /**
+     * Produces a safe diagnostic label before remote URL validation completes.
+     *
+     * Valid URLs reuse the canonical display contract. Malformed URL-like inputs
+     * still lose user information, query values, and fragments without changing
+     * ordinary local filesystem spellings.
+     */
+    function safeDisplay(source: string): string;
+    /**
+     * Removes the configured remote source and any URL repeated by a lower error.
+     *
+     * Fetch implementations may embed credential-bearing input in exception text,
+     * so sanitizing only the diagnostic location cannot establish redaction.
+     */
+    function safeMessage(cause: unknown, source: string): string;
+}

package/lib/adapters/swagger/EvidenceSwaggerRemoteReader.js

@@ -0,0 +1,153 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EvidenceSwaggerRemoteReader = void 0;
+const node_crypto_1 = require("node:crypto");
+const MAX_DOCUMENT_BYTES = 16 * 1024 * 1024;
+const REMOTE_TIMEOUT_MILLISECONDS = 30_000;
+/**
+ * Validates and reads explicitly configured HTTP(S) Swagger sources.
+ *
+ * Remote input is intentionally bounded before parsing so a configured URL
+ * cannot turn schema discovery into an unbounded memory or time consumer.
+ */
+var EvidenceSwaggerRemoteReader;
+(function (EvidenceSwaggerRemoteReader) {
+    /**
+     * Parses a configured remote source only when it has a URL scheme.
+     *
+     * Returning `undefined` leaves ordinary paths to the local-source loader;
+     * explicit remote URLs must be HTTP(S) and cannot use fragments.
+     */
+    function parse(source) {
+        if (!/^[A-Za-z][A-Za-z0-9+.-]*:\/\//u.test(source))
+            return undefined;
+        const url = new URL(source);
+        if (url.protocol !== "http:" && url.protocol !== "https:")
+            throw new Error("Only HTTP(S) URLs can name a remote Swagger source.");
+        if (url.hash !== "")
+            throw new Error("A remote Swagger document URL must not contain a fragment.");
+        return url;
+    }
+    EvidenceSwaggerRemoteReader.parse = parse;
+    /**
+     * Reads one remote document and fingerprints the exact accepted bytes.
+     *
+     * The content-length preflight and streamed byte count enforce the same limit
+     * when a server omits or lies about its response header.
+     */
+    async function read(url) {
+        const response = await fetch(url, {
+            signal: AbortSignal.timeout(REMOTE_TIMEOUT_MILLISECONDS),
+        });
+        if (!response.ok)
+            throw new Error(`HTTP ${response.status} ${response.statusText === "" ? "response" : response.statusText}`);
+        const declared = Number(response.headers.get("content-length"));
+        if (Number.isFinite(declared) && declared > MAX_DOCUMENT_BYTES)
+            throw new Error(`The Swagger document exceeds the ${MAX_DOCUMENT_BYTES} byte limit.`);
+        if (response.body === null)
+            return decode(new Uint8Array());
+        const reader = response.body.getReader();
+        const chunks = [];
+        let length = 0;
+        let next = await reader.read();
+        while (next.done === false) {
+            length += next.value.byteLength;
+            if (length > MAX_DOCUMENT_BYTES) {
+                await reader.cancel();
+                throw new Error(`The Swagger document exceeds the ${MAX_DOCUMENT_BYTES} byte limit.`);
+            }
+            chunks.push(next.value);
+            next = await reader.read();
+        }
+        const bytes = new Uint8Array(length);
+        let offset = 0;
+        for (const chunk of chunks) {
+            bytes.set(chunk, offset);
+            offset += chunk.byteLength;
+        }
+        return decode(bytes);
+    }
+    EvidenceSwaggerRemoteReader.read = read;
+    /**
+     * Renders a safe source label for diagnostics.
+     *
+     * Query values may carry credentials or arbitrary user data, so their
+     * presence is retained while their contents are never exposed.
+     */
+    function display(url) {
+        const query = url.search === "" ? "" : "?<redacted>";
+        return `${url.origin}${url.pathname}${query}`;
+    }
+    EvidenceSwaggerRemoteReader.display = display;
+    /**
+     * Produces a safe diagnostic label before remote URL validation completes.
+     *
+     * Valid URLs reuse the canonical display contract. Malformed URL-like inputs
+     * still lose user information, query values, and fragments without changing
+     * ordinary local filesystem spellings.
+     */
+    function safeDisplay(source) {
+        const candidate = source.trim();
+        if (!remoteCandidate(candidate))
+            return source;
+        try {
+            const url = new URL(candidate);
+            const query = url.search === "" ? "" : "?<redacted>";
+            const fragment = url.hash === "" ? "" : "#<redacted>";
+            url.username = "";
+            url.password = "";
+            return `${url.origin}${url.pathname}${query}${fragment}`;
+        }
+        catch {
+            return candidate
+                .replace(/^([A-Za-z][A-Za-z0-9+.-]*:\/\/)[^/?#]*@/u, "$1<redacted>@")
+                .replace(/\?[^#]*/u, "?<redacted>")
+                .replace(/#[\s\S]*/u, "#<redacted>");
+        }
+    }
+    EvidenceSwaggerRemoteReader.safeDisplay = safeDisplay;
+    /**
+     * Removes the configured remote source and any URL repeated by a lower error.
+     *
+     * Fetch implementations may embed credential-bearing input in exception text,
+     * so sanitizing only the diagnostic location cannot establish redaction.
+     */
+    function safeMessage(cause, source) {
+        let output = cause instanceof Error ? cause.message : String(cause);
+        const candidate = source.trim();
+        if (!remoteCandidate(candidate))
+            return output;
+        const display = safeDisplay(source);
+        output = output.replaceAll(source, display);
+        output = output.replaceAll(candidate, display);
+        try {
+            output = output.replaceAll(new URL(candidate).href, display);
+        }
+        catch {
+            // The exact source replacement above covers the invalid URL parser message.
+        }
+        return output;
+    }
+    EvidenceSwaggerRemoteReader.safeMessage = safeMessage;
+})(EvidenceSwaggerRemoteReader || (exports.EvidenceSwaggerRemoteReader = EvidenceSwaggerRemoteReader = {}));
+/**
+ * Decodes accepted bytes and keeps a byte-exact cache identity.
+ *
+ * Digesting before text parsing makes cache ownership independent of Unicode
+ * normalization performed by later document processing.
+ */
+function decode(bytes) {
+    return {
+        content: new TextDecoder("utf-8", { fatal: true }).decode(bytes),
+        digest: (0, node_crypto_1.createHash)("sha256").update(bytes).digest("hex"),
+    };
+}
+/**
+ * Recognizes input whose spelling can expose remote URL secrets.
+ *
+ * Redaction starts before strict URL parsing because malformed remote-looking
+ * input can still contain credentials or query values in parser diagnostics.
+ */
+function remoteCandidate(source) {
+    return /^[A-Za-z][A-Za-z0-9+.-]*:\/\//u.test(source);
+}

package/lib/adapters/swagger/EvidenceSwaggerTarget.d.ts

@@ -0,0 +1,16 @@
+import type { IEvidenceAddress } from "../../structures/IEvidenceAddress";
+/**
+ * Parses one whitespace-free Swagger operation target.
+ *
+ * Swagger has no physical source-file address, so accepted selectors are placed
+ * in the synthetic `swagger:` file namespace as one atomic segment.
+ */
+export declare namespace EvidenceSwaggerTarget {
+    /**
+     * Converts a public `METHOD:/path` selector to an Evidence address.
+     *
+     * Validation here matches loader targets so a citation cannot select an
+     * operation shape the adapter would never materialize.
+     */
+    function parse(target: string): IEvidenceAddress;
+}

package/lib/adapters/swagger/EvidenceSwaggerTarget.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EvidenceSwaggerTarget = void 0;
+/**
+ * Parses one whitespace-free Swagger operation target.
+ *
+ * Swagger has no physical source-file address, so accepted selectors are placed
+ * in the synthetic `swagger:` file namespace as one atomic segment.
+ */
+var EvidenceSwaggerTarget;
+(function (EvidenceSwaggerTarget) {
+    /**
+     * Converts a public `METHOD:/path` selector to an Evidence address.
+     *
+     * Validation here matches loader targets so a citation cannot select an
+     * operation shape the adapter would never materialize.
+     */
+    function parse(target) {
+        if (/\s/u.test(target))
+            throw new Error("Remove whitespace from the Swagger operation target.");
+        const separator = target.indexOf(":");
+        const method = separator < 0 ? "" : target.slice(0, separator);
+        const path = separator < 0 ? "" : target.slice(separator + 1);
+        if (!/^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/u.test(method) ||
+            method !== method.toUpperCase() ||
+            !path.startsWith("/"))
+            throw new Error("Use an uppercase METHOD:/path target such as POST:/members.");
+        return { file: "swagger:", segments: [target] };
+    }
+    EvidenceSwaggerTarget.parse = parse;
+})(EvidenceSwaggerTarget || (exports.EvidenceSwaggerTarget = EvidenceSwaggerTarget = {}));

package/lib/adapters/swagger/EvidenceYamlScalarMapper.d.ts

@@ -0,0 +1,11 @@
+import type { Scalar } from "yaml";
+import type { IEvidenceYamlScalarMapping } from "./IEvidenceYamlScalarMapping";
+/**
+ * Maps a decoded YAML string scalar back to its original UTF-16 token.
+ *
+ * Swagger documentation extraction needs this mapping because YAML escape
+ * decoding changes text length while Evidence diagnostics must address source.
+ */
+export declare namespace EvidenceYamlScalarMapper {
+    function map(content: string, node: Scalar<string>): IEvidenceYamlScalarMapping | undefined;
+}

package/lib/adapters/swagger/EvidenceYamlScalarMapper.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EvidenceYamlScalarMapper = void 0;
+const EvidenceSourceText_1 = require("../../internal/EvidenceSourceText");
+/**
+ * Maps a decoded YAML string scalar back to its original UTF-16 token.
+ *
+ * Swagger documentation extraction needs this mapping because YAML escape
+ * decoding changes text length while Evidence diagnostics must address source.
+ */
+var EvidenceYamlScalarMapper;
+(function (EvidenceYamlScalarMapper) {
+    function map(content, node) {
+        const tuple = node.range;
+        if (tuple === undefined || tuple === null)
+            return undefined;
+        const source = new EvidenceSourceText_1.EvidenceSourceText(content);
+        const range = source.range(tuple[0], tuple[1]);
+        const text = node.value;
+        const offsets = [];
+        const ends = [];
+        let cursor = tuple[0];
+        let escapedStart = cursor;
+        let escapedEnd = cursor;
+        let escapedUnits = 0;
+        if (node.type === "QUOTE_DOUBLE" || node.type === "QUOTE_SINGLE")
+            ++cursor;
+        for (let index = 0; index < text.length; ++index) {
+            if (escapedUnits > 0) {
+                offsets.push(escapedStart);
+                ends.push(escapedEnd);
+                escapedStart = escapedEnd;
+                --escapedUnits;
+                continue;
+            }
+            if (node.type === "QUOTE_DOUBLE" && content[cursor] === "\\") {
+                const escape = escaped(content, cursor, tuple[1]);
+                const unitEnd = escape[1] === 1
+                    ? escape[0]
+                    : cursor + Math.floor((escape[0] - cursor) / escape[1]);
+                offsets.push(cursor);
+                ends.push(unitEnd);
+                escapedStart = unitEnd;
+                escapedEnd = escape[0];
+                escapedUnits = escape[1] - 1;
+                cursor = escape[0];
+                continue;
+            }
+            const found = content.indexOf(text[index] ?? "", cursor);
+            if (found >= cursor && found < tuple[1]) {
+                offsets.push(found);
+                ends.push(found + 1);
+                cursor = found + 1;
+            }
+            else {
+                const start = Math.min(cursor, tuple[1]);
+                const end = Math.min(start + 1, tuple[1]);
+                offsets.push(start);
+                ends.push(end);
+                cursor = end;
+            }
+        }
+        offsets.push(Math.min(cursor, tuple[1]));
+        return { text, range, offsets, ends };
+    }
+    EvidenceYamlScalarMapper.map = map;
+})(EvidenceYamlScalarMapper || (exports.EvidenceYamlScalarMapper = EvidenceYamlScalarMapper = {}));
+function escaped(content, start, limit) {
+    const marker = content[start + 1];
+    const length = marker === "x" ? 4 : marker === "u" ? 6 : marker === "U" ? 10 : 2;
+    const end = Math.min(start + length, limit);
+    if (marker !== "U")
+        return [end, 1];
+    const value = Number.parseInt(content.slice(start + 2, end), 16);
+    return [end, Number.isFinite(value) && value > 0xffff ? 2 : 1];
+}

package/lib/adapters/swagger/IEvidenceRemoteSwaggerSource.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Bounded UTF-8 response read from one configured Swagger URL.
+ *
+ * Remote loading owns the bytes and their digest together so later parsing and
+ * caching describe the exact response that passed the size limit.
+ */
+export interface IEvidenceRemoteSwaggerSource {
+    /**
+     * Decoded response content.
+     *
+     * The reader accepts only valid UTF-8, so loaders may parse this text without
+     * applying a replacement-character normalization.
+     */
+    content: string;
+    /**
+     * SHA-256 identity of the received bytes.
+     *
+     * This remains byte-based because semantically equal decoded strings can have
+     * arrived from different invalid or normalized encodings.
+     */
+    digest: string;
+}

package/lib/adapters/swagger/IEvidenceSwaggerCacheEntry.d.ts

@@ -0,0 +1,21 @@
+import type { IEvidenceSwaggerLoadResult } from "./IEvidenceSwaggerLoadResult";
+/**
+ * Remembered normalization outcome for one exact document digest.
+ *
+ * The cache records failures as well as results so a malformed unchanged source
+ * has deterministic behavior without repeating conversion work.
+ */
+export interface IEvidenceSwaggerCacheEntry {
+    /**
+     * Successful operation inventory, when normalization completed.
+     *
+     * Omission means this entry represents the failure below.
+     */
+    result?: IEvidenceSwaggerLoadResult;
+    /**
+     * Stable failure message for the cached input.
+     *
+     * Omission means the result is safe to clone for a caller.
+     */
+    problem?: string;
+}

package/lib/adapters/swagger/IEvidenceSwaggerLoadResult.d.ts

@@ -0,0 +1,15 @@
+import type { IEvidenceSwaggerOperation } from "./IEvidenceSwaggerOperation";
+/**
+ * Normalized operations from one Swagger or OpenAPI document.
+ *
+ * The loader converts accepted source versions to this version-neutral shape
+ * before the adapter materializes public operation units.
+ */
+export interface IEvidenceSwaggerLoadResult {
+    /**
+     * Operations ordered by their public targets.
+     *
+     * Each target occurs at most once; duplicates are rejected during loading.
+     */
+    operations: IEvidenceSwaggerOperation[];
+}

package/lib/adapters/swagger/IEvidenceSwaggerOperation.d.ts

@@ -0,0 +1,48 @@
+import type { IEvidenceSwaggerOperationLocation } from "./IEvidenceSwaggerOperationLocation";
+/**
+ * One normalized Swagger operation and its semantic fingerprint input.
+ *
+ * This separates the public operation address from content used to detect a
+ * schema change, while retaining optional source coordinates for diagnostics.
+ */
+export interface IEvidenceSwaggerOperation {
+    /**
+     * Stores the uppercase HTTP method forming the public target prefix.
+     *
+     * Normalization keeps OpenAPI method spelling independent from target
+     * matching.
+     */
+    method: string;
+    /**
+     * Stores the absolute OpenAPI path forming the public target suffix.
+     *
+     * Its literal path spelling remains distinct from the HTTP method identity.
+     */
+    path: string;
+    /**
+     * Provides the stable public address in `METHOD:/path` form.
+     *
+     * Evidence tags resolve operations through this combined method-and-path
+     * identity.
+     */
+    target: string;
+    /**
+     * Digest of canonical operation semantics.
+     *
+     * Description metadata and reference indirection are normalized before this
+     * value is computed, keeping review state tied to API meaning.
+     */
+    digest: string;
+    /**
+     * Original description text, when the operation supplies one.
+     *
+     * Omission distinguishes no description from an explicitly empty string.
+     */
+    description?: string;
+    /**
+     * Source coordinates for the operation and mapped description, when known.
+     *
+     * Converted or aliased YAML may not have a direct scalar location.
+     */
+    location?: IEvidenceSwaggerOperationLocation;
+}

package/lib/adapters/swagger/IEvidenceSwaggerOperationLocation.d.ts

@@ -0,0 +1,22 @@
+import type { IEvidenceSourceRange } from "../../structures/IEvidenceSourceRange";
+import type { IEvidenceYamlScalarMapping } from "./IEvidenceYamlScalarMapping";
+/**
+ * Source spans for one normalized Swagger operation and its description.
+ *
+ * Locations are optional on operations because OpenAPI conversion can preserve
+ * semantics for values that do not map to one source token.
+ */
+export interface IEvidenceSwaggerOperationLocation {
+    /**
+     * Locates the full operation node used as the physical unit site.
+     *
+     * The range keeps diagnostics and fingerprints tied to the original document.
+     */
+    range: IEvidenceSourceRange;
+    /**
+     * Maps description characters when the scalar has a source-backed location.
+     *
+     * Omission means converted or aliased content has no direct scalar token.
+     */
+    description?: IEvidenceYamlScalarMapping;
+}

package/lib/adapters/swagger/IEvidenceYamlScalarMapping.d.ts

@@ -0,0 +1,38 @@
+import type { IEvidenceSourceRange } from "../../structures/IEvidenceSourceRange";
+/**
+ * Decoded YAML scalar with monotonic positions in its source token.
+ *
+ * Documentation handling uses the maps to convert decoded annotation offsets
+ * back to the UTF-16 positions that users can edit.
+ */
+export interface IEvidenceYamlScalarMapping {
+    /**
+     * Decoded scalar text inspected for Evidence annotations.
+     *
+     * Annotation parsing uses this value while `offsets` and `ends` translate its
+     * decoded UTF-16 positions back into the original YAML source token.
+     */
+    text: string;
+    /**
+     * Complete scalar token span in the original document.
+     *
+     * This range bounds every decoded-offset mapping and supplies the source
+     * location when a YAML scalar's annotation needs a diagnostic.
+     */
+    range: IEvidenceSourceRange;
+    /**
+     * Source start offsets indexed by decoded UTF-16 code unit.
+     *
+     * Each entry identifies where the corresponding decoded unit begins,
+     * including escape sequences that occupy a wider physical spelling in the
+     * document.
+     */
+    offsets: number[];
+    /**
+     * Source end offsets paired with `offsets` entries.
+     *
+     * The matching interval permits annotation spans to include an entire escape
+     * spelling rather than pointing into only part of one YAML scalar token.
+     */
+    ends: number[];
+}

package/lib/adapters/swift/EvidenceSwiftAdapter.d.ts

@@ -1,15 +1,124 @@
-import { SwiftAdapter } from "./SwiftAdapter";
+import type { IEvidenceAdapter } from "../../structures/IEvidenceAdapter";
+import type { IEvidenceInventory } from "../../structures/IEvidenceInventory";
+import type { IEvidenceSourceSnapshot } from "../../structures/IEvidenceSourceSnapshot";
 /**
- * Extracts explicit public and open Swift declarations within one selected module.
+ * Reconciles Swift extension ownership and DocC within one configured module.
  *
- * Local nominal extensions and protocol requirements participate in ownership
- * reconciliation before publication. Overloads group by base name, static members
- * use an explicit static segment, and attached DocC retains the declaration site
- * that owns each annotation. Separately configured module roots remain independent.
- *
- * External or constrained extensions, macro and custom-attribute expansion,
- * conditional compilation, and generated or inherited members are outside this
- * declared-source boundary.
+ * The scanner records explicit declarations before snapshot-wide ownership
+ * resolution links extensions and nominal types. Materialization includes the
+ * root identity so equal declarations in separate module selections stay
+ * distinct. Documentation then attaches to the reconciled owners, while source
+ * dependencies retain every physical file needed to invalidate the analysis.
  */
-export declare class EvidenceSwiftAdapter extends SwiftAdapter {
+export declare class EvidenceSwiftAdapter implements IEvidenceAdapter<"swift"> {
+    /**
+     * Swift discriminator for explicit public and open source declarations.
+     *
+     * The module boundary comes from the snapshot root. This value selects Swift
+     * grammar and visibility rules without inferring generated members.
+     */
+    get type(): "swift";
+    /**
+     * Builds a module-scoped Swift inventory from a captured source population.
+     *
+     * Extension ownership resolves before units are published. Inaccessible
+     * input, unsupported ownership, and syntax failures remain incomplete
+     * findings; the invocation releases its parser regardless of the
+     * materialization outcome.
+     */
+    analyze(snapshot: IEvidenceSourceSnapshot): Promise<IEvidenceInventory>;
+    private scan;
+    /**
+     * Reconciles overload families and retains each physical declaration address.
+     *
+     * Conflicting public identities remain incomplete instead of being merged by
+     * source order.
+     */
+    private materializeUnits;
+    /**
+     * Allows a protocol requirement and its explicit extension property
+     * implementation to share a unit.
+     *
+     * Other repeated non-function declarations remain conflicts because they do
+     * not establish this pairing.
+     */
+    private protocolDefault;
+    /**
+     * Resolves withdrawals before publishing attached annotation hosts.
+     *
+     * Hidden units remain unavailable to ordinary tags while their withdrawal
+     * location stays diagnostic context.
+     */
+    private materializeDocumentation;
+    /**
+     * Retains public declaration sites even when they carry no documentation.
+     *
+     * Host policies can therefore distinguish an eligible untagged site from
+     * missing extraction.
+     */
+    private materializeUndocumentedHosts;
+    /**
+     * Groups published semantic owners by their physical declaration site.
+     *
+     * One documentation carrier can attach to several selected units at the same
+     * source occurrence.
+     */
+    private attachmentGroups;
+    /**
+     * Creates an attached or explicitly unsupported documentation carrier.
+     *
+     * Unsupported annotation carriers retain repair guidance rather than being
+     * discarded.
+     */
+    private host;
+    /**
+     * Parses Evidence tags only after the adapter establishes their host.
+     *
+     * Host ownership determines the source context in which authored targets
+     * resolve.
+     */
+    private parse;
+    /**
+     * Detects Evidence or withdrawal annotations outside masked examples.
+     *
+     * The result decides whether an otherwise unsupported carrier needs a
+     * diagnostic host.
+     */
+    private annotation;
+    /**
+     * Detects acknowledgements and reviews on withdrawn carriers.
+     *
+     * Withdrawal directives themselves are excluded so they can be processed as
+     * visibility state.
+     */
+    private claimAnnotation;
+    /**
+     * Recognizes supported annotation names at documentation line boundaries.
+     *
+     * Restricting the match avoids treating inline prose or example fragments as
+     * annotations.
+     */
+    private annotationPattern;
+    /**
+     * Follows explicit parent ownership to propagate withdrawal.
+     *
+     * The visited set rejects cycles while preserving the nearest valid hidden
+     * ancestor.
+     */
+    private withdrawn;
+    /**
+     * Separates programming kinds while unifying module-scoped overload
+     * identities.
+     *
+     * The module root keeps equal source-relative declarations in different
+     * selections distinct.
+     */
+    private unitId;
+    /**
+     * Marks a declaration conflict as incomplete analysis.
+     *
+     * The diagnostic remains associated with the source analysis that supplied
+     * the conflict.
+     */
+    private problem;
 }