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

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

@@ -1,11 +1,11 @@
-import{idFragment}from'../../native-import-utils.js';
+import{idFragment,caseSensitiveIdFragment}from'../../native-import-utils.js';
 import{nativeNodeId}from'./nativeNodeId.js';
 export function declarationRecord(input, nativeNodeId, name, symbolKind, role = 'definition') {
   return {
     name: String(name),
     symbolKind,
     role,
-    symbolId: `symbol:${input.language}:${role === 'import' ? 'import:' : ''}${idFragment(name)}`,
+    symbolId: `symbol:${input.language}:${role === 'import' ? 'import:' : ''}${caseSensitiveIdFragment(name)}`,
     nativeNodeId
   };
 }

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

@@ -74,6 +74,8 @@ export function inferSemanticLineageEvents(input = {}, options = {}) {
       inferredEvents: events.length,
       moved: events.filter((event) => event.eventKind === 'moved').length,
       renamed: events.filter((event) => event.eventKind === 'renamed').length,
+      split: events.filter((event) => event.eventKind === 'split').length,
+      recreated: events.filter((event) => event.eventKind === 'recreated').length,
       deleted: deleted.length,
       ambiguous: candidates.ambiguous.length,
       unmatchedAdded: candidates.unmatchedAfter.length,
@@ -169,6 +171,10 @@ function lineageInferenceEvidence(input) {
       language: input.language,
       unchangedAnchors: input.exact.matched.length,
       inferredEvents: input.events.length,
+      moved: input.events.filter((event) => event.eventKind === 'moved').length,
+      renamed: input.events.filter((event) => event.eventKind === 'renamed').length,
+      split: input.events.filter((event) => event.eventKind === 'split').length,
+      recreated: input.events.filter((event) => event.eventKind === 'recreated').length,
       deleted: input.deleted.length,
       ambiguous: input.candidates.ambiguous.length,
       unmatchedAdded: input.candidates.unmatchedAfter.length,
@@ -188,6 +194,8 @@ function inferenceReadiness(input, options) {
 function inferenceReasons(input) {
   return uniqueStrings([
     input.events.length ? 'semantic-lineage-inferred' : undefined,
+    input.events.some((event) => event.eventKind === 'split') ? 'split-anchor-lineage-inferred' : undefined,
+    input.events.some((event) => event.eventKind === 'recreated') ? 'recreated-anchor-lineage-inferred' : undefined,
     input.deleted.length ? 'deleted-anchor-lineage-inferred' : undefined,
     input.added.length ? 'unmatched-added-anchor-review' : undefined,
     input.ambiguous.length ? 'ambiguous-lineage-candidates' : undefined,

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/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??[]),

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

@@ -0,0 +1,74 @@
+const readinessScore = Object.freeze({ ready: 100, 'ready-with-losses': 75, 'needs-review': 45, blocked: 0 });
+
+export 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 roundScore(value) {
+  return Math.round((Number.isFinite(value) ? value : 0) * 100) / 100;
+}