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

package/dist/js-ts-safe-project-merge-files.js

@@ -0,0 +1,70 @@
+export function normalizeProjectFiles(input) {
+  if (Array.isArray(input.files)) return input.files.map(normalizeFileRecord).sort(bySourcePath);
+  const base = normalizeFileMap(input.baseFiles);
+  const worker = normalizeFileMap(input.workerFiles);
+  const head = normalizeFileMap(input.headFiles);
+  const paths = [...new Set([...base.keys(), ...worker.keys(), ...head.keys()])].sort();
+  const field = (entry, name) => entry?.[name];
+  return paths.map((sourcePath) => normalizeFileRecord({
+    sourcePath,
+    baseSourceText: field(base.get(sourcePath), 'sourceText'),
+    workerSourceText: field(worker.get(sourcePath), 'sourceText'),
+    headSourceText: field(head.get(sourcePath), 'sourceText'),
+    baseParserTriviaEvidence: field(base.get(sourcePath), 'parserTriviaEvidence'),
+    workerParserTriviaEvidence: field(worker.get(sourcePath), 'parserTriviaEvidence'),
+    headParserTriviaEvidence: field(head.get(sourcePath), 'parserTriviaEvidence')
+  }));
+}
+
+function normalizeFileRecord(record = {}) {
+  return {
+    sourcePath: record.sourcePath ?? record.path,
+    language: record.language,
+    baseSourceText: stringOrUndefined(record.baseSourceText ?? record.baseText),
+    workerSourceText: stringOrUndefined(record.workerSourceText ?? record.workerText),
+    headSourceText: stringOrUndefined(record.headSourceText ?? record.headText),
+    workerDeleted: record.workerDeleted === true,
+    headDeleted: record.headDeleted === true,
+    policy: record.policy,
+    mergePolicy: record.mergePolicy,
+    parserTriviaEvidence: record.parserTriviaEvidence,
+    baseParserTriviaEvidence: record.baseParserTriviaEvidence,
+    workerParserTriviaEvidence: record.workerParserTriviaEvidence,
+    headParserTriviaEvidence: record.headParserTriviaEvidence,
+    outputParserTriviaEvidence: record.outputParserTriviaEvidence
+  };
+}
+
+function normalizeFileMap(value) {
+  const map = new Map();
+  if (!value) return map;
+  if (value instanceof Map) {
+    for (const [sourcePath, entry] of value) map.set(String(sourcePath), normalizeMapFileEntry(entry));
+    return map;
+  }
+  if (Array.isArray(value)) {
+    for (const entry of value) {
+      if (!entry?.sourcePath && !entry?.path) continue;
+      map.set(String(entry.sourcePath ?? entry.path), normalizeMapFileEntry(entry));
+    }
+    return map;
+  }
+  for (const [sourcePath, entry] of Object.entries(value)) map.set(sourcePath, normalizeMapFileEntry(entry));
+  return map;
+}
+
+function normalizeMapFileEntry(entry) {
+  if (entry && typeof entry === 'object') return {
+    sourceText: String(entry.sourceText ?? entry.text ?? ''),
+    parserTriviaEvidence: entry.parserTriviaEvidence
+  };
+  return { sourceText: String(entry ?? '') };
+}
+
+function stringOrUndefined(value) {
+  return typeof value === 'string' ? value : undefined;
+}
+
+function bySourcePath(left, right) {
+  return String(left.sourcePath ?? '').localeCompare(String(right.sourcePath ?? ''));
+}

package/dist/js-ts-safe-project-merge-global-augmentation-compatibility.js

@@ -0,0 +1,99 @@
+import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
+import { compactRecord } from './js-ts-safe-merge-context.js';
+
+const GlobalAugmentationCompatibilityRoute = Object.freeze({
+  routeId: 'prove-global-augmentation-compatibility',
+  routeLane: 'module-runtime-global-augmentation',
+  routeNext: 'supply-source-bound-global-augmentation-compatibility-proof'
+});
+
+function globalAugmentationCompatibilityAssessment(input = {}, options = {}) {
+  const proof = globalAugmentationCompatibilityProofFor(input, options);
+  const reasonCodes = [];
+  if (!proof) reasonCodes.push('global-augmentation-compatibility-proof-missing');
+  else {
+    if (proof.status !== 'passed') reasonCodes.push('global-augmentation-compatibility-proof-status-not-passed');
+    if (proof.kind !== undefined && proof.kind !== 'frontier.lang.globalAugmentationCompatibilityProof') reasonCodes.push('global-augmentation-compatibility-proof-schema-mismatch');
+    if (proof.schema !== undefined && proof.schema !== 'frontier.lang.globalAugmentationCompatibilityProof.v1') reasonCodes.push('global-augmentation-compatibility-proof-schema-mismatch');
+    if (proof.surfaceKind !== 'global-augmentation') reasonCodes.push('global-augmentation-compatibility-proof-surface-mismatch');
+    if (input.sourcePath && proof.sourcePath !== input.sourcePath) reasonCodes.push('global-augmentation-compatibility-proof-source-path-mismatch');
+    if (!sourceHashesMatch(input, proof)) reasonCodes.push('global-augmentation-compatibility-proof-stale-source');
+    if (input.moduleName && proof.moduleName !== input.moduleName) reasonCodes.push('global-augmentation-compatibility-proof-surface-mismatch');
+    if (input.moduleDeclarationRecordId && proof.moduleDeclarationRecordId !== input.moduleDeclarationRecordId) reasonCodes.push('global-augmentation-compatibility-shape-hash-mismatch');
+    if (input.moduleDeclarationShapeHash && proof.moduleDeclarationShapeHash !== input.moduleDeclarationShapeHash) reasonCodes.push('global-augmentation-compatibility-shape-hash-mismatch');
+    if (input.moduleDeclarationSignatureHash && proof.moduleDeclarationSignatureHash !== input.moduleDeclarationSignatureHash) reasonCodes.push('global-augmentation-compatibility-shape-hash-mismatch');
+    if (input.sourceSpanHash && proof.sourceSpanHash !== input.sourceSpanHash) reasonCodes.push('global-augmentation-compatibility-source-span-mismatch');
+    if (input.declarationOutputHash && proof.declarationOutputHash !== input.declarationOutputHash) reasonCodes.push('global-augmentation-compatibility-declaration-output-mismatch');
+    if (!proof.declarationOutputGateId || !proof.declarationOutputHash) reasonCodes.push('global-augmentation-compatibility-declaration-output-missing');
+    if (!proof.consumerDiagnosticsGateId || !proof.consumerDiagnosticsHash) reasonCodes.push('global-augmentation-compatibility-consumer-diagnostics-missing');
+    if (proof.consumerDiagnosticsPassed !== true || input.consumerDiagnosticsPassed === false) reasonCodes.push('global-augmentation-compatibility-consumer-diagnostics-failed');
+    if (!Array.isArray(proof.consumerEntrypoints) || proof.consumerEntrypoints.length === 0) reasonCodes.push('global-augmentation-compatibility-consumer-diagnostics-missing');
+    if (proof.globalCompatibilityClaim !== 'declaration-boundary-consumer-diagnostics-only'
+      || proof.hostRuntimeInteractionClaim !== false
+      || proof.runtimeEquivalenceClaim !== false
+      || proof.semanticEquivalenceClaim !== false
+      || proof.autoMergeClaim !== false) reasonCodes.push('global-augmentation-compatibility-proof-claim-bearing');
+  }
+  const status = proof && reasonCodes.length === 0 ? 'passed' : proof ? 'failed' : 'missing';
+  return {
+    status,
+    ...GlobalAugmentationCompatibilityRoute,
+    reasonCodes: uniqueStrings(reasonCodes),
+    record: compactRecord({
+      schema: 'frontier.lang.globalAugmentationCompatibilityProofAssessment.v1',
+      status,
+      proofStatus: proof?.status,
+      proofId: proof?.id,
+      proofHash: proof?.proofHash,
+      ...GlobalAugmentationCompatibilityRoute,
+      reasonCodes: uniqueStrings(reasonCodes),
+      expected: compactRecord(input),
+      globalCompatibilityClaim: 'declaration-boundary-consumer-diagnostics-only',
+      autoMergeClaim: false,
+      semanticEquivalenceClaim: false,
+      runtimeEquivalenceClaim: false,
+      hostRuntimeInteractionClaim: false
+    })
+  };
+}
+
+function globalAugmentationCompatibilityProofFor(input = {}, options = {}) {
+  const proofs = [
+    options.globalAugmentationCompatibilityProof,
+    ...(Array.isArray(options.globalAugmentationCompatibilityProofs) ? options.globalAugmentationCompatibilityProofs : [])
+  ].filter(Boolean);
+  return proofs.find((proof) => (
+    proof.moduleDeclarationRecordId === input.moduleDeclarationRecordId
+      || proof.sourcePath === input.sourcePath
+        && proof.moduleName === (input.moduleName ?? 'global')
+        && proof.surfaceKind === 'global-augmentation'
+  ));
+}
+
+function sourceHashesMatch(input, proof) {
+  const expectedHashes = uniqueStrings([input.sourceHash, ...(input.sourceHashes ?? [])]);
+  if (!expectedHashes.length) return true;
+  const proofHashes = uniqueStrings([proof.sourceHash, ...(proof.sourceHashes ?? [])]);
+  return expectedHashes.every((hash) => proofHashes.includes(hash));
+}
+
+function sourceSpanHash(sourceSpan) {
+  return sourceSpan ? hashSemanticValue({
+    start: sourceSpan.start,
+    end: sourceSpan.end,
+    startLine: sourceSpan.startLine,
+    startColumn: sourceSpan.startColumn,
+    endLine: sourceSpan.endLine,
+    endColumn: sourceSpan.endColumn
+  }) : undefined;
+}
+
+function uniqueStrings(values) {
+  return [...new Set(values.filter((value) => typeof value === 'string' && value.length > 0))];
+}
+
+export {
+  GlobalAugmentationCompatibilityRoute,
+  globalAugmentationCompatibilityAssessment,
+  sourceSpanHash
+};

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

@@ -1,5 +1,6 @@
 import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
 import { compactRecord } from './js-ts-safe-merge-context.js';
+import { cssModuleUseSiteBlockerConflicts, isResolvedCssModuleImportEdge } from './js-ts-safe-project-merge-css-module-conflicts.js';
 import { projectGraphDeltaConflicts } from './js-ts-safe-project-merge-graph-delta-conflicts.js';
 
 function outputProjectGraphConflicts(projectSymbolGraph) {
@@ -7,6 +8,7 @@ function outputProjectGraphConflicts(projectSymbolGraph) {
   projectSymbolGraph = projectSymbolGraph?.projectSymbolGraph ?? projectSymbolGraph;
   const importEdges = Array.isArray(projectSymbolGraph?.importEdges) ? projectSymbolGraph.importEdges : [];
   const exportEdges = Array.isArray(projectSymbolGraph?.exportEdges) ? projectSymbolGraph.exportEdges : [];
+  const cssModuleBlockers = Array.isArray(projectSymbolGraph?.cssModuleUseSiteBlockers) ? projectSymbolGraph.cssModuleUseSiteBlockers : [];
   const missingModuleGroups = new Map();
   const missingSymbolGroups = new Map();
   for (const edge of importEdges) {
@@ -26,6 +28,7 @@ function outputProjectGraphConflicts(projectSymbolGraph) {
   }
   return [
     ...limitConflicts,
+    ...cssModuleUseSiteBlockerConflicts(cssModuleBlockers),
     ...[...missingModuleGroups.values()].map(projectGraphMissingImportConflict),
     ...[...missingSymbolGroups.values()].map(projectGraphMissingTargetConflict),
     ...duplicateReExportIdentityConflicts(projectSymbolGraph?.reExportIdentities)
@@ -48,7 +51,9 @@ function projectGraphMissingImportConflict(group) {
       resolvedModulePath: edge.resolvedModulePath,
       edgeIds: uniqueStrings(group.map((record) => record.id)),
       importKinds: uniqueStrings(group.map((record) => record.importKind)),
-      importedNames: uniqueStrings(group.map((record) => record.importedName))
+      importedNames: uniqueStrings(group.map((record) => record.importedName)),
+      moduleEdgeFailureReasonCodes: uniqueStrings(group.flatMap(moduleEdgeFailureReasonCodes)),
+      moduleEdgeEvidence: group.map(moduleEdgeEvidence)
     })
   };
 }
@@ -73,7 +78,9 @@ function projectGraphMissingTargetConflict(group) {
       edgeIds: uniqueStrings(group.map((record) => record.id)),
       importKinds: uniqueStrings(group.map((record) => record.importKind)),
       importedNames: uniqueStrings(group.map((record) => record.importedName)),
-      localNames: uniqueStrings(group.map((record) => record.localName))
+      localNames: uniqueStrings(group.map((record) => record.localName)),
+      moduleEdgeFailureReasonCodes: uniqueStrings(['project-output-symbol-unresolved', ...group.flatMap(moduleEdgeFailureReasonCodes)]),
+      moduleEdgeEvidence: group.map(moduleEdgeEvidence)
     })
   };
 }
@@ -86,6 +93,7 @@ function isMissingProjectImportTargetEdge(edge, exportEdges = []) {
   return hasResolvedProjectModule(edge)
     && Boolean(projectImportTargetName(edge))
     && !edge.resolvedTargetSymbolId
+    && !isResolvedCssModuleImportEdge(edge)
     && !commonJsRequireResolvedByExportAssignment(edge, exportEdges);
 }
 
@@ -160,6 +168,11 @@ function reExportIdentityKey(record) {
 function reExportIdentityFingerprint(record) {
   return hashSemanticValue({
     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,
@@ -176,6 +189,11 @@ function reExportIdentityFingerprint(record) {
 function reExportIdentityDetails(record) {
   return compactRecord({
     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,
@@ -189,6 +207,76 @@ function reExportIdentityDetails(record) {
   });
 }
 
+function moduleEdgeFailureReasonCodes(edge) {
+  return [
+    edge?.packageRuntimeConditionReasonCode,
+    edge?.packageEnvironmentConditionReasonCode,
+    edge?.packageResolutionReasonCode,
+    typeof edge?.resolutionKind === 'string' && edge.resolutionKind.endsWith('-missing') ? edge.resolutionKind : undefined
+  ];
+}
+
+function moduleEdgeEvidence(edge) {
+  return compactRecord(Object.fromEntries(moduleEdgeEvidenceFields.map((field) => [field, edge?.[field]])));
+}
+
+const moduleEdgeEvidenceFields = [
+  'id',
+  'sourcePath',
+  'moduleSpecifier',
+  'resolutionKind',
+  'resolvedModulePath',
+  'targetDocumentId',
+  'resolvedTargetSymbolId',
+  'edgeKind',
+  'importKind',
+  'exportKind',
+  'importedName',
+  'exportedName',
+  'localName',
+  'isTypeOnly',
+  'resolutionPathVariant',
+  'packageName',
+  'packageSubpath',
+  'packageExportKey',
+  'packageExportCondition',
+  'packageExportTarget',
+  'packageImportKey',
+  'packageImportCondition',
+  'packageImportTarget',
+  'packageType',
+  'packageRuntimeCondition',
+  'packageRuntimeConditionEvidenceSource',
+  'packageRuntimeConditionEdgeKind',
+  'packageRuntimeConditionCandidates',
+  'packageRuntimeConditionReasonCode',
+  'packageEnvironmentCondition',
+  'packageEnvironmentConditionEvidenceSource',
+  'packageEnvironmentConditionCandidates',
+  'packageEnvironmentConditionReasonCode',
+  'packageWorkspaceRootAmbiguous',
+  'packageWorkspaceRoots',
+  'packageResolutionReasonCode',
+  'hostDependencyKind',
+  'hostDependencyBase',
+  'hostDependencyExpressionHash',
+  'hostDependencyStaticSpecifierEvidence',
+  'hostDependencyRuntimeResolutionClaim',
+  'hostDependencyResolutionProofRequired',
+  'dynamicImport',
+  'dynamicImportSpecifierKind',
+  'dynamicImportExpressionText',
+  'dynamicImportExpressionHash',
+  'dynamicImportStaticSpecifierEvidence',
+  'dynamicImportRuntimeResolutionClaim',
+  'dynamicImportResolutionProofRequired',
+  'hasImportAttributes',
+  'importAttributeCount',
+  'importAttributeKeys',
+  'importAttributeHash',
+  'importAttributes'
+];
+
 function stableKey(parts) {
   const values = parts.map((part) => part === undefined || part === null ? '' : String(part));
   return values.some(Boolean) ? values.join('#') : undefined;

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

@@ -0,0 +1,108 @@
+import { compactRecord } from './js-ts-safe-merge-context.js';
+
+function commonJsRuntimeInteropDelta(identityKey, edge, workerEdge, outputGraph) {
+  if (!isDefaultModuleExportsTarget(edge)) return undefined;
+  const exportShape = (outputGraph?.exportAssignmentRecords ?? [])
+    .find((record) => record.sourcePath === edge.resolvedModulePath && record.exportedName === 'module.exports');
+  return compactRecord({
+    schema: 'frontier.lang.commonJsRuntimeInteropDelta.v1',
+    identityKey,
+    sourcePath: edge.sourcePath,
+    sourceHash: edge.sourceHash,
+    moduleSpecifier: edge.moduleSpecifier,
+    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,
+    exportAssignmentShapeHash: exportShape?.shapeHash,
+    autoMergeClaim: false,
+    semanticEquivalenceClaim: false,
+    runtimeEquivalenceClaim: false,
+    runtimeInteropEquivalenceClaim: false
+  });
+}
+
+function commonJsRuntimeInteropProofAssessment(delta, options = {}) {
+  const proof = commonJsRuntimeInteropProofFor(delta, options);
+  const reasonCodes = [];
+  if (!proof) reasonCodes.push('commonjs-runtime-interop-proof-missing');
+  else {
+    if (proof.status !== 'passed') reasonCodes.push('commonjs-runtime-interop-proof-status-not-passed');
+    if (proof.schema !== 'frontier.lang.commonJsRuntimeInteropProof.v1' && proof.kind !== 'frontier.lang.commonJsRuntimeInteropProof') reasonCodes.push('commonjs-runtime-interop-proof-schema-missing');
+    if (proof.sourcePath !== delta.sourcePath) reasonCodes.push('commonjs-runtime-interop-proof-source-path-mismatch');
+    if (proof.sourceHash !== delta.sourceHash) reasonCodes.push('commonjs-runtime-interop-proof-source-hash-mismatch');
+    if (proof.identityKey !== undefined && proof.identityKey !== delta.identityKey) reasonCodes.push('commonjs-runtime-interop-proof-import-edge-mismatch');
+    if (proof.moduleSpecifier !== delta.moduleSpecifier || proof.importedName !== delta.importedName || proof.localName !== delta.localName || proof.importKind !== delta.importKind) reasonCodes.push('commonjs-runtime-interop-proof-import-edge-mismatch');
+    if ((delta.interopHelper || proof.interopHelper) && proof.interopHelper !== delta.interopHelper) reasonCodes.push('commonjs-runtime-interop-proof-helper-identity-mismatch');
+    if ((delta.packageRuntimeCondition || proof.packageRuntimeCondition) && proof.packageRuntimeCondition !== delta.packageRuntimeCondition) reasonCodes.push('commonjs-runtime-interop-proof-package-runtime-condition-mismatch');
+    if ((delta.packageRuntimeConditionEdgeKind || proof.packageRuntimeConditionEdgeKind) && proof.packageRuntimeConditionEdgeKind !== delta.packageRuntimeConditionEdgeKind) reasonCodes.push('commonjs-runtime-interop-proof-package-runtime-condition-mismatch');
+    if (proof.outputTargetSymbolId !== delta.outputTargetSymbolId) reasonCodes.push('commonjs-runtime-interop-proof-resolved-target-symbol-mismatch');
+    if ((delta.exportAssignmentShapeHash || proof.exportAssignmentShapeHash) && proof.exportAssignmentShapeHash !== delta.exportAssignmentShapeHash) reasonCodes.push('commonjs-runtime-interop-proof-export-assignment-shape-hash-mismatch');
+    if (!proof.runtimeTraceHash && !proof.helperTraceHash) reasonCodes.push('commonjs-runtime-interop-proof-trace-hash-missing');
+    if (!proof.evidenceHash) reasonCodes.push('commonjs-runtime-interop-proof-evidence-hash-missing');
+    if (proof.autoMergeClaim !== false || proof.semanticEquivalenceClaim !== false || proof.runtimeEquivalenceClaim !== false || proof.runtimeInteropEquivalenceClaim !== false) reasonCodes.push('commonjs-runtime-interop-proof-claim-flags-missing');
+  }
+  const status = proof && reasonCodes.length === 0 ? 'passed' : proof ? 'failed' : 'missing';
+  return {
+    status,
+    routeId: 'prove-commonjs-runtime-interop-equivalence',
+    routeLane: 'module-runtime-interop',
+    routeNext: 'supply-commonjs-runtime-interop-proof',
+    reasonCodes: uniqueStrings(reasonCodes),
+    record: compactRecord({
+      schema: 'frontier.lang.commonJsRuntimeInteropProofAssessment.v1',
+      status,
+      proofStatus: proof?.status,
+      proofId: proof?.id,
+      proofHash: proof?.proofHash,
+      routeId: 'prove-commonjs-runtime-interop-equivalence',
+      routeLane: 'module-runtime-interop',
+      routeNext: 'supply-commonjs-runtime-interop-proof',
+      reasonCodes: uniqueStrings(reasonCodes),
+      delta,
+      autoMergeClaim: false,
+      semanticEquivalenceClaim: false,
+      runtimeEquivalenceClaim: false,
+      runtimeInteropEquivalenceClaim: false
+    })
+  };
+}
+
+function commonJsRuntimeInteropProofFor(delta, options = {}) {
+  const proofs = [
+    options.commonJsRuntimeInteropProof,
+    ...(Array.isArray(options.commonJsRuntimeInteropProofs) ? options.commonJsRuntimeInteropProofs : [])
+  ].filter(Boolean);
+  return proofs.find((proof) => (
+    proof.identityKey === delta.identityKey
+      || proof.sourcePath === delta.sourcePath
+        && proof.moduleSpecifier === delta.moduleSpecifier
+        && proof.importedName === delta.importedName
+        && proof.localName === delta.localName
+        && proof.importKind === delta.importKind
+  ));
+}
+
+function isDefaultModuleExportsTarget(edge) {
+  return projectImportTargetName(edge) === 'default'
+    && /:export:module_exports$/.test(String(edge?.resolvedTargetSymbolId ?? ''));
+}
+
+function projectImportTargetName(edge) {
+  if (edge?.importKind === 'side-effect' || edge?.importKind === 'namespace') return undefined;
+  const name = edge?.importedName ?? edge?.localName ?? edge?.exportedName;
+  if (!name || name === '*') return undefined;
+  return String(name);
+}
+
+function uniqueStrings(values) {
+  return [...new Set(values.filter((value) => typeof value === 'string' && value.length > 0))];
+}
+
+export { commonJsRuntimeInteropDelta, commonJsRuntimeInteropProofAssessment };

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

@@ -0,0 +1,179 @@
+import { compactRecord } from './js-ts-safe-merge-context.js';
+import { missingDeclarationEmitParityEvidence } from './js-ts-safe-project-merge-declaration-emit-parity.js';
+import { compilerTypeDetails, compilerTypeFingerprint } from './js-ts-safe-project-merge-graph-delta-compiler-details.js';
+import { missingSharedCompilerTypeInferenceSyntaxEvidence } from './js-ts-safe-project-merge-graph-delta-inference-syntax.js';
+
+function publicCompilerTypeDeltaConflicts(baseGraph, workerGraph, headGraph, outputGraph, options = {}) {
+  return changedIdentityConflicts({
+    code: 'project-public-compiler-type-delta-conflict',
+    label: 'public compiler type',
+    baseRecords: publicCompilerTypeRecords(baseGraph.compilerTypeRecords),
+    workerRecords: publicCompilerTypeRecords(workerGraph.compilerTypeRecords),
+    headRecords: publicCompilerTypeRecords(headGraph.compilerTypeRecords),
+    outputRecords: publicCompilerTypeRecords(outputGraph?.compilerTypeRecords),
+    identityKey: compilerTypeIdentityKey,
+    fingerprint: compilerTypeFingerprint,
+    details: compilerTypeDetails,
+    declarationEmitParityProof: options.declarationEmitParityProof, requireDeclarationEmitParity: options.requireDeclarationEmitParity === true || Boolean(options.declarationEmitParityProof)
+  });
+}
+
+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) return [];
+    if (workerFingerprint === headFingerprint) {
+      const missingTypeEvidence = missingSharedCompilerTypeEquivalenceEvidence(workerRecord, headRecord);
+      const missingInferenceSyntaxEvidence = missingSharedCompilerTypeInferenceSyntaxEvidence(workerRecord, headRecord);
+      const missingDeclarationEvidence = missingDeclarationEmitParityEvidence(input.declarationEmitParityProof, input);
+      if (!missingTypeEvidence && !missingInferenceSyntaxEvidence && !missingDeclarationEvidence) return [];
+      const missingEvidence = missingDeclarationEvidence ?? missingTypeEvidence ?? missingInferenceSyntaxEvidence;
+      return [projectGraphDeltaConflict({
+        ...input,
+        identityKey,
+        baseRecord,
+        workerRecord,
+        headRecord,
+        outputRecord: output.get(identityKey),
+        reasonCode: missingEvidence.reasonCode,
+        typeEquivalenceEvidence: missingTypeEvidence,
+        typeInferenceSyntaxEvidence: missingInferenceSyntaxEvidence,
+        declarationEmitParityEvidence: missingDeclarationEvidence,
+        message: `Worker and head both changed ${input.label} ${JSON.stringify(identityKey)} to the same compiler public API fingerprint, but required public API evidence is missing.`
+      })];
+    }
+    return [projectGraphDeltaConflict({ ...input, identityKey, baseRecord, workerRecord, headRecord, outputRecord: output.get(identityKey) })];
+  });
+}
+
+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: input.message ?? `Worker and head both changed ${input.label} ${JSON.stringify(input.identityKey)} in incompatible ways.`,
+    sourcePath,
+    details: compactRecord({
+      reasonCode: input.reasonCode ?? input.code,
+      conflictCode: input.reasonCode ? input.code : undefined,
+      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),
+      typeEquivalenceEvidence: input.typeEquivalenceEvidence,
+      typeInferenceSyntaxEvidence: input.typeInferenceSyntaxEvidence,
+      declarationEmitParityEvidence: input.declarationEmitParityEvidence
+    })
+  };
+}
+
+function publicCompilerTypeRecords(records) { return (records ?? []).filter((record) => record?.publicContract); }
+function compilerTypeIdentityKey(record) { return stableKey(['compiler-public-type', record?.fullyQualifiedName ?? record?.localName ?? record?.symbolName ?? record?.symbolId]); }
+
+function missingSharedCompilerTypeEquivalenceEvidence(workerRecord, headRecord) {
+  const requiringProof = [workerRecord, headRecord].filter(requiresCompilerTypeEquivalenceProof);
+  if (!requiringProof.length) return undefined;
+  const missing = requiringProof.filter((record) => !hasPassedCompilerTypeEquivalenceProof(record));
+  if (!missing.length) return undefined;
+  return {
+    reasonCode: 'typescript-public-api-type-equivalence-proof-missing',
+    requiredEvidence: 'typescript-checker-public-api-type-equivalence',
+    missingRecords: missing.map((record) => compactRecord({
+      sourcePath: record.sourcePath, sourceHash: record.sourceHash,
+      symbolId: record.symbolId,
+      symbolName: record.symbolName,
+      fullyQualifiedName: record.fullyQualifiedName,
+      typeEquivalenceStatus: record.typeEquivalenceStatus,
+      typeEquivalenceReasonCodes: record.typeEquivalenceReasonCodes,
+      propertyCount: record.propertyCount, propertyOptionalCount: record.propertyOptionalCount,
+      propertyReadonlyCount: record.propertyReadonlyCount, indexSignatureCount: record.indexSignatureCount,
+      indexSignatureReadonlyCount: record.indexSignatureReadonlyCount,
+      constructorSignatureCount: record.constructorSignatureCount,
+      classHeritageCount: record.classHeritageCount,
+      assignabilityOracleCount: record.assignabilityOracleCount,
+      assignabilityOracleDirectionCount: record.assignabilityOracleDirectionCount,
+      typeEquivalenceAssignabilityOracleHash: record.typeEquivalenceAssignabilityOracleHash,
+      privateClassMemberCount: record.privateClassMemberCount,
+      accessorFieldCount: record.accessorFieldCount,
+      classPrivateAccessorRuntimeHash: record.classPrivateAccessorRuntimeHash,
+      classPrivateAccessorRuntimeProofStatus: record.classPrivateAccessorRuntimeProof?.status,
+      classPrivateAccessorRuntimeProofSourcePath: record.classPrivateAccessorRuntimeProof?.sourcePath,
+      classPrivateAccessorRuntimeProofSourceHash: record.classPrivateAccessorRuntimeProof?.sourceHash,
+      classPrivateAccessorRuntimeProofReasonCodes: record.classPrivateAccessorRuntimeProofReasonCodes,
+      enumMemberCount: record.enumMemberCount,
+      enumComputedMemberCount: record.enumComputedMemberCount,
+      typeEquivalenceEnumRuntimeShapeHash: record.typeEquivalenceEnumRuntimeShapeHash,
+      typeEquivalenceSignatureSetHash: record.typeEquivalenceSignatureSetHash,
+      typeEquivalenceCallSignatureSetHash: record.typeEquivalenceCallSignatureSetHash, typeEquivalenceConstructSignatureSetHash: record.typeEquivalenceConstructSignatureSetHash,
+      typeEquivalenceTypeParameterSetHash: record.typeEquivalenceTypeParameterSetHash,
+      typeEquivalencePropertySetHash: record.typeEquivalencePropertySetHash,
+      typeEquivalenceConstructorSetHash: record.typeEquivalenceConstructorSetHash,
+      typeEquivalenceClassHeritageHash: record.typeEquivalenceClassHeritageHash,
+      typeEquivalencePrivateClassMemberSetHash: record.typeEquivalencePrivateClassMemberSetHash,
+      typeEquivalenceAccessorFieldSetHash: record.typeEquivalenceAccessorFieldSetHash,
+      typeEquivalenceIndexSignatureSetHash: record.typeEquivalenceIndexSignatureSetHash,
+      typeEquivalenceConditionalTypeSetHash: record.typeEquivalenceConditionalTypeSetHash, typeEquivalenceIndexedAccessTypeSetHash: record.typeEquivalenceIndexedAccessTypeSetHash,
+      typeEquivalenceMappedTypeSetHash: record.typeEquivalenceMappedTypeSetHash, typeEquivalenceKeyofTypeOperatorSetHash: record.typeEquivalenceKeyofTypeOperatorSetHash,
+      typeReferenceTargetCount: record.typeReferenceTargetCount,
+      typeEquivalenceTypeReferenceTargetSetHash: record.typeEquivalenceTypeReferenceTargetSetHash,
+      typeEquivalenceTemplateLiteralTypeSetHash: record.typeEquivalenceTemplateLiteralTypeSetHash, typeEquivalenceInferTypeSetHash: record.typeEquivalenceInferTypeSetHash,
+      typeEquivalenceUnionTypeSetHash: record.typeEquivalenceUnionTypeSetHash, typeEquivalenceIntersectionTypeSetHash: record.typeEquivalenceIntersectionTypeSetHash, typeEquivalenceTupleTypeSetHash: record.typeEquivalenceTupleTypeSetHash,
+      typeEquivalenceProofStatus: record.typeEquivalenceProof?.status, typeEquivalenceProofSourcePath: record.typeEquivalenceProof?.sourcePath, typeEquivalenceProofSourceHash: record.typeEquivalenceProof?.sourceHash,
+      semanticEquivalenceClaim: record.typeEquivalenceProof?.semanticEquivalenceClaim,
+      assignabilityOracle: record.assignabilityOracle,
+      missingSignals: record.typeEquivalenceProof?.missingSignals,
+      unsupportedSignals: record.typeEquivalenceProof?.unsupportedSignals,
+      checkerEvidence: record.typeEquivalenceCheckerEvidence,
+      evidenceIds: record.evidenceIds
+    }))
+  };
+}
+
+function requiresCompilerTypeEquivalenceProof(record) { return Boolean(record && (record.callSignatureCount > 0 || record.constructSignatureCount > 0 || record.overloadSignatureCount > 1 || record.declarationCount > 1 || record.typeParameterCount > 0 || record.propertyCount > 0 || record.indexSignatureCount > 0 || record.constructorSignatureCount > 0 || record.classHeritageCount > 0 || record.assignabilityOracleCount > 0 || record.privateClassMemberCount > 0 || record.accessorFieldCount > 0 || record.enumMemberCount > 0 || record.advancedTypeShapeCount > 0 || record.typeReferenceTargetCount > 0 || record.typeEquivalenceStatus === 'unsupported')); }
+function hasPassedCompilerTypeEquivalenceProof(record) {
+  const requiredHashes = [
+    [record?.callSignatureCount > 0, record?.typeEquivalenceCallSignatureSetHash],
+    [record?.constructSignatureCount > 0, record?.typeEquivalenceConstructSignatureSetHash],
+    [record?.overloadSignatureCount > 1 || record?.declarationCount > 1, record?.typeEquivalenceSignatureSetHash],
+    [record?.typeParameterCount > 0, record?.typeEquivalenceTypeParameterSetHash],
+    [record?.propertyCount > 0, record?.typeEquivalencePropertySetHash],
+    [record?.indexSignatureCount > 0, record?.typeEquivalenceIndexSignatureSetHash],
+    [record?.constructorSignatureCount > 0, record?.typeEquivalenceConstructorSetHash],
+    [record?.classHeritageCount > 0, record?.typeEquivalenceClassHeritageHash],
+    [record?.assignabilityOracleCount > 0, record?.typeEquivalenceAssignabilityOracleHash],
+    [record?.privateClassMemberCount > 0, record?.typeEquivalencePrivateClassMemberSetHash],
+    [record?.accessorFieldCount > 0, record?.typeEquivalenceAccessorFieldSetHash],
+    [record?.enumMemberCount > 0, record?.typeEquivalenceEnumRuntimeShapeHash],
+    [record?.conditionalTypeCount > 0, record?.typeEquivalenceConditionalTypeSetHash],
+    [record?.indexedAccessTypeCount > 0, record?.typeEquivalenceIndexedAccessTypeSetHash],
+    [record?.mappedTypeCount > 0, record?.typeEquivalenceMappedTypeSetHash],
+    [record?.keyofTypeOperatorCount > 0, record?.typeEquivalenceKeyofTypeOperatorSetHash],
+    [record?.typeReferenceTargetCount > 0, record?.typeEquivalenceTypeReferenceTargetSetHash],
+    [record?.templateLiteralTypeCount > 0, record?.typeEquivalenceTemplateLiteralTypeSetHash],
+    [record?.inferTypeCount > 0, record?.typeEquivalenceInferTypeSetHash], [record?.unionTypeCount > 0, record?.typeEquivalenceUnionTypeSetHash],
+    [record?.intersectionTypeCount > 0, record?.typeEquivalenceIntersectionTypeSetHash], [record?.tupleTypeCount > 0, record?.typeEquivalenceTupleTypeSetHash]
+  ];
+  return Boolean(record?.typeEquivalenceStatus === 'compiler-backed-equivalent'
+    && record?.typeEquivalenceProof?.status === 'passed'
+    && requiredHashes.every(([required, hash]) => !required || hash)
+    && record?.apiSignatureHash);
+}
+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 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 uniqueStrings(values) { return [...new Set(values.filter((value) => typeof value === 'string' && value.length > 0))]; }
+export { publicCompilerTypeDeltaConflicts };