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

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

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

@@ -1,3 +1,5 @@
+import { semanticImportSidecarQualityRecord } from '../../semantic-import-sidecar-entry.js';
+
 function sidecarSourcePaths(importEntries) {
   return [...new Set(importEntries.map((entry) => entry.sourcePath).filter(Boolean))];
 }
@@ -15,10 +17,19 @@ function sidecarQualityWarning(code, message, action, sourcePaths) {
 export function createSemanticImportSidecarQuality(input) {
   const { importEntries, symbols, ownershipRegions, patchHints, proofSpec, evidence, readiness } = input;
   const expected = input.expected === true;
+  const expectedEmpty = input.expectedEmpty === true || input.semanticImportExpectedEmpty === true;
   const sourcePaths = sidecarSourcePaths(importEntries);
   const importCount = importEntries.length;
+  const record = semanticImportSidecarQualityRecord({
+    expected,
+    expectedEmpty,
+    importCount,
+    symbolCount: symbols.length,
+    sourcePaths
+  });
+  const expectedEmptySatisfied = record.classification === 'expected-empty';
   const warnings = [];
-  if (expected && importCount === 0) warnings.push(sidecarQualityWarning(
+  if ((expected || expectedEmpty) && importCount === 0) warnings.push(sidecarQualityWarning(
     'expected-semantic-import-missing',
     'Semantic import was expected but no import entries were selected.',
     'check-semantic-import-include-globs-and-workspace-paths',
@@ -30,31 +41,31 @@ export function createSemanticImportSidecarQuality(input) {
     'run-native-import',
     sourcePaths
   ));
-  if (expected && importCount > 0 && symbols.length === 0) warnings.push(sidecarQualityWarning(
+  if (!expectedEmptySatisfied && expected && importCount > 0 && symbols.length === 0) warnings.push(sidecarQualityWarning(
     'expected-semantic-import-empty',
     'Semantic import was expected but selected imports produced zero semantic symbols.',
     'rerun-importer-with-semantic-source-selection',
     sourcePaths
   ));
-  if (importCount > 0 && symbols.length === 0) warnings.push(sidecarQualityWarning(
+  if (!expectedEmptySatisfied && importCount > 0 && symbols.length === 0) warnings.push(sidecarQualityWarning(
     'empty-semantic-index',
     'Semantic sidecar has import entries but no semantic symbols.',
     'rerun-importer-with-semantic-index',
     sourcePaths
   ));
-  if (importCount > 0 && ownershipRegions.length === 0) warnings.push(sidecarQualityWarning(
+  if (!expectedEmptySatisfied && importCount > 0 && ownershipRegions.length === 0) warnings.push(sidecarQualityWarning(
     'missing-ownership-regions',
     'Semantic sidecar has no ownership regions for safe merge ownership.',
     'rerun-sidecar-generation-with-ownership-regions',
     sourcePaths
   ));
-  if (importCount > 0 && patchHints.length === 0) warnings.push(sidecarQualityWarning(
+  if (!expectedEmptySatisfied && importCount > 0 && patchHints.length === 0) warnings.push(sidecarQualityWarning(
     'missing-patch-hints',
     'Semantic sidecar has no patch hints.',
     'generate-semantic-patch-hints',
     sourcePaths
   ));
-  if (importCount > 0 && evidence.length === 0) warnings.push(sidecarQualityWarning(
+  if (!expectedEmptySatisfied && importCount > 0 && evidence.length === 0) warnings.push(sidecarQualityWarning(
     'empty-evidence',
     'Semantic sidecar has no evidence records.',
     'attach-semantic-import-evidence',
@@ -116,16 +127,18 @@ export function createSemanticImportSidecarQuality(input) {
     warning.code === 'missing-ownership-regions' ||
     warning.code === 'missing-patch-hints'
   ));
-  const expectedMissingReasonCodes = expected
-    ? emptyEvidenceWarnings.map((warning) => warning.code)
-    : [];
-  const expectedSatisfied = !expected || (
+  const expectedSatisfied = expectedEmpty
+    ? expectedEmptySatisfied
+    : !expected || (
     importCount > 0 &&
     symbols.length > 0 &&
     ownershipRegions.length > 0 &&
     patchHints.length > 0 &&
     evidence.length > 0
   );
+  const expectedMissingReasonCodes = (expected || expectedEmpty) && !expectedSatisfied
+    ? emptyEvidenceWarnings.map((warning) => warning.code)
+    : [];
   const proofSummary = {
     total: proofSpec.total,
     obligations: proofSpec.obligations,
@@ -143,12 +156,14 @@ export function createSemanticImportSidecarQuality(input) {
   return {
     schema: 'frontier.lang.semanticSidecarQuality.v1',
     expected,
+    expectedEmpty,
     expectedSatisfied,
     expectedMissingReasonCodes,
     selected: importCount > 0,
-    eligible: importCount > 0 && emptyEvidenceWarnings.length === 0 && proofSpec.failed === 0 && readiness !== 'blocked',
+    eligible: record.classification === 'useful' && emptyEvidenceWarnings.length === 0 && proofSpec.failed === 0 && readiness !== 'blocked',
     imported: importCount > 0,
     importCount,
+    record,
     symbolCount: symbols.length,
     ownershipRegionCount: ownershipRegions.length,
     patchHintCount: patchHints.length,
@@ -164,6 +179,7 @@ export function createSemanticImportSidecarAdmission(quality, readiness) {
   return {
     schema: 'frontier.lang.semanticSidecarAdmission.v1',
     expected: quality.expected,
+    expectedEmpty: quality.expectedEmpty,
     expectedSatisfied: quality.expectedSatisfied,
     expectedMissingReasonCodes: quality.expectedMissingReasonCodes,
     selected: quality.selected,
@@ -172,6 +188,7 @@ export function createSemanticImportSidecarAdmission(quality, readiness) {
     importCount: quality.importCount,
     readiness,
     action: sidecarAdmissionAction(quality, readiness),
+    record: quality.record,
     counts: {
       symbols: quality.symbolCount,
       ownershipRegions: quality.ownershipRegionCount,
@@ -191,6 +208,7 @@ function sidecarAdmissionAction(quality, readiness) {
   if (!quality.imported) return 'reject-missing-imports';
   if (readiness === 'blocked') return 'reject-blocked';
   if (quality.proofSummary.failed > 0) return 'reject-failed-proof';
+  if (quality.record?.classification === 'expected-empty') return 'skip-expected-empty';
   if (quality.emptyEvidenceWarnings.length > 0) return 'reject-empty-evidence';
   if (!quality.eligible) return 'reject-quality';
   if (sidecarProofReviewObligations(quality.proofSummary) > 0) return 'review-proof-obligations';

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/nativeChangeProjectionEndpoint.js

@@ -1,4 +1,4 @@
-import{nativeChangeMappingTouchesRegion}from'./nativeChangeMappingTouchesRegion.js';import{nativeImportSourcePreservationRecord}from'./nativeImportSourcePreservationRecord.js';
+import{uniqueStrings}from'../../native-import-utils.js';import{nativeChangeMappingTouchesRegion}from'./nativeChangeMappingTouchesRegion.js';import{nativeImportSourcePreservationRecord}from'./nativeImportSourcePreservationRecord.js';
 export function nativeChangeProjectionEndpoint(imported, sidecar, region, side) {
   if (!imported && !region) return undefined;
   const preservation = nativeImportSourcePreservationRecord(imported);
@@ -6,23 +6,63 @@ export function nativeChangeProjectionEndpoint(imported, sidecar, region, side)
   const regionMappings = sourceMaps
     .flatMap((sourceMap) => (sourceMap?.mappings ?? []).map((mapping) => ({ sourceMap, mapping })))
     .filter(({ mapping }) => nativeChangeMappingTouchesRegion(mapping, region, []));
+  const sourceMapIds = uniqueStrings(sourceMaps.map((sourceMap) => sourceMap?.id));
+  const sourceMapMappingIds = uniqueStrings(regionMappings.map(({ mapping }) => mapping?.id));
+  const importId = imported?.id;
+  const nativeSourceId = imported?.nativeSource?.id;
+  const nativeAstId = imported?.nativeAst?.id;
+  const semanticIndexId = imported?.semanticIndex?.id;
+  const universalAstId = imported?.universalAst?.id;
+  const sourcePath = imported?.sourcePath ?? region?.sourcePath;
+  const sourceHash = imported?.nativeSource?.sourceHash ?? imported?.nativeAst?.sourceHash ?? region?.sourceHash;
+  const sourcePreservationId = preservation?.id;
+  const exactSourceAvailable = preservation?.summary?.exactSourceAvailable === true;
+  const ownershipRegionId = region?.id;
+  const ownershipKey = region?.key;
+  const ownershipRegionKind = region?.regionKind;
+  const sourceSpan = region?.sourceSpan;
+  const identity = compactRecord({
+    schema: 'frontier.lang.nativeChangeProjectionEndpointIdentity.v1',
+    version: 1,
+    side,
+    importId,
+    nativeSourceId,
+    nativeAstId,
+    semanticIndexId,
+    universalAstId,
+    sourcePath,
+    sourceHash,
+    sourcePreservationId,
+    exactSourceAvailable,
+    ownershipRegionId,
+    ownershipKey,
+    ownershipRegionKind,
+    sourceSpan,
+    sourceMapIds,
+    sourceMapMappingIds
+  });
   return {
     side,
-    importId: imported?.id,
+    importId,
     sidecarId: sidecar?.id,
-    nativeSourceId: imported?.nativeSource?.id,
-    nativeAstId: imported?.nativeAst?.id,
-    semanticIndexId: imported?.semanticIndex?.id,
-    universalAstId: imported?.universalAst?.id,
-    sourcePath: imported?.sourcePath ?? region?.sourcePath,
-    sourceHash: imported?.nativeSource?.sourceHash ?? imported?.nativeAst?.sourceHash ?? region?.sourceHash,
-    sourcePreservationId: preservation?.id,
-    exactSourceAvailable: preservation?.summary?.exactSourceAvailable === true,
-    ownershipRegionId: region?.id,
-    ownershipKey: region?.key,
-    ownershipRegionKind: region?.regionKind,
-    sourceSpan: region?.sourceSpan,
-    sourceMapIds: sourceMaps.map((sourceMap) => sourceMap?.id).filter(Boolean),
-    sourceMapMappingIds: regionMappings.map(({ mapping }) => mapping?.id).filter(Boolean)
+    nativeSourceId,
+    nativeAstId,
+    semanticIndexId,
+    universalAstId,
+    sourcePath,
+    sourceHash,
+    sourcePreservationId,
+    exactSourceAvailable,
+    ownershipRegionId,
+    ownershipKey,
+    ownershipRegionKind,
+    sourceSpan,
+    sourceMapIds,
+    sourceMapMappingIds,
+    identity
   };
 }
+
+function compactRecord(value) {
+  return Object.fromEntries(Object.entries(value ?? {}).filter(([, entry]) => entry !== undefined && (!Array.isArray(entry) || entry.length > 0)));
+}

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/projectImportAdmissionMergeScore.js

@@ -1,4 +1,5 @@
 import{uniqueRecordsById,uniqueStrings}from'../../native-import-utils.js';
+import{targetProjectionCoverageSignals}from'./projectImportAdmissionProjectionCoverage.js';
 
 const scoreWeights=Object.freeze({
   semanticEvidence:22,
@@ -95,15 +96,35 @@ function sourcePreservationScore(input){
 
 function sourceFreshnessScore(input){
   const sourceCount=Math.max(input.sourceCount??0,input.sourcePreservation.total,1);
-  const fresh=Math.max(0,sourceCount-input.sourcePreservation.stale);
+  const sourceStaleness=input.sourceStaleness??{};
+  const stale=sourceStaleness.stale??input.sourcePreservation.stale;
+  const contentHashStale=sourceStaleness.contentHashStale??input.sourcePreservation.contentHashStale??0;
+  const baseHashStale=sourceStaleness.baseHashStale??input.sourcePreservation.baseHashStale??0;
+  const dirtyWorkspace=sourceStaleness.dirtyWorkspace??input.sourcePreservation.dirtyWorkspace??0;
+  const fresh=Math.max(0,sourceCount-stale);
   const score=roundScore(fresh*100/sourceCount);
   return scoreComponent('sourceFreshness',score,[
-    ...(input.sourcePreservation.stale?[
-      `Project import has stale source hashes for ${input.sourcePreservation.stale} source(s).`
+    ...(contentHashStale?[
+      `Project import has stale content hashes for ${contentHashStale} source(s).`
+    ]:[]),
+    ...(baseHashStale?[
+      `Project import has stale base hashes for ${baseHashStale} source(s).`
+    ]:[]),
+    ...(!contentHashStale&&!baseHashStale&&stale?[
+      `Project import has stale source hashes for ${stale} source(s).`
+    ]:[]),
+    ...(dirtyWorkspace&&!stale?[
+      `Project workspace is marked dirty for ${dirtyWorkspace} source(s), but no content or base hash staleness was detected.`
     ]:[])
   ],{
-    stale:input.sourcePreservation.stale,
-    staleSourcePaths:input.sourcePreservation.staleSourcePaths,
+    stale,
+    contentHashStale,
+    baseHashStale,
+    dirtyWorkspace,
+    staleSourcePaths:sourceStaleness.staleSourcePaths??input.sourcePreservation.staleSourcePaths,
+    contentHashStaleSourcePaths:sourceStaleness.contentHashStaleSourcePaths??input.sourcePreservation.contentHashStaleSourcePaths??[],
+    baseHashStaleSourcePaths:sourceStaleness.baseHashStaleSourcePaths??input.sourcePreservation.baseHashStaleSourcePaths??[],
+    dirtyWorkspaceSourcePaths:sourceStaleness.dirtyWorkspaceSourcePaths??input.sourcePreservation.dirtyWorkspaceSourcePaths??[],
     checkedSources:sourceCount
   });
 }
@@ -186,75 +207,6 @@ function targetProjectionCoverageScore(input){
   ],coverage);
 }
 
-function targetProjectionCoverageSignals(input){
-  const entries=targetProjectionEntries(input.projectResult,input.imports);
-  const matrices=projectionMatrices(input.projectResult,input.imports);
-  for(const matrix of matrices){
-    for(const language of matrix?.languages??[]) entries.push(...(language?.targets??[]));
-  }
-  const sourceMapSummary=input.contract?.sourceMaps??{};
-  const summary=matrices.reduce((current,matrix)=>{
-    current.exactSourceProjection+=matrix?.summary?.exactSourceProjection??0;
-    current.targetAdapterProjection+=matrix?.summary?.targetAdapterProjection??0;
-    current.missingAdapters+=matrix?.summary?.missingAdapters??0;
-    current.unsupportedTargetFeatures+=matrix?.summary?.unsupportedTargetFeatures??0;
-    return current;
-  },{exactSourceProjection:0,targetAdapterProjection:0,missingAdapters:0,unsupportedTargetFeatures:0});
-  const targetEntries=entries.length;
-  const supportedTargets=entries.filter((entry)=>entry?.supported===true).length;
-  const adapterProjectionTargets=entries.filter((entry)=>
-    entry?.lossClass==='targetAdapterProjection'||entry?.lossClass==='exactSourceProjection'||entry?.adapter||entry?.adapterKind==='targetProjection'
-  ).length+summary.targetAdapterProjection+summary.exactSourceProjection;
-  const readinessValues=entries.map((entry)=>readinessScore[entry?.readiness]??45);
-  const readinessAverage=readinessValues.length?readinessValues.reduce((sum,value)=>sum+value,0)/readinessValues.length:0;
-  return {
-    targetEntries,
-    supportedTargets,
-    adapterProjectionTargets,
-    exactSourceProjection:Math.max(summary.exactSourceProjection,input.sourcePreservation.exactSourceAvailable??0),
-    targetAdapterProjection:summary.targetAdapterProjection,
-    missingAdapters:summary.missingAdapters+entries.filter((entry)=>entry?.lossClass==='missingAdapter'||entry?.supported===false).length,
-    unsupportedTargetFeatures:summary.unsupportedTargetFeatures+entries.filter((entry)=>entry?.lossClass==='unsupportedTargetFeatures').length,
-    readinessScore:roundScore(readinessAverage),
-    sourceMapMappings:sourceMapSummary.mappingCount??0,
-    generatedRangeMappings:sourceMapSummary.generatedRangeMappings??0,
-    targetPaths:sourceMapSummary.targetPaths?.length??0,
-    adapterGeneratedRanges:input.contract?.adapterCoverage?.generatedRanges??0
-  };
-}
-
-function targetProjectionEntries(projectResult,imports){
-  return [
-    projectResult?.targetCoverage,
-    projectResult?.metadata?.targetCoverage,
-    projectResult?.metadata?.targetProjectionCoverage,
-    ...(projectResult?.targetCoverages??[]),
-    ...(projectResult?.metadata?.targetCoverages??[]),
-    ...(imports??[]).flatMap((imported)=>[
-      imported?.targetCoverage,
-      imported?.metadata?.targetCoverage,
-      imported?.metadata?.targetProjectionCoverage,
-      ...(imported?.targetCoverages??[]),
-      ...(imported?.metadata?.targetCoverages??[])
-    ])
-  ].flatMap((entry)=>Array.isArray(entry)?entry:[entry]).filter((entry)=>entry&&typeof entry==='object'&&(entry.target||entry.lossClass||entry.supported!==undefined));
-}
-
-function projectionMatrices(projectResult,imports){
-  return [
-    projectResult?.projectionMatrix,
-    projectResult?.metadata?.projectionMatrix,
-    ...(projectResult?.projectionMatrices??[]),
-    ...(projectResult?.metadata?.projectionMatrices??[]),
-    ...(imports??[]).flatMap((imported)=>[
-      imported?.projectionMatrix,
-      imported?.metadata?.projectionMatrix,
-      ...(imported?.projectionMatrices??[]),
-      ...(imported?.metadata?.projectionMatrices??[])
-    ])
-  ].filter((matrix)=>matrix?.kind==='frontier.lang.projectionTargetLossMatrix'||Array.isArray(matrix?.languages));
-}
-
 function admissionEvidenceRecords(projectResult,imports){
   return uniqueRecordsById([
     ...(projectResult?.evidence??[]),