@shapeshift-labs/frontier-lang-compiler 0.2.149 → 0.2.151

package/dist/js-ts-safe-project-merge-graph-delta-conflicts.js

@@ -1,7 +1,14 @@
-import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
 import { compactRecord } from './js-ts-safe-merge-context.js';
-
-function projectGraphDeltaConflicts(projectGraphDelta) {
+import { publicCompilerTypeDeltaConflicts } from './js-ts-safe-project-merge-graph-delta-compiler-conflicts.js';
+import { projectJsxPropDeltaConflicts, projectJsxRenderRiskDeltaConflicts } from './js-ts-safe-project-merge-jsx-graph-conflicts.js';
+import { projectRuntimeRegionDeltaConflicts } from './js-ts-safe-project-merge-runtime-region-conflicts.js';
+import { projectScopeUseDefDeltaConflicts } from './js-ts-safe-project-merge-scope-use-def-conflicts.js';
+import { projectSourceSpanDeltaConflicts } from './js-ts-safe-project-merge-source-span-conflicts.js';
+import { projectModuleDeclarationDeltaConflicts } from './js-ts-safe-project-merge-graph-delta-module-declarations.js';
+import { commonJsRuntimeInteropDelta, commonJsRuntimeInteropProofAssessment } from './js-ts-safe-project-merge-graph-delta-commonjs-interop.js';
+import { projectImportAttributeDeltaConflicts, projectPublicContractDeltaConflicts, projectReExportIdentityDeltaConflicts } from './js-ts-safe-project-merge-graph-delta-identity-conflicts.js';
+
+function projectGraphDeltaConflicts(projectGraphDelta, options = {}) {
   const limitConflicts = projectGraphDeltaLimitConflicts(projectGraphDelta);
   const baseGraph = projectGraphDelta?.stages?.base?.projectSymbolGraph;
   const workerGraph = projectGraphDelta?.stages?.worker?.projectSymbolGraph;
@@ -10,29 +17,17 @@ function projectGraphDeltaConflicts(projectGraphDelta) {
   if (!baseGraph || !workerGraph || !headGraph) return limitConflicts;
   return [
     ...limitConflicts,
-    ...changedIdentityConflicts({
-      code: 'project-public-contract-delta-conflict',
-      label: 'public contract',
-      baseRecords: baseGraph.publicContractRegions,
-      workerRecords: workerGraph.publicContractRegions,
-      headRecords: headGraph.publicContractRegions,
-      outputRecords: outputGraph?.publicContractRegions,
-      identityKey: publicContractIdentityKey,
-      fingerprint: publicContractFingerprint,
-      details: publicContractDetails
-    }),
-    ...changedIdentityConflicts({
-      code: 'project-re-export-identity-delta-conflict',
-      label: 're-export identity',
-      baseRecords: baseGraph.reExportIdentities,
-      workerRecords: workerGraph.reExportIdentities,
-      headRecords: headGraph.reExportIdentities,
-      outputRecords: outputGraph?.reExportIdentities,
-      identityKey: reExportIdentityKey,
-      fingerprint: reExportIdentityFingerprint,
-      details: reExportIdentityDetails
-    }),
-    ...projectImportTargetDeltaConflicts(projectGraphDelta)
+    ...projectPublicContractDeltaConflicts(baseGraph, workerGraph, headGraph, outputGraph),
+    ...publicCompilerTypeDeltaConflicts(baseGraph, workerGraph, headGraph, outputGraph, options),
+    ...projectSourceSpanDeltaConflicts(projectGraphDelta),
+    ...projectRuntimeRegionDeltaConflicts(projectGraphDelta, options),
+    ...projectScopeUseDefDeltaConflicts(projectGraphDelta),
+    ...projectJsxPropDeltaConflicts(projectGraphDelta),
+    ...projectJsxRenderRiskDeltaConflicts(projectGraphDelta, options),
+    ...projectReExportIdentityDeltaConflicts(baseGraph, workerGraph, headGraph, outputGraph),
+    ...projectModuleDeclarationDeltaConflicts(projectGraphDelta, options),
+    ...projectImportAttributeDeltaConflicts(baseGraph, workerGraph, headGraph, outputGraph),
+    ...projectImportTargetDeltaConflicts(projectGraphDelta, options)
   ];
 }
 
@@ -44,7 +39,15 @@ function addProjectGraphDeltaConflictSummary(projectGraphDelta, conflicts) {
       ...projectGraphDelta.summary,
       conflicts: conflicts.length,
       publicContractConflicts: conflicts.filter((conflict) => conflict.code === 'project-public-contract-delta-conflict').length,
+      sourceSpanConflicts: conflicts.filter((conflict) => conflict.code === 'project-source-span-delta-conflict').length,
+      compilerTypeConflicts: conflicts.filter((conflict) => conflict.code === 'project-public-compiler-type-delta-conflict').length,
+      runtimeRegionConflicts: conflicts.filter((conflict) => conflict.code === 'project-public-runtime-region-delta-conflict').length,
+      scopeUseDefConflicts: conflicts.filter(isScopeUseDefConflict).length,
+      jsxPropConflicts: conflicts.filter((conflict) => conflict.code === 'project-jsx-public-prop-delta-conflict').length,
+      jsxRenderRiskConflicts: conflicts.filter((conflict) => conflict.code === 'project-jsx-public-render-risk-delta-conflict').length,
       reExportIdentityConflicts: conflicts.filter((conflict) => conflict.code === 'project-re-export-identity-delta-conflict').length,
+      moduleDeclarationShapeConflicts: conflicts.filter((conflict) => conflict.code === 'project-module-declaration-shape-delta-conflict').length, exportAssignmentShapeConflicts: conflicts.filter((conflict) => conflict.code === 'project-export-assignment-shape-delta-conflict').length,
+      importAttributeConflicts: conflicts.filter((conflict) => conflict.code === 'project-import-attribute-delta-conflict').length,
       importTargetConflicts: conflicts.filter((conflict) => conflict.code === 'project-import-target-delta-conflict').length,
       limitConflicts: conflicts.filter((conflict) => conflict.gateId === 'project-graph-limit').length
     }
@@ -54,35 +57,9 @@ function addProjectGraphDeltaConflictSummary(projectGraphDelta, conflicts) {
 function projectGraphDeltaLimitConflicts(projectGraphDelta) {
   return Object.values(projectGraphDelta?.stages ?? {}).flatMap((stage) => stage?.limitConflicts ?? []);
 }
+function isScopeUseDefConflict(conflict) { return conflict.code === 'project-public-scope-use-def-delta-conflict' || conflict.code === 'project-public-scope-reference-delta-conflict'; }
 
-function changedIdentityConflicts(input) {
-  const base = recordsByIdentityKey(input.baseRecords, input.identityKey);
-  const worker = recordsByIdentityKey(input.workerRecords, input.identityKey);
-  const head = recordsByIdentityKey(input.headRecords, input.identityKey);
-  const output = recordsByIdentityKey(input.outputRecords, input.identityKey);
-  const keys = uniqueStrings([...base.keys(), ...worker.keys(), ...head.keys()]);
-  return keys.flatMap((identityKey) => {
-    const baseRecord = base.get(identityKey);
-    const workerRecord = worker.get(identityKey);
-    const headRecord = head.get(identityKey);
-    const baseFingerprint = optionalFingerprint(baseRecord, input.fingerprint);
-    const workerFingerprint = optionalFingerprint(workerRecord, input.fingerprint);
-    const headFingerprint = optionalFingerprint(headRecord, input.fingerprint);
-    if (baseFingerprint === workerFingerprint || baseFingerprint === headFingerprint || workerFingerprint === headFingerprint) return [];
-    return [projectGraphDeltaConflict({
-      code: input.code,
-      label: input.label,
-      identityKey,
-      baseRecord,
-      workerRecord,
-      headRecord,
-      outputRecord: output.get(identityKey),
-      details: input.details
-    })];
-  });
-}
-
-function projectImportTargetDeltaConflicts(projectGraphDelta) {
+function projectImportTargetDeltaConflicts(projectGraphDelta, options = {}) {
   const baseStage = projectGraphDelta?.stages?.base;
   const workerStage = projectGraphDelta?.stages?.worker;
   const headStage = projectGraphDelta?.stages?.head;
@@ -91,38 +68,23 @@ function projectImportTargetDeltaConflicts(projectGraphDelta) {
   const baseSymbolIds = semanticSymbolIds(baseStage);
   const headSymbolIds = semanticSymbolIds(headStage);
   const conflicts = [];
-  for (const [identityKey, edge] of importEdgesByIdentityKey(outputStage?.projectSymbolGraph?.importEdges)) {
+  const outputGraph = outputStage?.projectSymbolGraph;
+  for (const [identityKey, edge] of importEdgesByIdentityKey(outputGraph?.importEdges)) {
     if (!edge.resolvedTargetSymbolId) continue;
     const workerEdge = workerEdges.get(identityKey);
     if (!workerEdge || workerEdge.resolvedTargetSymbolId === edge.resolvedTargetSymbolId) continue;
     if (baseSymbolIds.has(edge.resolvedTargetSymbolId) || !headSymbolIds.has(edge.resolvedTargetSymbolId)) continue;
-    conflicts.push(projectImportTargetDeltaConflict(identityKey, edge, workerEdge));
+    const commonJsInteropDelta = commonJsRuntimeInteropDelta(identityKey, edge, workerEdge, outputGraph);
+    const commonJsProof = commonJsInteropDelta
+      ? commonJsRuntimeInteropProofAssessment(commonJsInteropDelta, options)
+      : undefined;
+    if (commonJsProof?.status === 'passed') continue;
+    conflicts.push(projectImportTargetDeltaConflict(identityKey, edge, workerEdge, commonJsProof));
   }
   return conflicts;
 }
 
-function projectGraphDeltaConflict(input) {
-  const sourcePath = input.workerRecord?.sourcePath ?? input.headRecord?.sourcePath ?? input.baseRecord?.sourcePath;
-  const conflictKey = `project-graph-delta#${input.label.replace(/\s+/g, '-')}#${input.identityKey}`;
-  return {
-    code: input.code,
-    gateId: 'project-graph-delta',
-    message: `Worker and head both changed ${input.label} ${JSON.stringify(input.identityKey)} in incompatible ways.`,
-    sourcePath,
-    details: compactRecord({
-      reasonCode: input.code,
-      conflictKey,
-      identityKey: input.identityKey,
-      sourcePath,
-      base: input.details(input.baseRecord),
-      worker: input.details(input.workerRecord),
-      head: input.details(input.headRecord),
-      output: input.details(input.outputRecord)
-    })
-  };
-}
-
-function projectImportTargetDeltaConflict(identityKey, edge, workerEdge) {
+function projectImportTargetDeltaConflict(identityKey, edge, workerEdge, commonJsProof) {
   return {
     code: 'project-import-target-delta-conflict',
     gateId: 'project-graph-delta',
@@ -137,105 +99,25 @@ function projectImportTargetDeltaConflict(identityKey, edge, workerEdge) {
       importedName: edge.importedName,
       localName: edge.localName,
       importKind: edge.importKind,
+      commonJs: edge.commonJs,
+      interopHelper: edge.interopHelper,
+      packageRuntimeCondition: edge.packageRuntimeCondition,
+      packageRuntimeConditionEdgeKind: edge.packageRuntimeConditionEdgeKind,
       resolvedModulePath: edge.resolvedModulePath,
       outputTargetSymbolId: edge.resolvedTargetSymbolId,
       workerTargetSymbolId: workerEdge.resolvedTargetSymbolId,
       workerResolutionKind: workerEdge.resolutionKind,
-      outputResolutionKind: edge.resolutionKind
+      outputResolutionKind: edge.resolutionKind,
+      routeId: commonJsProof?.routeId,
+      routeLane: commonJsProof?.routeLane,
+      routeNext: commonJsProof?.routeNext,
+      reasonCodes: commonJsProof?.reasonCodes,
+      commonJsRuntimeInteropProof: commonJsProof?.record,
+      semanticEquivalenceClaim: false
     })
   };
 }
 
-function recordsByIdentityKey(records, identityKey) {
-  const result = new Map();
-  for (const record of records ?? []) {
-    const key = identityKey(record);
-    if (!key || result.has(key)) continue;
-    result.set(key, record);
-  }
-  return result;
-}
-
-function publicContractIdentityKey(record) {
-  return firstString(
-    record?.key,
-    stableKey(['public-contract', record?.sourcePath, record?.apiSurfaceKind, record?.edgeKind, record?.moduleSpecifier, record?.exportedName ?? record?.symbolName ?? record?.symbolId])
-  );
-}
-
-function publicContractFingerprint(record) {
-  return hashSemanticValue({
-    kind: 'frontier.lang.projectGraphDelta.publicContractFingerprint',
-    contractHash: record.contractHash,
-    signatureHash: record.signatureHash,
-    symbolName: record.symbolName,
-    symbolKind: record.symbolKind,
-    apiSurfaceKind: record.apiSurfaceKind,
-    exportedName: record.exportedName,
-    moduleSpecifier: record.moduleSpecifier,
-    edgeKind: record.edgeKind
-  });
-}
-
-function publicContractDetails(record) {
-  if (!record) return undefined;
-  return compactRecord({
-    sourcePath: record.sourcePath,
-    key: publicContractIdentityKey(record),
-    symbolName: record.symbolName,
-    symbolKind: record.symbolKind,
-    apiSurfaceKind: record.apiSurfaceKind,
-    exportedName: record.exportedName,
-    moduleSpecifier: record.moduleSpecifier,
-    edgeKind: record.edgeKind,
-    signatureHash: record.signatureHash,
-    contractHash: record.contractHash,
-    sourceHash: record.sourceHash
-  });
-}
-
-function reExportIdentityKey(record) {
-  return stableKey(['re-export-identity', record?.sourcePath, record?.exportedName ?? record?.localName ?? record?.namespace ?? (record?.exportStar || record?.isExportStar ? '*' : undefined)]);
-}
-
-function reExportIdentityFingerprint(record) {
-  return hashSemanticValue({
-    kind: 'frontier.lang.projectGraphDelta.reExportIdentityFingerprint',
-    sourcePath: record.sourcePath,
-    moduleSpecifier: record.moduleSpecifier,
-    exportedName: record.exportedName,
-    importedName: record.importedName,
-    localName: record.localName,
-    namespace: record.namespace,
-    isTypeOnly: record.isTypeOnly,
-    exportStar: record.exportStar,
-    isExportStar: record.isExportStar,
-    originSymbolId: record.originSymbolId,
-    exportedSymbolId: record.exportedSymbolId,
-    localSymbolId: record.localSymbolId
-  });
-}
-
-function reExportIdentityDetails(record) {
-  if (!record) return undefined;
-  return compactRecord({
-    sourcePath: record.sourcePath,
-    key: reExportIdentityKey(record),
-    moduleSpecifier: record.moduleSpecifier,
-    exportedName: record.exportedName,
-    importedName: record.importedName,
-    localName: record.localName,
-    namespace: record.namespace,
-    isTypeOnly: record.isTypeOnly,
-    exportStar: record.exportStar,
-    isExportStar: record.isExportStar,
-    originSymbolId: record.originSymbolId,
-    exportedSymbolId: record.exportedSymbolId,
-    localSymbolId: record.localSymbolId,
-    sourceHash: record.sourceHash
-  });
-}
-
 function importEdgesByIdentityKey(records) {
   const result = new Map();
   for (const record of records ?? []) {
@@ -259,10 +141,6 @@ function projectImportTargetName(edge) {
   return String(name);
 }
 
-function optionalFingerprint(record, fingerprint) {
-  return record ? fingerprint(record) : undefined;
-}
-
 function semanticSymbolIds(stage) {
   return new Set((stage?.projectImport?.semanticIndex?.symbols ?? []).map((symbol) => symbol.id).filter(Boolean));
 }
@@ -272,15 +150,4 @@ function stableKey(parts) {
   return values.some(Boolean) ? values.join('#') : undefined;
 }
 
-function firstString(...values) {
-  for (const value of values) {
-    if (value !== undefined && value !== null && String(value)) return String(value);
-  }
-  return undefined;
-}
-
-function uniqueStrings(values) {
-  return [...new Set(values.filter((value) => typeof value === 'string' && value.length > 0))];
-}
-
 export { addProjectGraphDeltaConflictSummary, projectGraphDeltaConflicts };

package/dist/js-ts-safe-project-merge-graph-delta-identity-conflicts.js

@@ -0,0 +1,202 @@
+import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
+import { compactRecord } from './js-ts-safe-merge-context.js';
+
+function projectPublicContractDeltaConflicts(baseGraph, workerGraph, headGraph, outputGraph) {
+  return changedIdentityConflicts({
+    code: 'project-public-contract-delta-conflict',
+    label: 'public contract',
+    baseRecords: baseGraph.publicContractRegions,
+    workerRecords: workerGraph.publicContractRegions,
+    headRecords: headGraph.publicContractRegions,
+    outputRecords: outputGraph?.publicContractRegions,
+    identityKey: publicContractIdentityKey,
+    fingerprint: publicContractFingerprint,
+    details: publicContractDetails
+  });
+}
+
+function projectReExportIdentityDeltaConflicts(baseGraph, workerGraph, headGraph, outputGraph) {
+  return changedIdentityConflicts({
+    code: 'project-re-export-identity-delta-conflict',
+    label: 're-export identity',
+    baseRecords: baseGraph.reExportIdentities,
+    workerRecords: workerGraph.reExportIdentities,
+    headRecords: headGraph.reExportIdentities,
+    outputRecords: outputGraph?.reExportIdentities,
+    identityKey: reExportIdentityKey,
+    fingerprint: reExportIdentityFingerprint,
+    details: reExportIdentityDetails
+  });
+}
+
+function projectImportAttributeDeltaConflicts(baseGraph, workerGraph, headGraph, outputGraph) {
+  return changedIdentityConflicts({
+    code: 'project-import-attribute-delta-conflict',
+    label: 'import attributes',
+    baseRecords: attributedEdges(baseGraph),
+    workerRecords: attributedEdges(workerGraph),
+    headRecords: attributedEdges(headGraph),
+    outputRecords: attributedEdges(outputGraph),
+    identityKey: importAttributeIdentityKey,
+    fingerprint: importAttributeFingerprint,
+    details: importAttributeDetails
+  });
+}
+
+function changedIdentityConflicts(input) {
+  const base = recordsByIdentityKey(input.baseRecords, input.identityKey);
+  const worker = recordsByIdentityKey(input.workerRecords, input.identityKey);
+  const head = recordsByIdentityKey(input.headRecords, input.identityKey);
+  const output = recordsByIdentityKey(input.outputRecords, input.identityKey);
+  const keys = uniqueStrings([...base.keys(), ...worker.keys(), ...head.keys()]);
+  return keys.flatMap((identityKey) => {
+    const baseRecord = base.get(identityKey);
+    const workerRecord = worker.get(identityKey);
+    const headRecord = head.get(identityKey);
+    const baseFingerprint = optionalFingerprint(baseRecord, input.fingerprint);
+    const workerFingerprint = optionalFingerprint(workerRecord, input.fingerprint);
+    const headFingerprint = optionalFingerprint(headRecord, input.fingerprint);
+    if (baseFingerprint === workerFingerprint || baseFingerprint === headFingerprint || workerFingerprint === headFingerprint) return [];
+    return [projectGraphDeltaConflict({
+      code: input.code,
+      label: input.label,
+      identityKey,
+      baseRecord,
+      workerRecord,
+      headRecord,
+      outputRecord: output.get(identityKey),
+      details: input.details
+    })];
+  });
+}
+
+function projectGraphDeltaConflict(input) {
+  const sourcePath = input.workerRecord?.sourcePath ?? input.headRecord?.sourcePath ?? input.baseRecord?.sourcePath;
+  const conflictKey = `project-graph-delta#${input.label.replace(/\s+/g, '-')}#${input.identityKey}`;
+  return {
+    code: input.code,
+    gateId: 'project-graph-delta',
+    message: `Worker and head both changed ${input.label} ${JSON.stringify(input.identityKey)} in incompatible ways.`,
+    sourcePath,
+    details: compactRecord({
+      reasonCode: input.code,
+      conflictKey,
+      identityKey: input.identityKey,
+      sourcePath,
+      base: input.details(input.baseRecord),
+      worker: input.details(input.workerRecord),
+      head: input.details(input.headRecord),
+      output: input.details(input.outputRecord)
+    })
+  };
+}
+
+function recordsByIdentityKey(records, identityKey) {
+  const result = new Map();
+  for (const record of records ?? []) {
+    const key = identityKey(record);
+    if (!key || result.has(key)) continue;
+    result.set(key, record);
+  }
+  return result;
+}
+
+function publicContractIdentityKey(record) {
+  return firstString(
+    record?.key,
+    stableKey(['public-contract', record?.sourcePath, record?.apiSurfaceKind, record?.edgeKind, record?.moduleSpecifier, record?.exportedName ?? record?.symbolName ?? record?.symbolId])
+  );
+}
+
+function publicContractFingerprint(record) {
+  return hashSemanticValue({
+    kind: 'frontier.lang.projectGraphDelta.publicContractFingerprint',
+    signatureHash: record.signatureHash,
+    symbolName: record.symbolName,
+    symbolKind: record.symbolKind,
+    apiSurfaceKind: record.apiSurfaceKind,
+    exportedName: record.exportedName,
+    moduleSpecifier: record.moduleSpecifier,
+    edgeKind: record.edgeKind
+  });
+}
+
+function publicContractDetails(record) {
+  if (!record) return undefined;
+  return compactRecord({
+    sourcePath: record.sourcePath,
+    key: publicContractIdentityKey(record),
+    symbolName: record.symbolName,
+    symbolKind: record.symbolKind,
+    apiSurfaceKind: record.apiSurfaceKind,
+    exportedName: record.exportedName,
+    moduleSpecifier: record.moduleSpecifier,
+    edgeKind: record.edgeKind,
+    signatureHash: record.signatureHash,
+    contractHash: record.contractHash,
+    sourceHash: record.sourceHash
+  });
+}
+
+function reExportIdentityKey(record) {
+  return stableKey(['re-export-identity', record?.sourcePath, record?.exportedName ?? record?.localName ?? record?.namespace ?? (record?.exportStar || record?.isExportStar ? '*' : undefined)]);
+}
+
+function reExportIdentityFingerprint(record) {
+  return hashSemanticValue({
+    kind: 'frontier.lang.projectGraphDelta.reExportIdentityFingerprint',
+    sourcePath: record.sourcePath,
+    moduleSpecifier: record.moduleSpecifier,
+    hasImportAttributes: record.hasImportAttributes,
+    importAttributeCount: record.importAttributeCount,
+    importAttributeKeys: record.importAttributeKeys, importAttributeHash: record.importAttributeHash, importAttributes: record.importAttributes,
+    exportedName: record.exportedName,
+    importedName: record.importedName,
+    localName: record.localName,
+    namespace: record.namespace,
+    isTypeOnly: record.isTypeOnly,
+    exportStar: record.exportStar,
+    isExportStar: record.isExportStar,
+    originSymbolId: record.originSymbolId,
+    exportedSymbolId: record.exportedSymbolId,
+    localSymbolId: record.localSymbolId
+  });
+}
+
+function reExportIdentityDetails(record) {
+  if (!record) return undefined;
+  return compactRecord({
+    sourcePath: record.sourcePath,
+    key: reExportIdentityKey(record),
+    moduleSpecifier: record.moduleSpecifier,
+    hasImportAttributes: record.hasImportAttributes,
+    importAttributeCount: record.importAttributeCount,
+    importAttributeKeys: record.importAttributeKeys, importAttributeHash: record.importAttributeHash, importAttributes: record.importAttributes,
+    exportedName: record.exportedName,
+    importedName: record.importedName,
+    localName: record.localName,
+    namespace: record.namespace,
+    isTypeOnly: record.isTypeOnly,
+    exportStar: record.exportStar,
+    isExportStar: record.isExportStar,
+    originSymbolId: record.originSymbolId,
+    exportedSymbolId: record.exportedSymbolId,
+    localSymbolId: record.localSymbolId,
+    sourceHash: record.sourceHash
+  });
+}
+
+function attributedEdges(graph) { return [...(graph?.importEdges ?? []), ...(graph?.exportEdges ?? [])].filter((edge) => edge?.hasImportAttributes || edge?.importAttributeHash); }
+function importAttributeIdentityKey(edge) { return stableKey(['import-attribute', edge?.predicate, edge?.edgeKind, edge?.sourcePath, edge?.moduleSpecifier, edge?.isTypeOnly]); }
+function importAttributeFingerprint(edge) { return hashSemanticValue({ kind: 'frontier.lang.projectGraphDelta.importAttributeFingerprint', hasImportAttributes: edge.hasImportAttributes, importAttributeCount: edge.importAttributeCount, importAttributeKeys: edge.importAttributeKeys, importAttributeHash: edge.importAttributeHash, importAttributes: edge.importAttributes }); }
+function importAttributeDetails(edge) { if (!edge) return undefined; return compactRecord({ sourcePath: edge.sourcePath, key: importAttributeIdentityKey(edge), predicate: edge.predicate, moduleSpecifier: edge.moduleSpecifier, importedName: edge.importedName, exportedName: edge.exportedName, localName: edge.localName, importKind: edge.importKind, exportKind: edge.exportKind, isTypeOnly: edge.isTypeOnly, hasImportAttributes: edge.hasImportAttributes, importAttributeCount: edge.importAttributeCount, importAttributeKeys: edge.importAttributeKeys, importAttributeHash: edge.importAttributeHash, importAttributes: edge.importAttributes }); }
+function optionalFingerprint(record, fingerprint) { return record ? fingerprint(record) : undefined; }
+function stableKey(parts) { const values = parts.map((part) => part === undefined || part === null ? '' : String(part)); return values.some(Boolean) ? values.join('#') : undefined; }
+function firstString(...values) { for (const value of values) if (value !== undefined && value !== null && String(value)) return String(value); return undefined; }
+function uniqueStrings(values) { return [...new Set(values.filter((value) => typeof value === 'string' && value.length > 0))]; }
+
+export {
+  projectImportAttributeDeltaConflicts,
+  projectPublicContractDeltaConflicts,
+  projectReExportIdentityDeltaConflicts
+};

package/dist/js-ts-safe-project-merge-graph-delta-inference-syntax.js

@@ -0,0 +1,80 @@
+import { compactRecord } from './js-ts-safe-merge-context.js';
+
+function missingSharedCompilerTypeInferenceSyntaxEvidence(workerRecord, headRecord) {
+  const missing = [workerRecord, headRecord].filter((record) => (
+    requiresCompilerTypeInferenceSyntaxProof(record) && !hasPassedCompilerTypeInferenceSyntaxProof(record)
+  ));
+  if (!missing.length) return undefined;
+  return {
+    reasonCode: 'typescript-public-api-type-inference-syntax-proof-missing',
+    requiredEvidence: 'typescript-checker-public-api-type-inference-syntax-evidence',
+    semanticEquivalenceClaim: false,
+    missingRecords: missing.map(typeInferenceSyntaxMissingProofRecord)
+  };
+}
+
+function typeInferenceSyntaxMissingProofRecord(record) {
+  const proof = record?.typeInferenceSyntaxProof;
+  return compactRecord({
+    sourcePath: record.sourcePath,
+    sourceHash: record.sourceHash,
+    symbolId: record.symbolId,
+    symbolName: record.symbolName,
+    fullyQualifiedName: record.fullyQualifiedName,
+    typeInferenceSyntaxHash: record.typeInferenceSyntaxHash,
+    typeInferenceSyntaxProofStatus: proof?.status,
+    proofTypeInferenceSyntaxHash: proof?.typeInferenceSyntaxHash,
+    typeInferenceSyntaxProofSourcePath: proof?.sourcePath,
+    typeInferenceSyntaxProofSourceHash: proof?.sourceHash,
+    missingSignals: proof?.missingSignals,
+    reasonCodes: typeInferenceSyntaxProofReasonCodes(record, proof),
+    semanticEquivalenceClaim: proof?.semanticEquivalenceClaim ?? false,
+    evidenceIds: record.evidenceIds
+  });
+}
+
+function requiresCompilerTypeInferenceSyntaxProof(record) {
+  return Boolean(record && (
+    record.typeInferenceSyntaxCount > 0
+      || record.satisfiesExpressionCount > 0
+      || record.asConstAssertionCount > 0
+      || record.constTypeParameterCount > 0
+      || record.typeInferenceSyntaxHash
+      || record.typeInferenceSyntaxProof
+  ));
+}
+
+function hasPassedCompilerTypeInferenceSyntaxProof(record) {
+  const proof = record?.typeInferenceSyntaxProof;
+  return Boolean(
+    record?.typeInferenceSyntaxHash
+      && proof?.status === 'passed'
+      && proof?.typeInferenceSyntaxHash === record.typeInferenceSyntaxHash
+      && record?.sourcePath
+      && record?.sourceHash
+      && proof?.sourcePath === record.sourcePath
+      && proof?.sourceHash === record.sourceHash
+      && !arrayValue(proof?.missingSignals).length
+      && !arrayValue(proof?.reasonCodes).length
+      && proof.autoMergeClaim === false
+      && proof.semanticEquivalenceClaim === false
+  );
+}
+
+function typeInferenceSyntaxProofReasonCodes(record, proof) {
+  const reasonCodes = ['typescript-public-api-type-inference-syntax-proof-missing'];
+  if (!proof) return reasonCodes;
+  if (proof.status !== 'passed') reasonCodes.push('typescript-type-inference-syntax-proof-status-not-passed');
+  if (proof.typeInferenceSyntaxHash !== record?.typeInferenceSyntaxHash) reasonCodes.push('typescript-type-inference-syntax-proof-hash-mismatch');
+  if (!record?.sourcePath) reasonCodes.push('typescript-type-inference-syntax-record-source-path-missing');
+  if (!record?.sourceHash) reasonCodes.push('typescript-type-inference-syntax-record-source-hash-missing');
+  if (proof.sourcePath !== record?.sourcePath) reasonCodes.push('typescript-type-inference-syntax-proof-source-path-mismatch');
+  if (proof.sourceHash !== record?.sourceHash) reasonCodes.push('typescript-type-inference-syntax-proof-source-hash-mismatch');
+  if (proof.autoMergeClaim !== false || proof.semanticEquivalenceClaim !== false) reasonCodes.push('typescript-type-inference-syntax-proof-claim-flags-missing');
+  return uniqueStrings([...reasonCodes, ...arrayValue(proof.reasonCodes), ...arrayValue(proof.missingSignals).map((signal) => `typescript-${signal}-missing`)]);
+}
+
+function arrayValue(value) { return Array.isArray(value) ? value : []; }
+function uniqueStrings(values) { return [...new Set(values.filter((value) => typeof value === 'string' && value.length > 0))]; }
+
+export { missingSharedCompilerTypeInferenceSyntaxEvidence };