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

package/dist/internal/index-impl/replaySemanticEditProjection.js

@@ -6,6 +6,7 @@ import { normalizeNativeDiffImport } from './normalizeNativeDiffImport.js';
 import { replayReplacementText } from './replaySemanticEditLineEndings.js';
 import { replayDiagnostics, replayEditDiagnostics, replayEditsWithOverlapDiagnostics } from './semanticEditReplayDiagnostics.js';
 import { explicitSourceReplacementReplayRange } from './semanticEditReplaySourceReplacement.js';
+import { semanticReplayProofRoute } from '../../js-ts-safe-project-merge-semantic-replay-routes.js';
 import {
   findCurrentSymbol,
   findInsertionAnchor,
@@ -14,6 +15,8 @@ import {
   insertionRange
 } from './semanticEditReplayAnchors.js';
 import { bodyContentRange, removalRange, spanOffsets } from './semanticEditSourceRanges.js';
+import { replayOutputBinding, replayOutputSource } from './semanticEditReplayOutputBinding.js';
+import { isRerunnableStaleReasonCode, replayRerunRoute } from './semanticEditReplayRerunRoute.js';
 
 export function replaySemanticEditProjection(input = {}) {
   const projection = input.projection ?? input.semanticEditProjection;
@@ -21,9 +24,9 @@ export function replaySemanticEditProjection(input = {}) {
   const currentSourceText = input.currentSourceText ?? input.headSourceText;
   const sourcePath = input.currentSourcePath ?? input.headSourcePath ?? projection.sourcePath;
   const language = normalizeNativeLanguageId(input.language ?? projection.language);
-  const reasonCodes = baseReasonCodes(projection, currentSourceText);
+  const baseReasons = baseReasonCodes(projection, currentSourceText);
   const currentHash = typeof currentSourceText === 'string' ? hashSemanticValue(currentSourceText) : undefined;
-  if (input.currentSourceHash && currentHash !== input.currentSourceHash) reasonCodes.push('current-source-hash-mismatch');
+  if (input.currentSourceHash && currentHash !== input.currentSourceHash) baseReasons.push('current-source-hash-mismatch');
   const currentSymbols = currentSourceText && language
     ? currentSymbolIndex({ currentSourceText, sourcePath, language, parser: input.parser })
     : [];
@@ -35,8 +38,28 @@ export function replaySemanticEditProjection(input = {}) {
     }))
     : [];
   const edits = replayEditsWithOverlapDiagnostics(replayedEdits);
+  const replayedStatus = replayStatus(baseReasons, edits, projection);
+  const replayedOutputSourceText = replayOutputSource(replayedStatus, currentSourceText, edits);
+  const replayedOutputHash = replayedOutputSourceText === undefined ? undefined : hashSemanticValue(replayedOutputSourceText);
+  const outputBinding = replayOutputBinding(input, replayedOutputSourceText, replayedOutputHash, { replayStatus: replayedStatus });
+  const reasonCodes = reasonList([...baseReasons, ...(outputBinding.reasonCodes ?? [])]);
   const status = replayStatus(reasonCodes, edits, projection);
-  const outputSourceText = replayOutputSource(status, currentSourceText, edits);
+  const outputSourceText = outputBinding.status === 'failed' ? undefined : replayedOutputSourceText;
+  const outputHash = outputSourceText === undefined ? undefined : hashSemanticValue(outputSourceText);
+  const rerunRoute = replayRerunRoute(status, reasonCodes, input, currentHash);
+  const proofRoute = semanticReplayProofRoute(status, reasonCodes, rerunRoute, {
+    sourcePath,
+    replayId: input.id,
+    currentSourceHash: input.currentSourceHash,
+    currentHash,
+    outputHash,
+    outputBinding,
+    outputBindingStatus: outputBinding.status,
+    expectedOutputHash: outputBinding.expectedOutputHash,
+    projectionOutputHash: projection.projectedHash,
+    replayOutputHash: outputHash,
+    appliedOperations: edits.filter((edit) => edit.status === 'applied').map((edit) => edit.operationId).filter(Boolean)
+  });
   const diagnostics = replayDiagnostics({
     status,
     reasonCodes,
@@ -56,19 +79,30 @@ export function replaySemanticEditProjection(input = {}) {
     language,
     currentHash,
     projectedHash: projection.projectedHash,
-    outputHash: outputSourceText === undefined ? undefined : hashSemanticValue(outputSourceText),
+    outputHash,
     status,
     edits,
     appliedOperations: edits.filter((edit) => edit.status === 'applied').map((edit) => edit.operationId).filter(Boolean),
     skippedOperations: edits.filter((edit) => edit.status !== 'applied').map((edit) => edit.operationId).filter(Boolean),
     diagnostics,
-    admission: replayAdmission(status, reasonCodes, edits),
+    admission: replayAdmission(status, reasonCodes, edits, rerunRoute, proofRoute),
     outputSourceText,
     summary: replaySummary(edits, reasonCodes),
     metadata: compactRecord({
       autoMergeClaim: false,
       semanticEquivalenceClaim: false,
       anchorMode: currentSymbols.length ? 'javascript-like-symbols' : 'offsets',
+      structuralDiffId: projection.metadata?.structuralDiffId,
+      structuralDiffStatus: projection.metadata?.structuralDiffStatus,
+      structuralDiffSummary: projection.metadata?.structuralDiffSummary,
+      currentSourceBindingStatus: baseReasons.includes('current-source-hash-mismatch') ? 'stale' : input.currentSourceHash ? 'bound' : undefined,
+      expectedCurrentHash: input.currentSourceHash,
+      observedCurrentHash: currentHash,
+      rerunRoute,
+      proofRoute,
+      outputBindingStatus: outputBinding.status,
+      expectedOutputHash: outputBinding.expectedOutputHash,
+      replayedOutputHash: outputBinding.replayedOutputHash,
       ...input.metadata
     })
   };
@@ -165,6 +199,10 @@ function replayEditRecord(edit, status, range, reasonCodes, sourceText) {
     semanticIdentityHash: edit.semanticIdentityHash,
     sourceIdentityHash: edit.sourceIdentityHash,
     editContentHash: edit.editContentHash,
+    structuralEditId: edit.structuralEditId,
+    structuralEditHash: edit.structuralEditHash,
+    structuralKind: edit.structuralKind,
+    structuralActions: edit.structuralActions,
     editKind: edit.editKind,
     editOrder: edit.editOrder,
     sourceRangeKind: edit.sourceRangeKind,
@@ -207,7 +245,7 @@ function currentSymbolRangeLabel(edit) {
 }
 
 function replayStatus(reasonCodes, edits, projection) {
-  if (reasonCodes.length) return 'blocked';
+  if (reasonCodes.length) return reasonCodes.every(isRerunnableStaleReasonCode) ? 'stale' : 'blocked';
   if (!edits.length && !(projection.edits ?? []).length) return 'evidence-only';
   if (edits.some((edit) => edit.status === 'blocked')) return 'blocked';
   if (edits.some((edit) => edit.status === 'conflict')) return 'conflict';
@@ -216,18 +254,20 @@ function replayStatus(reasonCodes, edits, projection) {
   return edits.every((edit) => edit.status === 'applied' || edit.status === 'already-applied') ? 'accepted-clean' : 'needs-port';
 }
 
-function replayAdmission(status, reasonCodes, edits) {
+function replayAdmission(status, reasonCodes, edits, rerunRoute, proofRoute) {
   const apply = status === 'accepted-clean';
   const skip = status === 'already-applied';
-  return {
+  return compactRecord({
     status,
     action: apply ? 'apply' : skip ? 'skip' : status === 'stale' ? 'rerun-semantic-import' : status === 'blocked' ? 'block' : 'human-review',
     reviewRequired: !(apply || skip),
     autoApplyCandidate: apply,
     autoMergeClaim: false,
     semanticEquivalenceClaim: false,
-    reasonCodes: reasonList([...reasonCodes, ...edits.flatMap((edit) => edit.reasonCodes ?? [])])
-  };
+    reasonCodes: reasonList([...reasonCodes, ...edits.flatMap((edit) => edit.reasonCodes ?? [])]),
+    rerunRoute,
+    proofRoute
+  });
 }
 
 function replaySummary(edits, reasonCodes) {
@@ -242,19 +282,6 @@ function replaySummary(edits, reasonCodes) {
   };
 }
 
-function replayOutputSource(status, sourceText, edits) {
-  if (typeof sourceText !== 'string') return undefined;
-  if (status === 'already-applied') return sourceText;
-  if (status !== 'accepted-clean') return undefined;
-  return edits.filter((edit) => edit.status === 'applied')
-    .sort(replaySourceEditSort)
-    .reduce((text, edit) => text.slice(0, edit.start) + editReplacement(edit, edits) + text.slice(edit.end), sourceText);
-}
-
-function replaySourceEditSort(left, right) {
-  return right.start - left.start || right.end - left.end || (right.editOrder ?? 0) - (left.editOrder ?? 0);
-}
-
 function projectionEditWithOrder(edit, index) {
   return {
     ...edit,
@@ -266,10 +293,6 @@ function projectionEditWithOrder(edit, index) {
   };
 }
 
-function editReplacement(edit, edits) {
-  return edits.find((candidate) => candidate.operationId === edit.operationId)?.replacementText ?? '';
-}
-
 function baseReasonCodes(projection, currentSourceText) {
   return reasonList([
     projection.status !== 'projected' ? 'projection-not-projected' : undefined,
@@ -278,18 +301,9 @@ function baseReasonCodes(projection, currentSourceText) {
   ]);
 }
 
-function sameRange(left, right) {
-  return left?.start === right?.start && left?.end === right?.end;
-}
-
-function rangesOverlap(left, right) {
-  return Boolean(left && right && left.start < right.end && right.start < left.end);
-}
-
-function containedRange(inner, outer) {
-  return Boolean(inner && outer && outer.start <= inner.start && inner.end <= outer.end);
-}
-
+function sameRange(left, right) { return left?.start === right?.start && left?.end === right?.end; }
+function rangesOverlap(left, right) { return Boolean(left && right && left.start < right.end && right.start < left.end); }
+function containedRange(inner, outer) { return Boolean(inner && outer && outer.start <= inner.start && inner.end <= outer.end); }
 function reasonList(values) { return uniqueStrings((values ?? []).filter(Boolean)); }
 function lineEndingStableText(value) {
   if (typeof value !== 'string') return undefined;

package/dist/internal/index-impl/runtimeOrderEvidenceBinding.js

@@ -0,0 +1,151 @@
+import { uniqueStrings } from '../../native-import-utils.js';
+import {
+  runtimeOrderProofSurfaceReasonCodes,
+  runtimeOrderSurfaceExpectations
+} from './runtimeOrderProofSurfaces.js';
+
+const RuntimeOrderProofSchema = 'frontier.lang.runtimeOrderProofEvidence.v1';
+const RuntimeOrderProofKind = 'frontier.lang.runtimeOrderProofEvidence';
+const PassedStatuses = new Set(['passed', 'verified']);
+
+function runtimeOrderEvidenceBinding(input) {
+  const candidates = runtimeOrderEvidenceCandidates(input?.scriptInput);
+  if (!candidates.length) return { passed: false, evidenceIds: [], reasonCodes: [] };
+  const results = candidates.map((candidate) => validateRuntimeOrderEvidence(candidate, input));
+  const passed = results.filter((result) => result.passed);
+  if (passed.length) {
+    return {
+      passed: true,
+      evidenceIds: uniqueStrings(passed.flatMap((result) => result.evidenceIds)),
+      reasonCodes: []
+    };
+  }
+  return {
+    passed: false,
+    evidenceIds: [],
+    reasonCodes: uniqueStrings(results.flatMap((result) => result.reasonCodes))
+  };
+}
+
+function validateRuntimeOrderEvidence(candidate, input) {
+  if (!candidate || typeof candidate !== 'object' || Array.isArray(candidate)) {
+    return invalid(['runtime-order-explicit-evidence-structured-record-required']);
+  }
+  const expected = expectedRuntimeOrderBinding(input);
+  const reasonCodes = [];
+  if (!PassedStatuses.has(String(candidate.status ?? ''))) reasonCodes.push('runtime-order-explicit-evidence-status-not-passed');
+  if (candidate.schema !== RuntimeOrderProofSchema && candidate.kind !== RuntimeOrderProofKind) reasonCodes.push('runtime-order-explicit-evidence-schema-missing');
+  if (!fieldMatches(candidate.sourcePath, [expected.sourcePath])) reasonCodes.push('runtime-order-explicit-evidence-source-path-mismatch');
+  if (!sourceHashMatches(candidate, expected)) reasonCodes.push('runtime-order-explicit-evidence-source-hash-mismatch');
+  if (!regionIdentityMatches(candidate, expected)) reasonCodes.push('runtime-order-explicit-evidence-region-identity-mismatch');
+  if (!fieldMatches(candidate.regionKind, [expected.regionKind])) reasonCodes.push('runtime-order-explicit-evidence-region-kind-mismatch');
+  if (!runtimeKindMatches(candidate, expected)) reasonCodes.push('runtime-order-explicit-evidence-runtime-kind-mismatch');
+  if (expected.signatureHashes.length && !fieldMatches(candidate.signatureHash, expected.signatureHashes)) reasonCodes.push('runtime-order-explicit-evidence-signature-hash-mismatch');
+  if (candidate.autoMergeClaim !== false || candidate.semanticEquivalenceClaim !== false || candidate.runtimeEquivalenceClaim !== false) reasonCodes.push('runtime-order-explicit-evidence-claim-flags-missing');
+  reasonCodes.push(...runtimeOrderProofSurfaceReasonCodes(candidate, expected));
+  if (reasonCodes.length) return invalid(reasonCodes);
+  return {
+    passed: true,
+    evidenceIds: uniqueStrings([candidate.id, candidate.evidenceId, ...(array(candidate.evidenceIds))]),
+    reasonCodes: []
+  };
+}
+
+function expectedRuntimeOrderBinding(input) {
+  const region = input?.region ?? {};
+  const regionKey = region.key ?? stripRegionPrefix(region.conflictKey) ?? input?.anchorKey;
+  const sourcePath = region.sourcePath ?? region.sourceSpan?.path ?? input?.context?.workerChangeSet?.sourcePath;
+  return {
+    sourcePath,
+    sourceHashes: uniqueStrings([input?.context?.workerChangeSet?.afterHash, input?.context?.headChangeSet?.afterHash]),
+    stageHashes: {
+      baseSourceHash: input?.context?.workerChangeSet?.beforeHash,
+      workerSourceHash: input?.context?.workerChangeSet?.afterHash,
+      headSourceHash: input?.context?.headChangeSet?.afterHash
+    },
+    regionKeys: uniqueStrings([regionKey, region.key, stripRegionPrefix(region.conflictKey), input?.anchorKey, region.id]),
+    conflictKeys: uniqueStrings([region.conflictKey, regionKey ? `region:${regionKey}` : undefined]),
+    runtimeIdentityKeys: uniqueStrings([runtimeIdentityKey(region)]),
+    regionKind: runtimeRegionKind(region, input?.baseSymbol),
+    runtimeKinds: runtimeKinds(region),
+    ...runtimeOrderSurfaceExpectations(region),
+    signatureHashes: uniqueStrings([
+      region.signatureHash,
+      input?.baseSymbol?.signatureHash,
+      input?.baseSymbol?.beforeSignatureHash,
+      input?.baseSymbol?.afterSignatureHash,
+      input?.workerSymbol?.signatureHash,
+      input?.workerSymbol?.beforeSignatureHash,
+      input?.workerSymbol?.afterSignatureHash,
+      input?.headSymbol?.signatureHash
+    ])
+  };
+}
+
+function runtimeOrderEvidenceCandidates(input = {}) {
+  return [
+    ...array(input.runtimeOrderEvidence),
+    ...array(input.effectOrderEvidence),
+    ...array(input.metadata?.runtimeOrderEvidence),
+    ...array(input.metadata?.effectOrderEvidence),
+    ...array(input.evidence).filter(isRuntimeProofLike)
+  ];
+}
+
+function isRuntimeProofLike(value) {
+  return value === true || value?.schema === RuntimeOrderProofSchema || value?.kind === RuntimeOrderProofKind;
+}
+
+function sourceHashMatches(candidate, expected) {
+  const stageEntries = Object.entries(expected.stageHashes).filter(([, value]) => value);
+  const hasStageHashProof = stageEntries.length && stageEntries.every(([field, value]) => candidate[field] === value);
+  return hasStageHashProof || fieldMatches(candidate.sourceHash, expected.sourceHashes);
+}
+
+function regionIdentityMatches(candidate, expected) {
+  return fieldMatches(candidate.regionKey, expected.regionKeys)
+    || fieldMatches(stripRegionPrefix(candidate.conflictKey), expected.regionKeys)
+    || fieldMatches(candidate.conflictKey, expected.conflictKeys)
+    || fieldMatches(candidate.runtimeIdentityKey, expected.runtimeIdentityKeys);
+}
+
+function runtimeKindMatches(candidate, expected) {
+  const candidateKinds = uniqueStrings([candidate.runtimeKind, ...array(candidate.runtimeKinds)]);
+  return candidateKinds.length > 0 && candidateKinds.some((kind) => expected.runtimeKinds.includes(kind));
+}
+
+function runtimeKinds(region) {
+  return uniqueStrings([
+    ...array(region?.runtimeKinds),
+    ...array(region?.runtimeKind),
+    ...array(region?.metadata?.factKinds),
+    ...array(region?.metadata?.factKind),
+    ...array(factSignatureFromSymbolName(region?.symbolName, runtimeRegionKind(region)))
+  ].flatMap((kind) => String(kind ?? '').split('+')).filter(Boolean));
+}
+
+function runtimeIdentityKey(region) {
+  return stableKey(['runtime-region', region?.sourcePath, region?.symbolName, region?.regionKind, region?.runtimeKind, region?.ordinal]);
+}
+
+function runtimeRegionKind(region, symbol) { return String(region?.regionKind ?? symbol?.ownershipRegionKind ?? ''); }
+function factSignatureFromSymbolName(symbolName, regionKind) {
+  const marker = `:${regionKind}:`;
+  const text = String(symbolName ?? '');
+  const markerIndex = text.indexOf(marker);
+  if (markerIndex < 0) return undefined;
+  return text.slice(markerIndex + marker.length).replace(/#\d+$/, '') || undefined;
+}
+function fieldMatches(value, expectedValues) { return value !== undefined && value !== null && expectedValues.includes(String(value)); }
+function stableKey(parts) {
+  const values = parts.map((part) => part === undefined || part === null ? '' : String(part));
+  return values.some(Boolean) ? values.join('#') : undefined;
+}
+function stripRegionPrefix(value) {
+  const text = String(value ?? '');
+  return text.startsWith('region:') ? text.slice('region:'.length) : text || undefined;
+}
+function invalid(reasonCodes) { return { passed: false, evidenceIds: [], reasonCodes }; }
+function array(value) { return value === undefined || value === null ? [] : Array.isArray(value) ? value : [value]; }
+
+export { runtimeOrderEvidenceBinding };

package/dist/internal/index-impl/runtimeOrderProofSurfaces.js

@@ -0,0 +1,253 @@
+import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
+import { uniqueStrings } from '../../native-import-utils.js';
+
+function runtimeOrderSurfaceExpectations(region) {
+  const resourceOrderRecords = resourceManagementOrderRecords(region);
+  const generatorRecords = generatorProtocolRecords(region);
+  const promiseCombinatorRecords = promiseCombinatorOrderRecords(region);
+  const promiseChainRecords = promiseChainOrderRecords(region);
+  const generatorKinds = runtimeKinds(region);
+  return {
+    importMetaHostContextHash: importMetaHostContextHash(region),
+    promiseCombinatorOrderHash: promiseCombinatorOrderHash(region, promiseCombinatorRecords),
+    promiseCombinatorNeedsElementTrace: promiseCombinatorRecords.some((record) => record.arrayElementOrdinal),
+    promiseCombinatorMethods: uniqueStrings(promiseCombinatorRecords.map((record) => record.methodName)),
+    promiseChainOrderHash: promiseChainOrderHash(region, promiseChainRecords),
+    promiseChainNeedsRejectionTrace: promiseChainRecords.some((record) => record.hasCatch),
+    promiseChainNeedsFinalizerTrace: promiseChainRecords.some((record) => record.hasFinally),
+    resourceManagementOrderHash: resourceManagementOrderHash(region, resourceOrderRecords),
+    resourceManagementNeedsAsyncTrace: resourceOrderRecords.some((record) => record.awaitUsing || record.declarationKind === 'await-using'),
+    generatorProtocolOrderHash: generatorProtocolOrderHash(region, generatorRecords),
+    generatorProtocolNeedsIteratorTrace: generatorRecords.some((record) => record.delegated),
+    generatorProtocolNeedsAsyncIteratorTrace: generatorKinds.includes('async') && (generatorKinds.includes('generator') || generatorRecords.length > 0),
+    classStaticBlockOrderHash: classStaticBlockOrderHash(region),
+    topLevelAwaitOrderHash: topLevelAwaitOrderHash(region)
+  };
+}
+
+function runtimeOrderProofSurfaceReasonCodes(candidate, expected) {
+  return uniqueStrings([
+    ...importMetaHostContextProofReasonCodes(candidate, expected),
+    ...promiseCombinatorProofReasonCodes(candidate, expected),
+    ...promiseChainProofReasonCodes(candidate, expected),
+    ...resourceManagementProofReasonCodes(candidate, expected),
+    ...generatorProtocolProofReasonCodes(candidate, expected),
+    ...classStaticBlockProofReasonCodes(candidate, expected),
+    ...topLevelAwaitProofReasonCodes(candidate, expected)
+  ]);
+}
+
+function importMetaHostContextProofReasonCodes(candidate, expected) {
+  if (!expected.runtimeKinds.includes('host-context') && !expected.importMetaHostContextHash) return [];
+  const reasonCodes = [];
+  if (candidate.importMetaHostContextEquivalenceClaim !== false || candidate.hostRuntimeResolutionEquivalenceClaim !== false) reasonCodes.push('runtime-order-explicit-evidence-claim-flags-missing');
+  const contextHash = firstString(candidate.importMetaHostContextHash, candidate.hostContextMemberHash);
+  if (expected.importMetaHostContextHash && !contextHash) reasonCodes.push('runtime-order-explicit-evidence-import-meta-host-context-hash-missing');
+  else if (expected.importMetaHostContextHash && contextHash !== expected.importMetaHostContextHash) reasonCodes.push('runtime-order-explicit-evidence-import-meta-host-context-hash-mismatch');
+  if (!firstString(candidate.importMetaHostResolutionTraceHash, candidate.hostContextResolutionTraceHash, candidate.importMetaHostRuntimeTraceHash)) reasonCodes.push('runtime-order-explicit-evidence-import-meta-host-context-trace-missing');
+  return reasonCodes;
+}
+
+function promiseCombinatorProofReasonCodes(candidate, expected) {
+  if (!expected.promiseCombinatorOrderHash) return [];
+  const reasonCodes = [];
+  if (candidate.promiseCombinatorRuntimeEquivalenceClaim !== false || candidate.promiseConcurrencyEquivalenceClaim !== false || candidate.promiseSettlementEquivalenceClaim !== false) reasonCodes.push('runtime-order-explicit-evidence-claim-flags-missing');
+  if (expected.promiseCombinatorNeedsElementTrace && candidate.promiseElementOrderEquivalenceClaim !== false) reasonCodes.push('runtime-order-explicit-evidence-claim-flags-missing');
+  const orderHash = firstString(candidate.promiseCombinatorOrderHash, candidate.promiseConcurrencyOrderHash);
+  if (!orderHash) reasonCodes.push('runtime-order-explicit-evidence-promise-combinator-order-hash-missing');
+  else if (orderHash !== expected.promiseCombinatorOrderHash) reasonCodes.push('runtime-order-explicit-evidence-promise-combinator-order-hash-mismatch');
+  if (!firstString(candidate.promiseCombinatorConcurrencyTraceHash, candidate.promiseConcurrencyTraceHash)) reasonCodes.push('runtime-order-explicit-evidence-promise-combinator-concurrency-trace-missing');
+  if (!firstString(candidate.promiseCombinatorSettlementTraceHash, candidate.promiseSettlementTraceHash)) reasonCodes.push('runtime-order-explicit-evidence-promise-combinator-settlement-trace-missing');
+  if (expected.promiseCombinatorNeedsElementTrace && !firstString(candidate.promiseCombinatorElementOrderTraceHash, candidate.promiseElementOrderTraceHash)) reasonCodes.push('runtime-order-explicit-evidence-promise-combinator-element-order-trace-missing');
+  if (expected.promiseCombinatorMethods.includes('all') && !firstString(candidate.promiseAllSettlementTraceHash, candidate.promiseCombinatorAllSettlementTraceHash)) reasonCodes.push('runtime-order-explicit-evidence-promise-all-settlement-trace-missing');
+  if (expected.promiseCombinatorMethods.includes('allSettled') && !firstString(candidate.promiseAllSettledRecordTraceHash, candidate.promiseCombinatorAllSettledRecordTraceHash)) reasonCodes.push('runtime-order-explicit-evidence-promise-all-settled-record-trace-missing');
+  if (expected.promiseCombinatorMethods.includes('race') && !firstString(candidate.promiseRaceFirstSettlementTraceHash, candidate.promiseCombinatorRaceFirstSettlementTraceHash)) reasonCodes.push('runtime-order-explicit-evidence-promise-race-first-settlement-trace-missing');
+  if (expected.promiseCombinatorMethods.includes('any') && !firstString(candidate.promiseAnyFirstFulfillmentTraceHash, candidate.promiseCombinatorAnyFirstFulfillmentTraceHash)) reasonCodes.push('runtime-order-explicit-evidence-promise-any-first-fulfillment-trace-missing');
+  return reasonCodes;
+}
+
+function promiseChainProofReasonCodes(candidate, expected) {
+  if (!expected.promiseChainOrderHash) return [];
+  const reasonCodes = [];
+  if (candidate.promiseChainRuntimeEquivalenceClaim !== false || candidate.promiseHandlerExecutionEquivalenceClaim !== false) reasonCodes.push('runtime-order-explicit-evidence-claim-flags-missing');
+  if (expected.promiseChainNeedsRejectionTrace && candidate.promiseRejectionFlowEquivalenceClaim !== false) reasonCodes.push('runtime-order-explicit-evidence-claim-flags-missing');
+  if (expected.promiseChainNeedsFinalizerTrace && candidate.promiseFinalizerEquivalenceClaim !== false) reasonCodes.push('runtime-order-explicit-evidence-claim-flags-missing');
+  const orderHash = firstString(candidate.promiseChainOrderHash, candidate.promiseHandlerOrderHash);
+  if (!orderHash) reasonCodes.push('runtime-order-explicit-evidence-promise-chain-order-hash-missing');
+  else if (orderHash !== expected.promiseChainOrderHash) reasonCodes.push('runtime-order-explicit-evidence-promise-chain-order-hash-mismatch');
+  if (!firstString(candidate.promiseChainHandlerOrderTraceHash, candidate.promiseHandlerOrderTraceHash)) reasonCodes.push('runtime-order-explicit-evidence-promise-chain-handler-order-trace-missing');
+  if (expected.promiseChainNeedsRejectionTrace && !firstString(candidate.promiseChainRejectionFlowTraceHash, candidate.promiseRejectionFlowTraceHash)) reasonCodes.push('runtime-order-explicit-evidence-promise-chain-rejection-flow-trace-missing');
+  if (expected.promiseChainNeedsFinalizerTrace && !firstString(candidate.promiseChainFinalizerTraceHash, candidate.promiseFinalizerTraceHash)) reasonCodes.push('runtime-order-explicit-evidence-promise-chain-finalizer-trace-missing');
+  return reasonCodes;
+}
+
+function resourceManagementProofReasonCodes(candidate, expected) {
+  if (!expected.runtimeKinds.includes('resource-management')) return [];
+  const reasonCodes = [];
+  if (candidate.disposalEffectEquivalenceClaim !== false) reasonCodes.push('runtime-order-explicit-evidence-claim-flags-missing');
+  const orderHash = firstString(candidate.resourceManagementDisposalOrderHash, candidate.disposalOrderHash);
+  if (expected.resourceManagementOrderHash && !orderHash) reasonCodes.push('runtime-order-explicit-evidence-resource-management-disposal-order-hash-missing');
+  else if (expected.resourceManagementOrderHash && orderHash !== expected.resourceManagementOrderHash) reasonCodes.push('runtime-order-explicit-evidence-resource-management-disposal-order-hash-mismatch');
+  const asyncTraceHash = firstString(candidate.resourceManagementAsyncDisposalTraceHash, candidate.asyncDisposalTraceHash, candidate.disposalTraceHash);
+  if (expected.resourceManagementNeedsAsyncTrace && !asyncTraceHash) reasonCodes.push('runtime-order-explicit-evidence-resource-management-async-disposal-trace-missing');
+  return reasonCodes;
+}
+
+function generatorProtocolProofReasonCodes(candidate, expected) {
+  if (!expected.runtimeKinds.includes('generator') && !expected.generatorProtocolOrderHash) return [];
+  const reasonCodes = [];
+  if (candidate.generatorRuntimeEquivalenceClaim !== false) reasonCodes.push('runtime-order-explicit-evidence-claim-flags-missing');
+  const orderHash = firstString(candidate.generatorProtocolOrderHash, candidate.iteratorProtocolOrderHash, candidate.asyncGeneratorProtocolOrderHash, candidate.asyncIteratorProtocolOrderHash);
+  if (expected.generatorProtocolOrderHash && !orderHash) reasonCodes.push('runtime-order-explicit-evidence-generator-protocol-order-hash-missing');
+  else if (expected.generatorProtocolOrderHash && orderHash !== expected.generatorProtocolOrderHash) reasonCodes.push('runtime-order-explicit-evidence-generator-protocol-order-hash-mismatch');
+  if (!firstString(candidate.generatorProtocolTraceHash, candidate.iteratorProtocolTraceHash)) reasonCodes.push('runtime-order-explicit-evidence-generator-protocol-trace-missing');
+  if (expected.generatorProtocolNeedsAsyncIteratorTrace) {
+    if (!firstString(candidate.asyncGeneratorProtocolTraceHash, candidate.asyncIteratorProtocolTraceHash)) reasonCodes.push('runtime-order-explicit-evidence-async-generator-protocol-trace-missing');
+    if (!firstString(candidate.asyncGeneratorCancellationTraceHash, candidate.asyncIteratorCancellationTraceHash)) reasonCodes.push('runtime-order-explicit-evidence-async-generator-cancellation-trace-missing');
+    if (!firstString(candidate.asyncGeneratorBackpressureTraceHash, candidate.asyncIteratorBackpressureTraceHash)) reasonCodes.push('runtime-order-explicit-evidence-async-generator-backpressure-trace-missing');
+    if (candidate.asyncGeneratorRuntimeEquivalenceClaim !== false || candidate.asyncIteratorProtocolEquivalenceClaim !== false || candidate.asyncIteratorCancellationEquivalenceClaim !== false || candidate.asyncIteratorBackpressureEquivalenceClaim !== false) reasonCodes.push('runtime-order-explicit-evidence-claim-flags-missing');
+  }
+  if (expected.generatorProtocolNeedsIteratorTrace) {
+    if (!firstString(candidate.iteratorProtocolTraceHash, candidate.generatorIteratorTraceHash)) reasonCodes.push('runtime-order-explicit-evidence-generator-iterator-protocol-trace-missing');
+    if (!firstString(candidate.delegatedCompletionTraceHash, candidate.generatorCompletionTraceHash)) reasonCodes.push('runtime-order-explicit-evidence-generator-completion-trace-missing');
+    if (candidate.iteratorProtocolEquivalenceClaim !== false || candidate.delegatedCompletionPropagationClaim !== false) reasonCodes.push('runtime-order-explicit-evidence-claim-flags-missing');
+  }
+  return reasonCodes;
+}
+
+function classStaticBlockProofReasonCodes(candidate, expected) {
+  if (!expected.runtimeKinds.includes('class-static-block') && !expected.classStaticBlockOrderHash) return [];
+  const reasonCodes = [];
+  if (candidate.classStaticBlockRuntimeEquivalenceClaim !== false || candidate.staticInitializationEquivalenceClaim !== false) reasonCodes.push('runtime-order-explicit-evidence-claim-flags-missing');
+  const orderHash = firstString(candidate.classStaticBlockOrderHash, candidate.staticInitializationOrderHash);
+  if (expected.classStaticBlockOrderHash && !orderHash) reasonCodes.push('runtime-order-explicit-evidence-class-static-block-order-hash-missing');
+  else if (expected.classStaticBlockOrderHash && orderHash !== expected.classStaticBlockOrderHash) reasonCodes.push('runtime-order-explicit-evidence-class-static-block-order-hash-mismatch');
+  if (!firstString(candidate.classStaticBlockExecutionTraceHash, candidate.staticInitializationTraceHash, candidate.classStaticBlockEffectTraceHash)) reasonCodes.push('runtime-order-explicit-evidence-class-static-block-execution-trace-missing');
+  return reasonCodes;
+}
+
+function topLevelAwaitProofReasonCodes(candidate, expected) {
+  if (!expected.topLevelAwaitOrderHash) return [];
+  const reasonCodes = [];
+  if (candidate.topLevelAwaitSuspensionEquivalenceClaim !== false || candidate.moduleEvaluationOrderEquivalenceClaim !== false) reasonCodes.push('runtime-order-explicit-evidence-claim-flags-missing');
+  const orderHash = firstString(candidate.topLevelAwaitOrderHash, candidate.topLevelAwaitSuspensionOrderHash);
+  if (!orderHash) reasonCodes.push('runtime-order-explicit-evidence-top-level-await-order-hash-missing');
+  else if (orderHash !== expected.topLevelAwaitOrderHash) reasonCodes.push('runtime-order-explicit-evidence-top-level-await-order-hash-mismatch');
+  if (!firstString(candidate.topLevelAwaitSuspensionTraceHash, candidate.moduleEvaluationTraceHash)) reasonCodes.push('runtime-order-explicit-evidence-top-level-await-suspension-trace-missing');
+  return reasonCodes;
+}
+
+function importMetaHostContextHash(region) {
+  const evidence = region?.metadata?.runtimeOrderEvidence ?? region?.runtimeOrderEvidence;
+  const records = array(evidence?.importMetaHostContext);
+  return records.length ? hashSemanticValue({
+    kind: 'frontier.lang.runtimeOrderProofEvidence.importMetaHostContext',
+    sourcePath: region?.sourcePath,
+    regionKind: runtimeRegionKind(region),
+    runtimeKind: region?.runtimeKind,
+    symbolName: region?.symbolName,
+    ordinal: region?.ordinal,
+    hostContext: evidence?.hostContext,
+    importMetaMemberNames: evidence?.importMetaMemberNames,
+    records: records.map(importMetaHostContextRecordForHash)
+  }) : undefined;
+}
+
+function importMetaHostContextRecordForHash(record) {
+  return { kind: record?.kind, ordinal: record?.ordinal, text: record?.text, memberName: record?.memberName, memberPath: record?.memberPath };
+}
+
+function promiseCombinatorOrderHash(region, records = promiseCombinatorOrderRecords(region)) {
+  return records.length ? hashSemanticValue({ kind: 'frontier.lang.runtimeOrderProofEvidence.promiseCombinatorOrder', sourcePath: region?.sourcePath, regionKind: runtimeRegionKind(region), runtimeKind: region?.runtimeKind, symbolName: region?.symbolName, ordinal: region?.ordinal, records: records.map(promiseCombinatorRecordForHash) }) : undefined;
+}
+
+function promiseCombinatorRecordForHash(record) {
+  return { kind: record?.kind, methodName: record?.methodName, concurrencySemantics: record?.concurrencySemantics, settlementPolicy: record?.settlementPolicy, argumentOrdinal: record?.argumentOrdinal, argumentText: record?.argumentText, directArrayArgument: record?.directArrayArgument === true, arrayElementOrdinal: record?.arrayElementOrdinal, arrayElementCount: record?.arrayElementCount, arrayElementText: record?.arrayElementText, callText: record?.callText, runtimeEquivalenceClaim: record?.runtimeEquivalenceClaim, semanticEquivalenceClaim: record?.semanticEquivalenceClaim };
+}
+
+function promiseCombinatorOrderRecords(region) {
+  return array(region?.metadata?.runtimeOrderEvidence?.sameLinePromiseCombinator ?? region?.runtimeOrderEvidence?.sameLinePromiseCombinator);
+}
+
+function promiseChainOrderHash(region, records = promiseChainOrderRecords(region)) {
+  return records.length ? hashSemanticValue({ kind: 'frontier.lang.runtimeOrderProofEvidence.promiseChainOrder', sourcePath: region?.sourcePath, regionKind: runtimeRegionKind(region), runtimeKind: region?.runtimeKind, symbolName: region?.symbolName, ordinal: region?.ordinal, records: records.map(promiseChainRecordForHash) }) : undefined;
+}
+
+function promiseChainRecordForHash(record) {
+  return { kind: record?.kind, regionRole: record?.regionRole, handlerMethodName: record?.handlerMethodName, handlerStepOrdinal: record?.handlerStepOrdinal, chainMethods: array(record?.chainMethods), stepCount: record?.stepCount, hasThen: record?.hasThen === true, hasCatch: record?.hasCatch === true, hasFinally: record?.hasFinally === true, chainText: record?.chainText, steps: array(record?.steps).map(promiseChainStepForHash), handlerExecutionEquivalenceClaim: record?.handlerExecutionEquivalenceClaim, runtimeEquivalenceClaim: record?.runtimeEquivalenceClaim, semanticEquivalenceClaim: record?.semanticEquivalenceClaim };
+}
+
+function promiseChainStepForHash(step) {
+  return { ordinal: step?.ordinal, methodName: step?.methodName, handlerText: step?.handlerText, handlerOrdinal: step?.handlerOrdinal };
+}
+
+function promiseChainOrderRecords(region) {
+  return array(region?.metadata?.runtimeOrderEvidence?.sameLinePromiseChain ?? region?.runtimeOrderEvidence?.sameLinePromiseChain);
+}
+
+function classStaticBlockOrderHash(region) {
+  const records = classStaticBlockOrderRecords(region);
+  return records.length ? hashSemanticValue({ kind: 'frontier.lang.runtimeOrderProofEvidence.classStaticBlockOrder', sourcePath: region?.sourcePath, regionKind: runtimeRegionKind(region), runtimeKind: region?.runtimeKind, symbolName: region?.symbolName, ordinal: region?.ordinal, records: records.map(classStaticBlockOrderRecordForHash) }) : undefined;
+}
+
+function classStaticBlockOrderRecordForHash(record) {
+  return { kind: record?.kind, className: record?.className, ordinal: record?.ordinal, statementCount: record?.statementCount, line: record?.line, column: record?.column, text: record?.text };
+}
+
+function classStaticBlockOrderRecords(region) {
+  return array(region?.metadata?.runtimeOrderEvidence?.classStaticBlockOrder ?? region?.runtimeOrderEvidence?.classStaticBlockOrder);
+}
+
+function topLevelAwaitOrderHash(region) {
+  const records = topLevelAwaitOrderRecords(region);
+  return records.length ? hashSemanticValue({ kind: 'frontier.lang.runtimeOrderProofEvidence.topLevelAwaitOrder', sourcePath: region?.sourcePath, regionKind: runtimeRegionKind(region), runtimeKind: region?.runtimeKind, symbolName: region?.symbolName, ordinal: region?.ordinal, records }) : undefined;
+}
+
+function topLevelAwaitOrderRecords(region) {
+  const evidence = region?.metadata?.runtimeOrderEvidence ?? region?.runtimeOrderEvidence;
+  return evidence?.topLevelAwait ? [...array(evidence.sameLineAwaitOrder).map((record) => ({ kind: record?.kind, ordinal: record?.ordinal, text: record?.text })), { kind: 'top-level-await', runtimeScope: evidence.runtimeScope, line: evidence.line, runtimeOrderIndex: evidence.runtimeOrderIndex, previousRegionKind: evidence.previousRegionKind, previousRuntimeKind: evidence.previousRuntimeKind, previousRuntimeKinds: evidence.previousRuntimeKinds }] : [];
+}
+
+function generatorProtocolOrderHash(region, records = generatorProtocolRecords(region)) {
+  return records.length ? hashSemanticValue({ kind: 'frontier.lang.runtimeOrderProofEvidence.generatorProtocolOrder', sourcePath: region?.sourcePath, regionKind: runtimeRegionKind(region), runtimeKind: region?.runtimeKind, symbolName: region?.symbolName, ordinal: region?.ordinal, records: records.map(generatorProtocolRecordForHash) }) : undefined;
+}
+
+function generatorProtocolRecordForHash(record) {
+  return { kind: record?.kind, delegated: record?.delegated === true, delegationKind: record?.delegationKind, delegatedIterableText: record?.delegatedIterableText, line: record?.line, column: record?.column, targetText: record?.targetText, calleeName: record?.calleeName, effectKind: record?.effectKind, iteratorProtocolEquivalenceClaim: record?.iteratorProtocolEquivalenceClaim, delegatedCompletionPropagationClaim: record?.delegatedCompletionPropagationClaim };
+}
+
+function generatorProtocolRecords(region) {
+  const evidence = region?.metadata?.runtimeOrderEvidence ?? region?.runtimeOrderEvidence;
+  return [...array(evidence?.exitOrder), ...array(evidence?.effectTargetOrder), ...array(evidence?.sameLineYieldOrder)].filter(isGeneratorProtocolRecord);
+}
+
+function isGeneratorProtocolRecord(record) {
+  return record?.kind === 'yield' || record?.effectKind === 'generator' || record?.delegated === true || record?.delegationKind === 'iterator-delegation';
+}
+
+function runtimeKinds(region) {
+  return uniqueStrings([
+    ...array(region?.runtimeKinds),
+    ...array(region?.runtimeKind),
+    ...array(region?.metadata?.factKinds),
+    ...array(region?.metadata?.factKind)
+  ].flatMap((kind) => String(kind ?? '').split('+')).filter(Boolean));
+}
+
+function resourceManagementOrderHash(region, records = resourceManagementOrderRecords(region)) {
+  return records.length ? hashSemanticValue({ kind: 'frontier.lang.runtimeOrderProofEvidence.resourceManagementDisposalOrder', sourcePath: region?.sourcePath, regionKind: runtimeRegionKind(region), runtimeKind: region?.runtimeKind, symbolName: region?.symbolName, ordinal: region?.ordinal, records: records.map(resourceManagementOrderRecordForHash) }) : undefined;
+}
+
+function resourceManagementOrderRecordForHash(record) {
+  return { name: record?.name, declarationKind: record?.declarationKind, awaitUsing: record?.awaitUsing === true, acquisitionOrderIndex: record?.acquisitionOrderIndex, disposalOrderIndex: record?.disposalOrderIndex, disposalOrder: record?.disposalOrder, scopeStartLine: record?.scopeStartLine, scopeExitLine: record?.scopeExitLine, declarationText: record?.declarationText, initializerText: record?.initializerText, disposalMethodPolicy: record?.disposalMethodPolicy };
+}
+
+function resourceManagementOrderRecords(region) {
+  return array(region?.metadata?.runtimeOrderEvidence?.resourceManagementOrder ?? region?.runtimeOrderEvidence?.resourceManagementOrder);
+}
+
+function runtimeRegionKind(region) { return String(region?.regionKind ?? ''); }
+function firstString(...values) { return values.find((value) => typeof value === 'string' && value.length > 0); }
+function array(value) { return value === undefined || value === null ? [] : Array.isArray(value) ? value : [value]; }
+
+export { runtimeOrderProofSurfaceReasonCodes, runtimeOrderSurfaceExpectations };