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

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

@@ -0,0 +1,283 @@
+import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
+import { compactRecord, uniqueStrings } from './js-ts-safe-merge-context.js';
+import { diagnosticsGateMetadata } from './js-ts-safe-project-merge-diagnostics-metadata.js';
+import { collectTypeScriptDiagnostics } from './js-ts-safe-project-merge-diagnostics-ts.js';
+import {
+  collectJsxComponentPropContractsFromFileResults,
+  jsxComponentPropContractConflict,
+  jsxComponentPropContractEvidence,
+  jsxComponentPropContractSummary,
+  matchingJsxComponentPropContracts,
+  normalizeJsxComponentPropContracts
+} from './js-ts-safe-project-merge-jsx-prop-contracts.js';
+import {
+  describeJsTsProjectCompilerInputs,
+  normalizeSuppliedDiagnostics
+} from './js-ts-safe-project-merge-ts-program.js';
+
+const projectOutputDiagnosticCode = 'project-output-diagnostic';
+const projectOutputSyntaxDiagnosticCode = 'project-output-syntax-diagnostic';
+const projectOutputDiagnosticsUnavailableCode = 'project-output-diagnostics-unavailable';
+const projectOutputSyntaxDiagnosticsUnavailableCode = 'project-output-syntax-diagnostics-unavailable';
+
+function createJsTsProjectMergeDiagnosticsGate(input = {}, outputFiles = [], id = 'js_ts_project_safe_merge', context = {}) {
+  const jsxComponentPropContracts = normalizeJsxComponentPropContracts(
+    input.jsxComponentPropContracts
+      ?? input.jsxComponentPropContractCandidates
+      ?? context.jsxComponentPropContracts
+      ?? collectJsxComponentPropContractsFromFileResults(context.fileResults)
+  );
+  const suppliedDiagnostics = normalizeSuppliedOutputDiagnostics(input);
+  const diagnosticsResult = suppliedDiagnostics !== undefined
+    ? suppliedDiagnosticsResult(input, suppliedDiagnostics)
+    : collectTypeScriptDiagnostics(input, outputFiles);
+  const diagnostics = diagnosticsResult?.diagnostics;
+  const metadata = diagnosticsGateMetadata(input, diagnosticsResult);
+  const syntaxOnly = requiresOutputSyntaxDiagnostics(input) && input.requireOutputDiagnostics !== true && input.outputDiagnostics === undefined;
+  if (!diagnostics && input.requireOutputDiagnostics !== true && !requiresOutputSyntaxDiagnostics(input) && !jsxComponentPropContracts.length) return undefined;
+  if (!diagnostics) return unavailableGate(input, id, syntaxOnly, metadata, outputFiles, jsxComponentPropContracts);
+  const errorDiagnostics = diagnostics.filter((diagnostic) => (
+    diagnostic.severity === 'error' && (!syntaxOnly || isSyntaxDiagnostic(diagnostic))
+  ));
+  const conflicts = errorDiagnostics.map((diagnostic) => diagnosticConflict(input, diagnostic, jsxComponentPropContracts));
+  const status = conflicts.length ? 'blocked' : 'passed';
+  const core = {
+    kind: 'frontier.lang.jsTsProjectMergeDiagnosticsGate',
+    version: 1,
+    schema: 'frontier.lang.jsTsProjectMergeDiagnosticsGate.v1',
+    id: `${id}_output_diagnostics`,
+    status,
+    sourcePaths: outputFiles.map((file) => file.sourcePath).filter(Boolean),
+    diagnostics,
+    conflicts,
+    admission: {
+      status: status === 'passed' ? 'auto-merge-candidate' : 'blocked',
+      action: status === 'passed' ? 'accept-diagnostics' : 'human-review',
+      reviewRequired: status !== 'passed',
+      autoApplyCandidate: status === 'passed',
+      autoMergeClaim: false,
+      semanticEquivalenceClaim: false,
+      reasonCodes: uniqueStrings(conflicts.map((conflict) => conflict.code))
+    },
+    summary: diagnosticsSummary(diagnostics, conflicts, jsxComponentPropContracts),
+    metadata,
+    evidence: [{
+      id: `${id}_output_diagnostics_evidence`,
+      kind: 'js-ts-project-output-diagnostics',
+      status: status === 'passed' ? 'passed' : 'failed',
+      summary: status === 'passed'
+        ? `Validated ${outputFiles.length} JS/TS output file(s) with no blocking diagnostics.`
+        : `Blocked JS/TS project merge on ${conflicts.length} output diagnostic conflict(s).`,
+      metadata: {
+        diagnostics: diagnostics.length,
+        conflicts: conflicts.length,
+        diagnosticSource: metadata.diagnosticSource,
+        compilerOptions: metadata.compilerOptions,
+        compilerOptionSources: metadata.compilerOptionSources,
+        projectReferences: metadata.projectReferences,
+        projectReferenceCount: metadata.projectReferenceCount,
+        jsxComponentPropContractCandidates: jsxComponentPropContracts.length || undefined,
+        syntaxOnly,
+        autoMergeClaim: false,
+        semanticEquivalenceClaim: false
+      }
+    }, ...jsxComponentPropContractEvidence(id, status, diagnostics, conflicts, metadata.diagnosticSource, jsxComponentPropContracts)]
+  };
+  return { ...core, hash: hashSemanticValue(core) };
+}
+
+function suppliedDiagnosticsResult(input, diagnostics) {
+  return {
+    diagnostics,
+    metadata: {
+      ...describeJsTsProjectCompilerInputs(input),
+      diagnosticSource: diagnosticSource(input),
+      hasTypescriptCompilerApi: Boolean(input.typescript ?? input.ts ?? input.typescriptModule)
+    }
+  };
+}
+
+function unavailableGate(input, id, syntaxOnly = false, metadata = {}, outputFiles = [], jsxComponentPropContracts = []) {
+  const code = syntaxOnly ? projectOutputSyntaxDiagnosticsUnavailableCode : projectOutputDiagnosticsUnavailableCode;
+  const diagnosticConflict = {
+    code,
+    gateId: 'project-output-diagnostics',
+    message: syntaxOnly
+      ? 'Project output syntax diagnostics are required but no TypeScript compiler API or supplied syntax diagnostics were provided.'
+      : 'Project output diagnostics are required but no TypeScript compiler API or supplied diagnostics were provided.',
+    details: { required: input.requireOutputDiagnostics === true, syntaxRequired: requiresOutputSyntaxDiagnostics(input) }
+  };
+  const conflicts = [
+    ...(input.requireOutputDiagnostics === true || requiresOutputSyntaxDiagnostics(input) ? [diagnosticConflict] : []),
+    ...(jsxComponentPropContracts.length ? [jsxComponentPropContractConflict(jsxComponentPropContracts)] : [])
+  ];
+  const gateConflicts = conflicts.length ? conflicts : [diagnosticConflict];
+  const core = {
+    kind: 'frontier.lang.jsTsProjectMergeDiagnosticsGate',
+    version: 1,
+    schema: 'frontier.lang.jsTsProjectMergeDiagnosticsGate.v1',
+    id: `${id}_output_diagnostics`,
+    status: 'blocked',
+    sourcePaths: outputFiles.map((file) => file.sourcePath).filter(Boolean),
+    diagnostics: [],
+    conflicts: gateConflicts,
+    admission: {
+      status: 'blocked',
+      action: 'human-review',
+      reviewRequired: true,
+      autoApplyCandidate: false,
+      autoMergeClaim: false,
+      semanticEquivalenceClaim: false,
+      reasonCodes: uniqueStrings(gateConflicts.map((conflict) => conflict.code))
+    },
+    summary: diagnosticsSummary([], gateConflicts, jsxComponentPropContracts),
+    metadata,
+    evidence: [{
+      id: `${id}_output_diagnostics_evidence`,
+      kind: 'js-ts-project-output-diagnostics',
+      status: 'failed',
+      summary: gateConflicts.map((conflict) => conflict.message).join(' '),
+      metadata: {
+        diagnostics: 0,
+        conflicts: gateConflicts.length,
+        diagnosticSource: 'missing',
+        compilerOptions: metadata.compilerOptions,
+        compilerOptionSources: metadata.compilerOptionSources,
+        projectReferences: metadata.projectReferences,
+        projectReferenceCount: metadata.projectReferenceCount,
+        jsxComponentPropContractCandidates: jsxComponentPropContracts.length || undefined,
+        syntaxOnly
+      }
+    }, ...jsxComponentPropContractEvidence(id, 'blocked', [], gateConflicts, 'missing', jsxComponentPropContracts)]
+  };
+  return { ...core, hash: hashSemanticValue(core) };
+}
+
+function diagnosticConflict(input, diagnostic, jsxComponentPropContracts = []) {
+  const syntax = isSyntaxDiagnostic(diagnostic);
+  const matchingContracts = matchingJsxComponentPropContracts(diagnostic, jsxComponentPropContracts);
+  return compactRecord({
+    code: syntax ? projectOutputSyntaxDiagnosticCode : projectOutputDiagnosticCode,
+    gateId: 'project-output-diagnostics',
+    message: `${syntax ? 'Project output syntax diagnostic' : 'Project output diagnostic'} ${diagnostic.code}: ${diagnostic.message}`,
+    sourcePath: diagnostic.sourcePath,
+    details: {
+      diagnostic,
+      syntax,
+      projectRoot: input.projectRoot,
+      jsxComponentPropContracts: matchingContracts.length ? matchingContracts : undefined
+    }
+  });
+}
+
+function diagnosticsSummary(diagnostics, conflicts, jsxComponentPropContracts = []) {
+  const bySeverity = {};
+  const bySource = {};
+  const byPhase = {};
+  for (const diagnostic of diagnostics) {
+    bySeverity[diagnostic.severity] = (bySeverity[diagnostic.severity] ?? 0) + 1;
+    bySource[diagnostic.source ?? 'unknown'] = (bySource[diagnostic.source ?? 'unknown'] ?? 0) + 1;
+    byPhase[diagnostic.phase ?? 'unknown'] = (byPhase[diagnostic.phase ?? 'unknown'] ?? 0) + 1;
+  }
+  return {
+    diagnostics: diagnostics.length,
+    conflicts: conflicts.length,
+    errors: diagnostics.filter((diagnostic) => diagnostic.severity === 'error').length,
+    warnings: diagnostics.filter((diagnostic) => diagnostic.severity === 'warning').length,
+    syntaxErrors: diagnostics.filter((diagnostic) => diagnostic.severity === 'error' && isSyntaxDiagnostic(diagnostic)).length,
+    bySeverity,
+    bySource,
+    byPhase,
+    ...jsxComponentPropContractSummary(jsxComponentPropContracts)
+  };
+}
+
+function normalizeSuppliedOutputDiagnostics(input) {
+  const hasOutputDiagnostics = Object.hasOwn(input, 'outputDiagnostics');
+  const hasOutputSyntaxDiagnostics = Object.hasOwn(input, 'outputSyntaxDiagnostics')
+    || Object.hasOwn(input, 'mergedOutputSyntaxDiagnostics')
+    || input.syntaxDiagnostics?.output !== undefined
+    || input.syntaxDiagnostics?.merged !== undefined;
+  if (!hasOutputDiagnostics && !hasOutputSyntaxDiagnostics) return undefined;
+  return [
+    ...normalizeSuppliedDiagnosticsWithPhase(input.outputDiagnostics, undefined),
+    ...normalizeSuppliedDiagnosticsWithPhase(input.outputSyntaxDiagnostics, 'syntax'),
+    ...normalizeSuppliedDiagnosticsWithPhase(input.mergedOutputSyntaxDiagnostics, 'syntax'),
+    ...normalizeSuppliedDiagnosticsWithPhase(input.syntaxDiagnostics?.output, 'syntax'),
+    ...normalizeSuppliedDiagnosticsWithPhase(input.syntaxDiagnostics?.merged, 'syntax')
+  ];
+}
+
+function normalizeSuppliedDiagnosticsWithPhase(value, fallbackPhase) {
+  if (value === undefined) return [];
+  const rawDiagnostics = Array.isArray(value) ? value : [value].filter(Boolean);
+  const normalized = normalizeSuppliedDiagnostics(value);
+  return normalized.map((diagnostic, index) => withDiagnosticPhase(diagnostic, suppliedDiagnosticPhase(rawDiagnostics[index], fallbackPhase)));
+}
+
+function withDiagnosticPhase(diagnostic, phase) {
+  const normalizedPhase = normalizeDiagnosticPhase(phase);
+  const syntax = diagnostic.syntax === true || normalizedPhase === 'syntax' || isSyntaxDiagnostic(diagnostic);
+  return compactRecord({
+    ...diagnostic,
+    phase: normalizedPhase,
+    syntax: syntax ? true : undefined
+  });
+}
+
+function suppliedDiagnosticPhase(diagnostic, fallbackPhase) {
+  return diagnostic?.phase
+    ?? diagnostic?.diagnosticPhase
+    ?? diagnostic?.kind
+    ?? diagnostic?.type
+    ?? (diagnostic?.syntax === true ? 'syntax' : undefined)
+    ?? fallbackPhase;
+}
+
+function requiresOutputSyntaxDiagnostics(input) {
+  return input.requireOutputSyntaxDiagnostics === true
+    || input.requireOutputSyntaxGate === true
+    || input.requireMergedOutputSyntaxDiagnostics === true
+    || input.requireSyntaxGate === true;
+}
+
+function isSyntaxDiagnostic(diagnostic) {
+  if (diagnostic.syntax === true) return true;
+  const text = [
+    diagnostic.phase,
+    diagnostic.kind,
+    diagnostic.category,
+    diagnostic.type,
+    diagnostic.source,
+    diagnostic.ruleId,
+    diagnostic.name,
+    diagnostic.code
+  ].filter(Boolean).join(' ').toLowerCase();
+  return /\bsyntax\b|\bsyntactic\b|\bparse\b|\bparser\b/.test(text) || isTypeScriptSyntaxDiagnosticCode(diagnostic.code);
+}
+
+function isTypeScriptSyntaxDiagnosticCode(code) {
+  const match = /^TS(\d+)$/.exec(String(code ?? ''));
+  if (!match) return false;
+  const numeric = Number(match[1]);
+  return numeric >= 1000 && numeric < 2000;
+}
+
+function normalizeDiagnosticPhase(value) {
+  if (typeof value !== 'string') return undefined;
+  const lowered = value.toLowerCase();
+  if (lowered.includes('syntax') || lowered.includes('syntactic') || lowered.includes('parse')) return 'syntax';
+  if (lowered.includes('semantic') || lowered.includes('type')) return 'semantic';
+  return value;
+}
+
+function diagnosticSource(input) {
+  if (input.outputDiagnostics !== undefined && (input.outputSyntaxDiagnostics !== undefined || input.mergedOutputSyntaxDiagnostics !== undefined)) {
+    return 'supplied-mixed';
+  }
+  if (input.outputDiagnostics !== undefined) return 'supplied';
+  if (input.outputSyntaxDiagnostics !== undefined || input.mergedOutputSyntaxDiagnostics !== undefined || input.syntaxDiagnostics) return 'supplied-syntax';
+  return 'typescript-compiler-api';
+}
+
+export { createJsTsProjectMergeDiagnosticsGate };

package/dist/js-ts-safe-project-merge-evidence-routing.js

@@ -0,0 +1,38 @@
+function failedEvidenceMissingItems(evidence = []) {
+  return evidence
+    .filter((record) => record?.status === 'failed' && isPlainObject(record.metadata?.nextMissingEvidence))
+    .map((record) => {
+      const nextMissingEvidence = record.metadata.nextMissingEvidence;
+      const route = nextMissingEvidence.route;
+      return compactRecord({
+        ...nextMissingEvidence,
+        status: nextMissingEvidence.status ?? 'missing-or-failed',
+        evidenceId: record.id,
+        routeId: nextMissingEvidence.routeId ?? route?.id,
+        routeLane: nextMissingEvidence.routeLane ?? route?.lane,
+        routeNext: nextMissingEvidence.routeNext ?? route?.next,
+        autoMergeClaim: false,
+        semanticEquivalenceClaim: false
+      });
+    });
+}
+
+function fileAdmissionEvidenceRecords(files = []) {
+  return files.flatMap((file) => [
+    ...recordArraysWithSuffix(file.summary, 'AdmissionEvidence'),
+    ...recordArraysWithSuffix(file.metadata, 'Admissions')
+  ]);
+}
+
+function recordArraysWithSuffix(record, suffix) {
+  if (!isPlainObject(record)) return [];
+  return Object.entries(record)
+    .filter(([key, value]) => key.endsWith(suffix) && Array.isArray(value))
+    .flatMap(([, value]) => value)
+    .filter((value) => value?.kind && value?.id);
+}
+
+function isPlainObject(value) { return Boolean(value && typeof value === 'object' && !Array.isArray(value)); }
+function compactRecord(record) { return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== undefined)); }
+
+export { failedEvidenceMissingItems, fileAdmissionEvidenceRecords };

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;