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

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/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
     },

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

@@ -22,7 +22,8 @@ export function createProjectImportAdmissionRecord(projectResult,options={}){
   const importSummaries=projectAdmissionImports(imports,contract?.sources??[],mergeCandidates);
   const languages=admissionLanguages(importSummaries);
   const semanticEvidence=admissionSemanticEvidence(projectResult,imports,importSummaries);
-  const sourcePreservation=admissionSourcePreservation(importSummaries,contract);
+  const sourceStaleness=admissionSourceStaleness(imports,importSummaries,contract);
+  const sourcePreservation=admissionSourcePreservationWithStaleness(admissionSourcePreservation(importSummaries,contract),sourceStaleness);
   const ownership=admissionOwnership(contract,mergeCandidates);
   const mergeCandidateRisk=admissionMergeCandidates(projectResult,imports,mergeCandidates,lossSummary);
   const readiness=maxSemanticMergeReadiness(
@@ -54,6 +55,7 @@ export function createProjectImportAdmissionRecord(projectResult,options={}){
     readiness,
     sourceCount:imports.length,
     semanticEvidence,
+    sourceStaleness,
     sourcePreservation,
     ownership,
     mergeCandidateRisk,
@@ -71,6 +73,7 @@ export function createProjectImportAdmissionRecord(projectResult,options={}){
     sourceCount:imports.length,
     languages,
     semanticEvidence,
+    sourceStaleness,
     sourcePreservation,
     ownership,
     mergeCandidates:mergeCandidateRisk,
@@ -89,3 +92,150 @@ export function createProjectImportAdmissionRecord(projectResult,options={}){
     }
   };
 }
+
+function admissionSourceStaleness(imports,importSummaries,contract){
+  const total=Math.max(imports.length,importSummaries.length,contract?.sources?.length??0);
+  const records=[];
+  for(let index=0;index<total;index+=1){
+    const record=sourceStalenessRecord(imports[index],importSummaries[index],contract?.sources?.[index]);
+    if(record.reasonCodes.length) records.push(record);
+  }
+  const staleRecords=records.filter((record)=>record.staleByContentHash||record.staleByBaseHash);
+  const contentHashRecords=records.filter((record)=>record.staleByContentHash);
+  const baseHashRecords=records.filter((record)=>record.staleByBaseHash);
+  const dirtyWorkspaceRecords=records.filter((record)=>record.dirtyWorkspace);
+  const unverifiedRecords=records.filter((record)=>record.unverifiedSourceHash);
+  return {
+    total,
+    stale:staleRecords.length,
+    contentHashStale:contentHashRecords.length,
+    baseHashStale:baseHashRecords.length,
+    dirtyWorkspace:dirtyWorkspaceRecords.length,
+    unverified:unverifiedRecords.length,
+    staleSourcePaths:sourcePaths(staleRecords),
+    contentHashStaleSourcePaths:sourcePaths(contentHashRecords),
+    baseHashStaleSourcePaths:sourcePaths(baseHashRecords),
+    dirtyWorkspaceSourcePaths:sourcePaths(dirtyWorkspaceRecords),
+    unverifiedSourcePaths:sourcePaths(unverifiedRecords),
+    records
+  };
+}
+
+function sourceStalenessRecord(imported,summary,source){
+  const nativeSource=imported?.nativeSource;
+  const nativeAst=imported?.nativeAst??nativeSource?.ast;
+  const preservation=imported?.metadata?.sourcePreservation
+    ??nativeSource?.metadata?.sourcePreservation
+    ??nativeAst?.metadata?.sourcePreservation
+    ??imported?.universalAst?.metadata?.sourcePreservation;
+  const metadata=[
+    imported?.metadata,
+    nativeSource?.metadata,
+    nativeAst?.metadata,
+    preservation?.metadata,
+    imported?.universalAst?.metadata,
+    imported?.patch?.metadata
+  ].filter((entry)=>entry&&typeof entry==='object');
+  const lossReasons=(imported?.losses??nativeAst?.losses??[]).flatMap((loss)=>[
+    loss?.reason,
+    loss?.metadata?.reason,
+    ...(Array.isArray(loss?.reasonCodes)?loss.reasonCodes:[]),
+    ...(Array.isArray(loss?.metadata?.reasonCodes)?loss.metadata.reasonCodes:[])
+  ]);
+  const observedReasonCodes=uniqueStrings([
+    ...metadata.flatMap((entry)=>[
+      entry.reason,
+      ...(Array.isArray(entry.reasonCodes)?entry.reasonCodes:[]),
+      ...(Array.isArray(entry.reasons)?entry.reasons:[])
+    ]),
+    ...lossReasons
+  ]);
+  const sourcePath=firstString(summary?.sourcePath,source?.sourcePath,imported?.sourcePath,nativeSource?.sourcePath,nativeAst?.sourcePath,preservation?.sourcePath);
+  const sourceHash=firstString(summary?.sourceHash,source?.sourceHash,imported?.sourceHash,nativeSource?.sourceHash,nativeAst?.sourceHash,preservation?.sourceHash);
+  const declaredSourceHash=firstMetadataString(metadata,'declaredSourceHash');
+  const contentHash=firstMetadataString(metadata,'currentContentHash','actualContentHash','contentHash')??sourceHash;
+  const declaredContentHash=firstMetadataString(metadata,'declaredContentHash','expectedContentHash','expectedSourceHash')??declaredSourceHash;
+  const sourceHashMismatch=Boolean(declaredSourceHash&&sourceHash&&declaredSourceHash!==sourceHash);
+  const contentHashMismatch=Boolean(declaredContentHash&&contentHash&&declaredContentHash!==contentHash);
+  const preservationHashMismatch=Boolean(preservation?.sourceHash&&sourceHash&&preservation.sourceHash!==sourceHash);
+  const sourceHashVerifiedFalse=metadata.some((entry)=>entry.sourceHashVerified===false);
+  const staleByContentHash=sourceHashMismatch
+    ||contentHashMismatch
+    ||preservationHashMismatch
+    ||(sourceHashVerifiedFalse&&Boolean(declaredSourceHash||declaredContentHash));
+  const baseHash=firstString(imported?.baseHash,imported?.patch?.baseHash,firstMetadataString(metadata,'baseHash'));
+  const expectedBaseHash=firstMetadataString(metadata,'expectedBaseHash','declaredBaseHash','sourceBaseHash');
+  const currentBaseHash=firstMetadataString(metadata,'currentBaseHash','actualBaseHash','headBaseHash','workspaceBaseHash');
+  const staleByBaseHash=Boolean(
+    expectedBaseHash&&currentBaseHash&&expectedBaseHash!==currentBaseHash
+  )||metadata.some((entry)=>entry.baseHashVerified===false)||observedReasonCodes.includes('base-hash-mismatch');
+  const dirtyWorkspace=metadata.some((entry)=>
+    entry.dirtyWorkspace===true
+    ||entry.workspaceDirty===true
+    ||entry.worktreeDirty===true
+    ||entry.dirtyWorktree===true
+  )||observedReasonCodes.some((reason)=>reason==='dirty-workspace'||reason==='workspace-dirty'||reason==='dirty-worktree');
+  const unverifiedSourceHash=sourceHashVerifiedFalse&&!staleByContentHash;
+  const reasonCodes=uniqueStrings([
+    ...(sourceHashMismatch?['source-hash-mismatch']:[]),
+    ...(contentHashMismatch?['content-hash-mismatch']:[]),
+    ...(preservationHashMismatch?['source-preservation-hash-mismatch']:[]),
+    ...(staleByContentHash&&sourceHashVerifiedFalse?['source-hash-unverified']:[]),
+    ...(staleByBaseHash?['base-hash-mismatch']:[]),
+    ...(dirtyWorkspace?['dirty-workspace']:[]),
+    ...(unverifiedSourceHash?['source-hash-unverified']:[])
+  ]);
+  return {
+    ...(sourcePath?{sourcePath}:{}),
+    ...(sourceHash?{sourceHash}:{}),
+    ...(declaredSourceHash?{declaredSourceHash}:{}),
+    ...(contentHash?{contentHash}:{}),
+    ...(declaredContentHash?{declaredContentHash}:{}),
+    ...(baseHash?{baseHash}:{}),
+    ...(expectedBaseHash?{expectedBaseHash}:{}),
+    ...(currentBaseHash?{currentBaseHash}:{}),
+    staleByContentHash,
+    staleByBaseHash,
+    dirtyWorkspace,
+    unverifiedSourceHash,
+    reasonCodes
+  };
+}
+
+function admissionSourcePreservationWithStaleness(sourcePreservation,sourceStaleness){
+  const stale=sourceStaleness.stale;
+  const quality=stale>0?'stale':sourcePreservation.quality==='stale'
+    ? sourcePreservation.missing>0?'missing':sourcePreservation.lossy>0||sourcePreservation.truncated?'lossy':sourcePreservation.total===0?'empty':'exact'
+    : sourcePreservation.quality;
+  return {
+    ...sourcePreservation,
+    quality,
+    stale,
+    staleSourcePaths:sourceStaleness.staleSourcePaths,
+    contentHashStale:sourceStaleness.contentHashStale,
+    baseHashStale:sourceStaleness.baseHashStale,
+    dirtyWorkspace:sourceStaleness.dirtyWorkspace,
+    contentHashStaleSourcePaths:sourceStaleness.contentHashStaleSourcePaths,
+    baseHashStaleSourcePaths:sourceStaleness.baseHashStaleSourcePaths,
+    dirtyWorkspaceSourcePaths:sourceStaleness.dirtyWorkspaceSourcePaths
+  };
+}
+
+function sourcePaths(records){
+  return uniqueStrings(records.map((record)=>record.sourcePath).filter(Boolean));
+}
+
+function firstMetadataString(metadata,...keys){
+  for(const key of keys){
+    const value=firstString(...metadata.map((entry)=>entry?.[key]));
+    if(value) return value;
+  }
+  return undefined;
+}
+
+function firstString(...values){
+  for(const value of values){
+    if(value!==undefined&&value!==null&&String(value)) return String(value);
+  }
+  return undefined;
+}

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

@@ -29,6 +29,7 @@ export function createSemanticImportSidecar(importResult, options = {}) {
   const patchHints = ownershipRegions.map((region) => semanticPatchHintForRegion(region, readiness, options));
   const quality = createSemanticImportSidecarQuality({
     expected: options.expected === true || options.semanticImportExpected === true,
+    expectedEmpty: options.expectedEmpty === true || options.semanticImportExpectedEmpty === true,
     importEntries,
     symbols,
     ownershipRegions,
@@ -130,8 +131,12 @@ export function createSemanticImportSidecar(importResult, options = {}) {
       patchHints: patchHints.length,
       evidenceWarnings: quality.emptyEvidenceWarnings.length,
       semanticImportExpected: quality.expected,
+      semanticImportExpectedEmpty: quality.expectedEmpty,
       semanticImportExpectedSatisfied: quality.expectedSatisfied,
       semanticImportExpectedMissingReasonCodes: quality.expectedMissingReasonCodes,
+      semanticImportRecordClassification: quality.record.classification,
+      semanticImportRecordReasonCode: quality.record.reasonCode,
+      semanticImportRecordAction: quality.record.action,
       readiness,
       emptySemanticIndex: symbols.length === 0
     },