@wrtnlabs/evidence 0.0.0

package/lib/adapters/rust/IRustFilePlacement.d.ts

@@ -0,0 +1,35 @@
+import type { IRustFileAnalysis } from "./IRustFileAnalysis";
+/**
+ * Assigns a selected Rust file to one crate root and module prefix.
+ *
+ * RustModuleResolver creates placements before building module records, so the
+ * same scan result can be addressed in the crate namespace and source files.
+ */
+export interface IRustFilePlacement {
+    /**
+     * Node-free scan result for the selected file.
+     *
+     * This record owns declarations and diagnostics associated with the placement.
+     */
+    analysis: IRustFileAnalysis;
+    /**
+     * Stable key for the crate root that contains the file.
+     *
+     * Module and unit keys include it to keep identical paths in separate crates
+     * distinct.
+     */
+    rootKey: string;
+    /**
+     * Module segments prepended to declarations scanned from the file.
+     *
+     * An empty prefix identifies a crate root file.
+     */
+    prefix: string[];
+    /**
+     * Declaration ID of the external module that selected this file, when any.
+     *
+     * Omission marks a root file or an inline-module context without an external
+     * declaration to attach.
+     */
+    moduleDeclarationId?: string;
+}

package/lib/adapters/rust/IRustFilePlacement.js

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

package/lib/adapters/rust/IRustImplementation.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Describes a Rust impl block before its local nominal owner is resolved.
+ *
+ * The scanner records source-level paths; RustModuleResolver resolves them in
+ * the containing module and assigns member identities to the selected owner.
+ */
+export interface IRustImplementation {
+    /**
+     * Stable scanner ID shared by declarations emitted from this impl block.
+     *
+     * The resolver uses it to select exactly this block's associated members.
+     */
+    id: string;
+    /**
+     * Module path relative to the scanned file where the impl appears.
+     *
+     * Placement prepends the file prefix before path resolution.
+     */
+    modulePath: string[];
+    /**
+     * Source path naming the implemented nominal type.
+     *
+     * It must resolve to one selected local struct or enum before members publish.
+     */
+    ownerPath: string[];
+    /**
+     * Source path naming the implemented trait, when this is a trait impl.
+     *
+     * Omission represents an inherent impl and produces no trait qualifier.
+     */
+    traitPath?: string[];
+    /**
+     * Type parameter names declared by the impl block.
+     *
+     * The resolver uses them to reject blanket impls without one nominal owner.
+     */
+    typeParameters: string[];
+}

package/lib/adapters/rust/IRustImplementation.js

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

package/lib/adapters/rust/IRustLocatedDeclaration.d.ts

@@ -0,0 +1,35 @@
+import type { IRustDeclaration } from "./IRustDeclaration";
+import type { IRustFilePlacement } from "./IRustFilePlacement";
+import type { IRustModuleRecord } from "./IRustModuleRecord";
+/**
+ * Locates one Rust declaration in the resolved selected crate graph.
+ *
+ * Resolver phases enrich scanner output with module placement and a semantic
+ * identity before materializing units and public addresses.
+ */
+export interface IRustLocatedDeclaration {
+    /**
+     * Scanner record describing the declaration's syntax and local ownership.
+     *
+     * Its source site remains the provenance for the resulting Evidence unit.
+     */
+    declaration: IRustDeclaration;
+    /**
+     * Selected file and crate prefix containing the declaration.
+     *
+     * Address publication uses this placement to preserve file-qualified targets.
+     */
+    placement: IRustFilePlacement;
+    /**
+     * Resolved module that owns the declaration.
+     *
+     * Binding and export resolution start from this record.
+     */
+    module: IRustModuleRecord;
+    /**
+     * Canonical crate-relative segments naming the declaration semantically.
+     *
+     * Reexports may add public paths without changing this identity.
+     */
+    identity: string[];
+}

package/lib/adapters/rust/IRustLocatedDeclaration.js

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

package/lib/adapters/rust/IRustModuleRecord.d.ts

@@ -0,0 +1,62 @@
+import type { IRustDeclaration } from "./IRustDeclaration";
+import type { IRustFilePlacement } from "./IRustFilePlacement";
+import type { IRustUse } from "./IRustUse";
+/**
+ * Represents one inline or file-backed module in the selected crate graph.
+ *
+ * The resolver uses module records as the scope for direct bindings, use
+ * declarations, and paths that lead to externally reachable declarations.
+ */
+export interface IRustModuleRecord {
+    /**
+     * Stable serialized key combining the crate root and resolved module path.
+     *
+     * Internal maps use this key so same-named modules in different crates remain
+     * separate.
+     */
+    key: string;
+    /**
+     * Stable key identifying the crate that owns this module.
+     *
+     * Unit identities include this value to prevent cross-crate collisions.
+     */
+    rootKey: string;
+    /**
+     * Canonical module segments from the crate root to this module.
+     *
+     * Resolver path operations use this for `crate`, `self`, and `super` lookup.
+     */
+    path: string[];
+    /**
+     * Module segments relative to the placed file that supplied this record.
+     *
+     * The value lets the resolver find an inline module declaration in its source
+     * analysis.
+     */
+    localPath: string[];
+    /**
+     * File placement that provides this module's direct declarations.
+     *
+     * Reexport records carry this placement to retain a valid address carrier.
+     */
+    placement: IRustFilePlacement;
+    /**
+     * Declaration that introduced this module, when it is not a crate root.
+     *
+     * Omission identifies the synthetic root module for a selected crate file.
+     */
+    declaration?: IRustDeclaration;
+    /**
+     * Direct declarations grouped by their local Rust name.
+     *
+     * Multiple values preserve ambiguities so resolution can report them rather
+     * than choosing an arbitrary public target.
+     */
+    bindings: Map<string, IRustDeclaration[]>;
+    /**
+     * Public use declarations written in this module.
+     *
+     * Export construction expands these after direct module bindings exist.
+     */
+    uses: IRustUse[];
+}

package/lib/adapters/rust/IRustModuleRecord.js

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

package/lib/adapters/rust/IRustPublicOccurrence.d.ts

@@ -0,0 +1,35 @@
+import type { IRustExportRecord } from "./IRustExportRecord";
+import type { IRustFilePlacement } from "./IRustFilePlacement";
+import type { IRustLocatedDeclaration } from "./IRustLocatedDeclaration";
+/**
+ * Records one public path through which a selected Rust declaration is reachable.
+ *
+ * Materialization turns each occurrence into addresses while keeping the
+ * declaration's semantic identity independent of aliases and reexports.
+ */
+export interface IRustPublicOccurrence {
+    /**
+     * Resolved declaration reached through the public path.
+     *
+     * This supplies the unit identity and source site for materialization.
+     */
+    located: IRustLocatedDeclaration;
+    /**
+     * Export edge that introduced the final path segment.
+     *
+     * Its carrier identifies the source context that can address the alias.
+     */
+    exported: IRustExportRecord;
+    /**
+     * File placement carrying the namespace used to traverse the path.
+     *
+     * This can differ from the declaration's source file after a reexport.
+     */
+    namespaceCarrier: IRustFilePlacement;
+    /**
+     * Crate-relative public accessor segments for this occurrence.
+     *
+     * Each alias contributes a separate path without duplicating the Evidence unit.
+     */
+    publicPath: string[];
+}

package/lib/adapters/rust/IRustPublicOccurrence.js

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

package/lib/adapters/rust/IRustResolvedMember.d.ts

@@ -0,0 +1,34 @@
+import type { IRustLocatedDeclaration } from "./IRustLocatedDeclaration";
+/**
+ * Assigns one associated Rust item to its selected local nominal owner.
+ *
+ * Resolver materialization uses the relationship to publish public impl members
+ * beneath the owner type rather than as standalone declarations.
+ */
+export interface IRustResolvedMember {
+    /**
+     * Located associated declaration emitted from the impl block.
+     *
+     * Its identity is updated after the owner and optional trait are resolved.
+     */
+    declaration: IRustLocatedDeclaration;
+    /**
+     * Selected local struct or enum that semantically owns the member.
+     *
+     * Only one unambiguous nominal owner is supported for publication.
+     */
+    owner: IRustLocatedDeclaration;
+    /**
+     * Trait-derived segment that distinguishes a trait impl from an inherent impl.
+     *
+     * Omission means the member belongs to an inherent impl.
+     */
+    qualifier?: string;
+    /**
+     * Declaration ID of the selected local trait, when the trait resolved locally.
+     *
+     * Materialization requires that trait to be publicly reachable before exposing
+     * its impl members.
+     */
+    localTraitId?: string;
+}

package/lib/adapters/rust/IRustResolvedMember.js

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

package/lib/adapters/rust/IRustUse.d.ts

@@ -0,0 +1,33 @@
+import type { IRustUseBinding } from "./IRustUseBinding";
+/**
+ * Captures one unrestricted public Rust use declaration and its bindings.
+ *
+ * The scanner expands nested use trees into statically readable targets so the
+ * resolver can construct public aliases without retaining syntax nodes.
+ */
+export interface IRustUse {
+    /**
+     * Stable ID for this use declaration.
+     *
+     * Resolver diagnostics use it to report an unsupported or ambiguous export once.
+     */
+    id: string;
+    /**
+     * Module path relative to the scanned file where the use appears.
+     *
+     * File placement supplies the crate-relative prefix during resolution.
+     */
+    modulePath: string[];
+    /**
+     * Statically expanded leaf bindings declared by the use tree.
+     *
+     * A binding may name, rename, or wildcard-export a target.
+     */
+    bindings: IRustUseBinding[];
+    /**
+     * Source-site ID for attaching diagnostics to the declaration.
+     *
+     * It is distinct from the use ID so a scanner site can be shared consistently.
+     */
+    siteId: string;
+}

package/lib/adapters/rust/IRustUse.js

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

package/lib/adapters/rust/IRustUseBinding.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Describes one statically spelled target within a public Rust use declaration.
+ *
+ * Use-tree expansion preserves each leaf separately so aliases and wildcard
+ * exports receive their Rust-specific resolution rules.
+ */
+export interface IRustUseBinding {
+    /**
+     * Source path segments from the use declaration to the imported target.
+     *
+     * The resolver interprets crate, self, and super segments in the use module.
+     */
+    path: string[];
+    /**
+     * Public name assigned with `as`, when the binding renames its target.
+     *
+     * Omission publishes the target's final path segment.
+     */
+    alias?: string;
+    /**
+     * Whether this binding reexports all public names from its target module.
+     *
+     * A false value identifies one named import path.
+     */
+    wildcard: boolean;
+}

package/lib/adapters/rust/IRustUseBinding.js

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

package/lib/adapters/rust/RustAdapter.d.ts

@@ -0,0 +1,43 @@
+import type { IEvidenceAdapter } from "../../structures/IEvidenceAdapter";
+import type { IEvidenceInventory } from "../../structures/IEvidenceInventory";
+import type { IEvidenceSourceSnapshot } from "../../structures/IEvidenceSourceSnapshot";
+/**
+ * Builds Rust public inventories by resolving modules, implementations, and uses.
+ *
+ * File scans retain declaration and documentation candidates without assuming
+ * that lexical presence makes an item publicly reachable. RustModuleResolver
+ * publishes semantic identities across the configured snapshot before doc comments
+ * attach to those identities and inherited withdrawal removes eligible hosts.
+ */
+export declare class RustAdapter implements IEvidenceAdapter {
+    /**
+     * Artifact discriminator selecting Rust grammar and visibility rules.
+     *
+     * Population configuration uses this value to choose the crate-oriented adapter.
+     */
+    readonly type = "rust";
+    /**
+     * Extracts an isolated Rust inventory from captured source contents.
+     *
+     * Module publication precedes annotation materialization. Source and parser
+     * failures retain incomplete state, and the parser runtime closes after all
+     * accepted file scans finish.
+     */
+    analyze(snapshot: IEvidenceSourceSnapshot): Promise<IEvidenceInventory>;
+    private scan;
+    /**
+     * Maps Rust documentation attachments through published semantic identities.
+     *
+     * The first pass collects withdrawals across merged sites; the second creates
+     * visible hosts and accepted annotations after inherited hiding is known.
+     */
+    private materializeDocumentation;
+    private materializeUndocumentedHosts;
+    private attachmentGroups;
+    private host;
+    private parse;
+    private annotation;
+    private claimAnnotation;
+    private annotationPattern;
+    private withdrawn;
+}