@shapeshift-labs/frontier-lang-compiler 0.2.100 → 0.2.102

package/dist/declarations/semantic-sidecar.d.ts

@@ -24,7 +24,7 @@ import type {
   UniversalAstLayerMap,
   UniversalAstLayerRecord
 } from '@shapeshift-labs/frontier-lang-kernel';
-import type { SemanticImportSidecarAdmission, SemanticImportSidecarQuality } from './semantic-sidecar-admission.js';
+import type { SemanticImportSidecarAdmission, SemanticImportSidecarQuality, SemanticImportSidecarQualityRecord } from './semantic-sidecar-admission.js';
 import type { SemanticMergeCandidateAdmissionRecord, SemanticMergeCandidateProjectionRisk } from './semantic-merge-candidates.js';
 import type { SemanticMergeConflictClass, SemanticMergeConflictSummary } from './semantic-merge-conflicts.js';
 import type { SemanticImportImpactSummary } from './semantic-impact.js';
@@ -52,7 +52,6 @@ import type { JavaAstNativeImporterAdapterOptions, KotlinPsiNativeImporterAdapte
 import type { NativeTargetProjectionAdapterCoverageInput, NativeTargetProjectionAdapterSummary, NativeTargetProjectionAdapterInput, NativeTargetProjectionAdapterResult, NativeTargetProjectionAdapter, NativeTargetProjectionAdapterResolverInput, NativeTargetProjectionResult } from './target-adapters.js';
 import type { NativeProjectSourceInput, ImportNativeProjectOptions, NativeProjectImportResult, NativeSourceProjectionMode, ProjectNativeImportToSourceOptions, NativeSourceProjectionDeclaration, NativeSourceProjectionResult, NativeSourceCompileOutputMode, CompileNativeSourceOptions, NativeSourceCompileResult } from './native-project.js';
 import type { NativeImportRoundtripReadinessStatus, NativeImportRoundtripReadinessOptions, NativeImportRoundtripReadinessClassification } from './roundtrip.js';
-
 export interface SemanticImportOwnershipRegion {
   readonly id: string;
   readonly key: string;
@@ -71,7 +70,6 @@ export interface SemanticImportOwnershipRegion {
   readonly mergePolicy?: string;
   readonly metadata?: Record<string, unknown>;
 }
-
 export interface SemanticImportSidecarSymbol {
   readonly id: string;
   readonly name?: string;
@@ -87,7 +85,6 @@ export interface SemanticImportSidecarSymbol {
   readonly ownershipRegionKind?: NativeImportRegionTaxonomyKind;
   readonly readiness: SemanticMergeReadiness;
 }
-
 export interface SemanticImportRegionTaxonomySummary {
   readonly kinds: readonly NativeImportRegionTaxonomyKind[];
   readonly presentKinds: readonly NativeImportRegionTaxonomyKind[];
@@ -95,12 +92,12 @@ export interface SemanticImportRegionTaxonomySummary {
   readonly keys: readonly string[];
   readonly keysByKind: Readonly<Record<string, readonly string[]>>;
 }
-
 export interface SemanticImportPatchHint {
   readonly id: string;
   readonly kind: 'source-region-patch' | string;
   readonly ownershipRegionId: string;
   readonly ownershipKey: string;
+  readonly operation: string;
   readonly sourcePath?: string;
   readonly sourceHash?: string;
   readonly sourceSpan?: SourceSpan;
@@ -113,7 +110,6 @@ export interface SemanticImportPatchHint {
     readonly requiresSourceMap: boolean;
   };
 }
-
 export interface SemanticImportSidecarImportEntry {
   readonly id: string;
   readonly language?: FrontierSourceLanguage | string;
@@ -135,11 +131,17 @@ export interface SemanticImportSidecarImportEntry {
   readonly proofSpec: SemanticImportSidecarProofSpecSummary;
   readonly paradigmSemantics: SemanticImportSidecarParadigmSemanticsSummary;
   readonly dependencyRelationCount: number; readonly dependencyPredicates: readonly string[];
+  readonly semanticFactCount?: number;
+  readonly semanticFactPredicates?: readonly string[];
+  readonly semanticFactSummary?: Readonly<Record<string, number>>;
+  readonly patchHintCount?: number;
+  readonly patchHintOperations?: readonly string[];
+  readonly patchHints?: readonly SemanticImportPatchHint[];
   readonly readiness: SemanticMergeReadiness;
   readonly emptySemanticIndex: boolean;
+  readonly qualityRecord: SemanticImportSidecarQualityRecord;
   readonly regionTaxonomy?: SemanticImportRegionTaxonomySummary;
 }
-
 export interface SemanticImportSidecarSourcePreservationRecord {
   readonly id: string;
   readonly level: SourcePreservationLevel;
@@ -157,7 +159,6 @@ export interface SemanticImportSidecarSourcePreservationRecord {
   readonly evidenceIds: readonly string[];
   readonly reasons: readonly string[];
 }
-
 export interface SemanticImportSidecarUniversalAstLayerSummary {
   readonly total: number;
   readonly names: readonly string[];
@@ -165,7 +166,6 @@ export interface SemanticImportSidecarUniversalAstLayerSummary {
   readonly byName: Readonly<Record<string, number>>;
   readonly empty: boolean;
 }
-
 export interface SemanticImportSidecarProofSpecSummary {
   readonly total: number;
   readonly ids: readonly string[];
@@ -194,7 +194,6 @@ export interface SemanticImportSidecarProofSpecSummary {
   readonly byArtifactKind: Readonly<Record<string, number>>;
   readonly empty: boolean;
 }
-
 export interface SemanticImportSidecarParadigmSemanticsSummary {
   readonly total: number;
   readonly ids: readonly string[];
@@ -230,14 +229,12 @@ export interface SemanticImportSidecarParadigmSemanticsSummary {
   readonly hasLowering: boolean;
   readonly empty: boolean;
 }
-
 export interface SemanticImportDependencySummary {
   readonly total: number; readonly calls: number; readonly uses: number; readonly references: number;
   readonly imports: number; readonly extends: number; readonly implements: number; readonly includes: number; readonly requires: number;
   readonly byPredicate: Readonly<Record<string, number>>; readonly predicates: readonly string[];
   readonly ids: readonly string[]; readonly sourceSymbolIds: readonly string[]; readonly targetSymbolIds: readonly string[];
 }
-
 export interface SemanticImportSidecar {
   readonly kind: 'frontier.lang.semanticImportSidecar';
   readonly version: 1;
@@ -313,8 +310,9 @@ export interface SemanticImportSidecar {
     readonly semanticImpactRecords: number; readonly semanticImpactHighRiskRecords: number; readonly semanticImpactRequiredVerificationSteps: number;
     readonly patchHints: number;
     readonly evidenceWarnings: number;
-    readonly semanticImportExpected: boolean; readonly semanticImportExpectedSatisfied: boolean; readonly semanticImportExpectedMissingReasonCodes: readonly string[];
+    readonly semanticImportExpected: boolean; readonly semanticImportExpectedEmpty: boolean; readonly semanticImportExpectedSatisfied: boolean; readonly semanticImportExpectedMissingReasonCodes: readonly string[];
+    readonly semanticImportRecordClassification: string; readonly semanticImportRecordReasonCode: string; readonly semanticImportRecordAction: string;
     readonly readiness: SemanticMergeReadiness; readonly emptySemanticIndex: boolean;
   };
   readonly metadata?: Record<string, unknown>; }
-export interface SemanticImportSidecarOptions { readonly id?: string; readonly generatedAt?: number; readonly regionPrefix?: string; readonly targetPath?: string; readonly expected?: boolean; readonly semanticImportExpected?: boolean; readonly metadata?: Record<string, unknown>; }
+export interface SemanticImportSidecarOptions { readonly id?: string; readonly generatedAt?: number; readonly regionPrefix?: string; readonly targetPath?: string; readonly expected?: boolean; readonly semanticImportExpected?: boolean; readonly expectedEmpty?: boolean; readonly semanticImportExpectedEmpty?: boolean; readonly metadata?: Record<string, unknown>; }

package/dist/internal/index-impl/bidirectionalTargetRoundtripEvidence.js

@@ -0,0 +1,200 @@
+import { idFragment, uniqueRecordsById, uniqueStrings } from '../../native-import-utils.js';
+import { sourceHash } from './bidirectionalTargetChangeRecordInternals.js';
+
+export function summarizeSourceMapBackprojection(matches) {
+  const links = matches.flatMap((match) => match.sourceMapLinks ?? []);
+  return {
+    sourceMapBackedMatches: matches.filter((match) => (match.sourceMapLinks ?? []).length > 0).length,
+    sourceMapLinks: links.length,
+    sourceMapIds: uniqueStrings(links.map((link) => link.sourceMapId)),
+    sourceMapMappingIds: uniqueStrings(links.map((link) => link.sourceMapMappingId))
+  };
+}
+
+export function createRoundtripEvidence(context) {
+  const sourceMapLinks = uniqueRecordsById(context.sourceAnchorMatches.flatMap((match) => match.sourceMapLinks ?? []));
+  const targetProjectionLinks = uniqueRecordsById((context.targetChangeSet.changedRegions ?? [])
+    .flatMap((region) => array(region.metadata?.changedRegionProjection?.sourceMapLinks)));
+  const sourceAnchors = uniqueRecordsByKey(context.sourceAnchorMatches.flatMap((match) => match.sourceAnchors ?? []));
+  const lineageResolutions = uniqueRecordsById(context.sourceAnchorMatches.flatMap((match) => match.lineageResolutions ?? []));
+  return {
+    schema: 'frontier.lang.bidirectionalTargetChangeRoundtripEvidence.v1',
+    version: 1,
+    id: `roundtrip_evidence_${idFragment(context.id)}`,
+    evidenceId: context.evidenceId,
+    sourcePatchBundleId: context.sourcePatchBundleId,
+    historyRecordId: context.historyRecordId,
+    source: sourceIdentity(context.source),
+    target: targetChangeIdentity(context.targetChangeSet),
+    targetRegions: (context.targetChangeSet.changedRegions ?? []).map(targetRegionIdentity),
+    sourceAnchorMatches: context.sourceAnchorMatches.map(matchIdentity),
+    sourceAnchors,
+    sourceMapEvidence: {
+      ...context.sourceMapBackprojection,
+      sourceMapLinkIds: uniqueStrings(sourceMapLinks.map((link) => link.id)),
+      staleSourceMapLinkIds: uniqueStrings(context.targetPortability.staleSourceMapLinkIds),
+      targetProjectionSourceMapLinks: targetProjectionLinks.length,
+      targetProjectionSourceMapLinkIds: uniqueStrings(targetProjectionLinks.map((link) => link.id)),
+      targetProjectionSourceMapIds: uniqueStrings(targetProjectionLinks.map((link) => link.sourceMapId)),
+      targetProjectionSourceMapMappingIds: uniqueStrings(targetProjectionLinks.map((link) => link.sourceMapMappingId))
+    },
+    lineageEvidence: {
+      lineageResolutionIds: uniqueStrings(lineageResolutions.map((resolution) => resolution.id)),
+      lineageEventIds: uniqueStrings(lineageResolutions.flatMap((resolution) => resolution.traversedEventIds ?? [])),
+      lineageEvidenceIds: uniqueStrings(lineageResolutions.flatMap((resolution) => resolution.evidenceIds ?? [])),
+      lineageProofIds: uniqueStrings(lineageResolutions.flatMap((resolution) => resolution.proofIds ?? [])),
+      lineageReasonCodes: uniqueStrings(lineageResolutions.flatMap((resolution) => resolution.reasonCodes ?? []))
+    },
+    targetPortability: {
+      status: context.targetPortability.status,
+      action: context.targetPortability.action,
+      readiness: context.targetPortability.readiness,
+      reasonCodes: context.targetPortability.reasonCodes,
+      conflictKeys: context.targetPortability.conflictKeys
+    },
+    admission: {
+      status: context.readiness === 'blocked' ? 'blocked' : 'needs-review',
+      readiness: context.readiness,
+      action: context.targetPortability.action,
+      reasonCodes: context.reasons,
+      conflictKeys: uniqueStrings([
+        ...array(context.targetPortability.conflictKeys),
+        ...context.sourceAnchorMatches.flatMap((match) => match.conflictKeys ?? [])
+      ]),
+      evidenceIds: [context.evidenceId],
+      reviewRequired: true,
+      autoMergeClaim: false,
+      semanticEquivalenceClaim: false
+    },
+    reviewRequired: true,
+    autoMergeClaim: false,
+    semanticEquivalenceClaim: false
+  };
+}
+
+export function createSemanticMergeAdmissionEvidence(context) {
+  return {
+    schema: 'frontier.lang.bidirectionalTargetChangeSemanticMergeAdmission.v1',
+    version: 1,
+    id: `semantic_merge_admission_${idFragment(context.id)}_target_change`,
+    evidenceIds: [context.evidenceId],
+    sourcePatchBundleId: context.sourcePatchBundleId,
+    historyRecordId: context.historyRecordId,
+    targetChangeSetId: context.targetChangeSet.id,
+    targetPatchId: context.targetChangeSet.patch?.id,
+    targetMergeCandidateId: context.targetChangeSet.mergeCandidate?.id,
+    readiness: context.readiness,
+    status: context.readiness === 'blocked' ? 'blocked' : 'needs-review',
+    action: context.targetPortability.action,
+    reasonCodes: context.reasons,
+    conflictKeys: context.roundtripEvidence.admission.conflictKeys,
+    sourceAnchorMatchIds: uniqueStrings(context.sourceAnchorMatches.map((match) => match.id)),
+    sourceAnchorKeys: uniqueStrings(context.roundtripEvidence.sourceAnchors.map((anchor) => anchor.key)),
+    targetRegionKeys: uniqueStrings(context.roundtripEvidence.targetRegions.map((region) => region.key)),
+    sourceMapLinkIds: context.roundtripEvidence.sourceMapEvidence.sourceMapLinkIds,
+    sourceMapIds: context.roundtripEvidence.sourceMapEvidence.sourceMapIds,
+    sourceMapMappingIds: context.roundtripEvidence.sourceMapEvidence.sourceMapMappingIds,
+    staleSourceMapLinkIds: context.roundtripEvidence.sourceMapEvidence.staleSourceMapLinkIds,
+    targetProjectionSourceMapLinkIds: context.roundtripEvidence.sourceMapEvidence.targetProjectionSourceMapLinkIds,
+    targetProjectionSourceMapMappingIds: context.roundtripEvidence.sourceMapEvidence.targetProjectionSourceMapMappingIds,
+    lineageResolutionIds: context.roundtripEvidence.lineageEvidence.lineageResolutionIds,
+    reviewRequired: true,
+    autoMergeClaim: false,
+    semanticEquivalenceClaim: false
+  };
+}
+
+function sourceIdentity(source) {
+  return compactRecord({
+    importId: source?.id,
+    language: source?.language,
+    sourcePath: source?.sourcePath,
+    sourceHash: sourceHash(source),
+    nativeSourceId: source?.nativeSource?.id,
+    nativeAstId: source?.nativeAst?.id,
+    semanticIndexId: source?.semanticIndex?.id,
+    universalAstId: source?.universalAst?.id,
+    sourceMapIds: uniqueStrings((source?.sourceMaps ?? []).map((sourceMap) => sourceMap?.id))
+  });
+}
+
+function targetChangeIdentity(targetChangeSet) {
+  return compactRecord({
+    changeSetId: targetChangeSet.id,
+    language: targetChangeSet.language,
+    sourcePath: targetChangeSet.sourcePath,
+    beforeHash: targetChangeSet.beforeHash,
+    afterHash: targetChangeSet.afterHash,
+    beforeImportId: targetChangeSet.before?.id,
+    afterImportId: targetChangeSet.after?.id,
+    beforeNativeSourceId: targetChangeSet.before?.nativeSource?.id,
+    afterNativeSourceId: targetChangeSet.after?.nativeSource?.id,
+    beforeNativeAstId: targetChangeSet.before?.nativeAst?.id,
+    afterNativeAstId: targetChangeSet.after?.nativeAst?.id,
+    beforeSemanticIndexId: targetChangeSet.before?.semanticIndex?.id,
+    afterSemanticIndexId: targetChangeSet.after?.semanticIndex?.id,
+    patchId: targetChangeSet.patch?.id,
+    mergeCandidateId: targetChangeSet.mergeCandidate?.id,
+    sourceMapIds: uniqueStrings((targetChangeSet.sourceMaps ?? []).map((sourceMap) => sourceMap?.id))
+  });
+}
+
+function targetRegionIdentity(region) {
+  const projection = region.metadata?.changedRegionProjection;
+  return compactRecord({
+    id: region.id,
+    key: region.key,
+    conflictKey: region.conflictKey,
+    changeKind: region.changeKind,
+    regionKind: region.regionKind,
+    language: region.language,
+    sourcePath: region.sourcePath,
+    sourceHash: region.sourceHash,
+    symbolId: region.symbolId,
+    symbolName: region.symbolName ?? region.name,
+    sourceSpan: region.sourceSpan,
+    changedRegionProjectionId: projection?.id,
+    beforeIdentity: projection?.before?.identity,
+    afterIdentity: projection?.after?.identity,
+    sourceMapLinkIds: uniqueStrings(array(projection?.sourceMapLinks).map((link) => link.id)),
+    sourceMapIds: uniqueStrings(array(projection?.sourceMapLinks).map((link) => link.sourceMapId)),
+    sourceMapMappingIds: uniqueStrings(array(projection?.sourceMapLinks).map((link) => link.sourceMapMappingId))
+  });
+}
+
+function matchIdentity(match) {
+  return compactRecord({
+    id: match.id,
+    status: match.status,
+    targetRegionKey: match.targetRegion?.key,
+    targetRegionConflictKey: match.targetRegion?.conflictKey,
+    sourceAnchorKeys: uniqueStrings((match.sourceAnchors ?? []).map((anchor) => anchor.key)),
+    sourceMapLinkIds: uniqueStrings((match.sourceMapLinks ?? []).map((link) => link.id)),
+    sourceMapMappingIds: uniqueStrings((match.sourceMapLinks ?? []).map((link) => link.sourceMapMappingId)),
+    lineageResolutionIds: uniqueStrings((match.lineageResolutions ?? []).map((resolution) => resolution.id)),
+    portabilityStatus: match.portability?.status,
+    portabilityAction: match.portability?.action,
+    reasonCodes: match.reasonCodes,
+    conflictKeys: match.conflictKeys
+  });
+}
+
+function uniqueRecordsByKey(records) {
+  const seen = new Set();
+  const result = [];
+  for (const record of records ?? []) {
+    const key = record?.key ?? record?.id;
+    if (!key || seen.has(key)) continue;
+    seen.add(key);
+    result.push(record);
+  }
+  return result;
+}
+
+function array(value) {
+  return value === undefined || value === null ? [] : Array.isArray(value) ? value : [value];
+}
+
+function compactRecord(value) {
+  return Object.fromEntries(Object.entries(value ?? {}).filter(([, entry]) => entry !== undefined && (!Array.isArray(entry) || entry.length > 0)));
+}

package/dist/internal/index-impl/createBidirectionalTargetChangeRecord.js

@@ -9,6 +9,7 @@ import { createSemanticHistoryRecord } from './semanticHistoryRecords.js';
 import { diffNativeSourceImports } from './diffNativeSourceImports.js';
 import { normalizeNativeDiffImport } from './normalizeNativeDiffImport.js';
 import { attachBidirectionalMatchPortability, classifyBidirectionalTargetPortability } from './bidirectionalTargetPortability.js';
+import { createRoundtripEvidence, createSemanticMergeAdmissionEvidence, summarizeSourceMapBackprojection } from './bidirectionalTargetRoundtripEvidence.js';
 import {
   anchorsFromSourceSidecar,
   classifyBidirectionalReadiness,
@@ -85,16 +86,54 @@ export function createBidirectionalTargetChangeRecord(input = {}, options = {})
     ...array(targetPortability.reasonCodes),
     ...sourceAnchorMatches.flatMap((match) => match.reasonCodes)
   ]);
-  const evidence = [createBidirectionalEvidence({
+  const evidenceId = input.evidenceId ?? `evidence_${idFragment(id)}_bidirectional_target_change`;
+  const sourcePatchBundleId = input.sourcePatchBundleId ?? `semantic_patch_bundle_${idFragment(id)}_source_port`;
+  const historyRecordId = input.historyRecordId ?? `semantic_history_${idFragment(id)}_target_change`;
+  const sourceMapBackprojection = summarizeSourceMapBackprojection(sourceAnchorMatches);
+  const roundtripEvidence = createRoundtripEvidence({
     id,
-    input,
+    evidenceId,
+    sourcePatchBundleId,
+    historyRecordId,
+    source,
+    targetChangeSet,
+    sourceAnchorMatches,
+    targetPortability,
+    readiness,
+    reasons,
+    sourceMapBackprojection
+  });
+  const semanticMergeAdmission = createSemanticMergeAdmissionEvidence({
+    id,
+    evidenceId,
+    sourcePatchBundleId,
+    historyRecordId,
+    targetChangeSet,
+    sourceAnchorMatches,
+    targetPortability,
+    readiness,
+    reasons,
+    roundtripEvidence
+  });
+  const bidirectionalEvidence = createBidirectionalEvidence({
+    id,
+    input: { ...input, evidenceId },
     source,
     targetChangeSet,
     sourceAnchorMatches,
     targetPortability,
     readiness,
     reasons
-  })];
+  });
+  const evidence = [{
+    ...bidirectionalEvidence,
+    metadata: {
+      ...bidirectionalEvidence.metadata,
+      roundtripEvidenceId: roundtripEvidence.id,
+      roundtripEvidence,
+      semanticMergeAdmission
+    }
+  }];
   const sourceChangedRegions = sourceAnchorMatches.flatMap((match) => sourceRegionsForMatch(match, readiness));
   const sourcePatchBundle = createSemanticPatchBundleRecord({
     id: `${id}_source_port_projection`,
@@ -112,22 +151,30 @@ export function createBidirectionalTargetChangeRecord(input = {}, options = {})
       targetPatchId: targetChangeSet.patch?.id,
       targetMergeCandidateId: targetChangeSet.mergeCandidate?.id,
       targetPortability,
-      sourceMapBackprojection: summarizeSourceMapBackprojection(sourceAnchorMatches)
+      sourceMapBackprojection,
+      roundtripEvidenceId: roundtripEvidence.id,
+      semanticMergeAdmission
     }
   }, {
-    id: input.sourcePatchBundleId ?? `semantic_patch_bundle_${idFragment(id)}_source_port`,
+    id: sourcePatchBundleId,
     patchId: targetChangeSet.patch?.id,
     mergeCandidateId: targetChangeSet.mergeCandidate?.id,
     admission: { status: readiness === 'blocked' ? 'blocked' : 'needs-review', readiness },
     metadata: {
       source: 'createBidirectionalTargetChangeRecord',
+      targetChangeSetId: targetChangeSet.id,
+      targetPatchId: targetChangeSet.patch?.id,
+      targetMergeCandidateId: targetChangeSet.mergeCandidate?.id,
       targetPortability,
+      sourceMapBackprojection,
+      roundtripEvidenceId: roundtripEvidence.id,
+      semanticMergeAdmission,
       autoMergeClaim: false,
       semanticEquivalenceClaim: false
     }
   });
   const historyRecord = createSemanticHistoryRecord({
-    id: input.historyRecordId ?? `semantic_history_${idFragment(id)}_target_change`,
+    id: historyRecordId,
     importResult: source,
     language: source?.language,
     sourcePath: source?.sourcePath,
@@ -155,7 +202,9 @@ export function createBidirectionalTargetChangeRecord(input = {}, options = {})
       sourcePatchBundleId: sourcePatchBundle.id,
       targetChangeSetId: targetChangeSet.id,
       targetPortability,
-      sourceMapBackprojection: summarizeSourceMapBackprojection(sourceAnchorMatches),
+      sourceMapBackprojection,
+      roundtripEvidenceId: roundtripEvidence.id,
+      semanticMergeAdmission,
       autoMergeClaim: false,
       semanticEquivalenceClaim: false
     }
@@ -172,6 +221,7 @@ export function createBidirectionalTargetChangeRecord(input = {}, options = {})
     targetChangeSet,
     sourceAnchorMatches,
     targetPortability,
+    roundtripEvidence,
     sourcePatchBundle,
     historyRecord,
     evidence,
@@ -185,6 +235,9 @@ export function createBidirectionalTargetChangeRecord(input = {}, options = {})
       deletedSourceAnchors: sourceAnchorMatches.filter((match) => match.status === 'deleted').length,
       sourceChangedRegions: sourceChangedRegions.length,
       sourceMapBackedMatches: sourceAnchorMatches.filter((match) => match.sourceMapLinks.length > 0).length,
+      sourceMapLinks: sourceMapBackprojection.sourceMapLinks,
+      sourceMapMappingIds: sourceMapBackprojection.sourceMapMappingIds.length,
+      lineageResolutions: roundtripEvidence.lineageEvidence.lineageResolutionIds.length,
       targetPortabilityStatus: targetPortability.status,
       portableTargetRegions: targetPortability.status === 'portable' ? targetPortability.targetChangedRegions : 0,
       staleTargetRegions: targetPortability.status === 'stale' ? targetPortability.targetChangedRegions : 0,
@@ -195,21 +248,13 @@ export function createBidirectionalTargetChangeRecord(input = {}, options = {})
       semanticEquivalenceClaim: false,
       reviewRequired: true,
       targetPortability,
+      roundtripEvidenceId: roundtripEvidence.id,
+      semanticMergeAdmission,
       ...input.metadata
     }
   };
 }
 
-function summarizeSourceMapBackprojection(matches) {
-  const links = matches.flatMap((match) => match.sourceMapLinks ?? []);
-  return {
-    sourceMapBackedMatches: matches.filter((match) => (match.sourceMapLinks ?? []).length > 0).length,
-    sourceMapLinks: links.length,
-    sourceMapIds: uniqueStrings(links.map((link) => link.sourceMapId)),
-    sourceMapMappingIds: uniqueStrings(links.map((link) => link.sourceMapMappingId))
-  };
-}
-
 function array(value) {
   return value === undefined || value === null ? [] : Array.isArray(value) ? value : [value];
 }

package/dist/internal/index-impl/createLightweightNativeImport.js

@@ -1,4 +1,4 @@
-import{idFragment}from'../../native-import-utils.js';import{lightweightDependencyRelations}from'../../lightweight-dependency-relations.js';import{lightweightCoverageLosses,scanNativeDeclarations}from'../../native-region-scanner.js';import{semanticOwnershipRegionForDeclaration}from'../../semantic-import-regions.js';import{createSemanticIndexRecord,hashSemanticValue}from'@shapeshift-labs/frontier-lang-kernel';
+import{idFragment,uniqueRecordsById}from'../../native-import-utils.js';import{lightweightDependencyRelations}from'../../lightweight-dependency-relations.js';import{lightweightCoverageLosses,scanNativeDeclarations}from'../../native-region-scanner.js';import{semanticOwnershipRegionForDeclaration,semanticPatchHintForRegion}from'../../semantic-import-regions.js';import{createSemanticIndexRecord,hashSemanticValue}from'@shapeshift-labs/frontier-lang-kernel';
 export function createLightweightNativeImport(input) {
   const parser = input.parser ?? `${input.language}.lightweight-declaration-scan`;
   const rootId = 'native_root';
@@ -19,11 +19,13 @@ export function createLightweightNativeImport(input) {
   const relations = [];
   const facts = [];
   const mappings = [];
+  const ownershipRegions = [];
   const evidenceId = `evidence_${idFragment(input.sourcePath ?? input.language)}_lightweight_scan`;
   const dependencies = lightweightDependencyRelations(input, declarations, documentId);
 
   for (const declaration of declarations) {
     const ownershipRegion = semanticOwnershipRegionForDeclaration(input, declaration, documentId);
+    ownershipRegions.push(ownershipRegion);
     nodes[rootId].children.push(declaration.nodeId);
     nodes[declaration.nodeId] = {
       id: declaration.nodeId,
@@ -122,6 +124,8 @@ export function createLightweightNativeImport(input) {
     });
   }
   losses.push(...lightweightCoverageLosses(input, declarations, input.sourcePreservation));
+  const semanticOwnershipRegions = uniqueRecordsById(ownershipRegions);
+  const semanticPatchHints = semanticOwnershipRegions.map((region) => semanticPatchHintForRegion(region, 'needs-review'));
 
   const semanticIndex = createSemanticIndexRecord({
     id: `index_${idFragment(input.sourcePath ?? input.language)}`,
@@ -135,6 +139,8 @@ export function createLightweightNativeImport(input) {
     occurrences,
     relations,
     facts,
+    ownershipRegions: semanticOwnershipRegions,
+    patchHints: semanticPatchHints,
     evidence: [{
       id: evidenceId,
       kind: 'import',
@@ -162,6 +168,8 @@ export function createLightweightNativeImport(input) {
     losses,
     semanticIndex,
     mappings,
+    ownershipRegions: semanticOwnershipRegions,
+    patchHints: semanticPatchHints,
     metadata: {
       parser,
       scanKind: 'lightweight-declaration-scan',

package/dist/internal/index-impl/createNativeSourcePreservation.js

@@ -1,4 +1,4 @@
-import{idFragment}from'../../native-import-utils.js';import{detectNewlineStyle,scanPreservedSourceDirectives,scanPreservedSourceTokens}from'../../native-region-scanner.js';import{hashSemanticValue}from'@shapeshift-labs/frontier-lang-kernel';
+import{countBy,idFragment,uniqueStrings}from'../../native-import-utils.js';import{detectNewlineStyle,scanPreservedSourceDirectives,scanPreservedSourceTokens}from'../../native-region-scanner.js';import{hashSemanticValue}from'@shapeshift-labs/frontier-lang-kernel';
 export function createNativeSourcePreservation(options) {
   if (!options || typeof options.sourceText !== 'string') {
     throw new Error('createNativeSourcePreservation requires sourceText');
@@ -26,6 +26,16 @@ export function createNativeSourcePreservation(options) {
       maxDirectives: options.maxDirectives
     });
   const directives = directiveScan.directives;
+  const triviaByKind = countBy(tokensAndTrivia.trivia.map((entry) => entry.kind ?? 'unknown'));
+  const directivesByKind = countBy(directives.map((entry) => entry.kind ?? 'directive'));
+  const directiveKinds = uniqueStrings(directives.map((entry) => entry.kind ?? 'directive'));
+  const commentSpanIds = tokensAndTrivia.trivia
+    .filter((entry) => entry.kind === 'comment')
+    .map((entry) => entry.id)
+    .filter(Boolean);
+  const directiveSpanIds = directives
+    .map((entry) => entry.id)
+    .filter(Boolean);
   const newline = detectNewlineStyle(sourceText);
   return {
     kind: 'frontier.lang.nativeSourcePreservation',
@@ -48,6 +58,11 @@ export function createNativeSourcePreservation(options) {
       directives: directives.length,
       comments: tokensAndTrivia.trivia.filter((entry) => entry.kind === 'comment').length,
       whitespace: tokensAndTrivia.trivia.filter((entry) => entry.kind === 'whitespace' || entry.kind === 'newline').length,
+      triviaByKind,
+      directivesByKind,
+      directiveKinds,
+      commentSpanIds,
+      directiveSpanIds,
       exactSourceAvailable: options.includeSourceText !== false,
       truncated: tokensAndTrivia.truncated || directiveScan.truncated
     },