@wrtnlabs/evidence 0.0.0

package/lib/adapters/java/JavaFileScanner.d.ts

@@ -0,0 +1,51 @@
+import type { EvidenceParseSession } from "../../parsers/EvidenceParseSession";
+import type { IEvidenceSourceFile } from "../../structures/IEvidenceSourceFile";
+import type { IJavaFileAnalysis } from "./IJavaFileAnalysis";
+/**
+ * Extracts Java packages, declarations, and Javadoc before family materialization.
+ *
+ * Ownership and visibility are recorded from selected source only; `JavaAdapter`
+ * later reconciles compatible declaration families into graph units.
+ */
+export declare class JavaFileScanner {
+    private readonly session;
+    private readonly source;
+    private readonly declarations;
+    private readonly documentation;
+    private readonly carrierDocumentation;
+    private readonly diagnostics;
+    private readonly reported;
+    private readonly text;
+    private complete;
+    /**
+     * Creates a scanner for one Java parse session and source snapshot.
+     *
+     * Javadoc carriers are collected before declaration walking so their physical
+     * attachment cannot be confused with same-named declarations elsewhere.
+     */
+    constructor(session: EvidenceParseSession, source: IEvidenceSourceFile);
+    /**
+     * Produces node-free package declarations, documentation, and diagnostics.
+     *
+     * The result records unsupported relevant forms as incomplete rather than
+     * allowing the adapter to publish a falsely complete smaller inventory.
+     */
+    scan(): IJavaFileAnalysis;
+    private scanType;
+    private scanTypeBody;
+    private scanRecordComponents;
+    private scanField;
+    private scanMethod;
+    private scanEnumConstant;
+    private scanAnnotationElement;
+    private typePublic;
+    private memberPublic;
+    private addDeclaration;
+    private collectDocumentation;
+    private attach;
+    private ensureDocumentation;
+    private annotation;
+    private nodeKey;
+    private siteId;
+    private problem;
+}

package/lib/adapters/java/JavaFileScanner.js

@@ -0,0 +1,317 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JavaFileScanner = void 0;
+const JavaSyntax_1 = require("./JavaSyntax");
+const SourceText_1 = require("../../internal/SourceText");
+/**
+ * Extracts Java packages, declarations, and Javadoc before family materialization.
+ *
+ * Ownership and visibility are recorded from selected source only; `JavaAdapter`
+ * later reconciles compatible declaration families into graph units.
+ */
+class JavaFileScanner {
+    session;
+    source;
+    declarations = [];
+    documentation = new Map();
+    carrierDocumentation = new Map();
+    diagnostics = [];
+    reported = new Set();
+    text;
+    complete = true;
+    /**
+     * Creates a scanner for one Java parse session and source snapshot.
+     *
+     * Javadoc carriers are collected before declaration walking so their physical
+     * attachment cannot be confused with same-named declarations elsewhere.
+     */
+    constructor(session, source) {
+        this.session = session;
+        this.source = source;
+        this.text = new SourceText_1.SourceText(source.content);
+        this.collectDocumentation();
+    }
+    /**
+     * Produces node-free package declarations, documentation, and diagnostics.
+     *
+     * The result records unsupported relevant forms as incomplete rather than
+     * allowing the adapter to publish a falsely complete smaller inventory.
+     */
+    scan() {
+        const packageDeclaration = this.session.root.namedChildren.find((child) => child.type === "package_declaration");
+        const packagePath = JavaSyntax_1.JavaSyntax.packagePath(packageDeclaration);
+        for (const item of this.session.root.namedChildren)
+            switch (item.type) {
+                case "package_declaration":
+                case "import_declaration":
+                case "line_comment":
+                case "block_comment":
+                case "module_declaration":
+                    break;
+                case "class_declaration":
+                    this.scanType(item, packagePath, undefined, "class", "class");
+                    break;
+                case "interface_declaration":
+                    this.scanType(item, packagePath, undefined, "interface", "interface");
+                    break;
+                case "enum_declaration":
+                    this.scanType(item, packagePath, undefined, "enum", "enum");
+                    break;
+                case "annotation_type_declaration":
+                    this.scanType(item, packagePath, undefined, "annotation", "annotation");
+                    break;
+                case "record_declaration":
+                    this.scanType(item, packagePath, undefined, "record", "record");
+                    break;
+                default:
+                    if (JavaSyntax_1.JavaSyntax.hasModifier(item, "public"))
+                        this.problem("java-public-form", `Public Java source form '${item.type}' is not classified by this adapter.`, "Add an explicit declaration-form rule before evaluating this public surface.", item);
+            }
+        return {
+            source: this.source,
+            declarations: this.declarations,
+            documentation: Array.from(this.documentation.values()),
+            diagnostics: this.diagnostics,
+            complete: this.complete,
+        };
+    }
+    scanType(item, packagePath, owner, kind, form) {
+        const name = JavaSyntax_1.JavaSyntax.name(item.childForFieldName("name"));
+        if (name === undefined) {
+            this.problem("java-type-name", `A Java ${form} declaration has no statically readable name.`, "Use one ordinary named declaration.", item);
+            return;
+        }
+        const identity = [
+            ...(owner === undefined ? packagePath : owner.identity),
+            name,
+        ];
+        const address = [...(owner?.address ?? []), name];
+        const visible = this.typePublic(item, owner);
+        const declaration = this.addDeclaration(item, item, JavaSyntax_1.JavaSyntax.javadoc(item), [this.session.range(item)], name, "type", form, identity, address, visible, owner?.declarationId);
+        const context = {
+            declarationId: declaration.id,
+            identity,
+            address,
+            kind,
+            public: visible,
+        };
+        if (kind === "record")
+            this.scanRecordComponents(item, context);
+        const body = item.childForFieldName("body");
+        if (body !== null)
+            this.scanTypeBody(body, context);
+    }
+    scanTypeBody(body, owner) {
+        for (const member of body.namedChildren)
+            switch (member.type) {
+                case "line_comment":
+                case "block_comment":
+                case "constructor_declaration":
+                case "compact_constructor_declaration":
+                case "static_initializer":
+                    break;
+                case "enum_body_declarations":
+                    this.scanTypeBody(member, owner);
+                    break;
+                case "class_declaration":
+                    this.scanType(member, [], owner, "class", "class");
+                    break;
+                case "interface_declaration":
+                    this.scanType(member, [], owner, "interface", "interface");
+                    break;
+                case "enum_declaration":
+                    this.scanType(member, [], owner, "enum", "enum");
+                    break;
+                case "annotation_type_declaration":
+                    this.scanType(member, [], owner, "annotation", "annotation");
+                    break;
+                case "record_declaration":
+                    this.scanType(member, [], owner, "record", "record");
+                    break;
+                case "field_declaration":
+                    this.scanField(member, owner, "field");
+                    break;
+                case "constant_declaration":
+                    this.scanField(member, owner, "interface-constant");
+                    break;
+                case "method_declaration":
+                    this.scanMethod(member, owner);
+                    break;
+                case "enum_constant":
+                    this.scanEnumConstant(member, owner);
+                    break;
+                case "annotation_type_element_declaration":
+                    this.scanAnnotationElement(member, owner);
+                    break;
+                default:
+                    if (JavaSyntax_1.JavaSyntax.hasModifier(member, "public"))
+                        this.problem("java-public-form", `Public Java member form '${member.type}' is not classified by this adapter.`, "Add an explicit member rule before evaluating this public type.", member);
+            }
+    }
+    scanRecordComponents(item, owner) {
+        const parameters = item.childForFieldName("parameters");
+        for (const parameter of parameters === null
+            ? []
+            : parameters.namedChildren) {
+            if (parameter.type !== "formal_parameter" &&
+                parameter.type !== "spread_parameter")
+                continue;
+            const name = JavaSyntax_1.JavaSyntax.parameterName(parameter);
+            if (name === undefined)
+                continue;
+            this.addDeclaration(parameter, parameter, JavaSyntax_1.JavaSyntax.javadoc(parameter), [this.session.range(parameter)], name, "property", "record-component", [...owner.identity, name], [...owner.address, name], owner.public, owner.declarationId);
+        }
+    }
+    scanField(item, owner, form) {
+        const declarators = item.namedChildren.filter((child) => child.type === "variable_declarator");
+        const first = declarators[0];
+        if (first === undefined)
+            return;
+        const header = this.text.range(item.startIndex, first.startIndex);
+        const documentation = JavaSyntax_1.JavaSyntax.javadoc(item);
+        const visible = this.memberPublic(item, owner, form !== "field");
+        for (const declarator of declarators) {
+            const name = JavaSyntax_1.JavaSyntax.name(declarator.childForFieldName("name"));
+            if (name === undefined)
+                continue;
+            this.addDeclaration(declarator, item, documentation, [header, this.session.range(declarator)], name, "property", form, [...owner.identity, name], [...owner.address, name], visible, owner.declarationId);
+        }
+    }
+    scanMethod(item, owner) {
+        const name = JavaSyntax_1.JavaSyntax.name(item.childForFieldName("name"));
+        if (name === undefined)
+            return;
+        this.addDeclaration(item, item, JavaSyntax_1.JavaSyntax.javadoc(item), [this.session.range(item)], name, "function", "method", [...owner.identity, name], [...owner.address, name], this.memberPublic(item, owner, owner.kind === "interface"), owner.declarationId);
+    }
+    scanEnumConstant(item, owner) {
+        const name = JavaSyntax_1.JavaSyntax.name(item.childForFieldName("name"));
+        if (name === undefined)
+            return;
+        this.addDeclaration(item, item, JavaSyntax_1.JavaSyntax.javadoc(item), [this.session.range(item)], name, "property", "enum-constant", [...owner.identity, name], [...owner.address, name], owner.public, owner.declarationId);
+    }
+    scanAnnotationElement(item, owner) {
+        const name = JavaSyntax_1.JavaSyntax.name(item.childForFieldName("name"));
+        if (name === undefined)
+            return;
+        this.addDeclaration(item, item, JavaSyntax_1.JavaSyntax.javadoc(item), [this.session.range(item)], name, "property", "annotation-element", [...owner.identity, name], [...owner.address, name], owner.public, owner.declarationId);
+    }
+    typePublic(item, owner) {
+        if (owner === undefined)
+            return JavaSyntax_1.JavaSyntax.hasModifier(item, "public");
+        if (!owner.public)
+            return false;
+        if (JavaSyntax_1.JavaSyntax.hasModifier(item, "private"))
+            return false;
+        if (JavaSyntax_1.JavaSyntax.hasModifier(item, "protected"))
+            return false;
+        return owner.kind === "interface" || owner.kind === "annotation"
+            ? true
+            : JavaSyntax_1.JavaSyntax.hasModifier(item, "public");
+    }
+    memberPublic(item, owner, implicit) {
+        if (!owner.public)
+            return false;
+        if (JavaSyntax_1.JavaSyntax.hasModifier(item, "private"))
+            return false;
+        if (JavaSyntax_1.JavaSyntax.hasModifier(item, "protected"))
+            return false;
+        return implicit || JavaSyntax_1.JavaSyntax.hasModifier(item, "public");
+    }
+    addDeclaration(item, siteNode, documentationNode, content, name, symbol, form, identity, address, visible, ownerDeclarationId) {
+        const site = {
+            id: this.siteId(siteNode),
+            file: this.source.physicalPath,
+            range: this.text.range(documentationNode?.startIndex ?? siteNode.startIndex, siteNode.endIndex),
+            content,
+        };
+        const declaration = {
+            id: `java:${this.source.id}:declaration:${form}:${item.startIndex}:${name}`,
+            name,
+            symbol,
+            form,
+            identity,
+            address,
+            site,
+            public: visible,
+            ...(ownerDeclarationId === undefined ? {} : { ownerDeclarationId }),
+        };
+        this.declarations.push(declaration);
+        if (documentationNode !== null) {
+            const documentation = this.carrierDocumentation.get(this.nodeKey(documentationNode));
+            if (documentation !== undefined)
+                this.attach(documentation, declaration.id, site.id);
+        }
+        return declaration;
+    }
+    collectDocumentation() {
+        const comments = [
+            ...this.session.root.descendantsOfType("line_comment"),
+            ...this.session.root.descendantsOfType("block_comment"),
+        ];
+        for (const comment of comments) {
+            const syntax = JavaSyntax_1.JavaSyntax.comment(comment);
+            const range = this.session.range(comment);
+            const javadoc = comment.type === "block_comment" && comment.text.startsWith("/**");
+            const raw = this.source.content.slice(range.start.offset + syntax.opening.length, range.end.offset - syntax.closing.length);
+            if (!javadoc && !this.annotation(raw))
+                continue;
+            const documentation = this.ensureDocumentation(range, syntax);
+            this.carrierDocumentation.set(this.nodeKey(comment), documentation);
+        }
+        const literals = [...this.session.root.descendantsOfType("string_literal")];
+        for (const literal of literals) {
+            const syntax = JavaSyntax_1.JavaSyntax.string(literal);
+            if (syntax === undefined)
+                continue;
+            const raw = literal.text.slice(syntax.opening.length, literal.text.length - syntax.closing.length);
+            if (this.annotation(raw))
+                this.ensureDocumentation(this.session.range(literal), syntax);
+        }
+    }
+    attach(documentation, declarationId, siteId) {
+        if (!documentation.attachments.some((attachment) => attachment.declarationId === declarationId &&
+            attachment.siteId === siteId))
+            documentation.attachments.push({ declarationId, siteId });
+    }
+    ensureDocumentation(range, syntax) {
+        const key = `${range.start.offset}:${range.end.offset}`;
+        let documentation = this.documentation.get(key);
+        if (documentation === undefined) {
+            documentation = {
+                id: `java:${this.source.id}:documentation:${key}`,
+                range,
+                syntax,
+                attachments: [],
+            };
+            this.documentation.set(key, documentation);
+        }
+        return documentation;
+    }
+    annotation(raw) {
+        return /(?:^|[\r\n])[ \t]*@(evidenceExcludeReview|evidenceReview|evidenceExclude|evidence|link|internal|hidden|ignore)\b/u.test(raw);
+    }
+    nodeKey(node) {
+        return `${node.startIndex}:${node.endIndex}`;
+    }
+    siteId(node) {
+        return `java:${this.source.id}:site:${this.nodeKey(node)}`;
+    }
+    problem(code, message, repair, node) {
+        const key = `${code}:${node.startIndex}:${node.endIndex}`;
+        if (this.reported.has(key))
+            return;
+        this.reported.add(key);
+        this.complete = false;
+        this.diagnostics.push({
+            code,
+            severity: "error",
+            message,
+            repair,
+            location: {
+                file: this.source.physicalPath,
+                range: this.session.range(node),
+            },
+        });
+    }
+}
+exports.JavaFileScanner = JavaFileScanner;

package/lib/adapters/java/JavaSyntax.d.ts

@@ -0,0 +1,18 @@
+import type { Node } from "web-tree-sitter";
+import type { IEvidenceCommentSyntax } from "../../structures/IEvidenceCommentSyntax";
+/**
+ * Grammar-specific Java names, packages, modifiers, literals, and Javadoc.
+ *
+ * Java extraction uses these helpers to interpret parser nodes without resolving
+ * compiler symbols, preserving source-spelled ownership and documentation boundaries.
+ */
+export declare namespace JavaSyntax {
+    function name(node: Node | null): string | undefined;
+    function path(node: Node | null): string[] | undefined;
+    function packagePath(node: Node | undefined): string[];
+    function parameterName(node: Node): string | undefined;
+    function hasModifier(node: Node, modifier: string): boolean;
+    function javadoc(node: Node): Node | null;
+    function comment(node: Node): IEvidenceCommentSyntax;
+    function string(node: Node): IEvidenceCommentSyntax | undefined;
+}

package/lib/adapters/java/JavaSyntax.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JavaSyntax = void 0;
+/**
+ * Grammar-specific Java names, packages, modifiers, literals, and Javadoc.
+ *
+ * Java extraction uses these helpers to interpret parser nodes without resolving
+ * compiler symbols, preserving source-spelled ownership and documentation boundaries.
+ */
+var JavaSyntax;
+(function (JavaSyntax) {
+    function name(node) {
+        return node !== null && node.type === "identifier" ? node.text : undefined;
+    }
+    JavaSyntax.name = name;
+    function path(node) {
+        if (node === null)
+            return undefined;
+        const direct = name(node);
+        if (direct !== undefined)
+            return [direct];
+        if (node.type !== "scoped_identifier")
+            return undefined;
+        const scope = path(node.childForFieldName("scope"));
+        const suffix = name(node.childForFieldName("name"));
+        return scope === undefined || suffix === undefined
+            ? undefined
+            : [...scope, suffix];
+    }
+    JavaSyntax.path = path;
+    function packagePath(node) {
+        if (node === undefined)
+            return [];
+        for (const child of node.namedChildren) {
+            const candidate = path(child);
+            if (candidate !== undefined)
+                return candidate;
+        }
+        return [];
+    }
+    JavaSyntax.packagePath = packagePath;
+    function parameterName(node) {
+        if (node.type === "formal_parameter")
+            return name(node.childForFieldName("name"));
+        if (node.type !== "spread_parameter")
+            return undefined;
+        const declarator = node.namedChildren.find((child) => child.type === "variable_declarator");
+        return declarator === undefined
+            ? undefined
+            : name(declarator.childForFieldName("name"));
+    }
+    JavaSyntax.parameterName = parameterName;
+    function hasModifier(node, modifier) {
+        const modifiers = node.namedChildren.find((child) => child.type === "modifiers");
+        return modifiers === undefined
+            ? false
+            : modifiers.children.some((child) => child.type === modifier);
+    }
+    JavaSyntax.hasModifier = hasModifier;
+    function javadoc(node) {
+        const previous = node.previousNamedSibling;
+        return previous !== null &&
+            previous.type === "block_comment" &&
+            previous.text.startsWith("/**")
+            ? previous
+            : null;
+    }
+    JavaSyntax.javadoc = javadoc;
+    function comment(node) {
+        if (node.type === "line_comment")
+            return {
+                opening: "//",
+                closing: "",
+                linePrefix: "//",
+                tagBoundaries: true,
+                allowWithdrawal: false,
+            };
+        const javadoc = node.text.startsWith("/**");
+        return {
+            opening: javadoc ? "/**" : "/*",
+            closing: "*/",
+            tagBoundaries: true,
+            allowWithdrawal: javadoc,
+            ...(javadoc ? { linePrefix: "*" } : {}),
+        };
+    }
+    JavaSyntax.comment = comment;
+    function string(node) {
+        if (node.type !== "string_literal")
+            return undefined;
+        const delimiter = node.text.startsWith('"""') ? '"""' : '"';
+        return {
+            opening: delimiter,
+            closing: delimiter,
+            tagBoundaries: true,
+            allowWithdrawal: false,
+        };
+    }
+    JavaSyntax.string = string;
+})(JavaSyntax || (exports.JavaSyntax = JavaSyntax = {}));

package/lib/adapters/java/JavaTypeKind.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Java type context that determines implicit member visibility.
+ *
+ * Member extraction carries this context because interfaces, annotations, and
+ * other nominal forms supply different defaults when modifiers are omitted.
+ */
+export type JavaTypeKind = "class" | "interface" | "enum" | "annotation" | "record";

package/lib/adapters/java/JavaTypeKind.js

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

package/lib/adapters/javascript/EvidenceJavaScriptAdapter.d.ts

@@ -0,0 +1,26 @@
+import { EcmaScriptAdapter } from "../ecmascript/EcmaScriptAdapter";
+/**
+ * Extracts static JavaScript module exports and bounded CommonJS initialization.
+ *
+ * The shared ECMAScript extractor classifies the selected files' module modes,
+ * establishes declaration and JSDoc ownership, and publishes file-qualified
+ * export paths. Public aliases retain one semantic identity; instance members
+ * use prototype paths while static members remain on their class.
+ *
+ * Dynamic CommonJS mutation, computed export keys, and unsafe aliases cannot be
+ * used to infer a complete public population. Those cases remain analysis
+ * failures rather than silently omitted exports.
+ *
+ * @example
+ * // A declared instance method is addressed as client.js#Client.prototype.send.
+ * // Adding another supported export name does not create a second method unit.
+ */
+export declare class EvidenceJavaScriptAdapter extends EcmaScriptAdapter {
+    /**
+     * Configures the shared extractor for JavaScript and JSX source.
+     *
+     * The inherited analysis chooses module semantics from file and package context.
+     * No grammar or source is loaded until a snapshot is analyzed.
+     */
+    constructor();
+}

package/lib/adapters/javascript/EvidenceJavaScriptAdapter.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EvidenceJavaScriptAdapter = void 0;
+const EcmaScriptAdapter_1 = require("../ecmascript/EcmaScriptAdapter");
+/**
+ * Extracts static JavaScript module exports and bounded CommonJS initialization.
+ *
+ * The shared ECMAScript extractor classifies the selected files' module modes,
+ * establishes declaration and JSDoc ownership, and publishes file-qualified
+ * export paths. Public aliases retain one semantic identity; instance members
+ * use prototype paths while static members remain on their class.
+ *
+ * Dynamic CommonJS mutation, computed export keys, and unsafe aliases cannot be
+ * used to infer a complete public population. Those cases remain analysis
+ * failures rather than silently omitted exports.
+ *
+ * @example
+ * // A declared instance method is addressed as client.js#Client.prototype.send.
+ * // Adding another supported export name does not create a second method unit.
+ */
+class EvidenceJavaScriptAdapter extends EcmaScriptAdapter_1.EcmaScriptAdapter {
+    /**
+     * Configures the shared extractor for JavaScript and JSX source.
+     *
+     * The inherited analysis chooses module semantics from file and package context.
+     * No grammar or source is loaded until a snapshot is analyzed.
+     */
+    constructor() {
+        super("javascript", "JavaScript");
+    }
+}
+exports.EvidenceJavaScriptAdapter = EvidenceJavaScriptAdapter;

package/lib/adapters/kotlin/EvidenceKotlinAdapter.d.ts

@@ -0,0 +1,15 @@
+import { KotlinAdapter } from "./KotlinAdapter";
+/**
+ * Extracts explicit public Kotlin declarations and receiver-qualified extensions.
+ *
+ * Analysis resolves supported nominal aliases and extension receivers across the
+ * selected snapshot while retaining file-private and lexical ownership. Public
+ * paths expose explicit companion owners and receiver segments; attached KDoc
+ * supplies evidence without importing a compiler's generated member population.
+ *
+ * Scripts, expect/actual composition, delegated members, implicit override
+ * visibility, and generic or unresolved extension receivers are not inferred.
+ * Those boundaries must remain visible when they affect public completeness.
+ */
+export declare class EvidenceKotlinAdapter extends KotlinAdapter {
+}

package/lib/adapters/kotlin/EvidenceKotlinAdapter.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EvidenceKotlinAdapter = void 0;
+const KotlinAdapter_1 = require("./KotlinAdapter");
+/**
+ * Extracts explicit public Kotlin declarations and receiver-qualified extensions.
+ *
+ * Analysis resolves supported nominal aliases and extension receivers across the
+ * selected snapshot while retaining file-private and lexical ownership. Public
+ * paths expose explicit companion owners and receiver segments; attached KDoc
+ * supplies evidence without importing a compiler's generated member population.
+ *
+ * Scripts, expect/actual composition, delegated members, implicit override
+ * visibility, and generic or unresolved extension receivers are not inferred.
+ * Those boundaries must remain visible when they affect public completeness.
+ */
+class EvidenceKotlinAdapter extends KotlinAdapter_1.KotlinAdapter {
+}
+exports.EvidenceKotlinAdapter = EvidenceKotlinAdapter;

package/lib/adapters/kotlin/IKotlinDeclaration.d.ts

@@ -0,0 +1,77 @@
+import type { IEvidenceUnitSite } from "../../structures/IEvidenceUnitSite";
+import type { EvidenceProgrammingSymbol } from "../../typings/EvidenceProgrammingSymbol";
+import type { IKotlinTypeReference } from "./IKotlinTypeReference";
+/**
+ * Represents one Kotlin declaration before overload families become inventory units.
+ *
+ * The scanner keeps source-level visibility, receiver, and alias information here
+ * because snapshot-wide resolution can change the semantic owner of an extension.
+ */
+export interface IKotlinDeclaration {
+    /** Identifies this physical extraction record within the source snapshot.
+     *
+     * Receiver resolution and documentation attachments use this scanner-local value before unit materialization assigns a semantic ID.
+     */
+    id: string;
+    /** Gives the literal Kotlin name decoded from the declaration.
+     *
+     * The scanner combines it with receiver and lexical paths while preserving its source spelling for diagnostics.
+     */
+    name: string;
+    /** Classifies the declaration in Evidence's language-independent selector vocabulary.
+     *
+     * The adapter retains this category while reconciling package-scoped overload families.
+     */
+    symbol: EvidenceProgrammingSymbol;
+    /** Lists type-parameter names visible at this declaration's lexical scope.
+     *
+     * Deferred receiver parsing uses these names to reject type-variable receivers that static nominal lookup cannot resolve.
+     */
+    typeParameters: string[];
+    /**
+     * Holds the nominal target when this declaration introduces a type alias.
+     *
+     * Later receiver resolution expands it only in the source context where its
+     * imports and file-private visibility rules are valid.
+     */
+    aliasTarget?: IKotlinTypeReference;
+    /**
+     * Retains the declared extension receiver before nominal lookup.
+     *
+     * Extension members belong to the resolved receiver type rather than to the
+     * file that happens to declare the extension.
+     */
+    receiver?: IKotlinTypeReference;
+    /** Lists package and lexical ownership segments for the semantic unit.
+     *
+     * Receiver resolution may replace the extension's lexical owner with its resolved nominal receiver.
+     */
+    identity: string[];
+    /** Lists public accessor segments as projected from the source file.
+     *
+     * These remain distinct from `identity` so consumers can cite the public spelling of an extension declaration.
+     */
+    address: string[];
+    /** Retains the physical declaration site and content used by hosts and fingerprints.
+     *
+     * A reconciled overload family can retain several of these source occurrences.
+     */
+    site: IEvidenceUnitSite;
+    /** States whether this declaration and each containing owner are public.
+     *
+     * The adapter retains non-public records for receiver lookup but does not publish their units or addresses.
+     */
+    public: boolean;
+    /**
+     * Records Kotlin file-private visibility for nominal lookup.
+     *
+     * A same-named declaration in another file must not satisfy a receiver or
+     * alias reference that can only see this physical source.
+     */
+    filePrivate: boolean;
+    /** Identifies the containing declaration when this record is a member.
+     *
+     * Omission denotes a package-level declaration; materialization uses this link to propagate ownership and withdrawals.
+     */
+    ownerDeclarationId?: string;
+}