@mortice/mapwright 0.8.0

package/dist/cli/index.js

@@ -0,0 +1,211 @@
+#!/usr/bin/env node
+import process from "node:process";
+import { runIndexCommand } from "./commands/indexWorkspace.js";
+import { runValidateCommand } from "./commands/validate.js";
+import { runCheckCommand } from "./commands/check.js";
+import { runSchemaCommand } from "./commands/schema.js";
+import { runAuditDocsCommand } from "./commands/auditDocs.js";
+import { runAdoptionPlanCommand } from "./commands/adoptionPlan.js";
+import { runTemplateCommand } from "./commands/template.js";
+import { runDogfoodCommand } from "./commands/dogfood.js";
+import { runRecommendConfigCommand } from "./commands/recommendConfig.js";
+import { runDiffCommand } from "./commands/diff.js";
+import { runDriftCommand } from "./commands/drift.js";
+import { runChangesCommand } from "./commands/changes.js";
+import { runCompatibilityCommand } from "./commands/compatibility.js";
+import { runChangeImpactCommand } from "./commands/changeImpact.js";
+function main(argv) {
+    const [command, ...rest] = argv;
+    const args = parseArgs(rest);
+    if (command === "index") {
+        const output = runIndexCommand({
+            workspace: getString(args, "workspace", "."),
+            config: getOptionalString(args, "config"),
+            mode: getOptionalString(args, "mode"),
+            write: args.has("write") ? true : args.has("no-write") ? false : undefined,
+            pretty: args.has("pretty")
+        });
+        process.stdout.write(`${JSON.stringify(output, null, 2)}\n`);
+        return;
+    }
+    if (command === "validate") {
+        const { output, exitCode } = runValidateCommand({
+            workspace: getString(args, "workspace", "."),
+            config: getOptionalString(args, "config"),
+            failOn: getOptionalString(args, "fail-on")
+        });
+        process.stdout.write(`${JSON.stringify(output, null, 2)}\n`);
+        process.exitCode = exitCode;
+        return;
+    }
+    if (command === "schema") {
+        process.stdout.write(`${JSON.stringify(runSchemaCommand(), null, 2)}\n`);
+        return;
+    }
+    if (command === "check") {
+        const { output, exitCode } = runCheckCommand({
+            workspace: getString(args, "workspace", "."),
+            config: getOptionalString(args, "config"),
+            failOn: getOptionalString(args, "fail-on")
+        });
+        process.stdout.write(`${JSON.stringify(output, null, 2)}\n`);
+        process.exitCode = exitCode;
+        return;
+    }
+    if (command === "audit-docs") {
+        const output = runAuditDocsCommand({
+            workspace: getString(args, "workspace", "."),
+            config: getOptionalString(args, "config"),
+            includeInfo: args.has("include-info") ? true : undefined,
+            includeGenerated: args.has("include-generated") ? true : undefined,
+            maxGaps: getOptionalNumber(args, "max-gaps")
+        });
+        process.stdout.write(`${JSON.stringify(output, null, 2)}\n`);
+        process.exitCode = output.ok ? 0 : 1;
+        return;
+    }
+    if (command === "adoption-plan") {
+        const output = runAdoptionPlanCommand({
+            workspace: getString(args, "workspace", "."),
+            config: getOptionalString(args, "config"),
+            includeInfo: args.has("include-info") ? true : undefined,
+            includeGenerated: args.has("include-generated") ? true : undefined,
+            maxGaps: getOptionalNumber(args, "max-gaps")
+        });
+        process.stdout.write(`${JSON.stringify(output, null, 2)}\n`);
+        process.exitCode = output.ok ? 0 : 1;
+        return;
+    }
+    if (command === "template") {
+        const firstPositional = rest.find((arg) => !arg.startsWith("--"));
+        const templateId = firstPositional ?? getOptionalString(args, "template-id");
+        const output = runTemplateCommand({
+            templateId,
+            list: args.has("list") || templateId === "list"
+        });
+        process.stdout.write(`${JSON.stringify(output, null, 2)}\n`);
+        process.exitCode = output.ok ? 0 : 1;
+        return;
+    }
+    if (command === "dogfood") {
+        const output = runDogfoodCommand({
+            workspace: getString(args, "workspace", "."),
+            config: getOptionalString(args, "config"),
+            mode: getOptionalString(args, "mode"),
+            maxDiagnostics: getOptionalNumber(args, "max-diagnostics"),
+            maxGaps: getOptionalNumber(args, "max-gaps")
+        });
+        process.stdout.write(`${JSON.stringify(output, null, 2)}\n`);
+        process.exitCode = output.ok ? 0 : 1;
+        return;
+    }
+    if (command === "recommend-config") {
+        const output = runRecommendConfigCommand({
+            workspace: getString(args, "workspace", "."),
+            config: getOptionalString(args, "config"),
+            mode: getOptionalString(args, "mode"),
+            limit: getOptionalNumber(args, "limit")
+        });
+        process.stdout.write(`${JSON.stringify(output, null, 2)}\n`);
+        process.exitCode = output.ok ? 0 : 1;
+        return;
+    }
+    if (command === "diff") {
+        const { output, exitCode } = runDiffCommand({
+            baseWorkspace: getString(args, "base-workspace", getString(args, "workspace", ".")),
+            baseCatalogueDir: getString(args, "base", ".mapwright"),
+            headWorkspace: getString(args, "head-workspace", getString(args, "workspace", ".")),
+            headCatalogueDir: getString(args, "head", ".mapwright"),
+            writeDir: getOptionalString(args, "write"),
+            failOn: getOptionalString(args, "fail-on")
+        });
+        process.stdout.write(`${JSON.stringify(output, null, 2)}\n`);
+        process.exitCode = exitCode;
+        return;
+    }
+    if (command === "changes") {
+        const { output, exitCode } = runChangesCommand({
+            comparisonDir: getString(args, "comparison-dir", ""),
+            domain: getOptionalString(args, "domain"),
+            status: getOptionalString(args, "status"),
+            offset: getOptionalNumber(args, "offset"),
+            limit: getOptionalNumber(args, "limit"),
+            failOn: getOptionalString(args, "fail-on")
+        });
+        process.stdout.write(`${JSON.stringify(output, null, 2)}\n`);
+        process.exitCode = exitCode;
+        return;
+    }
+    if (command === "compatibility") {
+        const { output, exitCode } = runCompatibilityCommand({
+            comparisonDir: getString(args, "comparison-dir", ""),
+            offset: getOptionalNumber(args, "offset"),
+            limit: getOptionalNumber(args, "limit"),
+            failOn: getOptionalString(args, "fail-on")
+        });
+        process.stdout.write(`${JSON.stringify(output, null, 2)}\n`);
+        process.exitCode = exitCode;
+        return;
+    }
+    if (command === "change-impact") {
+        const { output, exitCode } = runChangeImpactCommand({
+            comparisonDir: getString(args, "comparison-dir", ""),
+            changeId: getOptionalString(args, "change-id"),
+            maxDepth: getOptionalNumber(args, "max-depth"),
+            offset: getOptionalNumber(args, "offset"),
+            limit: getOptionalNumber(args, "limit")
+        });
+        process.stdout.write(`${JSON.stringify(output, null, 2)}\n`);
+        process.exitCode = exitCode;
+        return;
+    }
+    if (command === "drift") {
+        const { output, exitCode } = runDriftCommand({
+            workspace: getString(args, "workspace", "."),
+            catalogueDir: getOptionalString(args, "catalogue-dir"),
+            config: getOptionalString(args, "config")
+        });
+        process.stdout.write(`${JSON.stringify(output, null, 2)}\n`);
+        process.exitCode = exitCode;
+        return;
+    }
+    process.stderr.write("Usage: mapwright <index|validate|check|schema|audit-docs|adoption-plan|template|dogfood|recommend-config|diff|changes|compatibility|change-impact|drift> [options]\n");
+    process.exitCode = 2;
+}
+function parseArgs(args) {
+    const out = new Map();
+    for (let i = 0; i < args.length; i += 1) {
+        const arg = args[i];
+        if (!arg.startsWith("--")) {
+            continue;
+        }
+        const key = arg.replace(/^--/, "");
+        const next = args[i + 1];
+        if (next && !next.startsWith("--")) {
+            out.set(key, next);
+            i += 1;
+        }
+        else {
+            out.set(key, "true");
+        }
+    }
+    return out;
+}
+function getString(args, key, fallback) {
+    return args.get(key) ?? fallback;
+}
+function getOptionalString(args, key) {
+    return args.get(key);
+}
+function getOptionalNumber(args, key) {
+    const value = args.get(key);
+    if (!value) {
+        return undefined;
+    }
+    const parsed = Number(value);
+    if (!Number.isFinite(parsed)) {
+        return undefined;
+    }
+    return parsed;
+}
+main(process.argv.slice(2));

package/dist/comparison/artefactValidate.d.ts

@@ -0,0 +1,19 @@
+import type { ChangeRecord, ComparisonError, ComparisonSnapshot, CompatibilityFinding, RecordDomain, TransitionCandidate } from "./schema.js";
+export declare const REGISTERED_DOMAINS: Set<RecordDomain>;
+export declare const REGISTERED_STATUSES: Set<string>;
+export declare const REGISTERED_FACETS: Set<string>;
+export declare const REGISTERED_CANDIDATE_KINDS: Set<string>;
+export declare const REGISTERED_CONFIDENCE: Set<string>;
+export declare const REGISTERED_CLASSIFICATIONS: Set<string>;
+export declare const REGISTERED_RULE_IDS: Set<string>;
+export declare const REGISTERED_EVIDENCE_REASONS: Set<string>;
+export declare function validateArtefactSemantics(comparison: ComparisonSnapshot, lockMeta?: {
+    comparisonSchemaVersion?: number;
+    comparisonId?: string;
+    baseCatalogueId?: string;
+    headCatalogueId?: string;
+}): ComparisonError | null;
+export declare function candidateIdentityDiscriminator(candidate: Pick<TransitionCandidate, "ambiguity" | "candidateKind" | "headRecordId" | "identityDiscriminator">): string;
+export declare function attachChangeIdentity(change: ChangeRecord): ChangeRecord;
+export declare function attachCandidateIdentity(candidate: TransitionCandidate): TransitionCandidate;
+export declare function attachFindingIdentity(finding: CompatibilityFinding, identityBaseRecordId: string | null, identityHeadRecordId: string | null): CompatibilityFinding;

package/dist/comparison/artefactValidate.js

@@ -0,0 +1,334 @@
+/**
+ * Vocabularies and full semantic validation for loaded comparison artefacts.
+ */
+import { comparisonIdentityId, changeIdentityId } from "./identity.js";
+import { orderChangeRecords, orderCompatibilityFindings } from "./ordering.js";
+import { COMPATIBILITY_RULE_VERSION } from "./version.js";
+export const REGISTERED_DOMAINS = new Set([
+    "packages",
+    "files",
+    "symbols",
+    "publicApis",
+    "tests",
+    "examples",
+    "capabilities",
+    "relationships",
+    "diagnostics"
+]);
+export const REGISTERED_STATUSES = new Set(["added", "removed", "modified", "unchanged"]);
+export const REGISTERED_FACETS = new Set([
+    "signature_changed",
+    "implementation_changed",
+    "documentation_changed",
+    "module_path_changed",
+    "file_path_changed",
+    "visibility_changed",
+    "export_status_changed",
+    "canonical_target_changed",
+    "capability_links_changed",
+    "implementation_target_changed",
+    "stability_changed",
+    "contracts_changed",
+    "errors_changed",
+    "example_links_changed",
+    "test_links_changed",
+    "public_apis_changed",
+    "tests_changed",
+    "capabilities_changed",
+    "entrypoints_changed",
+    "console_scripts_changed",
+    "import_packages_changed",
+    "content_fingerprint_changed",
+    "public_surface_changed",
+    "evidence_changed",
+    "confidence_changed",
+    "local_discriminant_changed",
+    "severity_changed",
+    "import_path_changed",
+    "exported_name_changed",
+    "declaration_name_changed"
+]);
+export const REGISTERED_CANDIDATE_KINDS = new Set([
+    "probable_move",
+    "probable_rename",
+    "probable_move_and_rename",
+    "possible_replacement",
+    "ambiguous_candidate",
+    "public_surface_transition"
+]);
+export const REGISTERED_CONFIDENCE = new Set(["high", "medium", "low", "ambiguous"]);
+export const REGISTERED_CLASSIFICATIONS = new Set([
+    "breaking",
+    "potentially_breaking",
+    "non_breaking",
+    "documentation_only",
+    "unknown",
+    "not_applicable"
+]);
+export const REGISTERED_RULE_IDS = new Set([
+    "public-export-removed",
+    "public-export-added",
+    "documentation-only",
+    "implementation-target-stable-export",
+    "signature-fingerprint-or-display-changed",
+    "public-api-modified-unknown",
+    "public-surface-transition",
+    "python-console-script-removed",
+    "python-console-script-target-changed",
+    "python-console-script-renamed",
+    "python-console-script-added",
+    "python-console-script-metadata",
+    "stability-stable-to-deprecated",
+    "stability-stable-to-internal",
+    "stability-stable-to-experimental",
+    "stability-experimental-to-stable",
+    "stability-deprecated-to-stable",
+    "stability-deprecated-to-internal",
+    "stability-experimental-to-deprecated",
+    "stability-experimental-to-internal",
+    "stability-internal-to-stable",
+    "stability-internal-to-experimental",
+    "stability-transition-unknown-policy"
+]);
+export const REGISTERED_EVIDENCE_REASONS = new Set([
+    "package_continuity",
+    "exported_name_match",
+    "import_path_match",
+    "language_kind_match",
+    "declaration_name_match",
+    "signature_fingerprint_match",
+    "implementation_fingerprint_match",
+    "qualified_container_match",
+    "module_topology_match",
+    "documentation_fingerprint_match",
+    "capability_linkage_match",
+    "content_hash_match",
+    "basename_match"
+]);
+function edgeSortKey(edge) {
+    return `${edge.type}|${edge.fromKind}:${edge.fromId}|${edge.toKind}:${edge.toId}|${edge.provenance ?? ""}`;
+}
+function sameIdOrder(actual, expected) {
+    if (actual.length !== expected.length)
+        return false;
+    for (let i = 0; i < actual.length; i += 1) {
+        if (actual[i] !== expected[i])
+            return false;
+    }
+    return true;
+}
+function invalid(message, details) {
+    return { code: "comparison_artifact_invalid", message, details };
+}
+export function validateArtefactSemantics(comparison, lockMeta) {
+    const m = comparison.manifest;
+    if (lockMeta) {
+        if (lockMeta.comparisonSchemaVersion !== m.comparisonSchemaVersion) {
+            return invalid("Lock comparisonSchemaVersion does not match manifest.");
+        }
+        if (lockMeta.comparisonId !== m.comparisonId) {
+            return invalid("Lock comparisonId does not match manifest.");
+        }
+        if (lockMeta.baseCatalogueId !== m.baseCatalogueId) {
+            return invalid("Lock baseCatalogueId does not match manifest.");
+        }
+        if (lockMeta.headCatalogueId !== m.headCatalogueId) {
+            return invalid("Lock headCatalogueId does not match manifest.");
+        }
+    }
+    if (!m.options || !Array.isArray(m.options.enabledDomains)) {
+        return invalid("Manifest options.enabledDomains missing.");
+    }
+    const expectedComparisonId = comparisonIdentityId({
+        baseCatalogueId: m.baseCatalogueId,
+        headCatalogueId: m.headCatalogueId,
+        options: m.options
+    });
+    if (expectedComparisonId !== m.comparisonId) {
+        return {
+            code: "comparison_identity_mismatch",
+            message: "Recomputed comparison ID does not match manifest.comparisonId.",
+            details: { expected: expectedComparisonId, actual: m.comparisonId }
+        };
+    }
+    const changeIds = new Set();
+    const factualKeys = new Set();
+    for (const change of comparison.changes) {
+        if (!REGISTERED_DOMAINS.has(change.domain)) {
+            return invalid(`Unsupported change domain ${change.domain}.`);
+        }
+        if (!REGISTERED_STATUSES.has(change.status)) {
+            return invalid(`Unsupported change status ${change.status}.`);
+        }
+        if (change.status === "added" && (change.baseRecordId != null || !change.headRecordId)) {
+            return invalid(`Invalid base/head combination for added change ${change.id}.`);
+        }
+        if (change.status === "removed" && (change.headRecordId != null || !change.baseRecordId)) {
+            return invalid(`Invalid base/head combination for removed change ${change.id}.`);
+        }
+        if ((change.status === "modified" || change.status === "unchanged") &&
+            (!change.baseRecordId || !change.headRecordId)) {
+            return invalid(`Invalid base/head combination for ${change.status} change ${change.id}.`);
+        }
+        for (const facet of change.facets ?? []) {
+            if (!REGISTERED_FACETS.has(facet.facet)) {
+                return invalid(`Unknown facet ${facet.facet} on change ${change.id}.`);
+            }
+        }
+        const expectedId = changeIdentityId({
+            comparisonId: m.comparisonId,
+            domain: change.domain,
+            baseRecordId: change.baseRecordId,
+            headRecordId: change.headRecordId,
+            factualChangeKind: change.status,
+            discriminator: change.identityDiscriminator ?? null
+        });
+        if (expectedId !== change.id) {
+            return invalid(`Incorrect change ID for ${change.id}.`, { expected: expectedId });
+        }
+        if (changeIds.has(change.id)) {
+            return invalid(`Duplicate change ID ${change.id}.`);
+        }
+        changeIds.add(change.id);
+        const factualKey = `${change.domain}|${change.baseRecordId}|${change.headRecordId}|${change.status}|${change.identityDiscriminator ?? ""}`;
+        if (factualKeys.has(factualKey)) {
+            return invalid(`Duplicate factual change tuple for ${factualKey}.`);
+        }
+        factualKeys.add(factualKey);
+    }
+    const orderedChanges = orderChangeRecords(comparison.changes);
+    if (!sameIdOrder(comparison.changes.map((c) => c.id), orderedChanges.map((c) => c.id))) {
+        return invalid("Changes are not in declared deterministic order.");
+    }
+    const candidateIds = new Set();
+    for (const candidate of comparison.candidates) {
+        if (!REGISTERED_DOMAINS.has(candidate.domain)) {
+            return invalid(`Unsupported candidate domain ${candidate.domain}.`);
+        }
+        if (!candidate.baseRecordId || !candidate.headRecordId) {
+            return invalid(`Candidate ${candidate.id} missing base/head IDs.`);
+        }
+        if (!REGISTERED_CANDIDATE_KINDS.has(candidate.candidateKind)) {
+            return invalid(`Unregistered candidate kind ${candidate.candidateKind}.`);
+        }
+        if (!REGISTERED_CONFIDENCE.has(candidate.confidence)) {
+            return invalid(`Unregistered candidate confidence ${candidate.confidence}.`);
+        }
+        if (candidate.ambiguity && candidate.candidateKind !== "ambiguous_candidate" && candidate.confidence !== "ambiguous") {
+            // ambiguity true should mark confidence ambiguous or kind ambiguous_candidate
+            if (!candidate.ambiguity) {
+                /* unreachable */
+            }
+        }
+        if (candidate.ambiguity && candidate.confidence !== "ambiguous") {
+            return invalid(`Ambiguous candidate ${candidate.id} must have confidence ambiguous.`);
+        }
+        for (const reason of candidate.evidenceReasons ?? []) {
+            if (!REGISTERED_EVIDENCE_REASONS.has(reason)) {
+                return invalid(`Unregistered candidate evidence reason ${reason}.`);
+            }
+        }
+        for (const alt of candidate.alternativeCandidateIds ?? []) {
+            if (typeof alt !== "string" || !alt) {
+                return invalid(`Invalid alternativeCandidateIds on ${candidate.id}.`);
+            }
+        }
+        const expectedDiscriminator = candidate.identityDiscriminator ??
+            (candidate.ambiguity
+                ? `ambiguous_${candidate.candidateKind}:${candidate.headRecordId}`
+                : candidate.candidateKind);
+        const expectedId = changeIdentityId({
+            comparisonId: m.comparisonId,
+            domain: candidate.domain,
+            baseRecordId: candidate.baseRecordId,
+            headRecordId: candidate.headRecordId,
+            factualChangeKind: "modified",
+            discriminator: expectedDiscriminator
+        });
+        if (expectedId !== candidate.id) {
+            return invalid(`Incorrect candidate ID for ${candidate.id}.`, { expected: expectedId });
+        }
+        if (candidateIds.has(candidate.id)) {
+            return invalid(`Duplicate candidate ID ${candidate.id}.`);
+        }
+        candidateIds.add(candidate.id);
+    }
+    const sortedCandidateIds = [...comparison.candidates.map((c) => c.id)].sort((a, b) => a.localeCompare(b));
+    if (!sameIdOrder(comparison.candidates.map((c) => c.id), sortedCandidateIds)) {
+        return invalid("Candidates are not in declared deterministic order.");
+    }
+    const findingIds = new Set();
+    for (const finding of comparison.compatibilityFindings) {
+        if (!REGISTERED_RULE_IDS.has(finding.ruleId)) {
+            return invalid(`Unknown compatibility rule ${finding.ruleId}.`);
+        }
+        if (finding.ruleVersion !== COMPATIBILITY_RULE_VERSION) {
+            return invalid(`Unsupported rule version ${finding.ruleVersion}.`);
+        }
+        if (!REGISTERED_CLASSIFICATIONS.has(finding.classification)) {
+            return invalid(`Unregistered classification ${finding.classification}.`);
+        }
+        if (!REGISTERED_CONFIDENCE.has(finding.confidence)) {
+            return invalid(`Unregistered finding confidence ${finding.confidence}.`);
+        }
+        if (finding.changeId != null && finding.changeId !== "" && !changeIds.has(finding.changeId)) {
+            return invalid(`Dangling finding changeId ${finding.changeId}.`);
+        }
+        const identityBase = finding.identityBaseRecordId ?? finding.publicApiId ?? null;
+        const identityHead = finding.identityHeadRecordId ?? finding.changeId ?? null;
+        const identityDiscriminator = finding.identityDiscriminator ?? `compat:${finding.ruleId}`;
+        const expectedId = changeIdentityId({
+            comparisonId: m.comparisonId,
+            domain: "publicApis",
+            baseRecordId: identityBase,
+            headRecordId: identityHead,
+            factualChangeKind: "modified",
+            discriminator: identityDiscriminator
+        });
+        if (expectedId !== finding.id) {
+            return invalid(`Incorrect finding ID for ${finding.id}.`, { expected: expectedId });
+        }
+        if (findingIds.has(finding.id)) {
+            return invalid(`Duplicate finding ID ${finding.id}.`);
+        }
+        findingIds.add(finding.id);
+    }
+    const orderedFindings = orderCompatibilityFindings(comparison.compatibilityFindings);
+    if (!sameIdOrder(comparison.compatibilityFindings.map((f) => f.id), orderedFindings.map((f) => f.id))) {
+        return invalid("Compatibility findings are not in declared deterministic order.");
+    }
+    for (const side of ["base", "head"]) {
+        const edges = comparison.graphIndex[side];
+        const sorted = [...edges].sort((a, b) => edgeSortKey(a).localeCompare(edgeSortKey(b)));
+        for (let i = 0; i < edges.length; i += 1) {
+            if (edgeSortKey(edges[i]) !== edgeSortKey(sorted[i])) {
+                return invalid(`Graph index ${side} edges are not in declared deterministic order.`);
+            }
+        }
+    }
+    return null;
+}
+export function candidateIdentityDiscriminator(candidate) {
+    if (candidate.identityDiscriminator)
+        return candidate.identityDiscriminator;
+    return candidate.ambiguity
+        ? `ambiguous_${candidate.candidateKind}:${candidate.headRecordId}`
+        : candidate.candidateKind;
+}
+export function attachChangeIdentity(change) {
+    return { ...change, identityDiscriminator: change.identityDiscriminator ?? null };
+}
+export function attachCandidateIdentity(candidate) {
+    return {
+        ...candidate,
+        identityDiscriminator: candidateIdentityDiscriminator(candidate)
+    };
+}
+export function attachFindingIdentity(finding, identityBaseRecordId, identityHeadRecordId) {
+    return {
+        ...finding,
+        identityBaseRecordId,
+        identityHeadRecordId,
+        identityDiscriminator: `compat:${finding.ruleId}`
+    };
+}

package/dist/comparison/candidates.d.ts

@@ -0,0 +1,12 @@
+import type { CatalogueSnapshot } from "../catalogue/schema.js";
+import { type ComparisonCollisionTracker } from "./identity.js";
+import type { ChangeRecord, TransitionCandidate } from "./schema.js";
+export declare function matchAllTransitionCandidates(comparisonId: string, changes: ChangeRecord[], collisions: ComparisonCollisionTracker, catalogues?: {
+    base: CatalogueSnapshot;
+    head: CatalogueSnapshot;
+}): {
+    candidates: TransitionCandidate[];
+    warnings: string[];
+};
+/** @deprecated Use matchAllTransitionCandidates */
+export declare function matchPublicSurfaceTransitions(comparisonId: string, changes: ChangeRecord[], collisions: ComparisonCollisionTracker): TransitionCandidate[];