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

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

@@ -0,0 +1,161 @@
+import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
+import { compactRecord } from './js-ts-safe-merge-context.js';
+import { projectAdmissionRouteFromExactAdmission } from './js-ts-safe-project-merge-admission-routes.js';
+
+function createExactBranchProjectSemanticEditAdmissionFile(options) {
+  const {
+    fileResult,
+    file,
+    classifications = [],
+    admissionKind,
+    action,
+    operation,
+    summaryKey,
+    evidenceKey,
+    metadataKey,
+    requireOtherBranchUnchanged = true,
+    requireBaseForOtherBranchUnchanged = true,
+    allowDeletedBranchOutput = false,
+    allowExistingExactOutput = false,
+    classificationFilter = () => true,
+    admissionFields = () => ({}),
+    details = (classification) => classification.details
+  } = options;
+  if (!classifications.length || !classifications.every(classificationFilter)) return undefined;
+  const branches = uniqueStrings(classifications.map((classification) => classification.branch));
+  if (branches.length !== 1) return undefined;
+  const branch = branches[0];
+  const admissions = classifications
+    .map((classification) => exactBranchProjectSemanticEditAdmission({
+      fileResult,
+      file,
+      classification,
+      admissionKind,
+      requireOtherBranchUnchanged,
+      requireBaseForOtherBranchUnchanged,
+      allowDeletedBranchOutput,
+      allowExistingExactOutput,
+      admissionFields,
+      details
+    }))
+    .filter(Boolean);
+  if (admissions.length !== classifications.length) return undefined;
+  const branchText = branchSourceText(file, branch);
+  const outputHash = hashProjectSourceText(branchText);
+  return {
+    admissions,
+    fileResult: compactRecord({
+      ...fileResult,
+      status: 'merged',
+      operation: typeof operation === 'function' ? operation(fileResult) : operation,
+      outputSourceText: branchText,
+      outputHash,
+      baseHash: hashProjectSourceText(file.baseSourceText),
+      workerHash: hashProjectSourceText(branchSourceText(file, 'worker')),
+      headHash: hashProjectSourceText(branchSourceText(file, 'head')),
+      result: fileResult.status === 'merged' ? fileResult.result : undefined,
+      semanticArtifacts: fileResult.status === 'merged' ? fileResult.semanticArtifacts : undefined,
+      conflicts: [],
+      admission: exactBranchProjectSemanticEditFileAdmission(action),
+      summary: compactRecord({
+        ...(isPlainObject(fileResult.summary) ? fileResult.summary : {}),
+        conflicts: 0,
+        [summaryKey]: admissions.length,
+        [evidenceKey]: admissions
+      }),
+      metadata: metadataKey ? compactRecord({
+        ...(isPlainObject(fileResult.metadata) ? fileResult.metadata : {}),
+        [metadataKey]: admissions
+      }) : fileResult.metadata
+    })
+  };
+}
+
+function exactBranchProjectSemanticEditAdmission(options) {
+  const { fileResult, file, classification, admissionKind, requireOtherBranchUnchanged, requireBaseForOtherBranchUnchanged, allowDeletedBranchOutput, allowExistingExactOutput, admissionFields, details } = options;
+  const branchText = branchSourceText(file, classification.branch);
+  if (typeof branchText !== 'string' && !allowDeletedBranchOutput) return undefined;
+  const exactMergedOutput = fileResult.status === 'merged' && fileResult.outputSourceText === branchText;
+  if (!exactMergedOutput || !allowExistingExactOutput) {
+    if (requireOtherBranchUnchanged && !otherProjectBranchUnchanged(file, classification.branch, { requireBase: requireBaseForOtherBranchUnchanged })) return undefined;
+  }
+  const outputHash = hashProjectSourceText(branchText);
+  const admission = {
+    id: safeProjectEvidenceId(`${classification.details?.conflictKey ?? classification.code}_${file.sourcePath}`),
+    kind: admissionKind,
+    status: 'passed',
+    branch: classification.branch,
+    ...(admissionFields(classification) ?? {}),
+    sourcePath: file.sourcePath,
+    outputHash,
+    sourceHash: outputHash,
+    summary: `Project ${classification.branch} semantic edit output matched branch ${typeof branchText === 'string' ? 'source' : 'deletion'} for ${file.sourcePath}.`,
+    details: compactRecord({
+      ...(details(classification) ?? {}),
+      sourcePath: file.sourcePath,
+      outputHash,
+      exactBranchOutput: true,
+      deletedOutput: typeof branchText !== 'string' || undefined,
+      autoMergeClaim: false,
+      semanticEquivalenceClaim: false
+    })
+  };
+  return { ...admission, admissionRoute: projectAdmissionRouteFromExactAdmission(admission, { action: options.action }) };
+}
+
+function exactBranchProjectSemanticEditFileAdmission(action) {
+  return {
+    status: 'auto-merge-candidate',
+    action,
+    reviewRequired: false,
+    autoApplyCandidate: true,
+    autoMergeClaim: false,
+    semanticEquivalenceClaim: false,
+    reasonCodes: []
+  };
+}
+
+function summarizeProjectSemanticEditAdmissions(admissions = [], fields = {}) {
+  const unique = uniqueProjectSemanticEditAdmissions(admissions);
+  const summary = { [fields.totalKey ?? 'admissions']: unique.length };
+  for (const field of fields.byKind ?? []) {
+    summary[field.key] = unique.filter((admission) => admission[field.property] === field.value).length;
+  }
+  if (fields.evidenceIdsKey) summary[fields.evidenceIdsKey] = unique.map((admission) => admission.id);
+  return summary;
+}
+
+function uniqueProjectSemanticEditAdmissions(admissions) {
+  const seen = new Set();
+  return admissions.filter((admission) => {
+    const key = admission.details?.conflictKey ?? admission.id;
+    if (!key || seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+
+function branchSourceText(file, branch) {
+  if (branch === 'worker') return file.workerDeleted ? undefined : file.workerSourceText ?? file.baseSourceText;
+  return file.headDeleted ? undefined : file.headSourceText ?? file.baseSourceText;
+}
+
+function otherProjectBranchUnchanged(file, branch, options = {}) {
+  const other = branch === 'worker' ? branchSourceText(file, 'head') : branchSourceText(file, 'worker');
+  return (options.requireBase === false || typeof file.baseSourceText === 'string') && other === file.baseSourceText;
+}
+
+function hashProjectSourceText(text) { return typeof text === 'string' ? hashSemanticValue(text) : undefined; }
+function uniqueStrings(values) { return [...new Set(values.filter((value) => typeof value === 'string' && value.length > 0))]; }
+function isPlainObject(value) { return Boolean(value && typeof value === 'object' && !Array.isArray(value)); }
+function safeProjectEvidenceId(value) { return String(value ?? 'unknown').replace(/[^a-zA-Z0-9]+/g, '_').replace(/^_+|_+$/g, '') || 'evidence'; }
+
+export {
+  branchSourceText,
+  createExactBranchProjectSemanticEditAdmissionFile,
+  hashProjectSourceText,
+  otherProjectBranchUnchanged,
+  safeProjectEvidenceId,
+  summarizeProjectSemanticEditAdmissions,
+  uniqueProjectSemanticEditAdmissions
+};

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

@@ -0,0 +1,110 @@
+import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
+import { compactRecord } from './js-ts-safe-merge-context.js';
+import { globalAugmentationCompatibilityAssessment } from './js-ts-safe-project-merge-global-augmentation-compatibility.js';
+
+const ambientRequiredEvidence = [
+  'typescript-program-symbol-evidence',
+  'declaration-output-gate',
+  'consumer-diagnostics-gate',
+  'global-augmentation-compatibility-evidence'
+];
+
+function maybeBlockAmbientProjectFile(file, context, input = {}) {
+  const changed = changedProjectTexts(file);
+  if (!changed.length) return undefined;
+  const sourceText = changed.map((entry) => entry.sourceText).join('\n');
+  const ambient = ambientReason(file.sourcePath, sourceText);
+  if (!ambient) return undefined;
+  const compatibility = ambient.surface === 'global-augmentation'
+    ? globalAugmentationCompatibilityAssessment({
+      sourcePath: file.sourcePath,
+      sourceHashes: uniqueStrings(changed.map((entry) => hashText(entry.sourceText))),
+      moduleName: 'global',
+      surfaceKind: 'global-augmentation'
+    }, input)
+    : undefined;
+  if (compatibility?.status === 'passed') return undefined;
+  return blockedAmbientFile(file, context, ambient, compatibility);
+}
+
+function changedProjectTexts(file) {
+  const entries = [];
+  if (typeof file.workerSourceText === 'string' && file.workerSourceText !== file.baseSourceText) {
+    entries.push({ branch: 'worker', sourceText: file.workerSourceText });
+  }
+  if (typeof file.headSourceText === 'string' && file.headSourceText !== file.baseSourceText) {
+    entries.push({ branch: 'head', sourceText: file.headSourceText });
+  }
+  if (file.workerDeleted || file.headDeleted) entries.push({ branch: file.workerDeleted ? 'worker' : 'head', sourceText: file.baseSourceText ?? '' });
+  return entries;
+}
+
+function ambientReason(sourcePath, sourceText) {
+  if (/\.d\.[cm]?ts$/i.test(String(sourcePath ?? ''))) {
+    return { code: 'project-ambient-declaration-merge-blocked', operation: 'blocked-ambient-declaration', surface: 'declaration-file' };
+  }
+  if (/\bdeclare\s+global\b|\bdeclare\s+module\s+['"]|\bglobalThis\b/.test(String(sourceText ?? ''))) {
+    return { code: 'project-global-augmentation-merge-blocked', operation: 'blocked-global-augmentation', surface: 'global-augmentation' };
+  }
+  return undefined;
+}
+
+function blockedAmbientFile(file, context, ambient, compatibility = undefined) {
+  const conflict = {
+    code: ambient.code,
+    gateId: 'project-ambient-declaration-classifier',
+    message: `Project ${ambient.surface} changes require TypeScript program, declaration, and consumer diagnostics evidence.`,
+    sourcePath: file.sourcePath,
+    details: compactRecord({
+      reasonCode: ambient.code,
+      conflictKey: `project-ambient#${ambient.surface}#${file.sourcePath}`,
+      sourcePath: file.sourcePath,
+      surface: ambient.surface,
+      baseHash: hashText(file.baseSourceText),
+      workerHash: hashText(file.workerSourceText),
+      headHash: hashText(file.headSourceText),
+      requiredEvidence: ambientRequiredEvidence,
+      routeId: compatibility?.routeId,
+      routeLane: compatibility?.routeLane,
+      routeNext: compatibility?.routeNext,
+      reasonCodes: compatibility?.reasonCodes,
+      globalAugmentationCompatibilityProof: compatibility?.record,
+      autoMergeClaim: false,
+      semanticEquivalenceClaim: false
+    })
+  };
+  return compactRecord({
+    kind: 'frontier.lang.jsTsProjectSafeMergeFile',
+    version: 1,
+    sourcePath: file.sourcePath,
+    language: context.language,
+    status: 'blocked',
+    operation: ambient.operation,
+    baseHash: hashText(file.baseSourceText),
+    workerHash: hashText(file.workerSourceText),
+    headHash: hashText(file.headSourceText),
+    conflicts: [conflict],
+    admission: {
+      status: 'blocked',
+      action: 'human-review',
+      reviewRequired: true,
+      autoApplyCandidate: false,
+      autoMergeClaim: false,
+      semanticEquivalenceClaim: false,
+      reasonCodes: [ambient.code],
+      conflictKeys: [conflict.details.conflictKey]
+    },
+    summary: { conflicts: 1, projectAmbientDeclarationClassification: true },
+    conflictKeys: [conflict.details.conflictKey]
+  });
+}
+
+function hashText(text) {
+  return typeof text === 'string' ? hashSemanticValue(text) : undefined;
+}
+
+function uniqueStrings(values) {
+  return [...new Set(values.filter((value) => typeof value === 'string' && value.length > 0))];
+}
+
+export { maybeBlockAmbientProjectFile };

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

@@ -0,0 +1,85 @@
+import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
+import { compactRecord } from './js-ts-safe-merge-context.js';
+
+function syntheticFile(file, context, sourceText, operation) {
+  return compactRecord({
+    kind: 'frontier.lang.jsTsProjectSafeMergeFile',
+    version: 1,
+    sourcePath: file.sourcePath,
+    language: context.language,
+    status: 'merged',
+    operation,
+    outputSourceText: sourceText,
+    outputHash: hashText(sourceText),
+    baseHash: hashText(file.baseSourceText),
+    workerHash: hashText(file.workerSourceText),
+    headHash: hashText(file.headSourceText),
+    conflicts: [],
+    admission: admittedSyntheticAdmission(operation),
+    summary: { conflicts: 0, synthetic: true },
+    conflictKeys: [`source#${file.sourcePath}`]
+  });
+}
+
+function blockedFile(file, context, reasonCode) {
+  const conflict = {
+    code: reasonCode,
+    gateId: 'project-file-presence',
+    message: `Project file cannot be safely merged: ${reasonCode}.`,
+    sourcePath: file.sourcePath,
+    details: { sourcePath: file.sourcePath }
+  };
+  return compactRecord({
+    kind: 'frontier.lang.jsTsProjectSafeMergeFile',
+    version: 1,
+    sourcePath: file.sourcePath,
+    language: context.language,
+    status: 'blocked',
+    operation: 'blocked-file-presence',
+    conflicts: [conflict],
+    admission: blockedAdmission(reasonCode),
+    summary: { conflicts: 1, synthetic: true },
+    conflictKeys: [`source#${file.sourcePath ?? 'unknown'}`]
+  });
+}
+
+function policyForFile(input, sourcePath) {
+  if (input.policyByPath?.[sourcePath]) return input.policyByPath[sourcePath];
+  if (input.mergePolicyByPath?.[sourcePath]) return input.mergePolicyByPath[sourcePath];
+  return input.policy ?? input.mergePolicy;
+}
+
+function sourceLedgersForFile(input, sourcePath) {
+  const byPath = input.sourceLedgersByPath?.[sourcePath] ?? input.sourceLedgers?.[sourcePath];
+  return byPath ?? (input.sourceLedgers?.base || input.sourceLedgers?.worker || input.sourceLedgers?.head ? input.sourceLedgers : undefined);
+}
+
+function admittedSyntheticAdmission(operation) {
+  return {
+    status: 'auto-merge-candidate',
+    action: operation === 'head-only' ? 'preserve-head' : 'apply',
+    reviewRequired: false,
+    autoApplyCandidate: true,
+    autoMergeClaim: false,
+    semanticEquivalenceClaim: false,
+    reasonCodes: []
+  };
+}
+
+function blockedAdmission(reasonCode) {
+  return {
+    status: 'blocked',
+    action: 'human-review',
+    reviewRequired: true,
+    autoApplyCandidate: false,
+    autoMergeClaim: false,
+    semanticEquivalenceClaim: false,
+    reasonCodes: [reasonCode]
+  };
+}
+
+function hashText(text) { return typeof text === 'string' ? hashSemanticValue(text) : undefined; }
+function safeId(value) { return String(value ?? 'unknown').replace(/[^a-zA-Z0-9]+/g, '_').replace(/^_+|_+$/g, '') || 'file'; }
+function uniqueStrings(values) { return [...new Set(values.filter((value) => typeof value === 'string' && value.length > 0))]; }
+
+export { blockedFile, hashText, policyForFile, safeId, sourceLedgersForFile, syntheticFile, uniqueStrings };

package/dist/js-ts-safe-project-merge-css-module-conflicts.js

@@ -0,0 +1,60 @@
+import { compactRecord } from './js-ts-safe-merge-context.js';
+
+function cssModuleUseSiteBlockerConflicts(blockers = []) {
+  return blockers.map(cssModuleUseSiteBlockerConflict);
+}
+
+function cssModuleUseSiteBlockerConflict(blocker) {
+  const reasonCode = blocker.reasonCode ?? 'css-module-use-site-proof-blocked';
+  return {
+    code: 'project-css-module-use-site-proof-blocked',
+    gateId: 'project-css-module-use-site-graph',
+    message: `Output project graph has unproved CSS Module use-site evidence: ${reasonCode}.`,
+    sourcePath: blocker.sourcePath,
+    details: compactRecord({
+      reasonCode,
+      conflictKey: cssModuleUseSiteBlockerConflictKey(blocker),
+      sourcePath: blocker.sourcePath,
+      sourceSpan: blocker.sourceSpan,
+      moduleSpecifier: blocker.moduleSpecifier,
+      localName: blocker.localName,
+      cssModuleImportBindingId: blocker.cssModuleImportBindingId,
+      cssModuleSourcePath: blocker.cssModuleSourcePath,
+      expressionText: blocker.expressionText,
+      writeOperation: blocker.writeOperation,
+      jsxPropRecordId: blocker.jsxPropRecordId,
+      failClosed: blocker.failClosed === true,
+      semanticEquivalenceClaim: blocker.semanticEquivalenceClaim === true
+    })
+  };
+}
+
+function cssModuleUseSiteBlockerConflictKey(blocker) {
+  return [
+    'css-module-use-site',
+    blocker.cssModuleSourcePath ?? blocker.moduleSpecifier ?? 'unknown-module',
+    blocker.sourcePath ?? 'unknown-source',
+    blocker.localName ?? 'unknown-local',
+    blocker.reasonCode ?? 'unknown-reason',
+    spanKey(blocker.sourceSpan),
+    blocker.expressionText
+  ].map((part) => String(part ?? '')).join('#');
+}
+
+function isResolvedCssModuleImportEdge(edge) {
+  return isCssModulePath(edge?.resolvedModulePath ?? edge?.moduleSpecifier)
+    && Boolean(edge?.targetDocumentId)
+    && typeof edge?.resolutionKind === 'string'
+    && edge.resolutionKind.endsWith('-source');
+}
+
+function isCssModulePath(path) {
+  return /\.module\.css(?:[?#].*)?$/i.test(String(path ?? ''));
+}
+
+function spanKey(span) {
+  if (!span) return '';
+  return [span.path, span.start, span.end].map((part) => String(part ?? '')).join(':');
+}
+
+export { cssModuleUseSiteBlockerConflicts, isResolvedCssModuleImportEdge };

package/dist/js-ts-safe-project-merge-declaration-emit-parity.js

@@ -0,0 +1,186 @@
+import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
+import { compactRecord, uniqueStrings } from './js-ts-safe-merge-context.js';
+import { createJsTsProjectMergeDeclarationGate } from './js-ts-safe-project-merge-declarations.js';
+
+const DeclarationEmitParityKind = 'typescript-checker-public-api-declaration-emit-parity';
+const DeclarationEmitParityProofLevel = 'typescript-checker-public-api-declaration-output-boundary';
+
+function createJsTsProjectMergeDeclarationEmitParityProof(input = {}, files = [], outputFiles = [], id = 'js_ts_project_safe_merge') {
+  const suppliedProof = input.declarationEmitParityProof ?? input.outputDeclarationEmitParityProof;
+  if (suppliedProof) return normalizeDeclarationEmitParityProof(suppliedProof, id);
+  if (!shouldCreateDeclarationEmitParityProof(input)) return undefined;
+  const stageFiles = declarationParityStageFiles(files, outputFiles, input);
+  const gateInput = declarationParityGateInput(input);
+  const gates = Object.fromEntries(Object.entries(stageFiles).map(([stage, stageOutputFiles]) => [
+    stage,
+    createJsTsProjectMergeDeclarationGate(gateInput, stageOutputFiles, `${id}_${stage}`)
+  ]));
+  return declarationEmitParityProof(input, id, gates);
+}
+
+function shouldCreateDeclarationEmitParityProof(input) {
+  return input.includeDeclarationOutput === true
+    || input.requireDeclarationOutput === true
+    || input.requirePublicApiDeclarationEmitParity === true;
+}
+
+function declarationParityStageFiles(files, outputFiles, input) {
+  return {
+    worker: files.map((file) => stageFile(file, workerStageSourceText(file), input)).filter(Boolean),
+    head: files.map((file) => stageFile(file, headStageSourceText(file), input)).filter(Boolean),
+    output: outputFiles
+  };
+}
+
+function declarationParityGateInput(input) {
+  return {
+    ...input,
+    includeDeclarationOutput: true,
+    requireDeclarationOutput: true,
+    outputDeclarations: undefined,
+    outputDeclarationFiles: undefined
+  };
+}
+
+function declarationEmitParityProof(input, id, gates) {
+  const boundaries = Object.fromEntries(Object.entries(gates).map(([stage, gate]) => [stage, declarationBoundary(gate)]));
+  const reasonCodes = declarationEmitParityReasonCodes(gates, boundaries);
+  const status = reasonCodes.length ? 'failed' : 'passed';
+  const outputFiles = boundaries.output?.files ?? [];
+  const core = {
+    kind: DeclarationEmitParityKind,
+    version: 1,
+    schema: 'frontier.lang.typescriptDeclarationEmitParityProof.v1',
+    id: `${id}_declaration_emit_parity`,
+    status,
+    proofLevel: DeclarationEmitParityProofLevel,
+    workerDeclarationBoundaryHash: boundaries.worker?.hash,
+    headDeclarationBoundaryHash: boundaries.head?.hash,
+    outputDeclarationBoundaryHash: boundaries.output?.hash,
+    declarationFileCount: outputFiles.length,
+    declarationFiles: outputFiles,
+    compilerOptionsHash: compilerOptionsHash(input),
+    diagnosticsHash: diagnosticsHash(gates),
+    missingSignals: reasonCodes,
+    reasonCodes,
+    autoMergeClaim: false,
+    semanticEquivalenceClaim: false
+  };
+  return { ...compactRecord(core), hash: hashSemanticValue(core) };
+}
+
+function declarationEmitParityReasonCodes(gates, boundaries) {
+  const reasonCodes = [];
+  for (const [stage, gate] of Object.entries(gates)) {
+    if (!gate) reasonCodes.push(`typescript-public-api-declaration-emit-${stage}-missing`);
+    if (gate?.status !== 'passed') reasonCodes.push(stage === 'output'
+      ? 'typescript-public-api-declaration-emit-output-missing'
+      : 'typescript-public-api-declaration-emit-proof-missing');
+    if ((gate?.diagnostics ?? []).some((diagnostic) => diagnostic.severity === 'error')) {
+      reasonCodes.push('typescript-public-api-declaration-emit-diagnostics-blocked');
+    }
+  }
+  if (!boundaries.worker?.hash || !boundaries.head?.hash || !boundaries.output?.hash) {
+    reasonCodes.push('typescript-compiler-declaration-output-public-boundary-hash-missing');
+  } else if (boundaries.worker.hash !== boundaries.head.hash || boundaries.worker.hash !== boundaries.output.hash) {
+    reasonCodes.push('typescript-public-api-declaration-emit-parity-mismatch');
+  }
+  return uniqueStrings(reasonCodes);
+}
+
+function declarationBoundary(gate) {
+  if (!gate || gate.status !== 'passed') return undefined;
+  const files = [...(gate.declarationFiles ?? [])]
+    .map((file) => compactRecord({
+      sourcePath: file.sourcePath,
+      sourceHash: file.sourceHash,
+      bytes: file.bytes,
+      source: file.source
+    }))
+    .sort((a, b) => String(a.sourcePath).localeCompare(String(b.sourcePath)));
+  return {
+    files,
+    hash: hashSemanticValue({ kind: 'frontier.lang.typescriptDeclarationBoundary', files })
+  };
+}
+
+function missingDeclarationEmitParityEvidence(proof, options = {}) {
+  if (options.requireDeclarationEmitParity !== true) return undefined;
+  if (!proof) {
+    return {
+      reasonCode: 'typescript-public-api-declaration-emit-proof-missing',
+      requiredEvidence: DeclarationEmitParityKind,
+      proofLevel: DeclarationEmitParityProofLevel,
+      missingSignals: ['typescript-public-api-declaration-emit-proof-missing']
+    };
+  }
+  if (proof.status === 'passed') return undefined;
+  const missingSignals = uniqueStrings(proof.reasonCodes ?? proof.missingSignals ?? ['typescript-public-api-declaration-emit-parity-mismatch']);
+  return compactRecord({
+    reasonCode: missingSignals[0],
+    requiredEvidence: DeclarationEmitParityKind,
+    proofLevel: DeclarationEmitParityProofLevel,
+    status: proof.status,
+    missingSignals,
+    workerDeclarationBoundaryHash: proof.workerDeclarationBoundaryHash,
+    headDeclarationBoundaryHash: proof.headDeclarationBoundaryHash,
+    outputDeclarationBoundaryHash: proof.outputDeclarationBoundaryHash,
+    declarationFileCount: proof.declarationFileCount,
+    compilerOptionsHash: proof.compilerOptionsHash,
+    diagnosticsHash: proof.diagnosticsHash,
+    autoMergeClaim: false,
+    semanticEquivalenceClaim: false
+  });
+}
+
+function normalizeDeclarationEmitParityProof(proof, id) {
+  const core = compactRecord({
+    ...proof,
+    kind: proof.kind ?? DeclarationEmitParityKind,
+    version: proof.version ?? 1,
+    id: proof.id ?? `${id}_declaration_emit_parity`,
+    proofLevel: proof.proofLevel ?? DeclarationEmitParityProofLevel,
+    status: proof.status ?? 'failed',
+    reasonCodes: uniqueStrings(proof.reasonCodes ?? proof.missingSignals ?? []),
+    missingSignals: uniqueStrings(proof.missingSignals ?? proof.reasonCodes ?? []),
+    autoMergeClaim: false,
+    semanticEquivalenceClaim: false
+  });
+  return { ...core, hash: proof.hash ?? hashSemanticValue(core) };
+}
+
+function workerStageSourceText(file) {
+  if (file.workerDeleted) return undefined;
+  return file.workerSourceText ?? file.baseSourceText;
+}
+
+function headStageSourceText(file) {
+  if (file.headDeleted) return undefined;
+  return file.headSourceText ?? file.baseSourceText;
+}
+
+function stageFile(file, sourceText, input) {
+  if (typeof sourceText !== 'string' || !file.sourcePath) return undefined;
+  return compactRecord({ sourcePath: file.sourcePath, language: file.language ?? input.language, sourceText });
+}
+
+function compilerOptionsHash(input) {
+  return hashSemanticValue({
+    compilerOptions: input.compilerOptions,
+    typescriptCompilerOptions: input.typescriptCompilerOptions,
+    declarationCompilerOptions: input.declarationCompilerOptions,
+    typescriptDeclarationCompilerOptions: input.typescriptDeclarationCompilerOptions,
+    tsconfig: input.tsconfig,
+    moduleResolution: input.moduleResolution,
+    projectReferences: input.projectReferences ?? input.typescriptProjectReferences ?? input.tsconfigProjectReferences
+  });
+}
+
+function diagnosticsHash(gates) {
+  return hashSemanticValue(Object.fromEntries(Object.entries(gates).map(([stage, gate]) => [stage, gate?.diagnostics ?? []])));
+}
+
+export {
+  createJsTsProjectMergeDeclarationEmitParityProof,
+  missingDeclarationEmitParityEvidence
+};