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

package/dist/declarations/import-adapter-core.d.ts

@@ -98,6 +98,10 @@ export interface ImportNativeSourceOptions {
   readonly targetPath?: string;
   readonly targetHash?: string;
   readonly semanticIndex?: SemanticIndexRecord;
+  readonly ownershipRegions?: readonly SemanticImportOwnershipRegion[];
+  readonly semanticOwnershipRegions?: readonly SemanticImportOwnershipRegion[];
+  readonly patchHints?: readonly SemanticImportPatchHint[];
+  readonly semanticPatchHints?: readonly SemanticImportPatchHint[];
   readonly sourceMapId?: string;
   readonly sourceMaps?: readonly SourceMapRecord[];
   readonly universalAstId?: string;
@@ -112,6 +116,8 @@ export interface ImportNativeSourceOptions {
 export type NativeSourceImportResult = Omit<LanguageImportResult, 'metadata'> & {
   readonly nativeSource: NativeSourceNode;
   readonly semanticIndex?: SemanticIndexRecord;
+  readonly ownershipRegions: readonly SemanticImportOwnershipRegion[];
+  readonly patchHints: readonly SemanticImportPatchHint[];
   readonly universalAst: FrontierUniversalAstEnvelope;
   readonly metadata?: Record<string, unknown> & {
     readonly sourcePreservationRecords?: readonly SourcePreservationRecord[];

package/dist/declarations/native-project-admission-semantic-evidence.d.ts

@@ -0,0 +1,34 @@
+export type NativeProjectAdmissionSemanticEvidenceWarningCode =
+  | 'missing-ownership-regions'
+  | 'missing-patch-hints'
+  | (string & {});
+
+export interface NativeProjectAdmissionSemanticEvidenceWarning {
+  readonly code: NativeProjectAdmissionSemanticEvidenceWarningCode;
+  readonly reasonCode: NativeProjectAdmissionSemanticEvidenceWarningCode;
+  readonly severity: 'warning' | string;
+  readonly message: string;
+  readonly action: string;
+  readonly sourcePath?: string;
+  readonly sourcePaths: readonly string[];
+  readonly semanticSymbols: number;
+  readonly ownershipRegions: number;
+  readonly patchHints: number;
+  readonly semanticImportExpected: boolean;
+  readonly changedSource: boolean;
+}
+
+export interface NativeProjectAdmissionSemanticEvidence {
+  readonly empty: boolean;
+  readonly emptySourceCount: number;
+  readonly emptySourcePaths: readonly string[];
+  readonly symbols: number;
+  readonly occurrences: number;
+  readonly relations: number;
+  readonly facts: number;
+  readonly evidenceRecords: number;
+  readonly warningCount: number;
+  readonly warningReasonCodes: readonly NativeProjectAdmissionSemanticEvidenceWarningCode[];
+  readonly warningSourcePaths: readonly string[];
+  readonly warnings: readonly NativeProjectAdmissionSemanticEvidenceWarning[];
+}

package/dist/declarations/native-project-admission.d.ts

@@ -2,7 +2,13 @@ import type { FrontierSourceLanguage, SemanticMergeReadiness } from '@shapeshift
 import type { NativeImportLossSummary } from './native-import-losses.js';
 import type { NativeImportResultContract } from './native-import-contracts.js';
 import type { NativeProjectImportResult } from './native-project.js';
+import type { NativeProjectAdmissionSemanticEvidence } from './native-project-admission-semantic-evidence.js';
 import type { SemanticMergeCandidateAdmissionRecord, SemanticMergeCandidateOverlapRecord, SemanticMergeCandidateProjectionRisk } from './semantic-merge-candidates.js';
+export type {
+  NativeProjectAdmissionSemanticEvidence,
+  NativeProjectAdmissionSemanticEvidenceWarning,
+  NativeProjectAdmissionSemanticEvidenceWarningCode
+} from './native-project-admission-semantic-evidence.js';
 export type NativeProjectImportAdmissionAction = 'admit' | 'prioritize' | 'reject';
 export type NativeProjectImportAdmissionPriority = 'low' | 'normal' | 'high' | 'critical' | 'blocker';
 export type NativeProjectImportAdmissionRisk = 'low' | 'medium' | 'high' | 'unknown';
@@ -133,16 +139,6 @@ export interface NativeProjectAdmissionLanguages {
   readonly readinessRows: readonly NativeProjectAdmissionLanguageReadinessSummary[];
   readonly rows: readonly NativeProjectAdmissionLanguageSummary[];
 }
-export interface NativeProjectAdmissionSemanticEvidence {
-  readonly empty: boolean;
-  readonly emptySourceCount: number;
-  readonly emptySourcePaths: readonly string[];
-  readonly symbols: number;
-  readonly occurrences: number;
-  readonly relations: number;
-  readonly facts: number;
-  readonly evidenceRecords: number;
-}
 export type NativeProjectAdmissionSourceStalenessReason =
   | 'source-hash-mismatch'
   | 'content-hash-mismatch'

package/dist/declarations/semantic-edit-script.d.ts

@@ -147,7 +147,10 @@ export interface SemanticEditProjectionEdit {
   readonly replacementBytes: number;
   readonly deletedTextHash?: string;
   readonly replacementTextHash?: string;
+  readonly deletedTextLineEndingStableHash?: string;
+  readonly replacementTextLineEndingStableHash?: string;
   readonly replacementSpanTextHash?: string;
+  readonly replacementSpanTextLineEndingStableHash?: string;
   readonly insertionMode?: string;
   readonly insertionAnchorKey?: string;
   readonly insertionAnchorSymbolName?: string;

package/dist/declarations/semantic-patch-bundle-overlaps.d.ts

@@ -71,6 +71,7 @@ export interface SemanticPatchBundleOverlapRecord {
     readonly sourceSignals: number;
     readonly baseHashMismatch: boolean;
     readonly targetHashMismatch: boolean;
+    readonly replayOutputHashMismatch: boolean;
   };
   readonly metadata?: Record<string, unknown>;
 }

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/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)) 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']);
+const nativeDiffMemberKinds = new Set(['body', 'method', 'function', 'property', 'declaration']);

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

@@ -1,17 +1,14 @@
 import{commonGeneratedTargetPath,idFragment}from'../../native-import-utils.js';import{inferSourceMapMappings,normalizeSourceMapMappings,normalizeSourceMaps}from'../../native-source-maps.js';import{createKernelSourcePreservationRecords,summarizeKernelSourcePreservationRecords}from'../../semantic-import-source-preservation.js';import{createDocument,createImportResult,createNativeAstRecord,createPatch,createSourceMapRecord,createUniversalAstEnvelope,hashSemanticValue,nativeSourceNode}from'@shapeshift-labs/frontier-lang-kernel';
 import{attachInputUniversalDialectRegistry}from'../../universal-dialect-registry.js';
 import{createLightweightSemanticLayers}from'./createLightweightSemanticLayers.js';
-import{attachNativeImportLossSummary}from'./attachNativeImportLossSummary.js';import{createLightweightNativeImport}from'./createLightweightNativeImport.js';import{createNativeSourcePreservation}from'./createNativeSourcePreservation.js';import{hasNativeExactAstEvidence}from'./hasNativeExactAstEvidence.js';import{normalizeNativeLossRecords}from'./normalizeNativeLossRecords.js';import{summarizeNativeImportLosses}from'./summarizeNativeImportLosses.js';import{unverifiedNativeAstLosses}from'./unverifiedNativeAstLosses.js';import{withNativeImportReadiness}from'./withNativeImportReadiness.js';
+import{attachNativeImportLossSummary}from'./attachNativeImportLossSummary.js';import{createLightweightNativeImport}from'./createLightweightNativeImport.js';import{createNativeSourcePreservation}from'./createNativeSourcePreservation.js';import{hasNativeExactAstEvidence}from'./hasNativeExactAstEvidence.js';import{createNativeImportSemanticIndex}from'./nativeImportSemanticIndex.js';import{normalizeNativeLossRecords}from'./normalizeNativeLossRecords.js';import{summarizeNativeImportLosses}from'./summarizeNativeImportLosses.js';import{unverifiedNativeAstLosses}from'./unverifiedNativeAstLosses.js';import{withNativeImportReadiness}from'./withNativeImportReadiness.js';
 export function importNativeSource(input) {
   const language = input.language ?? input.nativeAst?.language;
   if (!language) throw new Error('importNativeSource requires a language or nativeAst.language');
   const sourcePath = input.sourcePath ?? input.nativeAst?.sourcePath;
   const declaredSourceHash = input.sourceHash ?? input.nativeAst?.sourceHash;
-  const sourceHash = typeof input.sourceText === 'string'
-    ? hashSemanticValue(input.sourceText)
-    : declaredSourceHash ?? hashSemanticValue(input.nativeAst?.nodes ?? input.nativeAst ?? {});
-  const targetPath = input.targetPath ?? input.target?.emitPath;
-  const targetHash = input.targetHash;
+  const sourceHash = typeof input.sourceText === 'string' ? hashSemanticValue(input.sourceText) : declaredSourceHash ?? hashSemanticValue(input.nativeAst?.nodes ?? input.nativeAst ?? {});
+  const targetPath = input.targetPath ?? input.target?.emitPath; const targetHash = input.targetHash;
   const importIdPart = idFragment(input.id ?? input.nativeSourceId ?? sourcePath ?? language);
   const sourcePreservation = input.sourcePreservation ?? (typeof input.sourceText === 'string'
     ? createNativeSourcePreservation({
@@ -146,6 +143,7 @@ export function importNativeSource(input) {
   });
   const evidence = attachNativeImportLossSummary(baseEvidence, lossSummary);
   const semanticIndex = input.semanticIndex ?? lightweight?.semanticIndex;
+  const { ownershipRegions, patchHints, semanticIndexForResult } = createNativeImportSemanticIndex(input, lightweight, semanticIndex);
   const sourceMapMappings = normalizeSourceMapMappings(
     input.mappings ?? lightweight?.mappings ?? inferSourceMapMappings({
       semanticIndex,
@@ -174,7 +172,7 @@ export function importNativeSource(input) {
       target: input.target,
       targetPath: inferredTargetPath,
       targetHash,
-      semanticIndexId: semanticIndex?.id,
+      semanticIndexId: semanticIndexForResult?.id,
       nativeAstId: nativeAst.id,
       nativeSourceId: nativeSource.id,
       mappings: sourceMapMappings,
@@ -191,7 +189,7 @@ export function importNativeSource(input) {
     nativeSources: [nativeSource],
     nativeAst,
     nativeSource,
-    semanticIndex,
+    semanticIndex: semanticIndexForResult,
     evidence,
     losses,
     sourcePreservation,
@@ -213,16 +211,16 @@ export function importNativeSource(input) {
     evidence,
     nativeSource,
     nativeAst,
-    semanticIndex
+    semanticIndex: semanticIndexForResult
   });
   const kernelSourcePreservationSummary = summarizeKernelSourcePreservationRecords(sourcePreservationRecords);
   const resultSourceMapMappings = sourceMaps.flatMap((sourceMap) => sourceMap.mappings ?? []);
-  const semanticLayers=input.semanticLayers??createLightweightSemanticLayers({importIdPart,language,sourcePath,sourceHash,nativeSource,nativeAst,semanticIndex,sourceMaps,losses,evidence,sourcePreservationRecords});
+  const semanticLayers=input.semanticLayers??createLightweightSemanticLayers({importIdPart,language,sourcePath,sourceHash,nativeSource,nativeAst,semanticIndex:semanticIndexForResult,sourceMaps,losses,evidence,sourcePreservationRecords});
   let universalAst = createUniversalAstEnvelope({
     id: input.universalAstId ?? `universal_ast_${importIdPart}`,
     document,
     nativeSources: [nativeSource],
-    semanticIndex,
+    semanticIndex: semanticIndexForResult,
     sourceMaps,
     losses,
     evidence,
@@ -262,7 +260,7 @@ export function importNativeSource(input) {
     metadata: {
       sourceLanguage: language,
       sourcePath,
-      semanticIndexId: semanticIndex?.id,
+      semanticIndexId: semanticIndexForResult?.id,
       universalAstId: universalAst.id,
       sourceMapIds: sourceMaps.map((sourceMap) => sourceMap.id),
       ...(sourcePreservation ? {
@@ -287,14 +285,16 @@ export function importNativeSource(input) {
     document,
     patch,
     nativeAst,
-    semanticIndex,
+    semanticIndex: semanticIndexForResult,
     universalAst,
     sourceMaps,
+    ownershipRegions,
+    patchHints: semanticIndexForResult?.patchHints ?? patchHints,
     losses,
     evidence,
     metadata: {
       nativeSourceId: nativeSource.id,
-      semanticIndexId: semanticIndex?.id,
+      semanticIndexId: semanticIndexForResult?.id,
       universalAstId: universalAst.id,
       sourceMapIds: sourceMaps.map((sourceMap) => sourceMap.id),
       semanticStatus,

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

@@ -0,0 +1,33 @@
+import{uniqueRecordsById}from'../../native-import-utils.js';
+import{semanticOwnershipRegionsFromSemanticIndex,semanticPatchHintForRegion}from'../../semantic-import-regions.js';
+
+export function createNativeImportSemanticIndex(input, lightweight, semanticIndex) {
+  const ownershipRegions = uniqueRecordsById([
+    ...(Array.isArray(input.ownershipRegions) ? input.ownershipRegions : []),
+    ...(Array.isArray(input.semanticOwnershipRegions) ? input.semanticOwnershipRegions : []),
+    ...(lightweight?.ownershipRegions ?? []),
+    ...semanticOwnershipRegionsFromSemanticIndex(semanticIndex),
+    ...(Array.isArray(input.universalAst?.ownershipRegions) ? input.universalAst.ownershipRegions : []),
+    ...(Array.isArray(input.metadata?.ownershipRegions) ? input.metadata.ownershipRegions : [])
+  ]);
+  const patchHints = uniqueRecordsById([
+    ...(Array.isArray(input.patchHints) ? input.patchHints : []),
+    ...(Array.isArray(input.semanticPatchHints) ? input.semanticPatchHints : []),
+    ...(lightweight?.patchHints ?? []),
+    ...(Array.isArray(semanticIndex?.patchHints) ? semanticIndex.patchHints : []),
+    ...(Array.isArray(input.universalAst?.patchHints) ? input.universalAst.patchHints : []),
+    ...(Array.isArray(input.metadata?.patchHints) ? input.metadata.patchHints : [])
+  ]);
+  const resultPatchHints = patchHints.length
+    ? patchHints
+    : ownershipRegions.map((region) => semanticPatchHintForRegion(region, 'needs-review'));
+  return {
+    ownershipRegions,
+    patchHints: resultPatchHints,
+    semanticIndexForResult: semanticIndex ? {
+      ...semanticIndex,
+      ownershipRegions,
+      patchHints: resultPatchHints
+    } : semanticIndex
+  };
+}

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;
+}