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

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

@@ -10,6 +10,8 @@ import { diffNativeSourceImports } from './diffNativeSourceImports.js';
 import { normalizeNativeDiffImport } from './normalizeNativeDiffImport.js';
 import { attachBidirectionalMatchPortability, classifyBidirectionalTargetPortability } from './bidirectionalTargetPortability.js';
 import { createRoundtripEvidence, createSemanticMergeAdmissionEvidence, summarizeSourceMapBackprojection } from './bidirectionalTargetRoundtripEvidence.js';
+import { createBidirectionalSourceEditProjection } from './bidirectionalSourceEditProjection.js';
+import { createSameLanguageTargetSourceProjection } from './bidirectionalSameLanguageSourceProjection.js';
 import {
   anchorsFromSourceSidecar,
   classifyBidirectionalReadiness,
@@ -86,6 +88,20 @@ export function createBidirectionalTargetChangeRecord(input = {}, options = {})
     ...array(targetPortability.reasonCodes),
     ...sourceAnchorMatches.flatMap((match) => match.reasonCodes)
   ]);
+  const sourceMapEditProjection = createBidirectionalSourceEditProjection({
+    id,
+    source,
+    targetChangeSet,
+    sourceAnchorMatches,
+    targetPortability,
+    reasons
+  });
+  const sourceEditProjection = sourceMapEditProjection.sourceEditScript ? sourceMapEditProjection : createSameLanguageTargetSourceProjection({
+    id,
+    source,
+    targetChangeSet,
+    generatedAt: input.generatedAt
+  });
   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`;
@@ -101,7 +117,8 @@ export function createBidirectionalTargetChangeRecord(input = {}, options = {})
     targetPortability,
     readiness,
     reasons,
-    sourceMapBackprojection
+    sourceMapBackprojection,
+    sourceEditProjection
   });
   const semanticMergeAdmission = createSemanticMergeAdmissionEvidence({
     id,
@@ -113,7 +130,8 @@ export function createBidirectionalTargetChangeRecord(input = {}, options = {})
     targetPortability,
     readiness,
     reasons,
-    roundtripEvidence
+    roundtripEvidence,
+    sourceEditProjection
   });
   const bidirectionalEvidence = createBidirectionalEvidence({
     id,
@@ -131,9 +149,20 @@ export function createBidirectionalTargetChangeRecord(input = {}, options = {})
       ...bidirectionalEvidence.metadata,
       roundtripEvidenceId: roundtripEvidence.id,
       roundtripEvidence,
-      semanticMergeAdmission
+      semanticMergeAdmission,
+      sourceEditProjectionId: sourceEditProjection.sourceEditProjection?.id,
+      sourceEditReplayId: sourceEditProjection.sourceEditReplay?.id,
+      sourceEditScriptId: sourceEditProjection.sourceEditScript?.id,
+      sourceProjectionHintId: sourceEditProjection.sourceProjectionHint?.id,
+      sourceProjectionHint: sourceEditProjection.sourceProjectionHint
     }
-  }];
+  }, ...(sourceEditProjection.evidence ?? [])];
+  const sourceReplayStatus = sourceEditProjection.sourceEditReplay?.status;
+  const sourcePatchAdmission = sourceReplayStatus === 'accepted-clean'
+    ? { readiness: 'ready', reasonCodes: ['bidirectional-source-edit-replay-accepted-clean'] }
+    : sourceReplayStatus === 'already-applied'
+      ? { status: 'admitted', readiness: 'ready', reasonCodes: ['bidirectional-source-edit-replay-already-applied'] }
+      : { status: readiness === 'blocked' ? 'blocked' : 'needs-review', readiness };
   const sourceChangedRegions = sourceAnchorMatches.flatMap((match) => sourceRegionsForMatch(match, readiness));
   const sourcePatchBundle = createSemanticPatchBundleRecord({
     id: `${id}_source_port_projection`,
@@ -159,7 +188,10 @@ export function createBidirectionalTargetChangeRecord(input = {}, options = {})
     id: sourcePatchBundleId,
     patchId: targetChangeSet.patch?.id,
     mergeCandidateId: targetChangeSet.mergeCandidate?.id,
-    admission: { status: readiness === 'blocked' ? 'blocked' : 'needs-review', readiness },
+    semanticEditScripts: [sourceEditProjection.sourceEditScript].filter(Boolean),
+    semanticEditProjections: [sourceEditProjection.sourceEditProjection].filter(Boolean),
+    semanticEditReplays: [sourceEditProjection.sourceEditReplay].filter(Boolean),
+    admission: sourcePatchAdmission,
     metadata: {
       source: 'createBidirectionalTargetChangeRecord',
       targetChangeSetId: targetChangeSet.id,
@@ -169,6 +201,11 @@ export function createBidirectionalTargetChangeRecord(input = {}, options = {})
       sourceMapBackprojection,
       roundtripEvidenceId: roundtripEvidence.id,
       semanticMergeAdmission,
+      sourceEditScriptId: sourceEditProjection.sourceEditScript?.id,
+      sourceEditProjectionId: sourceEditProjection.sourceEditProjection?.id,
+      sourceEditReplayId: sourceEditProjection.sourceEditReplay?.id,
+      sourceProjectionHintId: sourceEditProjection.sourceProjectionHint?.id,
+      sourceProjectionHint: sourceEditProjection.sourceProjectionHint,
       autoMergeClaim: false,
       semanticEquivalenceClaim: false
     }
@@ -191,7 +228,7 @@ export function createBidirectionalTargetChangeRecord(input = {}, options = {})
       conflictKeys: targetChangeSet.mergeCandidate?.conflictKeys,
       metadata: { direction: 'target-to-source' }
     }] : [],
-    admission: { status: readiness === 'blocked' ? 'blocked' : 'needs-review', readiness, reasonCodes: reasons },
+    admission: { status: semanticMergeAdmission.status, readiness: semanticMergeAdmission.readiness, reasonCodes: semanticMergeAdmission.reasonCodes },
     replayLinks: targetChangeSet.patch ? [{
       id: `replay_${idFragment(targetChangeSet.patch.id)}`,
       kind: 'patch',
@@ -205,6 +242,11 @@ export function createBidirectionalTargetChangeRecord(input = {}, options = {})
       sourceMapBackprojection,
       roundtripEvidenceId: roundtripEvidence.id,
       semanticMergeAdmission,
+      sourceEditProjectionId: sourceEditProjection.sourceEditProjection?.id,
+      sourceEditReplayId: sourceEditProjection.sourceEditReplay?.id,
+      sourceEditScriptId: sourceEditProjection.sourceEditScript?.id,
+      sourceProjectionHintId: sourceEditProjection.sourceProjectionHint?.id,
+      sourceProjectionHint: sourceEditProjection.sourceProjectionHint,
       autoMergeClaim: false,
       semanticEquivalenceClaim: false
     }
@@ -222,6 +264,10 @@ export function createBidirectionalTargetChangeRecord(input = {}, options = {})
     sourceAnchorMatches,
     targetPortability,
     roundtripEvidence,
+    sourceEditScript: sourceEditProjection.sourceEditScript,
+    sourceEditProjection: sourceEditProjection.sourceEditProjection,
+    sourceEditReplay: sourceEditProjection.sourceEditReplay,
+    sourceProjectionHint: sourceEditProjection.sourceProjectionHint,
     sourcePatchBundle,
     historyRecord,
     evidence,
@@ -237,6 +283,8 @@ export function createBidirectionalTargetChangeRecord(input = {}, options = {})
       sourceMapBackedMatches: sourceAnchorMatches.filter((match) => match.sourceMapLinks.length > 0).length,
       sourceMapLinks: sourceMapBackprojection.sourceMapLinks,
       sourceMapMappingIds: sourceMapBackprojection.sourceMapMappingIds.length,
+      sourceEditScripts: sourceEditProjection.sourceEditScript ? 1 : 0,
+      sourceProjectionHints: sourceEditProjection.sourceProjectionHint ? 1 : 0,
       lineageResolutions: roundtripEvidence.lineageEvidence.lineageResolutionIds.length,
       targetPortabilityStatus: targetPortability.status,
       portableTargetRegions: targetPortability.status === 'portable' ? targetPortability.targetChangedRegions : 0,
@@ -246,10 +294,15 @@ export function createBidirectionalTargetChangeRecord(input = {}, options = {})
     metadata: {
       autoMergeClaim: false,
       semanticEquivalenceClaim: false,
-      reviewRequired: true,
+      reviewRequired: sourcePatchBundle.admission.reviewRequired,
       targetPortability,
       roundtripEvidenceId: roundtripEvidence.id,
       semanticMergeAdmission,
+      sourceEditScriptId: sourceEditProjection.sourceEditScript?.id,
+      sourceEditProjectionId: sourceEditProjection.sourceEditProjection?.id,
+      sourceEditReplayId: sourceEditProjection.sourceEditReplay?.id,
+      sourceProjectionHintId: sourceEditProjection.sourceProjectionHint?.id,
+      sourceProjectionHint: sourceEditProjection.sourceProjectionHint,
       ...input.metadata
     }
   };

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

@@ -53,6 +53,7 @@ export function createLightweightNativeImport(input) {
         signatureHash: hashSemanticValue([input.language, declaration.kind, declaration.name, declaration.fields ?? {}]),
         definitionSpan: declaration.span,
         metadata: {
+          ...declaration.metadata,
           ownershipRegionId: ownershipRegion.id,
           ownershipRegionKey: ownershipRegion.key,
           ownershipRegionKind: ownershipRegion.regionKind

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

@@ -1,4 +1,13 @@
-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';
+import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
+import { countBy, idFragment, uniqueStrings } from '../../native-import-utils.js';
+import {
+  detectNewlineStyle,
+  isJavaScriptTypeScriptSource,
+  scanJavaScriptTypeScriptSourceLedger,
+  scanPreservedSourceDirectives,
+  scanPreservedSourceTokens
+} from '../../native-region-scanner.js';
+
 export function createNativeSourcePreservation(options) {
   if (!options || typeof options.sourceText !== 'string') {
     throw new Error('createNativeSourcePreservation requires sourceText');
@@ -26,6 +35,14 @@ export function createNativeSourcePreservation(options) {
       maxDirectives: options.maxDirectives
     });
   const directives = directiveScan.directives;
+  const ledger = options.includeSourceLedger === false || !isJavaScriptTypeScriptSource(language, options.sourcePath)
+    ? undefined
+    : scanJavaScriptTypeScriptSourceLedger(sourceText, {
+      language,
+      sourcePath: options.sourcePath,
+      sourceHash,
+      maxLedgerSpans: options.maxLedgerSpans
+    });
   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'));
@@ -52,23 +69,32 @@ export function createNativeSourcePreservation(options) {
     tokens: tokensAndTrivia.tokens,
     trivia: tokensAndTrivia.trivia,
     directives,
+    ...(ledger ? { ledger } : {}),
     summary: {
       tokens: tokensAndTrivia.tokens.length,
       trivia: tokensAndTrivia.trivia.length,
       directives: directives.length,
       comments: tokensAndTrivia.trivia.filter((entry) => entry.kind === 'comment').length,
       whitespace: tokensAndTrivia.trivia.filter((entry) => entry.kind === 'whitespace' || entry.kind === 'newline').length,
+      ...(ledger ? {
+        ledger: ledger.summary,
+        sourceMapComments: ledger.summary.sourceMapComments,
+        protectedRegions: ledger.summary.protectedRegions,
+        importExportSpans: ledger.summary.importExportSpans,
+        braces: ledger.summary.braces
+      } : {}),
       triviaByKind,
       directivesByKind,
       directiveKinds,
       commentSpanIds,
       directiveSpanIds,
       exactSourceAvailable: options.includeSourceText !== false,
-      truncated: tokensAndTrivia.truncated || directiveScan.truncated
+      truncated: tokensAndTrivia.truncated || directiveScan.truncated || Boolean(ledger?.summary?.truncated)
     },
     metadata: {
       preservation: 'source-text-token-trivia-directive-evidence',
       tokenization: 'frontier-lightweight-lexical-scan',
+      ...(ledger ? { sourceLedger: 'frontier-lightweight-js-ts-source-ledger' } : {}),
       ...(declaredSourceHash ? {
         declaredSourceHash,
         sourceHashVerified: declaredSourceHash === computedSourceHash

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

@@ -19,7 +19,7 @@ export function createProjectImportAdmissionRecord(projectResult,options={}){
     ...(projectResult?.mergeCandidates??[]),
     ...imports.flatMap((imported)=>imported?.mergeCandidates??[])
   ]);
-  const importSummaries=projectAdmissionImports(imports,contract?.sources??[],mergeCandidates);
+  const importSummaries=projectAdmissionImports(imports,contract?.sources??[],mergeCandidates,projectResult);
   const languages=admissionLanguages(importSummaries);
   const semanticEvidence=admissionSemanticEvidence(projectResult,imports,importSummaries);
   const sourceStaleness=admissionSourceStaleness(imports,importSummaries,contract);
@@ -42,7 +42,10 @@ export function createProjectImportAdmissionRecord(projectResult,options={}){
     failedEvidenceIds,
     blockingLossIds:contract?.readiness?.blockingLossIds??lossSummary?.blockingLossIds??[]
   });
-  const priorityReasons=admissionPriorityReasons({readiness,semanticEvidence,sourcePreservation,ownership,mergeCandidateRisk});
+  const priorityReasons=uniqueStrings([
+    ...admissionPriorityReasons({readiness,semanticEvidence,sourcePreservation,ownership,mergeCandidateRisk}),
+    ...semanticAdmissionWarningReasons(semanticEvidence)
+  ]);
   const action=rejectionReasons.length?'reject':priorityReasons.length?'prioritize':'admit';
   const priority=admissionPriority(action,readiness,sourcePreservation,mergeCandidateRisk);
   const mergeScore=admissionMergeScore({
@@ -221,6 +224,15 @@ function admissionSourcePreservationWithStaleness(sourcePreservation,sourceStale
   };
 }
 
+function semanticAdmissionWarningReasons(semanticEvidence){
+  return (semanticEvidence?.warnings??[]).map((warning)=>{
+    const reasonCode=warning.reasonCode??warning.code;
+    const sourcePaths=warning.sourcePaths?.length?warning.sourcePaths:warning.sourcePath?[warning.sourcePath]:[];
+    const sourceText=sourcePaths.length?` for ${sourcePaths.join(', ')}`:'';
+    return `Project import semantic admission warning ${reasonCode}${sourceText}.`;
+  });
+}
+
 function sourcePaths(records){
   return uniqueStrings(records.map((record)=>record.sourcePath).filter(Boolean));
 }

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

@@ -37,5 +37,86 @@ export function diffNativeSymbols(beforeSymbols, afterSymbols) {
       readiness: maxSemanticMergeReadiness(before?.readiness ?? 'ready', after?.readiness ?? 'ready')
     });
   }
-  return changed;
+  return downgradeCoveredContainerSymbols(changed);
 }
+
+function downgradeCoveredContainerSymbols(symbols) {
+  return symbols.filter((symbol) => !nativeDiffContainerCoveredByMorePreciseChange(symbol, symbols));
+}
+
+function nativeDiffContainerCoveredByMorePreciseChange(symbol, symbols) {
+  if (symbol.changeKind !== 'modified') return false;
+  if (!nativeDiffSymbolIsContainer(symbol)) return false;
+  if (nativeDiffSymbolHasOwnChange(symbol)) return false;
+  return symbols.some((candidate) => candidate !== symbol && nativeDiffSymbolIsMorePreciseNestedChange(candidate, symbol));
+}
+
+function nativeDiffSymbolHasOwnChange(symbol) {
+  return ((symbol.beforeSignatureHash ?? '') !== (symbol.afterSignatureHash ?? ''))
+    || ((symbol.beforeOwnershipKey ?? '') !== (symbol.afterOwnershipKey ?? ''))
+    || ((symbol.beforeNativeAstNodeId ?? '') !== (symbol.afterNativeAstNodeId ?? ''));
+}
+
+function nativeDiffSymbolIsMorePreciseNestedChange(candidate, container) {
+  if (candidate.changeKind === 'unchanged') return false;
+  if (nativeDiffSymbolIsContainer(candidate) && !nativeDiffSymbolIsMember(candidate)) return false;
+  if ((candidate.ownershipKey ?? '') === (container.ownershipKey ?? '')) return false;
+  if (!nativeDiffAnySpanContains(container, candidate)) return false;
+  return nativeDiffNestedSymbolName(candidate, container) || nativeDiffSymbolIsMember(candidate);
+}
+
+function nativeDiffSymbolIsContainer(symbol) {
+  return nativeDiffContainerKinds.has(nativeDiffKind(symbol.ownershipRegionKind ?? symbol.kind));
+}
+
+function nativeDiffSymbolIsMember(symbol) {
+  return nativeDiffMemberKinds.has(nativeDiffKind(symbol.ownershipRegionKind ?? symbol.kind));
+}
+
+function nativeDiffNestedSymbolName(candidate, container) {
+  const candidateName = String(candidate.name ?? '');
+  const containerName = String(container.name ?? '');
+  return Boolean(containerName && candidateName && candidateName !== containerName && candidateName.startsWith(`${containerName}.`));
+}
+
+function nativeDiffAnySpanContains(container, candidate) {
+  return nativeDiffSymbolSpans(container).some((containerSpan) => nativeDiffSymbolSpans(candidate).some((candidateSpan) => (
+    nativeDiffSameSourcePath(candidateSpan, containerSpan) && nativeDiffSpanContains(containerSpan, candidateSpan)
+  )));
+}
+
+function nativeDiffSymbolSpans(symbol) {
+  return [symbol.sourceSpan, symbol.beforeSourceSpan, symbol.afterSourceSpan].filter(Boolean);
+}
+
+function nativeDiffSameSourcePath(left, right) {
+  const leftPath = left?.path;
+  const rightPath = right?.path;
+  return !leftPath || !rightPath || leftPath === rightPath;
+}
+
+function nativeDiffSpanContains(containerSpan, candidateSpan) {
+  const container = nativeDiffSpanRange(containerSpan);
+  const candidate = nativeDiffSpanRange(candidateSpan);
+  if (!container || !candidate) return false;
+  return container.start <= candidate.start && candidate.end <= container.end && (container.start !== candidate.start || container.end !== candidate.end);
+}
+
+function nativeDiffSpanRange(span) {
+  const startLine = Number(span?.startLine ?? span?.line ?? span?.start?.line);
+  const endLine = Number(span?.endLine ?? span?.end?.line ?? startLine);
+  if (!Number.isFinite(startLine) || !Number.isFinite(endLine)) return undefined;
+  const startColumn = Number(span?.startColumn ?? span?.column ?? span?.start?.column ?? 0);
+  const endColumn = Number(span?.endColumn ?? span?.end?.column ?? startColumn);
+  return {
+    start: startLine * 100000 + (Number.isFinite(startColumn) ? startColumn : 0),
+    end: endLine * 100000 + Math.max(Number.isFinite(startColumn) ? startColumn : 0, Number.isFinite(endColumn) ? endColumn : 0)
+  };
+}
+
+function nativeDiffKind(value) {
+  return String(value ?? '').toLowerCase();
+}
+
+const nativeDiffContainerKinds = new Set(['type', 'class', 'interface', 'trait', 'protocol', 'struct', 'enum', 'record', 'body', 'function', 'method', 'export']);
+const nativeDiffMemberKinds = new Set(['body', 'method', 'function', 'property', 'declaration', 'call', 'effect', 'controlflow', 'mutation']);

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

@@ -23,6 +23,8 @@ export function nativeChangeProjectionSourceMapLinks(imported, side, region, sym
         precision: mapping.precision,
         sourceSpan: mapping.sourceSpan,
         generatedSpan: mapping.generatedSpan,
+        sourceReplacementText: mapping.sourceReplacementText,
+        sourceReplacementTextHash: mapping.sourceReplacementTextHash ?? mapping.sourceReplacementHash,
         ownershipRegionId: mapping.ownershipRegionId,
         ownershipRegionKey: mapping.ownershipRegionKey,
         ownershipRegionKind: mapping.ownershipRegionKind

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

@@ -1,5 +1,6 @@
 import{uniqueStrings}from'../../native-import-utils.js';
 import{nativeImportCategoryForLossKind}from'./nativeImportCategoryForLossKind.js';
+export{summarizeSemanticAdmissionWarnings}from'./projectImportAdmissionSemanticWarnings.js';
 
 export function importLosses(imported){
   const nativeAst=imported?.nativeAst??imported?.nativeSource?.ast;
@@ -157,4 +158,3 @@ export function summarizeImportPreservation(imported,source){
   const quality=stale?'stale':missing?'missing':truncated||!exactSourceAvailable||sourcePreservationLosses.length?'lossy':'exact';
   return {quality,missing,stale,truncated,exactSourceAvailable,lossCount:sourcePreservationLosses.length,id:record?.id};
 }
-

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

@@ -0,0 +1,178 @@
+import { uniqueRecordsById, uniqueStrings } from '../../native-import-utils.js';
+import { semanticOwnershipRegionsFromSemanticIndex } from '../../semantic-import-regions.js';
+
+export function summarizeSemanticAdmissionWarnings(imported, context = {}) {
+  const semanticIndex = imported?.semanticIndex ?? imported?.universalAst?.semanticIndex;
+  const symbols = semanticSymbolsForImport(imported, semanticIndex);
+  const ownershipRegions = semanticOwnershipRegionsForImport(imported, semanticIndex);
+  const patchHints = semanticPatchHintsForImport(imported, semanticIndex);
+  const sourcePath = firstString(context.sourcePath, context.source?.sourcePath, imported?.sourcePath, imported?.nativeSource?.sourcePath, imported?.nativeAst?.sourcePath, semanticIndex?.documents?.[0]?.path);
+  const semanticImportExpected = isSemanticImportExpected(imported, context);
+  const semanticImportExpectedEmpty = isSemanticImportExpectedEmpty(imported, context);
+  const changedSource = isChangedSemanticAdmissionSource(imported, { ...context, sourcePath });
+  const warnings = [];
+  if (semanticImportExpected && !semanticImportExpectedEmpty && changedSource && symbols.length > 0 && ownershipRegions.length === 0) {
+    warnings.push(semanticAdmissionWarning({
+      code: 'missing-ownership-regions',
+      message: 'Semantic import was expected for a changed source and produced symbols, but no ownership regions were available.',
+      action: 'rerun-sidecar-generation-with-ownership-regions',
+      sourcePath,
+      symbols,
+      ownershipRegions,
+      patchHints,
+      semanticImportExpected,
+      changedSource
+    }));
+  }
+  if (semanticImportExpected && !semanticImportExpectedEmpty && changedSource && symbols.length > 0 && patchHints.length === 0) {
+    warnings.push(semanticAdmissionWarning({
+      code: 'missing-patch-hints',
+      message: 'Semantic import was expected for a changed source and produced symbols, but no patch hints were available.',
+      action: 'generate-semantic-patch-hints',
+      sourcePath,
+      symbols,
+      ownershipRegions,
+      patchHints,
+      semanticImportExpected,
+      changedSource
+    }));
+  }
+  return {
+    semanticImportExpected,
+    semanticImportExpectedEmpty,
+    changedSource,
+    symbolCount: symbols.length,
+    ownershipRegionCount: ownershipRegions.length,
+    patchHintCount: patchHints.length,
+    warningCount: warnings.length,
+    reasonCodes: uniqueStrings(warnings.map((warning) => warning.reasonCode)),
+    warnings
+  };
+}
+
+function semanticAdmissionWarning(input) {
+  return {
+    code: input.code,
+    reasonCode: input.code,
+    severity: 'warning',
+    message: input.message,
+    action: input.action,
+    ...(input.sourcePath ? { sourcePath: input.sourcePath } : {}),
+    sourcePaths: uniqueStrings([input.sourcePath].filter(Boolean)),
+    semanticSymbols: input.symbols.length,
+    ownershipRegions: input.ownershipRegions.length,
+    patchHints: input.patchHints.length,
+    semanticImportExpected: input.semanticImportExpected,
+    changedSource: input.changedSource
+  };
+}
+
+function semanticSymbolsForImport(imported, semanticIndex) {
+  if (Array.isArray(semanticIndex?.symbols)) return semanticIndex.symbols;
+  for (const symbols of [
+    imported?.semanticSymbols,
+    imported?.symbols,
+    imported?.metadata?.semanticSymbols,
+    imported?.metadata?.symbols
+  ]) {
+    if (Array.isArray(symbols)) return symbols;
+  }
+  return [];
+}
+
+function semanticOwnershipRegionsForImport(imported, semanticIndex) {
+  return uniqueRecordsById([
+    ...(Array.isArray(imported?.ownershipRegions) ? imported.ownershipRegions : []),
+    ...(Array.isArray(imported?.semanticOwnershipRegions) ? imported.semanticOwnershipRegions : []),
+    ...semanticOwnershipRegionsFromSemanticIndex(semanticIndex),
+    ...(Array.isArray(imported?.universalAst?.ownershipRegions) ? imported.universalAst.ownershipRegions : []),
+    ...(Array.isArray(imported?.metadata?.ownershipRegions) ? imported.metadata.ownershipRegions : [])
+  ]);
+}
+
+function semanticPatchHintsForImport(imported, semanticIndex) {
+  return uniqueRecordsById([
+    ...(Array.isArray(imported?.patchHints) ? imported.patchHints : []),
+    ...(Array.isArray(imported?.semanticPatchHints) ? imported.semanticPatchHints : []),
+    ...(Array.isArray(semanticIndex?.patchHints) ? semanticIndex.patchHints : []),
+    ...(Array.isArray(imported?.universalAst?.patchHints) ? imported.universalAst.patchHints : []),
+    ...(Array.isArray(imported?.metadata?.patchHints) ? imported.metadata.patchHints : [])
+  ]);
+}
+
+function isSemanticImportExpected(imported, context) {
+  return semanticExpectationRecords(imported, context).some((entry) =>
+    entry.semanticImportExpected === true
+    || entry.expectedSemanticImport === true
+    || entry.semanticSidecarExpected === true
+    || entry.expected === true && looksLikeSemanticSidecarQuality(entry)
+  );
+}
+
+function isSemanticImportExpectedEmpty(imported, context) {
+  return semanticExpectationRecords(imported, context).some((entry) =>
+    entry.semanticImportExpectedEmpty === true
+    || entry.expectedSemanticImportEmpty === true
+    || entry.semanticSidecarExpectedEmpty === true
+    || entry.expectedEmpty === true && looksLikeSemanticSidecarQuality(entry)
+  );
+}
+
+function isChangedSemanticAdmissionSource(imported, context) {
+  const sourcePath = context.sourcePath;
+  const changedSourcePaths = uniqueStrings([
+    ...(context.projectResult?.changedSourcePaths ?? []),
+    ...(context.projectResult?.metadata?.changedSourcePaths ?? []),
+    ...(context.projectResult?.metadata?.semanticChangedSourcePaths ?? []),
+    ...(context.projectResult?.metadata?.semanticImportChangedSourcePaths ?? [])
+  ]);
+  return Boolean(
+    (context.candidates?.length ?? 0) > 0
+    || (sourcePath && changedSourcePaths.includes(sourcePath))
+    || semanticExpectationRecords(imported, context).some((entry) =>
+      entry.changedSource === true
+      || entry.sourceChanged === true
+      || entry.semanticSourceChanged === true
+      || entry.semanticImportChangedSource === true
+    )
+  );
+}
+
+function semanticExpectationRecords(imported, context) {
+  const nativeAst = imported?.nativeAst ?? imported?.nativeSource?.ast;
+  const semanticIndex = imported?.semanticIndex ?? imported?.universalAst?.semanticIndex;
+  return [
+    context.projectResult?.metadata,
+    context.source?.metadata,
+    imported?.metadata,
+    imported?.nativeSource?.metadata,
+    nativeAst?.metadata,
+    imported?.universalAst?.metadata,
+    imported?.patch?.metadata,
+    semanticIndex?.metadata,
+    imported?.semanticSidecarQuality,
+    imported?.sidecarQuality,
+    imported?.semanticSidecar?.quality,
+    imported?.sidecar?.quality,
+    imported?.metadata?.semanticSidecarQuality,
+    imported?.metadata?.sidecarQuality,
+    imported?.patch?.metadata?.semanticSidecarQuality
+  ].filter((entry) => entry && typeof entry === 'object');
+}
+
+function looksLikeSemanticSidecarQuality(value) {
+  return value && typeof value === 'object' && (
+    value.schema === 'frontier.lang.semanticSidecarQuality.v1'
+    || value.imported !== undefined
+    || value.expectedSatisfied !== undefined
+    || value.warningCount !== undefined
+    || value.proofSummary !== 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/projectImportAdmissionSummaries.js

@@ -1,12 +1,12 @@
 import{countBy,maxSemanticMergeReadiness,uniqueRecordsById,uniqueStrings}from'../../native-import-utils.js';
 import{createSemanticMergeCandidateAdmissionRecord,querySemanticMergeCandidateAdmissionOverlaps,sortSemanticMergeCandidateAdmissionRecords}from'./semanticMergeCandidateRecords.js';
-import{compactAdmissionSource,importLosses,sourceLossClasses,summarizeImportPreservation,summarizeParserEvidence}from'./projectImportAdmissionImportEvidence.js';
+import{compactAdmissionSource,importLosses,sourceLossClasses,summarizeImportPreservation,summarizeParserEvidence,summarizeSemanticAdmissionWarnings}from'./projectImportAdmissionImportEvidence.js';
 import{sourceMissingEvidence,sourceMissingTasks,sourceSemanticMergeScore}from'./projectImportAdmissionTasks.js';
 import{candidateRisk,maxPreservationQuality,maxRisk,normalizeRisk}from'./projectImportAdmissionRanks.js';
 
 export{admissionLanguages}from'./projectImportAdmissionLanguageSummaries.js';
 
-export function projectAdmissionImports(imports,sourceRows,mergeCandidates){
+export function projectAdmissionImports(imports,sourceRows,mergeCandidates,projectResult){
   return imports.map((imported,index)=>{
     const source=sourceRows?.[index]??compactAdmissionSource(imported,index);
     const sourcePath=source.sourcePath??imported?.sourcePath;
@@ -22,6 +22,7 @@ export function projectAdmissionImports(imports,sourceRows,mergeCandidates){
     };
     const readiness=source.readiness??imported?.metadata?.semanticMergeReadiness??candidates[0]?.readiness??'ready';
     const emptySemanticEvidence=Object.values(semanticCounts).reduce((sum,value)=>sum+value,0)===0;
+    const semanticAdmission=summarizeSemanticAdmissionWarnings(imported,{source,sourcePath,candidates,projectResult});
     const sourcePreservation=summarizeImportPreservation(imported,source);
     const losses=importLosses(imported);
     const lossClasses=sourceLossClasses(imported,losses);
@@ -55,6 +56,7 @@ export function projectAdmissionImports(imports,sourceRows,mergeCandidates){
       readiness,
       semanticCounts,
       emptySemanticEvidence,
+      semanticAdmission,
       parserEvidence,
       lossClasses,
       missingEvidence,
@@ -90,6 +92,7 @@ export function admissionSemanticEvidence(projectResult,imports,importSummaries)
     .filter((entry)=>entry.emptySemanticEvidence)
     .map((entry)=>entry.sourcePath)
     .filter(Boolean));
+  const warnings=uniqueSemanticAdmissionWarnings(importSummaries.flatMap((entry)=>entry.semanticAdmission?.warnings??[]));
   return {
     empty:Object.values(totals).reduce((sum,value)=>sum+value,0)===0,
     emptySourceCount:importSummaries.filter((entry)=>entry.emptySemanticEvidence).length,
@@ -98,10 +101,26 @@ export function admissionSemanticEvidence(projectResult,imports,importSummaries)
     evidenceRecords:uniqueRecordsById([
       ...(projectResult?.evidence??[]),
       ...imports.flatMap((imported)=>imported?.evidence??[])
-    ]).length
+    ]).length,
+    warningCount:warnings.length,
+    warningReasonCodes:uniqueStrings(warnings.map((warning)=>warning.reasonCode??warning.code)),
+    warningSourcePaths:uniqueStrings(warnings.flatMap((warning)=>warning.sourcePaths??[warning.sourcePath]).filter(Boolean)),
+    warnings
   };
 }
 
+function uniqueSemanticAdmissionWarnings(warnings){
+  const seen=new Set();
+  const result=[];
+  for(const warning of warnings.filter(Boolean)){
+    const key=[warning.reasonCode??warning.code,(warning.sourcePaths??[warning.sourcePath]).join('|')].join('\u0000');
+    if(seen.has(key)) continue;
+    seen.add(key);
+    result.push(warning);
+  }
+  return result;
+}
+
 export function admissionSourcePreservation(importSummaries,contract){
   const qualities=importSummaries.map((entry)=>entry.sourcePreservation.quality);
   const quality=qualities.length?qualities.reduce(maxPreservationQuality,'exact'):'empty';