@mortice/mapwright 0.8.0

package/dist/catalogue/resolveRefs.js

@@ -0,0 +1,284 @@
+export function isGeneratedArtefactPath(filePath) {
+    const normalized = filePath.replaceAll("\\", "/");
+    return /(^|\/)dist\//.test(normalized) || /(^|\/)build\//.test(normalized) || /(^|\/)out\//.test(normalized);
+}
+/** Prefer source symbols/APIs over generated dist/build artefacts when ranking matches. */
+export function preferSourceIds(ids, filePathForId) {
+    if (ids.length <= 1) {
+        return ids;
+    }
+    const source = ids.filter((id) => {
+        const filePath = filePathForId(id);
+        return filePath ? !isGeneratedArtefactPath(filePath) : true;
+    });
+    return source.length > 0 ? source : ids;
+}
+export function buildSymbolRefIndex(symbols, packageByFilePath) {
+    const byId = new Map(symbols.map((symbol) => [symbol.id, symbol]));
+    const byQualifiedName = new Map(symbols.map((symbol) => [symbol.qualifiedName, symbol.id]));
+    const byPathName = new Map();
+    const byName = new Map();
+    const byPackageName = new Map();
+    for (const symbol of symbols) {
+        const pathNameKey = `${symbol.filePath}:${symbol.name}`;
+        pushUnique(byPathName, pathNameKey, symbol.id);
+        pushUnique(byName, symbol.name, symbol.id);
+        const packageRecord = packageByFilePath?.get(symbol.filePath);
+        const packageName = packageRecord?.name?.trim();
+        if (packageName) {
+            pushUnique(byPackageName, `${packageName}:${symbol.name}`, symbol.id);
+            pushUnique(byPackageName, `${packageName}/${symbol.name}`, symbol.id);
+        }
+    }
+    return { byId, byQualifiedName, byPathName, byName, byPackageName };
+}
+export function buildPublicApiRefIndex(publicApis, symbols, packageByFilePath) {
+    const symbolById = new Map(symbols.map((symbol) => [symbol.id, symbol]));
+    const byId = new Map(publicApis.map((api) => [api.id, api]));
+    const byPathName = new Map();
+    const byName = new Map();
+    const byPackageName = new Map();
+    for (const api of publicApis) {
+        const symbol = symbolById.get(api.symbolId);
+        pushUnique(byName, api.name.toLowerCase(), api.id);
+        if (symbol) {
+            pushUnique(byPathName, `${symbol.filePath}:${symbol.name}`, api.id);
+            const packageRecord = packageByFilePath?.get(symbol.filePath);
+            const packageName = packageRecord?.name?.trim();
+            if (packageName) {
+                pushUnique(byPackageName, `${packageName}:${api.name}`.toLowerCase(), api.id);
+                pushUnique(byPackageName, `${packageName}/${api.name}`.toLowerCase(), api.id);
+            }
+        }
+    }
+    return { byId, byPathName, byName, byPackageName, symbolById };
+}
+export function resolveSymbolReference(reference, index) {
+    const ref = reference.trim();
+    if (!ref) {
+        return { status: "unknown", value: reference };
+    }
+    if (index.byId.has(ref)) {
+        return { status: "resolved", value: ref };
+    }
+    const byQualifiedName = index.byQualifiedName.get(ref);
+    if (byQualifiedName) {
+        return { status: "resolved", value: byQualifiedName };
+    }
+    const pathNameCandidates = [
+        ref,
+        ref.includes("::") ? ref.replace("::", ":") : undefined,
+        ref.startsWith("symbol:") ? stripSymbolLineSuffix(ref) : undefined
+    ].filter((value) => Boolean(value));
+    for (const candidate of pathNameCandidates) {
+        const pathName = normalizePathNameKey(candidate);
+        if (!pathName) {
+            continue;
+        }
+        const matches = preferSourceIds(index.byPathName.get(pathName) ?? [], (id) => index.byId.get(id)?.filePath);
+        if (matches.length === 1) {
+            return { status: "resolved", value: matches[0] };
+        }
+        if (matches.length > 1) {
+            return { status: "ambiguous", value: ref };
+        }
+    }
+    const lineTolerant = parseSymbolPathName(ref);
+    if (lineTolerant) {
+        const matches = preferSourceIds(index.byPathName.get(`${lineTolerant.filePath}:${lineTolerant.name}`) ?? [], (id) => index.byId.get(id)?.filePath);
+        if (matches.length === 1) {
+            return { status: "resolved", value: matches[0] };
+        }
+        if (matches.length > 1) {
+            return { status: "ambiguous", value: ref };
+        }
+        const byParsedName = preferSourceIds(index.byName.get(lineTolerant.name) ?? [], (id) => index.byId.get(id)?.filePath);
+        if (byParsedName.length === 1) {
+            return { status: "resolved", value: byParsedName[0] };
+        }
+        if (byParsedName.length > 1) {
+            return { status: "ambiguous", value: ref };
+        }
+    }
+    const packageKey = normalizePackageQualifiedKey(ref);
+    if (packageKey) {
+        const matches = preferSourceIds(index.byPackageName.get(packageKey) ?? [], (id) => index.byId.get(id)?.filePath);
+        if (matches.length === 1) {
+            return { status: "resolved", value: matches[0] };
+        }
+        if (matches.length > 1) {
+            return { status: "ambiguous", value: ref };
+        }
+    }
+    const bareName = stripPublicApiPrefix(ref);
+    const byName = preferSourceIds(index.byName.get(bareName) ?? [], (id) => index.byId.get(id)?.filePath);
+    if (byName.length === 1) {
+        return { status: "resolved", value: byName[0] };
+    }
+    if (byName.length > 1) {
+        return { status: "ambiguous", value: ref };
+    }
+    return { status: "unknown", value: ref };
+}
+export function resolvePublicApiReference(reference, index) {
+    const ref = reference.trim();
+    if (!ref) {
+        return { status: "unknown", value: reference };
+    }
+    if (index.byId.has(ref)) {
+        return { status: "resolved", value: ref };
+    }
+    const lineTolerant = parsePublicApiPathName(ref);
+    if (lineTolerant) {
+        const matches = preferSourceIds(index.byPathName.get(`${lineTolerant.filePath}:${lineTolerant.name}`) ?? [], (id) => index.symbolById.get(index.byId.get(id)?.symbolId ?? "")?.filePath);
+        if (matches.length === 1) {
+            return { status: "resolved", value: matches[0] };
+        }
+        if (matches.length > 1) {
+            return { status: "ambiguous", value: ref };
+        }
+        // Stale path (e.g. generated dist id) — fall back to unique name from the parsed id.
+        const byParsedName = preferSourceIds(index.byName.get(lineTolerant.name.toLowerCase()) ?? [], (id) => index.symbolById.get(index.byId.get(id)?.symbolId ?? "")?.filePath);
+        if (byParsedName.length === 1) {
+            return { status: "resolved", value: byParsedName[0] };
+        }
+        if (byParsedName.length > 1) {
+            return { status: "ambiguous", value: ref };
+        }
+    }
+    const pathName = normalizePathNameKey(stripPublicApiPrefix(ref));
+    if (pathName && pathName.includes("/")) {
+        const matches = preferSourceIds(index.byPathName.get(pathName) ?? [], (id) => index.symbolById.get(index.byId.get(id)?.symbolId ?? "")?.filePath);
+        if (matches.length === 1) {
+            return { status: "resolved", value: matches[0] };
+        }
+        if (matches.length > 1) {
+            return { status: "ambiguous", value: ref };
+        }
+    }
+    const packageKey = normalizePackageQualifiedKey(stripPublicApiPrefix(ref))?.toLowerCase();
+    if (packageKey) {
+        const matches = preferSourceIds(index.byPackageName.get(packageKey) ?? [], (id) => index.symbolById.get(index.byId.get(id)?.symbolId ?? "")?.filePath);
+        if (matches.length === 1) {
+            return { status: "resolved", value: matches[0] };
+        }
+        if (matches.length > 1) {
+            return { status: "ambiguous", value: ref };
+        }
+    }
+    const bareName = stripPublicApiPrefix(ref).toLowerCase();
+    const byName = preferSourceIds(index.byName.get(bareName) ?? [], (id) => index.symbolById.get(index.byId.get(id)?.symbolId ?? "")?.filePath);
+    if (byName.length === 1) {
+        return { status: "resolved", value: byName[0] };
+    }
+    if (byName.length > 1) {
+        return { status: "ambiguous", value: ref };
+    }
+    return { status: "unknown", value: ref };
+}
+function pushUnique(map, key, value) {
+    const current = map.get(key) ?? [];
+    if (!current.includes(value)) {
+        current.push(value);
+        current.sort();
+        map.set(key, current);
+    }
+}
+function stripPublicApiPrefix(ref) {
+    return ref.replace(/^public-api:/i, "").trim();
+}
+function stripSymbolLineSuffix(ref) {
+    const parsed = parseSymbolPathName(ref);
+    if (!parsed) {
+        return undefined;
+    }
+    return `${parsed.filePath}:${parsed.name}`;
+}
+/**
+ * Parse `symbol:path/to/file.ts:Name:12` or `symbol:path/to/file.ts:Name`.
+ * Relative catalogue paths are POSIX-style and do not contain colons.
+ */
+export function parseSymbolPathName(ref) {
+    const trimmed = ref.trim();
+    if (!trimmed.startsWith("symbol:")) {
+        return undefined;
+    }
+    const body = trimmed.slice("symbol:".length);
+    const parts = body.split(":");
+    if (parts.length < 2) {
+        return undefined;
+    }
+    let name;
+    let pathParts;
+    if (parts.length >= 3 && /^\d+$/.test(parts[parts.length - 1] ?? "")) {
+        name = parts[parts.length - 2] ?? "";
+        pathParts = parts.slice(0, -2);
+    }
+    else {
+        name = parts[parts.length - 1] ?? "";
+        pathParts = parts.slice(0, -1);
+    }
+    const filePath = pathParts.join(":");
+    if (!filePath || !name || !filePath.includes("/")) {
+        return undefined;
+    }
+    return { filePath, name };
+}
+export function parsePublicApiPathName(ref) {
+    const trimmed = stripPublicApiPrefix(ref.trim());
+    if (!trimmed.startsWith("symbol:")) {
+        return undefined;
+    }
+    return parseSymbolPathName(trimmed);
+}
+function normalizePathNameKey(ref) {
+    let value = stripPublicApiPrefix(ref.trim());
+    if (value.startsWith("symbol:")) {
+        const parsed = parseSymbolPathName(value);
+        return parsed ? `${parsed.filePath}:${parsed.name}` : undefined;
+    }
+    value = value.replace("::", ":");
+    if (!value.includes(":")) {
+        return undefined;
+    }
+    const lastColon = value.lastIndexOf(":");
+    const filePath = value.slice(0, lastColon).trim();
+    const name = value.slice(lastColon + 1).trim();
+    if (!filePath || !name) {
+        return undefined;
+    }
+    // Drop trailing :line if caller passed path:name:line without symbol: prefix.
+    if (/^\d+$/.test(name)) {
+        const previous = filePath.lastIndexOf(":");
+        if (previous > 0) {
+            return `${filePath.slice(0, previous)}:${filePath.slice(previous + 1)}`;
+        }
+    }
+    return `${filePath}:${name}`;
+}
+/**
+ * Accept `pkg:Name`, `@scope/pkg:Name`, or `pkg/Name` when the left side looks
+ * like a package name (not a source file path).
+ */
+function normalizePackageQualifiedKey(ref) {
+    const value = stripPublicApiPrefix(ref.trim());
+    if (!value || value.startsWith("symbol:")) {
+        return undefined;
+    }
+    const lastColon = value.lastIndexOf(":");
+    if (lastColon > 0) {
+        const pkg = value.slice(0, lastColon).trim();
+        const name = value.slice(lastColon + 1).trim();
+        if (pkg && name && !name.includes("/") && !/^\d+$/.test(name) && !looksLikeSourceFilePath(pkg)) {
+            return `${pkg}:${name}`;
+        }
+    }
+    const slash = value.match(/^(@?[\w.-]+(?:\/[\w.-]+)?)\/([\w.-]+)$/);
+    if (slash && !looksLikeSourceFilePath(slash[1])) {
+        return `${slash[1]}:${slash[2]}`;
+    }
+    return undefined;
+}
+function looksLikeSourceFilePath(value) {
+    return /\.(ts|tsx|js|jsx|mjs|cjs|py|d\.ts)$/i.test(value) || value.includes("\\");
+}

package/dist/catalogue/scanner.d.ts

@@ -0,0 +1,8 @@
+import type { CatalogueConfig, DiagnosticRecord, FileRecord } from "./schema.js";
+export interface ScanResult {
+    files: FileRecord[];
+    diagnostics: DiagnosticRecord[];
+}
+export declare function isExamplesTreePath(filePath: string): boolean;
+export declare function detectLanguage(filePath: string): string;
+export declare function scanWorkspace(workspaceRoot: string, config: CatalogueConfig): ScanResult;

package/dist/catalogue/scanner.js

@@ -0,0 +1,99 @@
+import { readFileSync, statSync } from "node:fs";
+import path from "node:path";
+import fg from "fast-glob";
+import { hashContent } from "./deterministic.js";
+import { createIgnoreMatcher, isIncludedByGlob, normalize } from "./ignore.js";
+import { isSecretLikeFile } from "../security/secretPatterns.js";
+export function isExamplesTreePath(filePath) {
+    return /(^|\/)examples\//.test(filePath.replaceAll("\\", "/"));
+}
+export function detectLanguage(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    if (ext === ".ts" || ext === ".tsx")
+        return "typescript";
+    if (ext === ".js" || ext === ".jsx" || ext === ".mjs" || ext === ".cjs")
+        return "javascript";
+    if (ext === ".py")
+        return "python";
+    if (ext === ".md")
+        return "markdown";
+    if (ext === ".json")
+        return "json";
+    if ([".yml", ".yaml", ".toml", ".ini", ".conf"].includes(ext))
+        return "config";
+    return "unknown";
+}
+export function scanWorkspace(workspaceRoot, config) {
+    const diagnostics = [];
+    const ignoreMatcher = createIgnoreMatcher(workspaceRoot, config);
+    const entries = fg.sync(["**/*"], {
+        cwd: workspaceRoot,
+        dot: true,
+        onlyFiles: true,
+        absolute: false,
+        followSymbolicLinks: false
+    }).sort();
+    const selected = entries
+        .map((entry) => normalize(entry))
+        .filter((entry) => !ignoreMatcher(entry))
+        .filter((entry) => isIncludedByGlob(entry, config.include));
+    const limited = selected.slice(0, config.limits.maxIndexedFiles);
+    const files = [];
+    for (const relativePath of limited) {
+        const absolute = path.resolve(workspaceRoot, relativePath);
+        const st = statSync(absolute);
+        if (st.size > config.limits.maxFileSizeBytes) {
+            diagnostics.push({
+                id: `diag:${relativePath}:file_too_large`,
+                severity: "warning",
+                category: "indexing",
+                code: "file_too_large",
+                message: `Skipped file larger than ${config.limits.maxFileSizeBytes} bytes.`,
+                filePath: relativePath,
+                provenance: { source: "scanner" }
+            });
+            continue;
+        }
+        if (isSecretLikeFile(path.basename(relativePath))) {
+            diagnostics.push({
+                id: `diag:${relativePath}:ignored_secret_like_file`,
+                severity: "info",
+                category: "security",
+                code: "ignored_secret_like_file",
+                message: "Skipped secret-like file.",
+                filePath: relativePath,
+                provenance: { source: "scanner" }
+            });
+            continue;
+        }
+        const content = readFileSync(absolute, "utf8");
+        const language = detectLanguage(relativePath);
+        const isTest = /(^|\/)tests?\//.test(relativePath) || /\.(test|spec)\./.test(relativePath);
+        const isExample = isExamplesTreePath(relativePath);
+        const isDocumentation = language === "markdown" || /CATALOGUE\.md$/i.test(relativePath);
+        const isConfig = language === "config" || /(^|\/)mapwright\.config\.json$/.test(relativePath);
+        const kind = isTest ? "test" : isDocumentation ? "documentation" : isConfig ? "config" : "source";
+        files.push({
+            path: relativePath,
+            language,
+            kind,
+            sizeBytes: Buffer.byteLength(content, "utf8"),
+            lineCount: content.length === 0 ? 0 : content.split(/\r?\n/).length,
+            hash: hashContent(content),
+            isGenerated: /generated|\.gen\./i.test(relativePath),
+            isTest,
+            isExample,
+            isConfig,
+            isDocumentation,
+            symbols: [],
+            capabilities: [],
+            publicApis: [],
+            provenance: {
+                source: "scanner",
+                extractors: ["workspace-scanner"]
+            }
+        });
+    }
+    files.sort((a, b) => a.path.localeCompare(b.path));
+    return { files, diagnostics };
+}

package/dist/catalogue/schema.d.ts

@@ -0,0 +1,289 @@
+export type CatalogueMode = "committed" | "local" | "memory";
+export type SymbolKind = "function" | "class" | "method" | "interface" | "type" | "enum" | "constant" | "variable" | "module" | "namespace" | "component" | "route" | "test" | "unknown";
+export type Visibility = "published" | "supported_internal" | "private" | "test_only" | "experimental" | "deprecated" | "ignored" | "unknown";
+export type Stability = "stable" | "experimental" | "deprecated" | "internal" | "test-only" | "unknown";
+export type Editability = "none" | "allowed" | "restricted" | "maintainer-only" | "unknown";
+export interface CatalogueDocTag {
+    tag: string;
+    value: string;
+}
+export interface DocumentationSourceRecord {
+    kind: "jsdoc" | "docstring" | "markdown" | "comment" | "unknown";
+    filePath: string;
+    symbolId?: string;
+    snippet?: string;
+}
+export interface ProvenanceRecord {
+    source: string;
+    extractors?: string[];
+    locations?: string[];
+    confidence?: number;
+    warnings?: string[];
+}
+export interface EditPolicyRecord {
+    id: string;
+    target: {
+        kind: "package" | "file" | "capability" | "symbol";
+        id: string;
+    };
+    editable: boolean;
+    status: Editability;
+    conditions: string[];
+    provenance: ProvenanceRecord;
+}
+export interface FileRecord {
+    path: string;
+    language: string;
+    kind: "source" | "test" | "documentation" | "config" | "generated" | "unknown";
+    sizeBytes: number;
+    lineCount: number;
+    hash: string;
+    isGenerated: boolean;
+    isTest: boolean;
+    isExample: boolean;
+    isConfig: boolean;
+    isDocumentation: boolean;
+    packageName?: string;
+    symbols: string[];
+    capabilities: string[];
+    publicApis: string[];
+    provenance: ProvenanceRecord;
+}
+export type PackageEcosystem = "npm" | "python" | "unknown";
+export interface PackageRecord {
+    id: string;
+    name: string;
+    path: string;
+    /** Package ecosystem for identity and ordering. */
+    ecosystem?: PackageEcosystem;
+    /** Python import package roots (dotted names); not a separate package ID. */
+    importPackages?: string[];
+    /** Declared console scripts / entry points (Python project.scripts, etc.). */
+    consoleScripts?: Array<{
+        name: string;
+        target: string;
+    }>;
+    summary?: string;
+    capabilities: string[];
+    publicApis: string[];
+    tests: string[];
+    stability: Stability;
+    entrypoints?: string[];
+    modules?: string[];
+    internalPaths?: string[];
+    publicPaths?: string[];
+    dependencyPolicy?: {
+        allowedInternalImports?: string[];
+        forbiddenImports?: string[];
+    };
+    provenance: ProvenanceRecord;
+}
+export interface CapabilityRecord {
+    id: string;
+    name: string;
+    summary?: string;
+    description?: string;
+    keywords: string[];
+    status: "available" | "experimental" | "deprecated" | "internal" | "unknown";
+    stability: Stability;
+    intendedUse?: string;
+    publicApis: string[];
+    symbols: string[];
+    files: string[];
+    packages: string[];
+    examples: string[];
+    tests: string[];
+    contracts: string[];
+    limitations: string[];
+    editable?: {
+        status: Editability;
+        policyId?: string;
+    };
+    provenance: ProvenanceRecord;
+}
+export type PublicExportKind = "named" | "default" | "namespace" | "type_only_export";
+export interface PublicApiRecord {
+    id: string;
+    symbolId: string;
+    name: string;
+    importPath?: string;
+    /** package.json exports key when known (e.g. "./components"). */
+    exportKey?: string;
+    exportKind?: PublicExportKind;
+    packageId?: string;
+    signature?: string;
+    capabilityIds: string[];
+    stability: Stability;
+    intendedUse?: string;
+    inputs?: string;
+    returns?: string;
+    contracts: string[];
+    errors: string[];
+    examples: string[];
+    tests: string[];
+    provenance: ProvenanceRecord;
+}
+export interface ExampleRecord {
+    id: string;
+    title?: string;
+    filePath?: string;
+    anchor?: string;
+    capabilityIds: string[];
+    publicApiIds: string[];
+    symbolIds: string[];
+    summary?: string;
+    provenance: ProvenanceRecord;
+}
+export type SymbolProvenanceKind = "authored_source" | "generated_declaration" | "generated_only";
+export interface SymbolRecord {
+    id: string;
+    name: string;
+    qualifiedName: string;
+    kind: SymbolKind;
+    language: string;
+    filePath: string;
+    packageId?: string;
+    /** Owning package-relative module path used in identity. */
+    modulePath?: string;
+    qualifiedContainerPath?: string;
+    range?: {
+        startLine: number;
+        startColumn?: number;
+        endLine?: number;
+        endColumn?: number;
+    };
+    signature?: string;
+    signatureFingerprint?: string;
+    implementationFingerprint?: string;
+    /** Self if canonical; otherwise points at preferred authored declaration. */
+    canonicalSymbolId?: string;
+    duplicateOf?: string | null;
+    symbolProvenance?: SymbolProvenanceKind;
+    visibility: Visibility;
+    exported: boolean;
+    doc?: {
+        present: boolean;
+        text?: string;
+        tags?: CatalogueDocTag[];
+    };
+    capabilities: string[];
+    publicApi?: string;
+    parents: string[];
+    children: string[];
+    confidence: number;
+    provenance: ProvenanceRecord;
+}
+export type RelationshipType = "defines" | "contains" | "documents" | "tests" | "covers" | "imports" | "exports" | "explicit_coverage" | "explicit_example" | "resolved_direct_import" | "resolved_direct_usage";
+export interface RelationshipEvidence {
+    filePath?: string;
+    line?: number;
+    startLine?: number;
+    endLine?: number;
+    text?: string;
+    extractedFromId?: string;
+    extractedToId?: string;
+}
+export interface RelationshipRecord {
+    id: string;
+    type: RelationshipType;
+    from: {
+        kind: "file" | "symbol" | "capability" | "publicApi" | "test" | "package" | "externalPackage";
+        id: string;
+    };
+    to: {
+        kind: "file" | "symbol" | "capability" | "publicApi" | "test" | "package" | "externalPackage";
+        id: string;
+    };
+    /** Semantic discriminant (binding, alias, runtime|type-only, etc.). Never line/order. */
+    localDiscriminant?: string | null;
+    evidence?: RelationshipEvidence;
+    evidenceRanges?: RelationshipEvidence[];
+    confidence: number;
+    provenance: ProvenanceRecord;
+}
+export interface TestRecord {
+    id: string;
+    filePath: string;
+    name: string;
+    /** Classification metadata — not part of identity. */
+    testKind?: "unit" | "example_linked" | "unknown";
+    framework?: string;
+    suitePath?: string;
+    implementationFingerprint?: string;
+    symbolId?: string;
+    coversCapabilities: string[];
+    coversSymbols: string[];
+    coversPublicApis: string[];
+    contracts: string[];
+    provenance: ProvenanceRecord;
+}
+export interface DiagnosticRecord {
+    id: string;
+    severity: "info" | "warning" | "error";
+    category: "documentation" | "indexing" | "resolution" | "style" | "security" | "determinism";
+    code: string;
+    message: string;
+    filePath?: string;
+    range?: {
+        startLine: number;
+        endLine?: number;
+    };
+    target?: {
+        kind: "file" | "symbol" | "capability" | "publicApi" | "test" | "package";
+        id: string;
+    };
+    provenance: ProvenanceRecord;
+}
+export interface CatalogueSnapshot {
+    schemaVersion: 2;
+    /** Required identity scheme; v0.7 uses stable-sha256-v1. */
+    identityScheme: "stable-sha256-v1";
+    catalogueId: string;
+    generator: {
+        /** New catalogues emit "mapwright"; "code-atlas" is accepted when loading pre-release catalogues. */
+        name: "mapwright" | "code-atlas";
+        version: string;
+    };
+    mode: CatalogueMode;
+    stats: {
+        fileCount: number;
+        symbolCount: number;
+        capabilityCount: number;
+        publicApiCount: number;
+        exampleCount: number;
+        diagnosticCount: number;
+        languages: Record<string, number>;
+    };
+    files: FileRecord[];
+    packages: PackageRecord[];
+    capabilities: CapabilityRecord[];
+    publicApis: PublicApiRecord[];
+    examples: ExampleRecord[];
+    symbols: SymbolRecord[];
+    relationships: RelationshipRecord[];
+    tests: TestRecord[];
+    diagnostics: DiagnosticRecord[];
+    provenance: ProvenanceRecord & {
+        documentationSources?: DocumentationSourceRecord[];
+    };
+}
+export interface CatalogueConfig {
+    schemaVersion: 2;
+    catalogueDir: string;
+    committedCatalogue: boolean;
+    languages: string[];
+    include: string[];
+    exclude: string[];
+    documentation: {
+        requirePublicApiDocs: boolean;
+        requireCapabilityForPublicApi: boolean;
+    };
+    validation: {
+        failOn: "info" | "warning" | "error" | "never";
+    };
+    limits: {
+        maxFileSizeBytes: number;
+        maxIndexedFiles: number;
+        maxSourcePreviewLines: number;
+    };
+}

package/dist/catalogue/schema.js

@@ -0,0 +1 @@
+export {};