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

package/dist/js-ts-safe-project-merge-semantic-replay-proof.js

@@ -0,0 +1,311 @@
+import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
+import {
+  semanticReplayCurrentHeadCommutationProofRoute,
+  semanticReplayMissingSignal,
+  semanticReplayNextAction,
+  semanticReplayNextMissingEvidence
+} from './js-ts-safe-project-merge-semantic-replay-routes.js';
+
+function semanticEditReplayCleanEvidence(id, fileResults, level) {
+  const facts = fileResults
+    .map(semanticReplayFact)
+    .filter((fact) => fact.semanticArtifacts && fact.changedOrBlocked);
+  const failed = facts.filter((fact) => fact.status === 'failed');
+  const missing = facts.filter((fact) => fact.status === 'missing');
+  const stale = facts.filter((fact) => fact.sourceBindingStatus === 'stale');
+  const status = failed.length ? 'failed' : missing.length ? 'skipped' : facts.length ? 'passed' : 'skipped';
+  const boundedAdmissionRoutes = facts
+    .map((fact) => boundedCurrentHeadRouteForFact(fact, level))
+    .filter(Boolean);
+  const boundedAdmissionRoute = status === 'passed' && boundedAdmissionRoutes.length === facts.length
+    ? boundedCurrentHeadAggregateRoute(boundedAdmissionRoutes, level)
+    : undefined;
+  const missingSignal = semanticReplayMissingSignal(status, facts, failed, stale);
+  const nextMissingEvidence = missingSignal ? semanticReplayNextMissingEvidence({
+    status,
+    level,
+    failed,
+    missing,
+    stale,
+    missingSignal
+  }) : undefined;
+  return evidenceRecord({
+    id,
+    suffix: 'semantic_edit_replay_clean',
+    level,
+    status,
+    scope: 'source-files',
+    summary: semanticReplaySummary(status, facts, failed, missing),
+    metadata: {
+      semanticArtifactFiles: facts.length,
+      replayIds: uniqueStrings(facts.map((fact) => fact.replayId)),
+      replayStatuses: uniqueStrings(facts.map((fact) => fact.replayStatus)),
+      replayDiagnosticCategories: uniqueStrings(facts.flatMap((fact) => fact.diagnosticCategories)),
+      reasonCodes: uniqueStrings(facts.flatMap((fact) => fact.reasonCodes)),
+      conflictKeys: uniqueStrings(facts.map((fact) => fact.conflictKey)),
+      sourcePaths: uniqueStrings(facts.map((fact) => fact.sourcePath)),
+      outputBindingStatuses: uniqueStrings(facts.map((fact) => fact.outputBindingStatus)),
+      expectedOutputHashes: uniqueStrings(facts.map((fact) => fact.expectedOutputHash)),
+      projectionOutputHashes: uniqueStrings(facts.map((fact) => fact.projectionOutputHash)),
+      replayOutputHashes: uniqueStrings(facts.map((fact) => fact.replayOutputHash)),
+      outputBindingFailures: facts.filter((fact) => fact.outputBindingStatus === 'failed').length,
+      missingOutputBindings: facts.filter((fact) => fact.outputBindingStatus === 'missing').length,
+      sourceBindingStatuses: uniqueStrings(facts.map((fact) => fact.sourceBindingStatus)),
+      expectedCurrentHashes: uniqueStrings(facts.map((fact) => fact.expectedCurrentHash)),
+      replayCurrentHashes: uniqueStrings(facts.map((fact) => fact.replayCurrentHash)),
+      replaySourcePaths: uniqueStrings(facts.map((fact) => fact.replaySourcePath)),
+      sourceBindingFailures: facts.filter((fact) => fact.sourceBindingStatus === 'failed' || fact.sourceBindingStatus === 'stale').length,
+      missingSourceBindings: facts.filter((fact) => fact.sourceBindingStatus === 'missing').length,
+      staleReplayFiles: stale.length,
+      rerunRouteIds: uniqueStrings(facts.map((fact) => fact.rerunRouteId)),
+      proofRouteIds: uniqueStrings(facts.map((fact) => fact.proofRouteId)),
+      boundedAdmissionRouteIds: uniqueStrings(boundedAdmissionRoutes.map((route) => route.routeId)),
+      currentHeadCommutationProofs: boundedAdmissionRoutes.length,
+      boundedAdmissionRoute,
+      acceptedCleanReplays: facts.filter((fact) => fact.replayStatus === 'accepted-clean').length,
+      alreadyAppliedChecks: facts.filter((fact) => fact.alreadyAppliedReplayStatus === 'already-applied').length,
+      failedReplayFiles: failed.length,
+      missingReplayFiles: missing.length,
+      missingSignal,
+      nextAction: semanticReplayNextAction(nextMissingEvidence, missingSignal),
+      nextMissingEvidence
+    }
+  });
+}
+
+function semanticReplayFact(file) {
+  const artifacts = file.semanticArtifacts ?? file.result?.semanticArtifacts;
+  const replay = artifacts?.replay;
+  const alreadyAppliedReplay = artifacts?.alreadyAppliedReplay;
+  const outputBinding = semanticReplayOutputBinding(file, artifacts, replay);
+  const sourceBinding = semanticReplaySourceBinding(file, artifacts, replay);
+  const proofRoute = replay?.admission?.proofRoute ?? replay?.metadata?.proofRoute;
+  const reasonCodes = uniqueStrings([
+    ...(artifacts?.admission?.reasonCodes ?? []),
+    ...(replay?.admission?.reasonCodes ?? []),
+    ...(replay?.summary?.reasonCodes ?? []),
+    ...(replay?.diagnostics ?? []).map((diagnostic) => diagnostic.code),
+    ...outputBinding.reasonCodes,
+    ...sourceBinding.reasonCodes
+  ]);
+  const diagnosticCategories = uniqueStrings((replay?.diagnostics ?? []).map((diagnostic) => diagnostic.category));
+  const replayClean = replay?.status === 'accepted-clean'
+    && replay?.outputSourceText === (artifacts?.projection?.sourceText ?? file.outputSourceText);
+  const alreadyAppliedClean = alreadyAppliedReplay?.status === 'already-applied';
+  const failed = artifacts?.status === 'blocked'
+    || ['blocked', 'conflict', 'stale', 'needs-port'].includes(String(replay?.status))
+    || outputBinding.status === 'failed'
+    || sourceBinding.status === 'failed'
+    || sourceBinding.status === 'stale'
+    || (replay?.diagnostics ?? []).some((diagnostic) => diagnostic.severity === 'error');
+  const missing = Boolean(artifacts) && (!replay || !alreadyAppliedReplay || !replayClean || !alreadyAppliedClean || outputBinding.status === 'missing' || sourceBinding.status === 'missing') && !failed;
+  return {
+    sourcePath: file.sourcePath,
+    semanticArtifacts: Boolean(artifacts),
+    changedOrBlocked: file.status !== 'merged' || !file.baseHash || file.outputHash !== file.baseHash,
+    status: failed ? 'failed' : missing ? 'missing' : replayClean && alreadyAppliedClean ? 'passed' : 'missing',
+    replayId: replay?.id,
+    replayStatus: replay?.status,
+    alreadyAppliedReplayStatus: alreadyAppliedReplay?.status,
+    diagnosticCategories,
+    reasonCodes,
+    outputBindingStatus: outputBinding.status,
+    expectedOutputHash: outputBinding.expectedOutputHash,
+    projectionOutputHash: outputBinding.projectionOutputHash,
+    replayOutputHash: outputBinding.replayOutputHash,
+    sourceBindingStatus: sourceBinding.status,
+    expectedCurrentHash: sourceBinding.expectedCurrentHash,
+    replayCurrentHash: sourceBinding.replayCurrentHash,
+    replaySourcePath: sourceBinding.replaySourcePath,
+    rerunRouteId: sourceBinding.rerunRouteId,
+    proofRouteId: proofRoute?.routeId,
+    conflictKey: file.conflictKeys?.[0]
+  };
+}
+
+function semanticReplaySummary(status, facts, failed, missing) {
+  if (status === 'passed') return `Verified clean semantic edit replay evidence for ${facts.length} source file(s).`;
+  if (status === 'failed' && failed.some((fact) => fact.sourceBindingStatus === 'stale')) {
+    return `Semantic edit replay proof was stale for ${failed.filter((fact) => fact.sourceBindingStatus === 'stale').length} source file(s).`;
+  }
+  if (status === 'failed' && failed.some((fact) => fact.sourceBindingStatus === 'failed')) {
+    return `Semantic edit replay source binding failed for ${failed.filter((fact) => fact.sourceBindingStatus === 'failed').length} source file(s).`;
+  }
+  if (status === 'failed' && failed.some((fact) => fact.outputBindingStatus === 'failed')) {
+    return `Semantic edit replay output binding failed for ${failed.filter((fact) => fact.outputBindingStatus === 'failed').length} source file(s).`;
+  }
+  if (status === 'failed') return `Semantic edit replay diagnostics failed for ${failed.length} source file(s).`;
+  return facts.length
+    ? `Semantic edit artifacts are missing clean replay evidence for ${missing.length} source file(s).`
+    : 'No semantic edit artifacts were available for replay-clean proof evidence.';
+}
+
+function evidenceRecord(input) {
+  return {
+    id: `${input.id}_proof_${input.suffix}`,
+    kind: 'js-ts-project-merge-proof-evidence',
+    level: input.level,
+    status: input.status,
+    scope: input.scope,
+    claimKind: 'evidence',
+    evidenceOnly: true,
+    proofClaim: false,
+    autoMergeClaim: false,
+    semanticEquivalenceClaim: false,
+    summary: input.summary,
+    metadata: compactRecord({
+      ...(input.metadata ?? {}),
+      proofClaim: false,
+      autoMergeClaim: false,
+      semanticEquivalenceClaim: false
+    })
+  };
+}
+
+function compactRecord(record) {
+  return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== undefined));
+}
+function uniqueStrings(values) {
+  return [...new Set(values.filter((value) => typeof value === 'string' && value.length > 0))];
+}
+
+function semanticReplayOutputBinding(file, artifacts, replay) {
+  const expectedOutputSourceText = firstString(file.outputSourceText, file.result?.outputSourceText, file.result?.mergedSourceText);
+  const expectedOutputHash = firstString(
+    file.outputHash,
+    file.result?.outputHash,
+    typeof expectedOutputSourceText === 'string' ? hashSemanticValue(expectedOutputSourceText) : undefined
+  );
+  const projectionOutputSourceText = firstString(artifacts?.projection?.sourceText);
+  const projectionOutputHash = firstString(
+    artifacts?.projection?.outputHash,
+    artifacts?.projection?.projectedHash,
+    typeof projectionOutputSourceText === 'string' ? hashSemanticValue(projectionOutputSourceText) : undefined
+  );
+  const replayOutputSourceText = firstString(replay?.outputSourceText);
+  const replayOutputHash = firstString(
+    replay?.outputHash,
+    typeof replayOutputSourceText === 'string' ? hashSemanticValue(replayOutputSourceText) : undefined
+  );
+  const reasonCodes = [];
+  if (typeof expectedOutputSourceText !== 'string' && typeof expectedOutputHash !== 'string') {
+    reasonCodes.push('semantic-edit-output-binding-missing');
+  }
+  if (typeof projectionOutputSourceText !== 'string' && typeof projectionOutputHash !== 'string') {
+    reasonCodes.push('semantic-edit-projection-output-binding-missing');
+  }
+  if (typeof replayOutputSourceText !== 'string' && typeof replayOutputHash !== 'string') {
+    reasonCodes.push('semantic-edit-replay-output-binding-missing');
+  }
+  if (typeof expectedOutputSourceText === 'string' && typeof projectionOutputSourceText === 'string' && expectedOutputSourceText !== projectionOutputSourceText) {
+    reasonCodes.push('semantic-edit-projection-output-source-mismatch');
+  }
+  if (typeof expectedOutputHash === 'string' && typeof projectionOutputHash === 'string' && expectedOutputHash !== projectionOutputHash) {
+    reasonCodes.push('semantic-edit-projection-output-hash-mismatch');
+  }
+  if (typeof expectedOutputSourceText === 'string' && typeof replayOutputSourceText === 'string' && expectedOutputSourceText !== replayOutputSourceText) {
+    reasonCodes.push('semantic-edit-replay-output-source-mismatch');
+  }
+  if (typeof expectedOutputHash === 'string' && typeof replayOutputHash === 'string' && expectedOutputHash !== replayOutputHash) {
+    reasonCodes.push('semantic-edit-replay-output-hash-mismatch');
+  }
+  if (typeof projectionOutputSourceText === 'string' && typeof replayOutputSourceText === 'string' && projectionOutputSourceText !== replayOutputSourceText) {
+    reasonCodes.push('semantic-edit-replay-projection-output-source-mismatch');
+  }
+  if (typeof projectionOutputHash === 'string' && typeof replayOutputHash === 'string' && projectionOutputHash !== replayOutputHash) {
+    reasonCodes.push('semantic-edit-replay-projection-output-hash-mismatch');
+  }
+  const mismatch = reasonCodes.some((code) => code.endsWith('-mismatch'));
+  return compactRecord({
+    status: mismatch ? 'failed' : reasonCodes.length ? 'missing' : 'bound',
+    reasonCodes: uniqueStrings(reasonCodes),
+    expectedOutputHash,
+    projectionOutputHash,
+    replayOutputHash
+  });
+}
+
+function semanticReplaySourceBinding(file, artifacts, replay) {
+  const expectedCurrentSourceText = firstString(
+    file.currentSourceText,
+    file.headSourceText,
+    file.result?.currentSourceText,
+    file.result?.headSourceText
+  );
+  const expectedCurrentHash = firstString(
+    file.currentHash,
+    file.headHash,
+    file.result?.currentHash,
+    file.result?.headHash,
+    typeof expectedCurrentSourceText === 'string' ? hashSemanticValue(expectedCurrentSourceText) : undefined
+  );
+  const replayCurrentHash = firstString(
+    replay?.currentHash,
+    replay?.metadata?.currentHash,
+    replay?.metadata?.observedCurrentHash,
+    artifacts?.replayCurrentHash
+  );
+  const replaySourcePath = firstString(replay?.sourcePath, artifacts?.projection?.sourcePath);
+  const reasonCodes = [];
+  if (typeof file.sourcePath === 'string' && typeof replaySourcePath === 'string' && file.sourcePath !== replaySourcePath) {
+    reasonCodes.push('semantic-edit-replay-source-path-mismatch');
+  }
+  if (typeof expectedCurrentHash === 'string') {
+    if (typeof replayCurrentHash !== 'string') reasonCodes.push('semantic-edit-replay-current-source-hash-missing');
+    else if (expectedCurrentHash !== replayCurrentHash) reasonCodes.push('semantic-edit-replay-current-source-hash-mismatch');
+  }
+  const pathMismatch = reasonCodes.includes('semantic-edit-replay-source-path-mismatch');
+  const hashMismatch = reasonCodes.includes('semantic-edit-replay-current-source-hash-mismatch');
+  const hashMissing = reasonCodes.includes('semantic-edit-replay-current-source-hash-missing');
+  return compactRecord({
+    status: pathMismatch ? 'failed' : hashMismatch ? 'stale' : hashMissing ? 'missing' : typeof expectedCurrentHash === 'string' ? 'bound' : undefined,
+    reasonCodes: uniqueStrings(reasonCodes),
+    expectedCurrentHash,
+    replayCurrentHash,
+    replaySourcePath,
+    rerunRouteId: hashMismatch ? 'rerun-semantic-edit-replay-current-head' : undefined
+  });
+}
+
+function boundedCurrentHeadRouteForFact(fact, level) {
+  return semanticReplayCurrentHeadCommutationProofRoute({
+    status: fact.replayStatus,
+    proofLevel: level,
+    sourcePath: fact.sourcePath,
+    replayId: fact.replayId,
+    outputBindingStatus: fact.outputBindingStatus,
+    expectedCurrentHash: fact.expectedCurrentHash,
+    replayCurrentHash: fact.replayCurrentHash,
+    expectedOutputHash: fact.expectedOutputHash,
+    projectionOutputHash: fact.projectionOutputHash,
+    replayOutputHash: fact.replayOutputHash
+  });
+}
+
+function boundedCurrentHeadAggregateRoute(routes, level) {
+  return {
+    routeId: 'admit-independent-semantic-edit-current-head-commutation',
+    routeLane: 'source-files',
+    routeNext: 'apply-source-bound-semantic-edit-replay',
+    action: 'apply',
+    proofKind: 'bounded-current-head-commutation',
+    status: 'passed',
+    proofLevel: level,
+    reasonCodes: ['semantic-edit-current-head-commutation-bound'],
+    sourcePaths: uniqueStrings(routes.map((route) => route.sourcePath)),
+    replayIds: uniqueStrings(routes.map((route) => route.replayId)),
+    expectedCurrentHashes: uniqueStrings(routes.map((route) => route.expectedCurrentHash)),
+    replayCurrentHashes: uniqueStrings(routes.map((route) => route.replayCurrentHash)),
+    expectedOutputHashes: uniqueStrings(routes.map((route) => route.expectedOutputHash)),
+    projectionOutputHashes: uniqueStrings(routes.map((route) => route.projectionOutputHash)),
+    replayOutputHashes: uniqueStrings(routes.map((route) => route.replayOutputHash)),
+    autoMergeClaim: false,
+    semanticEquivalenceClaim: false
+  };
+}
+
+function firstString(...values) {
+  return values.find((value) => typeof value === 'string');
+}
+
+export { semanticEditReplayCleanEvidence };

package/dist/js-ts-safe-project-merge-semantic-replay-routes.js

@@ -0,0 +1,179 @@
+const semanticReplaySignals = Object.freeze({
+  missingProof: 'semantic-edit-replay-proof-not-produced',
+  outputMismatch: 'semantic-edit-replay-proof-output-mismatch',
+  staleCurrentSource: 'semantic-edit-replay-proof-stale-current-source'
+});
+
+function semanticReplayMissingSignal(status, facts, failed, stale) {
+  if (!facts.length || status === 'passed') return undefined;
+  if (stale.length) return semanticReplaySignals.staleCurrentSource;
+  if (failed.some((fact) => fact.outputBindingStatus === 'failed')) return semanticReplaySignals.outputMismatch;
+  return semanticReplaySignals.missingProof;
+}
+
+function semanticReplayNextMissingEvidence(input) {
+  const failedOrMissing = [...input.failed, ...input.missing];
+  const stale = input.stale ?? [];
+  if (stale.length) return staleReplayEvidenceRoute(input, stale);
+  const outputMismatched = failedOrMissing.filter((fact) => fact.outputBindingStatus === 'failed');
+  if (outputMismatched.length) return outputMismatchEvidenceRoute(input, outputMismatched);
+  return missingReplayEvidenceRoute(input, failedOrMissing);
+}
+
+function semanticReplayNextAction(nextMissingEvidence, missingSignal) {
+  if (!missingSignal) return undefined;
+  if (nextMissingEvidence?.action === 'rerun') {
+    return 'Rerun semantic edit replay against the current project head hash before admission.';
+  }
+  if (nextMissingEvidence?.action === 'reject-proof') {
+    return 'Reject the output-mismatched semantic edit replay proof and inspect the replay output binding before admission.';
+  }
+  return 'Produce semantic edit replay diagnostics and require accepted-clean replay plus already-applied verification before admission.';
+}
+
+function semanticReplayProofRoute(status, reasonCodes, rerunRoute, binding = {}) {
+  if (rerunRoute) return rerunRoute;
+  const outputMismatchReasons = reasonCodes.filter(isReplayOutputMismatchReasonCode);
+  if (status === 'blocked' && outputMismatchReasons.length) return {
+    routeId: 'reject-semantic-edit-replay-output-mismatch',
+    routeLane: 'source-files',
+    routeNext: 'inspect-semantic-edit-replay-output-binding',
+    action: 'reject-proof',
+    reasonCodes: uniqueStrings(outputMismatchReasons),
+    autoMergeClaim: false,
+    semanticEquivalenceClaim: false
+  };
+  return semanticReplayCurrentHeadCommutationProofRoute({
+    ...binding,
+    status,
+    reasonCodes
+  });
+}
+
+function semanticReplayCurrentHeadCommutationProofRoute(input = {}) {
+  const reasonCodes = uniqueStrings(input.reasonCodes ?? []);
+  if (input.status !== 'accepted-clean' || reasonCodes.length) return undefined;
+  const outputBindingStatus = input.outputBindingStatus ?? input.outputBinding?.status;
+  if (outputBindingStatus !== 'bound') return undefined;
+  const expectedCurrentHash = firstString(input.expectedCurrentHash, input.currentSourceHash);
+  const replayCurrentHash = firstString(input.replayCurrentHash, input.currentHash, input.observedCurrentHash);
+  if (!expectedCurrentHash || expectedCurrentHash !== replayCurrentHash) return undefined;
+  const expectedOutputHash = firstString(
+    input.expectedOutputHash,
+    input.outputBinding?.expectedOutputHash,
+    input.projectionOutputHash,
+    input.projectedHash
+  );
+  const replayOutputHash = firstString(
+    input.replayOutputHash,
+    input.outputHash,
+    input.outputBinding?.replayedOutputHash
+  );
+  if (!expectedOutputHash || expectedOutputHash !== replayOutputHash) return undefined;
+  return compactRecord({
+    routeId: 'admit-independent-semantic-edit-current-head-commutation',
+    routeLane: 'source-files',
+    routeNext: 'apply-source-bound-semantic-edit-replay',
+    action: 'apply',
+    proofKind: 'bounded-current-head-commutation',
+    status: 'passed',
+    proofLevel: input.proofLevel,
+    reasonCodes: ['semantic-edit-current-head-commutation-bound'],
+    sourcePath: input.sourcePath,
+    replayId: input.replayId,
+    appliedOperations: input.appliedOperations,
+    expectedCurrentHash,
+    replayCurrentHash,
+    expectedOutputHash,
+    projectionOutputHash: input.projectionOutputHash,
+    replayOutputHash,
+    outputBindingStatus,
+    autoMergeClaim: false,
+    semanticEquivalenceClaim: false
+  });
+}
+
+function staleReplayEvidenceRoute(input, stale) {
+  return {
+    code: input.missingSignal,
+    kind: 'proof-level',
+    scope: 'source-files',
+    status: 'stale',
+    proofLevel: input.level,
+    action: 'rerun',
+    routeId: 'rerun-semantic-edit-replay-current-head',
+    routeLane: 'source-files',
+    routeNext: 'rerun-semantic-edit-replay-on-current-head',
+    reasonCodes: uniqueStrings(stale.flatMap((fact) => fact.reasonCodes)),
+    sourceBindingStatuses: uniqueStrings(stale.map((fact) => fact.sourceBindingStatus)),
+    expectedCurrentHashes: uniqueStrings(stale.map((fact) => fact.expectedCurrentHash)),
+    replayCurrentHashes: uniqueStrings(stale.map((fact) => fact.replayCurrentHash)),
+    autoMergeClaim: false,
+    semanticEquivalenceClaim: false
+  };
+}
+
+function outputMismatchEvidenceRoute(input, outputMismatched) {
+  return {
+    code: input.missingSignal,
+    kind: 'proof-level',
+    scope: 'source-files',
+    status: 'failed',
+    proofLevel: input.level,
+    action: 'reject-proof',
+    routeId: 'reject-semantic-edit-replay-output-mismatch',
+    routeLane: 'source-files',
+    routeNext: 'inspect-semantic-edit-replay-output-binding',
+    reasonCodes: uniqueStrings(outputMismatched.flatMap((fact) => fact.reasonCodes)),
+    outputBindingStatuses: uniqueStrings(outputMismatched.map((fact) => fact.outputBindingStatus)),
+    expectedOutputHashes: uniqueStrings(outputMismatched.map((fact) => fact.expectedOutputHash)),
+    projectionOutputHashes: uniqueStrings(outputMismatched.map((fact) => fact.projectionOutputHash)),
+    replayOutputHashes: uniqueStrings(outputMismatched.map((fact) => fact.replayOutputHash)),
+    autoMergeClaim: false,
+    semanticEquivalenceClaim: false
+  };
+}
+
+function missingReplayEvidenceRoute(input, failedOrMissing) {
+  return {
+    code: input.missingSignal,
+    kind: 'proof-level',
+    scope: 'source-files',
+    status: input.status === 'failed' ? 'failed' : 'missing',
+    proofLevel: input.level,
+    action: 'review',
+    routeId: 'produce-semantic-edit-replay-proof',
+    routeLane: 'source-files',
+    routeNext: 'run-semantic-edit-replay-diagnostics',
+    reasonCodes: uniqueStrings(failedOrMissing.flatMap((fact) => fact.reasonCodes)),
+    outputBindingStatuses: uniqueStrings(failedOrMissing.map((fact) => fact.outputBindingStatus)),
+    sourceBindingStatuses: uniqueStrings(failedOrMissing.map((fact) => fact.sourceBindingStatus)),
+    autoMergeClaim: false,
+    semanticEquivalenceClaim: false
+  };
+}
+
+function isReplayOutputMismatchReasonCode(code) {
+  return code === 'semantic-edit-replay-output-source-mismatch'
+    || code === 'semantic-edit-replay-output-hash-mismatch'
+    || code === 'semantic-edit-replay-projection-output-source-mismatch'
+    || code === 'semantic-edit-replay-projection-output-hash-mismatch'
+    || code === 'semantic-edit-replay-output-mismatch';
+}
+
+function uniqueStrings(values) {
+  return [...new Set((values ?? []).filter((value) => typeof value === 'string' && value.length > 0))];
+}
+function firstString(...values) { return values.find((value) => typeof value === 'string' && value.length > 0); }
+function compactRecord(value) {
+  return Object.fromEntries(Object.entries(value ?? {}).filter(([, entry]) => entry !== undefined && (!Array.isArray(entry) || entry.length > 0)));
+}
+
+export {
+  semanticReplayCurrentHeadCommutationProofRoute,
+  semanticReplayMissingSignal,
+  semanticReplayNextAction,
+  semanticReplayNextMissingEvidence,
+  semanticReplayProofRoute,
+  semanticReplaySignals
+};