@mortice/mapwright 0.8.0

package/dist/catalogue/linkage.d.ts

@@ -0,0 +1,16 @@
+import type { FileRecord, PublicApiRecord, RelationshipRecord, SymbolRecord } from "./schema.js";
+import type { PackageModel } from "./packages.js";
+export interface LinkageInput {
+    workspaceRoot: string;
+    files: FileRecord[];
+    symbols: SymbolRecord[];
+    publicApis: PublicApiRecord[];
+    relationships: RelationshipRecord[];
+    packageModel: PackageModel;
+}
+/**
+ * Build all Gate 3 linkage relationships. Endpoints are canonical (duplicate
+ * declarations collapse onto their preferred source), IDs come from
+ * `relationshipIdentityId`, and duplicate edges merge their evidence.
+ */
+export declare function buildLinkageRelationships(input: LinkageInput): RelationshipRecord[];

package/dist/catalogue/linkage.js

@@ -0,0 +1,419 @@
+/**
+ * Gate 3 linkage: provenanced, conservative consumer→API relationships.
+ *
+ * This module derives two relationship kinds and never anything weaker:
+ *   - `resolved_direct_import`: a file imports a binding that resolves, through
+ *     module resolution, to a catalogue public API or symbol. The binding may or
+ *     may not be used at runtime.
+ *   - `resolved_direct_usage`: a resolved, runtime (non type-only) imported
+ *     binding is actually referenced in the same file.
+ *
+ * Deliberately NOT emitted here (kept as diagnostics / ranking evidence only):
+ *   - package proximity links
+ *   - name-reference links
+ * Inferred imports/usages are never relabelled as `covers`/`explicit_coverage`.
+ */
+import path from "node:path";
+import { readFileSync } from "node:fs";
+import ts from "typescript";
+import { relationshipIdentityId } from "./identity.js";
+import { truncateEvidenceText } from "./evidence.js";
+import { isGeneratedArtefactPath } from "./resolveRefs.js";
+import { resolvePythonRelativeModuleTarget, resolveTypeScriptModuleTarget } from "./moduleResolution.js";
+/**
+ * Build all Gate 3 linkage relationships. Endpoints are canonical (duplicate
+ * declarations collapse onto their preferred source), IDs come from
+ * `relationshipIdentityId`, and duplicate edges merge their evidence.
+ */
+export function buildLinkageRelationships(input) {
+    const resolver = new TargetResolver(input);
+    const merged = new Map();
+    const emit = (type, filePath, target, discriminant, confidence, binding, language) => {
+        const from = { kind: "file", id: filePath };
+        const id = relationshipIdentityId({
+            type,
+            fromKind: from.kind,
+            fromId: from.id,
+            toKind: target.kind,
+            toId: target.id,
+            discriminant
+        });
+        const evidence = {
+            filePath,
+            startLine: binding.line,
+            endLine: binding.line,
+            text: truncateEvidenceText(binding.text)
+        };
+        const existing = merged.get(id);
+        if (existing) {
+            existing.evidenceRanges = [...(existing.evidenceRanges ?? []), evidence];
+            return;
+        }
+        merged.set(id, {
+            id,
+            type,
+            from,
+            to: target,
+            localDiscriminant: discriminant,
+            evidence,
+            confidence,
+            provenance: {
+                source: language === "python" ? "python-static" : "typescript-ast",
+                extractors: ["linkage"]
+            }
+        });
+    };
+    for (const file of input.files) {
+        if (file.language !== "typescript" && file.language !== "javascript" && file.language !== "python") {
+            continue;
+        }
+        let bindings;
+        try {
+            bindings = file.language === "python"
+                ? analyzePythonImports(input.workspaceRoot, file)
+                : analyzeTypeScriptImports(input.workspaceRoot, file);
+        }
+        catch {
+            continue;
+        }
+        for (const binding of bindings) {
+            // Namespace and side-effect imports are intentionally ambiguous: we do not
+            // know which member(s) resolve, so no per-symbol edge and no usage edge.
+            if (binding.externalName === null) {
+                continue;
+            }
+            const resolved = resolver.resolve(file, binding.moduleSpecifier, binding.externalName, binding.kind);
+            if (!resolved) {
+                continue;
+            }
+            const target = resolved.publicApiId
+                ? { kind: "publicApi", id: resolved.publicApiId }
+                : { kind: "symbol", id: resolved.symbolId };
+            emit("resolved_direct_import", file.path, target, binding.kind, 0.9, binding, file.language);
+            // Usage requires a runtime (non type-only) reference to the local binding.
+            if (!binding.typeOnly && binding.used) {
+                emit("resolved_direct_usage", file.path, target, "runtime", 0.85, binding, file.language);
+            }
+        }
+    }
+    return [...merged.values()].sort((a, b) => a.id.localeCompare(b.id));
+}
+/**
+ * Resolves an imported `(moduleSpecifier, externalName)` pair to a catalogue
+ * symbol by first resolving the module path (so identically named exports in
+ * different packages never cross-link) and then matching the exported name,
+ * following explicit re-export edges.
+ */
+class TargetResolver {
+    workspaceRoot;
+    symbolById;
+    publicApiBySymbolId;
+    /** filePath -> exported symbol ids emitted via `exports` edges to symbols. */
+    exportSymbolsByFile = new Map();
+    /** filePath -> default-exported symbol ids. */
+    defaultExportsByFile = new Map();
+    /** filePath -> re-export target file paths (`export ... from './x'`). */
+    reExportFilesByFile = new Map();
+    /** filePath -> top-level canonical symbol ids defined in the file. */
+    definedSymbolsByFile = new Map();
+    constructor(input) {
+        this.workspaceRoot = input.workspaceRoot;
+        this.symbolById = new Map(input.symbols.map((symbol) => [symbol.id, symbol]));
+        this.publicApiBySymbolId = new Map(input.publicApis.map((api) => [api.symbolId, api.id]));
+        for (const symbol of input.symbols) {
+            if (symbol.duplicateOf) {
+                continue;
+            }
+            if ((symbol.qualifiedContainerPath ?? "") !== "") {
+                continue;
+            }
+            pushUnique(this.definedSymbolsByFile, symbol.filePath, symbol.id);
+        }
+        for (const relationship of input.relationships) {
+            if (relationship.type !== "exports" || relationship.from.kind !== "file") {
+                continue;
+            }
+            if (relationship.to.kind === "symbol") {
+                pushUnique(this.exportSymbolsByFile, relationship.from.id, relationship.to.id);
+                if (relationship.localDiscriminant === "default") {
+                    pushUnique(this.defaultExportsByFile, relationship.from.id, relationship.to.id);
+                }
+            }
+            else if (relationship.to.kind === "file") {
+                pushUnique(this.reExportFilesByFile, relationship.from.id, relationship.to.id);
+            }
+        }
+    }
+    resolve(file, moduleSpecifier, externalName, kind) {
+        const targetFile = file.language === "python"
+            ? resolvePythonRelativeModuleTarget(this.workspaceRoot, file.path, moduleSpecifier)
+            : resolveTypeScriptModuleTarget(this.workspaceRoot, file.path, moduleSpecifier);
+        if (!targetFile) {
+            return undefined;
+        }
+        const symbolId = this.findExportedSymbol(targetFile, externalName, kind, new Set());
+        if (!symbolId) {
+            return undefined;
+        }
+        return { symbolId, publicApiId: this.publicApiBySymbolId.get(symbolId) };
+    }
+    findExportedSymbol(filePath, externalName, kind, visited) {
+        if (visited.has(filePath)) {
+            return undefined;
+        }
+        visited.add(filePath);
+        if (kind === "default") {
+            const defaults = this.defaultExportsByFile.get(filePath) ?? [];
+            const preferred = this.preferSource(defaults);
+            if (preferred) {
+                return preferred;
+            }
+        }
+        const candidates = [];
+        for (const symbolId of this.exportSymbolsByFile.get(filePath) ?? []) {
+            if (this.symbolById.get(symbolId)?.name === externalName) {
+                candidates.push(symbolId);
+            }
+        }
+        // Fall back to a top-level declaration with a matching name (covers cases
+        // where the export edge points at a file rather than a specific symbol).
+        for (const symbolId of this.definedSymbolsByFile.get(filePath) ?? []) {
+            const symbol = this.symbolById.get(symbolId);
+            if (symbol?.name === externalName && symbol.exported) {
+                candidates.push(symbolId);
+            }
+        }
+        const preferred = this.preferSource(candidates);
+        if (preferred) {
+            return preferred;
+        }
+        for (const reExportTarget of this.reExportFilesByFile.get(filePath) ?? []) {
+            const found = this.findExportedSymbol(reExportTarget, externalName, kind, visited);
+            if (found) {
+                return found;
+            }
+        }
+        return undefined;
+    }
+    preferSource(ids) {
+        if (ids.length === 0) {
+            return undefined;
+        }
+        const unique = [...new Set(ids)];
+        const authored = unique.filter((id) => {
+            const filePath = this.symbolById.get(id)?.filePath;
+            return filePath ? !isGeneratedArtefactPath(filePath) : true;
+        });
+        const pool = authored.length > 0 ? authored : unique;
+        // Deterministic selection when several remain (rare): lowest id.
+        return [...pool].sort()[0];
+    }
+}
+function analyzeTypeScriptImports(workspaceRoot, file) {
+    const absolute = path.resolve(workspaceRoot, file.path);
+    const sourceText = readFileSync(absolute, "utf8");
+    const sourceFile = ts.createSourceFile(file.path, sourceText, ts.ScriptTarget.ES2022, true);
+    const bindings = [];
+    const localNames = new Set();
+    for (const statement of sourceFile.statements) {
+        if (!ts.isImportDeclaration(statement) || !ts.isStringLiteral(statement.moduleSpecifier)) {
+            continue;
+        }
+        const moduleSpecifier = statement.moduleSpecifier.text;
+        const start = sourceFile.getLineAndCharacterOfPosition(statement.getStart(sourceFile));
+        const line = start.line + 1;
+        const text = statement.getText(sourceFile);
+        const clause = statement.importClause;
+        if (!clause) {
+            bindings.push({ moduleSpecifier, externalName: null, localName: null, kind: "side-effect", typeOnly: false, line, text });
+            continue;
+        }
+        const clauseTypeOnly = clause.isTypeOnly === true;
+        if (clause.name) {
+            bindings.push({
+                moduleSpecifier,
+                externalName: "default",
+                localName: clause.name.text,
+                kind: "default",
+                typeOnly: clauseTypeOnly,
+                line,
+                text
+            });
+            localNames.add(clause.name.text);
+        }
+        const named = clause.namedBindings;
+        if (named && ts.isNamespaceImport(named)) {
+            bindings.push({
+                moduleSpecifier,
+                externalName: null,
+                localName: named.name.text,
+                kind: "namespace",
+                typeOnly: clauseTypeOnly,
+                line,
+                text
+            });
+        }
+        else if (named && ts.isNamedImports(named)) {
+            for (const element of named.elements) {
+                const externalName = (element.propertyName ?? element.name).text;
+                const localName = element.name.text;
+                const typeOnly = clauseTypeOnly || element.isTypeOnly === true;
+                const aliased = Boolean(element.propertyName) && element.propertyName.text !== localName;
+                bindings.push({
+                    moduleSpecifier,
+                    externalName,
+                    localName,
+                    kind: typeOnly ? "type-only" : aliased ? "aliased" : "named",
+                    typeOnly,
+                    line,
+                    text
+                });
+                localNames.add(localName);
+            }
+        }
+    }
+    if (bindings.length === 0) {
+        return [];
+    }
+    const used = collectTypeScriptValueIdentifiers(sourceFile, localNames);
+    return bindings.map((binding) => ({
+        ...binding,
+        used: binding.localName ? used.has(binding.localName) : false
+    }));
+}
+/**
+ * Collect identifiers that appear in *value* positions outside import
+ * declarations. Type-only references (inside a TypeNode) are excluded so that a
+ * value import used only in a type annotation is not counted as runtime usage.
+ */
+function collectTypeScriptValueIdentifiers(sourceFile, interesting) {
+    const used = new Set();
+    const walk = (node) => {
+        if (ts.isImportDeclaration(node)) {
+            return;
+        }
+        if (ts.isTypeNode(node) || ts.isTypeReferenceNode(node)) {
+            return;
+        }
+        if (ts.isIdentifier(node) && interesting.has(node.text)) {
+            used.add(node.text);
+        }
+        ts.forEachChild(node, walk);
+    };
+    walk(sourceFile);
+    return used;
+}
+function analyzePythonImports(workspaceRoot, file) {
+    const absolute = path.resolve(workspaceRoot, file.path);
+    const sourceText = readFileSync(absolute, "utf8");
+    const lines = sourceText.split(/\r?\n/);
+    const typeCheckingRanges = collectTypeCheckingRanges(lines);
+    const bindings = [];
+    const localNames = new Set();
+    const importLineNumbers = new Set();
+    for (let i = 0; i < lines.length; i += 1) {
+        const line = lines[i] ?? "";
+        const fromImport = line.match(/^\s*from\s+([.A-Za-z_][A-Za-z0-9_.]*)\s+import\s+(.+)$/);
+        if (!fromImport) {
+            continue;
+        }
+        const moduleSpecifier = fromImport[1]?.trim() ?? "";
+        // Only relative (intra-repo) imports can resolve to catalogue files.
+        if (!moduleSpecifier.startsWith(".")) {
+            continue;
+        }
+        const typeOnly = typeCheckingRanges.some((range) => i >= range.start && i <= range.end);
+        const text = line.trim();
+        importLineNumbers.add(i);
+        const importList = stripImportWrappers(fromImport[2] ?? "");
+        for (const rawEntry of importList.split(",")) {
+            const entry = rawEntry.trim();
+            if (!entry || entry === "*") {
+                continue;
+            }
+            const parts = entry.split(/\s+as\s+/i);
+            const externalName = parts[0]?.trim();
+            const localName = (parts[1] ?? parts[0])?.trim();
+            if (!externalName || !localName || !/^[A-Za-z_][A-Za-z0-9_]*$/.test(externalName)) {
+                continue;
+            }
+            const aliased = Boolean(parts[1]) && parts[1].trim() !== externalName;
+            bindings.push({
+                moduleSpecifier,
+                externalName,
+                localName,
+                kind: typeOnly ? "type-only" : aliased ? "aliased" : "named",
+                typeOnly,
+                line: i + 1,
+                text
+            });
+            localNames.add(localName);
+        }
+    }
+    if (bindings.length === 0) {
+        return [];
+    }
+    const used = collectPythonValueIdentifiers(lines, localNames, importLineNumbers, typeCheckingRanges);
+    return bindings.map((binding) => ({
+        ...binding,
+        used: binding.localName ? used.has(binding.localName) : false
+    }));
+}
+function stripImportWrappers(value) {
+    return value.replace(/[()\\]/g, " ").trim();
+}
+/** Detect `if TYPE_CHECKING:` blocks and return their indented line ranges. */
+function collectTypeCheckingRanges(lines) {
+    const ranges = [];
+    for (let i = 0; i < lines.length; i += 1) {
+        const line = lines[i] ?? "";
+        const match = line.match(/^(\s*)if\s+(?:typing\.)?TYPE_CHECKING\s*:/);
+        if (!match) {
+            continue;
+        }
+        const headerIndent = match[1]?.length ?? 0;
+        let end = i;
+        for (let j = i + 1; j < lines.length; j += 1) {
+            const body = lines[j] ?? "";
+            if (body.trim() === "") {
+                end = j;
+                continue;
+            }
+            const indent = body.match(/^\s*/)?.[0].length ?? 0;
+            if (indent <= headerIndent) {
+                break;
+            }
+            end = j;
+        }
+        ranges.push({ start: i + 1, end });
+    }
+    return ranges;
+}
+function collectPythonValueIdentifiers(lines, interesting, importLineNumbers, typeCheckingRanges) {
+    const used = new Set();
+    for (let i = 0; i < lines.length; i += 1) {
+        if (importLineNumbers.has(i)) {
+            continue;
+        }
+        if (typeCheckingRanges.some((range) => i >= range.start && i <= range.end)) {
+            continue;
+        }
+        let line = lines[i] ?? "";
+        // Drop comments and string literals to avoid counting textual mentions.
+        line = line.replace(/#.*$/, "").replace(/(["']).*?\1/g, " ");
+        for (const token of line.matchAll(/[A-Za-z_][A-Za-z0-9_]*/g)) {
+            const name = token[0];
+            if (interesting.has(name)) {
+                used.add(name);
+            }
+        }
+    }
+    return used;
+}
+function pushUnique(map, key, value) {
+    const current = map.get(key) ?? [];
+    if (!current.includes(value)) {
+        current.push(value);
+        map.set(key, current);
+    }
+}

package/dist/catalogue/moduleResolution.d.ts

@@ -0,0 +1,4 @@
+export declare function toPosixPath(filePath: string): string;
+export declare function createExternalPackageId(specifier: string): string;
+export declare function resolveTypeScriptModuleTarget(workspaceRoot: string, fromFilePath: string, specifier: string): string | undefined;
+export declare function resolvePythonRelativeModuleTarget(workspaceRoot: string, fromFilePath: string, modulePath: string): string | undefined;

package/dist/catalogue/moduleResolution.js

@@ -0,0 +1,67 @@
+import { existsSync } from "node:fs";
+import path from "node:path";
+const TS_EXTENSIONS = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"];
+const TS_INDEX_EXTENSIONS = ["index.ts", "index.tsx", "index.js", "index.jsx", "index.mjs", "index.cjs"];
+export function toPosixPath(filePath) {
+    return filePath.replaceAll("\\", "/");
+}
+export function createExternalPackageId(specifier) {
+    return `external:${specifier}`;
+}
+export function resolveTypeScriptModuleTarget(workspaceRoot, fromFilePath, specifier) {
+    if (!specifier.startsWith(".")) {
+        return undefined;
+    }
+    const fromDir = path.resolve(workspaceRoot, path.dirname(fromFilePath));
+    const absoluteBase = path.resolve(fromDir, specifier);
+    const candidates = [absoluteBase];
+    const extension = path.extname(absoluteBase).toLowerCase();
+    if ([".js", ".mjs", ".cjs"].includes(extension)) {
+        candidates.push(absoluteBase.slice(0, -extension.length));
+    }
+    if (extension === ".jsx") {
+        candidates.push(absoluteBase.slice(0, -extension.length));
+    }
+    return resolveByProbing(workspaceRoot, candidates, TS_EXTENSIONS, TS_INDEX_EXTENSIONS);
+}
+export function resolvePythonRelativeModuleTarget(workspaceRoot, fromFilePath, modulePath) {
+    if (!modulePath.startsWith(".")) {
+        return undefined;
+    }
+    const leadingDots = modulePath.match(/^\.+/)?.[0].length ?? 0;
+    if (leadingDots === 0) {
+        return undefined;
+    }
+    const relativeName = modulePath.slice(leadingDots).replaceAll(".", path.sep);
+    let baseDir = path.resolve(workspaceRoot, path.dirname(fromFilePath));
+    for (let step = 1; step < leadingDots; step += 1) {
+        baseDir = path.dirname(baseDir);
+    }
+    const absoluteBase = relativeName ? path.resolve(baseDir, relativeName) : baseDir;
+    const probeOrder = [".py"];
+    const indexOrder = ["__init__.py"];
+    return resolveByProbing(workspaceRoot, [absoluteBase], probeOrder, indexOrder);
+}
+function resolveByProbing(workspaceRoot, absoluteBases, extensions, indexFiles) {
+    const candidates = [];
+    for (const absoluteBase of absoluteBases) {
+        candidates.push(absoluteBase);
+        for (const extension of extensions) {
+            candidates.push(`${absoluteBase}${extension}`);
+        }
+        for (const indexFile of indexFiles) {
+            candidates.push(path.join(absoluteBase, indexFile));
+        }
+    }
+    for (const candidate of candidates) {
+        const normalized = path.normalize(candidate);
+        if (!normalized.startsWith(path.normalize(workspaceRoot))) {
+            continue;
+        }
+        if (existsSync(normalized)) {
+            const relative = path.relative(workspaceRoot, normalized);
+            return toPosixPath(relative);
+        }
+    }
+    return undefined;
+}

package/dist/catalogue/ordering.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Deterministic semantic ordering for resources and list tools.
+ */
+import type { CapabilityRecord, DiagnosticRecord, ExampleRecord, FileRecord, PackageRecord, PublicApiRecord, RelationshipRecord, SymbolRecord, TestRecord } from "./schema.js";
+export declare function sortPackages(records: PackageRecord[]): PackageRecord[];
+export declare function sortFiles(records: FileRecord[]): FileRecord[];
+export declare function sortSymbols(records: SymbolRecord[]): SymbolRecord[];
+export declare function sortPublicApis(records: PublicApiRecord[]): PublicApiRecord[];
+export declare function sortCapabilities(records: CapabilityRecord[]): CapabilityRecord[];
+export declare function sortExamples(records: ExampleRecord[]): ExampleRecord[];
+export declare function sortRelationships(records: RelationshipRecord[]): RelationshipRecord[];
+export declare function sortTests(records: TestRecord[]): TestRecord[];
+export declare function sortDiagnostics(records: DiagnosticRecord[]): DiagnosticRecord[];

package/dist/catalogue/ordering.js

@@ -0,0 +1,86 @@
+import { normalizeIdentityString } from "./identity.js";
+function cmp(a, b) {
+    const left = normalizeIdentityString(a);
+    const right = normalizeIdentityString(b);
+    if (left < right)
+        return -1;
+    if (left > right)
+        return 1;
+    return 0;
+}
+function cmpNullable(a, b) {
+    return cmp(a ?? "", b ?? "");
+}
+export function sortPackages(records) {
+    return [...records].sort((a, b) => {
+        return (cmp(a.ecosystem ?? "unknown", b.ecosystem ?? "unknown") ||
+            cmp(a.name, b.name) ||
+            cmp(a.path, b.path) ||
+            cmp(a.id, b.id));
+    });
+}
+export function sortFiles(records) {
+    return [...records].sort((a, b) => {
+        return cmpNullable(a.packageName, b.packageName) || cmp(a.path, b.path);
+    });
+}
+export function sortSymbols(records) {
+    return [...records].sort((a, b) => {
+        return (cmpNullable(a.packageId, b.packageId) ||
+            cmp(a.filePath, b.filePath) ||
+            cmp(a.qualifiedName, b.qualifiedName) ||
+            cmp(a.kind, b.kind) ||
+            cmp(a.id, b.id));
+    });
+}
+export function sortPublicApis(records) {
+    return [...records].sort((a, b) => {
+        return (cmpNullable(a.packageId, b.packageId) ||
+            cmpNullable(a.importPath, b.importPath) ||
+            cmp(a.name, b.name) ||
+            cmp(a.exportKind ?? "named", b.exportKind ?? "named") ||
+            cmp(a.id, b.id));
+    });
+}
+export function sortCapabilities(records) {
+    return [...records].sort((a, b) => {
+        const aPkg = a.packages[0] ?? "";
+        const bPkg = b.packages[0] ?? "";
+        return cmp(aPkg, bPkg) || cmp(a.name, b.name) || cmp(a.id, b.id);
+    });
+}
+export function sortExamples(records) {
+    return [...records].sort((a, b) => {
+        return cmpNullable(a.filePath, b.filePath) || cmpNullable(a.title, b.title) || cmp(a.id, b.id);
+    });
+}
+export function sortRelationships(records) {
+    return [...records].sort((a, b) => {
+        return (cmp(a.type, b.type) ||
+            cmp(a.from.id, b.from.id) ||
+            cmp(a.to.id, b.to.id) ||
+            cmp(a.localDiscriminant ?? "", b.localDiscriminant ?? "") ||
+            cmp(a.id, b.id));
+    });
+}
+export function sortTests(records) {
+    return [...records].sort((a, b) => {
+        return (cmp(a.filePath, b.filePath) ||
+            cmpNullable(a.framework, b.framework) ||
+            cmpNullable(a.suitePath, b.suitePath) ||
+            cmp(a.name, b.name) ||
+            cmp(a.id, b.id));
+    });
+}
+const SEVERITY_ORDER = { error: 0, warning: 1, info: 2 };
+export function sortDiagnostics(records) {
+    return [...records].sort((a, b) => {
+        const sev = (SEVERITY_ORDER[a.severity] ?? 9) - (SEVERITY_ORDER[b.severity] ?? 9);
+        if (sev !== 0)
+            return sev;
+        return (cmp(a.category, b.category) ||
+            cmpNullable(a.filePath, b.filePath) ||
+            cmp(a.code, b.code) ||
+            cmp(a.id, b.id));
+    });
+}

package/dist/catalogue/packages.d.ts

@@ -0,0 +1,12 @@
+import type { FileRecord, PackageRecord, RelationshipRecord } from "./schema.js";
+export interface PackageModel {
+    packages: PackageRecord[];
+    packageByPath: Map<string, PackageRecord>;
+    packageById: Map<string, PackageRecord>;
+    filePackageByPath: Map<string, PackageRecord>;
+    entrypointImportPathByFile: Map<string, string>;
+}
+export declare function buildPackageModel(workspaceRoot: string, files: FileRecord[], markdownPackages: PackageRecord[]): PackageModel;
+export declare function findPackageForFile(model: PackageModel, filePath: string): PackageRecord | undefined;
+export declare function computePublicApiImportPath(workspaceRoot: string, filePath: string, packageRecord: PackageRecord | undefined, language: string, publicImportPath?: string): string;
+export declare function buildPublicImportPathBySymbolId(packageModel: PackageModel, relationships: RelationshipRecord[]): Map<string, string>;