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

package/dist/js-ts-safe-project-merge-runtime-region-conflicts.js

@@ -0,0 +1,156 @@
+import { compactRecord } from './js-ts-safe-merge-context.js';
+import { runtimeOrderEvidenceBinding } from './internal/index-impl/runtimeOrderEvidenceBinding.js';
+import { runtimeOrderReasonCodes } from './internal/index-impl/semanticEditRuntimeOrderReasons.js';
+
+function projectRuntimeRegionDeltaConflicts(projectGraphDelta, options = {}) {
+  const baseGraph = projectGraphDelta?.stages?.base?.projectSymbolGraph;
+  const workerGraph = projectGraphDelta?.stages?.worker?.projectSymbolGraph;
+  const headGraph = projectGraphDelta?.stages?.head?.projectSymbolGraph;
+  const outputGraph = projectGraphDelta?.stages?.output?.projectSymbolGraph;
+  if (!baseGraph || !workerGraph || !headGraph) return [];
+  const base = runtimeRecordsByIdentityKey(baseGraph.runtimeRegionRecords);
+  const worker = runtimeRecordsByIdentityKey(workerGraph.runtimeRegionRecords);
+  const head = runtimeRecordsByIdentityKey(headGraph.runtimeRegionRecords);
+  const output = runtimeRecordsByIdentityKey(outputGraph?.runtimeRegionRecords);
+  return uniqueStrings([...base.keys(), ...worker.keys(), ...head.keys()]).flatMap((identityKey) => {
+    const baseRecord = base.get(identityKey);
+    const workerRecord = worker.get(identityKey);
+    const headRecord = head.get(identityKey);
+    const fingerprints = [runtimeFingerprint(baseRecord), runtimeFingerprint(workerRecord), runtimeFingerprint(headRecord)];
+    if (fingerprints[0] === fingerprints[1] || fingerprints[0] === fingerprints[2] || fingerprints[1] === fingerprints[2]) return [];
+    const explicitEvidence = projectRuntimeOrderEvidenceBinding(identityKey, baseRecord, workerRecord, headRecord, output.get(identityKey), options);
+    if (explicitEvidence.passed) return [];
+    return [projectRuntimeRegionDeltaConflict(identityKey, baseRecord, workerRecord, headRecord, output.get(identityKey), explicitEvidence)];
+  });
+}
+
+function projectRuntimeRegionDeltaConflict(identityKey, baseRecord, workerRecord, headRecord, outputRecord, explicitEvidence) {
+  const sourcePath = workerRecord?.sourcePath ?? headRecord?.sourcePath ?? baseRecord?.sourcePath;
+  return {
+    code: 'project-public-runtime-region-delta-conflict',
+    gateId: 'project-graph-delta',
+    message: `Worker and head both changed public runtime region ${JSON.stringify(identityKey)} in incompatible ways.`,
+    sourcePath,
+    details: compactRecord({
+      reasonCode: 'project-public-runtime-region-delta-conflict',
+      conflictKey: `project-graph-delta#runtime-region#${identityKey}`,
+      identityKey,
+      sourcePath,
+      reasonCodes: runtimeConflictReasonCodes(baseRecord, workerRecord, headRecord, outputRecord, explicitEvidence),
+      explicitRuntimeOrderEvidence: explicitEvidenceDetails(explicitEvidence),
+      base: runtimeDetails(baseRecord),
+      worker: runtimeDetails(workerRecord),
+      head: runtimeDetails(headRecord),
+      output: runtimeDetails(outputRecord)
+    })
+  };
+}
+
+function projectRuntimeOrderEvidenceBinding(identityKey, baseRecord, workerRecord, headRecord, outputRecord, options) {
+  return runtimeOrderEvidenceBinding({
+    scriptInput: {
+      runtimeOrderEvidence: runtimeOrderEvidenceCandidates(options),
+      evidence: options.evidence
+    },
+    region: outputRecord ?? workerRecord ?? headRecord ?? baseRecord,
+    baseSymbol: baseRecord,
+    workerSymbol: workerRecord,
+    headSymbol: headRecord,
+    anchorKey: workerRecord?.key ?? headRecord?.key ?? baseRecord?.key ?? identityKey,
+    context: {
+      workerChangeSet: {
+        sourcePath: workerRecord?.sourcePath ?? baseRecord?.sourcePath,
+        beforeHash: baseRecord?.sourceHash,
+        afterHash: workerRecord?.sourceHash
+      },
+      headChangeSet: {
+        sourcePath: headRecord?.sourcePath ?? baseRecord?.sourcePath,
+        afterHash: headRecord?.sourceHash
+      }
+    }
+  });
+}
+
+function runtimeOrderEvidenceCandidates(options) {
+  return [
+    ...array(options.runtimeOrderEvidence),
+    ...array(options.projectRuntimeOrderEvidence),
+    ...array(options.metadata?.runtimeOrderEvidence)
+  ];
+}
+
+function runtimeRecordsByIdentityKey(records = []) {
+  const result = new Map();
+  for (const record of records) {
+    if (!record?.publicContract) continue;
+    const key = runtimeIdentityKey(record);
+    if (key && !result.has(key)) result.set(key, record);
+  }
+  return result;
+}
+
+function runtimeIdentityKey(record) {
+  return stableKey(['runtime-region', record?.sourcePath, record?.symbolName, record?.regionKind, record?.runtimeKind, record?.ordinal]);
+}
+
+function runtimeFingerprint(record) { return record ? stableKey([record.signatureHash, record.regionKind, record.runtimeKind]) : undefined; }
+function runtimeDetails(record) {
+  if (!record) return undefined;
+  return compactRecord({
+    sourcePath: record.sourcePath,
+    symbolName: record.symbolName,
+    symbolKind: record.symbolKind,
+    regionKind: record.regionKind,
+    runtimeKind: record.runtimeKind,
+    runtimeKinds: record.runtimeKinds,
+    line: record.line,
+    ordinal: record.ordinal,
+    spanKind: record.spanKind,
+    runtimeOrderEvidence: record.runtimeOrderEvidence,
+    reasonCodes: runtimeRecordReasonCodes(record),
+    signatureHash: record.signatureHash,
+    sourceHash: record.sourceHash
+  });
+}
+
+function runtimeConflictReasonCodes(...records) {
+  const explicitEvidence = records.find((record) => record?.reasonCodes);
+  const runtimeRecords = records.filter((record) => !record?.reasonCodes);
+  return uniqueStrings([
+    'project-public-runtime-region-delta-conflict',
+    ...(explicitEvidence?.reasonCodes ?? []),
+    ...runtimeRecords.flatMap(runtimeRecordReasonCodes)
+  ]);
+}
+
+function explicitEvidenceDetails(evidence) {
+  if (!evidence?.reasonCodes?.length) return undefined;
+  return {
+    status: 'failed',
+    reasonCodes: evidence.reasonCodes,
+    evidenceIds: evidence.evidenceIds
+  };
+}
+
+function runtimeRecordReasonCodes(record) {
+  if (!record) return [];
+  return runtimeOrderReasonCodes({
+    region: {
+      ...record,
+      metadata: {
+        factKinds: record.runtimeKinds ?? (record.runtimeKind ? [record.runtimeKind] : undefined),
+        runtimeOrderEvidence: record.runtimeOrderEvidence,
+        subjectName: record.symbolName
+      }
+    }
+  });
+}
+
+function stableKey(parts) {
+  const values = parts.map((part) => part === undefined || part === null ? '' : String(part));
+  return values.some(Boolean) ? values.join('#') : undefined;
+}
+function uniqueStrings(values) { return [...new Set(values.filter((value) => typeof value === 'string' && value.length > 0))]; }
+function array(value) { return value === undefined || value === null ? [] : Array.isArray(value) ? value : [value]; }
+
+export { projectRuntimeRegionDeltaConflicts };

package/dist/js-ts-safe-project-merge-scope-use-def-conflicts.js

@@ -0,0 +1,292 @@
+import { compactRecord } from './js-ts-safe-merge-context.js';
+
+function projectScopeUseDefDeltaConflicts(projectGraphDelta) {
+  const baseGraph = projectGraphDelta?.stages?.base?.projectSymbolGraph;
+  const workerGraph = projectGraphDelta?.stages?.worker?.projectSymbolGraph;
+  const headGraph = projectGraphDelta?.stages?.head?.projectSymbolGraph;
+  const outputGraph = projectGraphDelta?.stages?.output?.projectSymbolGraph;
+  const ambiguousOutputConflicts = projectScopeUseDefAmbiguousEvidenceConflicts(outputGraph);
+  if (!baseGraph || !workerGraph || !headGraph) return ambiguousOutputConflicts;
+  const base = publicScopeBindings(baseGraph.scopeBindingRecords);
+  const worker = publicScopeBindings(workerGraph.scopeBindingRecords);
+  const head = publicScopeBindings(headGraph.scopeBindingRecords);
+  const output = publicScopeBindings(outputGraph?.scopeBindingRecords);
+  const referenceDeltaConflicts = projectScopeReferenceDeltaConflicts(baseGraph, workerGraph, headGraph, outputGraph);
+  const deltaConflicts = uniqueStrings([...base.keys(), ...worker.keys(), ...head.keys()]).flatMap((identityKey) => {
+    const baseRecord = base.get(identityKey);
+    const workerRecord = worker.get(identityKey);
+    const headRecord = head.get(identityKey);
+    const fingerprints = [scopeFingerprint(baseRecord), scopeFingerprint(workerRecord), scopeFingerprint(headRecord)];
+    if (fingerprints[0] === fingerprints[1] || fingerprints[0] === fingerprints[2] || fingerprints[1] === fingerprints[2]) return [];
+    return [projectScopeUseDefDeltaConflict(identityKey, baseRecord, workerRecord, headRecord, output.get(identityKey))];
+  });
+  return [...ambiguousOutputConflicts, ...referenceDeltaConflicts, ...deltaConflicts];
+}
+
+function projectScopeUseDefDeltaConflict(identityKey, baseRecord, workerRecord, headRecord, outputRecord) {
+  const sourcePath = workerRecord?.sourcePath ?? headRecord?.sourcePath ?? baseRecord?.sourcePath;
+  return {
+    code: 'project-public-scope-use-def-delta-conflict',
+    gateId: 'project-graph-delta',
+    message: `Worker and head both changed public scope/use-def binding ${JSON.stringify(identityKey)} in incompatible ways.`,
+    sourcePath,
+    details: compactRecord({
+      reasonCode: 'project-public-scope-use-def-delta-conflict',
+      conflictKey: `project-graph-delta#scope-use-def#${identityKey}`,
+      identityKey,
+      sourcePath,
+      base: scopeDetails(baseRecord),
+      worker: scopeDetails(workerRecord),
+      head: scopeDetails(headRecord),
+      output: scopeDetails(outputRecord)
+    })
+  };
+}
+
+function publicScopeBindings(records = []) {
+  const result = new Map();
+  for (const record of records) {
+    if (!record?.publicContract) continue;
+    const key = scopeIdentityKey(record);
+    if (key && !result.has(key)) result.set(key, record);
+  }
+  return result;
+}
+
+function projectScopeUseDefAmbiguousEvidenceConflicts(graph) {
+  const bindingConflicts = [...publicScopeBindings(graph?.scopeBindingRecords).entries()]
+    .filter(([, record]) => record?.scopeUseDefStatus === 'blocked' && record.scopeUseDefReasonCodes?.length)
+    .map(([identityKey, record]) => projectScopeUseDefAmbiguousEvidenceConflict(identityKey, record));
+  const referenceConflicts = [...publicScopeReferences(graph?.scopeReferenceRecords).entries()]
+    .filter(([, record]) => (record.status === 'blocked' || record.status === 'unresolved') && record.reasonCodes?.length)
+    .map(([identityKey, record]) => projectScopeReferenceAmbiguousEvidenceConflict(identityKey, record));
+  return [...bindingConflicts, ...referenceConflicts];
+}
+
+function projectScopeUseDefAmbiguousEvidenceConflict(identityKey, record) {
+  return {
+    code: 'project-public-scope-use-def-ambiguous-evidence',
+    gateId: 'project-graph-delta',
+    message: `Output public scope/use-def binding ${JSON.stringify(identityKey)} has unsupported or ambiguous use-def evidence.`,
+    sourcePath: record.sourcePath,
+    details: compactRecord({
+      reasonCode: 'project-public-scope-use-def-ambiguous-evidence',
+      conflictKey: `project-graph-delta#scope-use-def-ambiguous#${identityKey}`,
+      identityKey,
+      sourcePath: record.sourcePath,
+      reasonCodes: record.scopeUseDefReasonCodes,
+      output: scopeDetails(record)
+    })
+  };
+}
+
+function scopeIdentityKey(record) {
+  return stableKey(['scope-binding', record?.sourcePath, record?.publicOwnerName, record?.name, record?.bindingKind, record?.namespaces?.join('|'), record?.ordinal]);
+}
+
+function projectScopeReferenceDeltaConflicts(baseGraph, workerGraph, headGraph, outputGraph) {
+  const base = publicScopeReferences(baseGraph.scopeReferenceRecords);
+  const worker = publicScopeReferences(workerGraph.scopeReferenceRecords);
+  const head = publicScopeReferences(headGraph.scopeReferenceRecords);
+  const output = publicScopeReferences(outputGraph?.scopeReferenceRecords);
+  return uniqueStrings([...base.keys(), ...worker.keys(), ...head.keys()]).flatMap((identityKey) => {
+    const baseRecord = base.get(identityKey);
+    const workerRecord = worker.get(identityKey);
+    const headRecord = head.get(identityKey);
+    const fingerprints = [scopeReferenceFingerprint(baseRecord), scopeReferenceFingerprint(workerRecord), scopeReferenceFingerprint(headRecord)];
+    if (fingerprints[0] === fingerprints[1] || fingerprints[0] === fingerprints[2] || fingerprints[1] === fingerprints[2]) return [];
+    return [projectScopeReferenceDeltaConflict(identityKey, baseRecord, workerRecord, headRecord, output.get(identityKey))];
+  });
+}
+
+function projectScopeReferenceDeltaConflict(identityKey, baseRecord, workerRecord, headRecord, outputRecord) {
+  const sourcePath = workerRecord?.sourcePath ?? headRecord?.sourcePath ?? baseRecord?.sourcePath;
+  return {
+    code: 'project-public-scope-reference-delta-conflict',
+    gateId: 'project-graph-delta',
+    message: `Worker and head both changed public scope/use-def reference ${JSON.stringify(identityKey)} in incompatible ways.`,
+    sourcePath,
+    details: compactRecord({
+      reasonCode: 'project-public-scope-reference-delta-conflict',
+      conflictKey: `project-graph-delta#scope-reference#${identityKey}`,
+      identityKey,
+      sourcePath,
+      base: scopeReferenceDetails(baseRecord),
+      worker: scopeReferenceDetails(workerRecord),
+      head: scopeReferenceDetails(headRecord),
+      output: scopeReferenceDetails(outputRecord)
+    })
+  };
+}
+
+function projectScopeReferenceAmbiguousEvidenceConflict(identityKey, record) {
+  return {
+    code: 'project-public-scope-reference-ambiguous-evidence',
+    gateId: 'project-graph-delta',
+    message: `Output public scope/use-def reference ${JSON.stringify(identityKey)} has unsupported or ambiguous evidence.`,
+    sourcePath: record.sourcePath,
+    details: compactRecord({
+      reasonCode: 'project-public-scope-reference-ambiguous-evidence',
+      conflictKey: `project-graph-delta#scope-reference-ambiguous#${identityKey}`,
+      identityKey,
+      sourcePath: record.sourcePath,
+      reasonCodes: record.reasonCodes,
+      output: scopeReferenceDetails(record)
+    })
+  };
+}
+
+function publicScopeReferences(records = []) {
+  const result = new Map();
+  for (const record of records) {
+    if (!record?.publicContract) continue;
+    const key = scopeReferenceIdentityKey(record);
+    if (key && !result.has(key)) result.set(key, record);
+  }
+  return result;
+}
+
+function scopeReferenceIdentityKey(record) {
+  return stableKey(['scope-reference', record?.sourcePath, record?.publicOwnerName, record?.bindingName ?? record?.name, record?.namespace, record?.ordinal ?? record?.start]);
+}
+
+function scopeFingerprint(record) {
+  return record ? stableKey([
+    record.signatureHash,
+    record.useHash,
+    record.localUseHash,
+    record.resolvedUseHash,
+    record.publicOwnerUseHash,
+    record.closureUseHash,
+    record.aliasHash,
+    record.scopeUseDefStatus,
+    record.scopeUseDefReasonCodes?.join('|'),
+    record.referenceCount,
+    record.closureReferenceCount
+  ]) : undefined;
+}
+
+function scopeReferenceFingerprint(record) {
+  return record ? stableKey([
+    record.signatureHash,
+    record.resolvedUseHash,
+    record.resolvedBindingUseHash,
+    record.moduleSpecifier,
+    record.importedName,
+    record.resolvedSourcePath,
+    record.resolvedExportName,
+    record.closureCaptureHash,
+    record.templateExpressionHash,
+    record.templateLiteralKind,
+    record.taggedTemplate,
+    record.templateTagText,
+    record.templateTagRoot,
+    record.templateTagMemberName,
+    record.memberName,
+    record.memberComputed,
+    record.memberOptional,
+    record.writeOperation,
+    record.status,
+    record.reasonCodes?.join('|'),
+    record.aliasResolutionStatus,
+    record.originSourcePath,
+    record.resolvedBindingName,
+    record.compilerReferenceStatus,
+    record.compilerReferenceReasonCodes?.join('|'),
+    record.compilerReferenceSymbolId,
+    record.compilerReferenceIdentityHash,
+    record.compilerReferenceProofHash
+  ]) : undefined;
+}
+
+function scopeDetails(record) {
+  if (!record) return undefined;
+  return compactRecord({
+    sourcePath: record.sourcePath,
+    name: record.name,
+    bindingKind: record.bindingKind,
+    publicOwnerName: record.publicOwnerName,
+    namespaces: record.namespaces,
+    ordinal: record.ordinal,
+    referenceCount: record.referenceCount,
+    closureReferenceCount: record.closureReferenceCount,
+    signatureHash: record.signatureHash,
+    useHash: record.useHash,
+    localUseHash: record.localUseHash,
+    resolvedUseHash: record.resolvedUseHash,
+    publicOwnerUseHash: record.publicOwnerUseHash,
+    closureUseHash: record.closureUseHash,
+    aliasHash: record.aliasHash,
+    scopeUseDefStatus: record.scopeUseDefStatus,
+    scopeUseDefReasonCodes: record.scopeUseDefReasonCodes,
+    importedName: record.importedName,
+    moduleSpecifier: record.moduleSpecifier,
+    resolvedSourcePath: record.resolvedSourcePath,
+    originSourcePath: record.originSourcePath,
+    resolvedBindingName: record.resolvedBindingName,
+    resolvedBindingUseHash: record.resolvedBindingUseHash,
+    exportedNames: record.exportedNames,
+    reExportedNames: record.reExportedNames,
+    sourceHash: record.sourceHash
+  });
+}
+
+function scopeReferenceDetails(record) {
+  if (!record) return undefined;
+  return compactRecord({
+    sourcePath: record.sourcePath,
+    name: record.name,
+    namespace: record.namespace,
+    bindingName: record.bindingName,
+    bindingKind: record.bindingKind,
+    bindingOrdinal: record.bindingOrdinal,
+    publicOwnerName: record.publicOwnerName,
+    referenceKind: record.referenceKind,
+    memberName: record.memberName,
+    memberComputed: record.memberComputed,
+    memberOptional: record.memberOptional,
+    writeOperation: record.writeOperation,
+    closure: record.closure,
+    closureDepthDelta: record.closureDepthDelta,
+    closureCaptureHash: record.closureCaptureHash,
+    templateExpressionHash: record.templateExpressionHash,
+    templateLiteralKind: record.templateLiteralKind,
+    taggedTemplate: record.taggedTemplate,
+    templateTagText: record.templateTagText,
+    templateTagRoot: record.templateTagRoot,
+    templateTagMemberName: record.templateTagMemberName,
+    signatureHash: record.signatureHash,
+    resolvedUseHash: record.resolvedUseHash,
+    importAlias: record.importAlias,
+    moduleSpecifier: record.moduleSpecifier,
+    importedName: record.importedName,
+    resolvedSourcePath: record.resolvedSourcePath,
+    resolvedExportName: record.resolvedExportName,
+    resolvedBindingId: record.resolvedBindingId,
+    resolvedBindingUseHash: record.resolvedBindingUseHash,
+    status: record.status,
+    reasonCodes: record.reasonCodes,
+    aliasResolutionStatus: record.aliasResolutionStatus,
+    originSourcePath: record.originSourcePath,
+    resolvedBindingName: record.resolvedBindingName,
+    compilerReferenceStatus: record.compilerReferenceStatus,
+    compilerReferenceReasonCodes: record.compilerReferenceReasonCodes,
+    compilerReferenceSymbolId: record.compilerReferenceSymbolId,
+    compilerReferenceIdentityHash: record.compilerReferenceIdentityHash,
+    compilerReferenceFullyQualifiedName: record.compilerReferenceFullyQualifiedName,
+    compilerReferenceLocalName: record.compilerReferenceLocalName,
+    compilerReferenceTargetName: record.compilerReferenceTargetName,
+    compilerReferenceAliased: record.compilerReferenceAliased,
+    compilerReferenceProofHash: record.compilerReferenceProofHash,
+    compilerReferenceCandidates: record.compilerReferenceCandidates,
+    sourceHash: record.sourceHash
+  });
+}
+
+function stableKey(parts) {
+  const values = parts.map((part) => part === undefined || part === null ? '' : String(part));
+  return values.some(Boolean) ? values.join('#') : undefined;
+}
+function uniqueStrings(values) { return [...new Set(values.filter((value) => typeof value === 'string' && value.length > 0))]; }
+
+export { projectScopeUseDefDeltaConflicts };

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

@@ -0,0 +1,175 @@
+import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
+import { compactRecord } from './js-ts-safe-merge-context.js';
+
+const ExternalSemanticEquivalenceLevel = 'semantic-equivalence-external';
+const ExternalSemanticEquivalenceSchema = 'frontier.lang.jsTsProjectSemanticEquivalenceProof.v1';
+const ExternalSemanticEquivalenceKind = 'frontier.lang.jsTsProjectSemanticEquivalenceProof';
+const ExternalSemanticEquivalenceClaimBoundary = 'exact-js-ts-project-source-output-and-gates';
+
+function semanticEquivalenceExternalEvidence(id, input = {}) {
+  const proof = input.externalSemanticEquivalenceProof ?? input.semanticEquivalenceProof;
+  if (proof === undefined) return undefined;
+  const expected = jsTsProjectSemanticEquivalenceExpectedBinding(id, input);
+  const reasonCodes = semanticEquivalenceProofReasonCodes(proof, expected);
+  const status = reasonCodes.length === 0 ? 'passed' : 'failed';
+  return {
+    id: `${id}_proof_semantic_equivalence_external`,
+    kind: 'js-ts-project-merge-proof-evidence',
+    level: ExternalSemanticEquivalenceLevel,
+    status,
+    scope: 'project',
+    claimKind: 'external-semantic-equivalence',
+    evidenceOnly: false,
+    proofClaim: status === 'passed',
+    autoMergeClaim: false,
+    semanticEquivalenceClaim: status === 'passed',
+    summary: status === 'passed'
+      ? 'External semantic equivalence proof is source/output/gate-bound and passed.'
+      : 'External semantic equivalence proof was supplied but did not validate against the project binding.',
+    metadata: compactRecord({
+      proofId: proof?.id,
+      evidenceId: proof?.evidenceId,
+      verifier: proof?.verifier,
+      command: proof?.command,
+      artifactHash: proof?.artifactHash,
+      expected,
+      reasonCodes,
+      proofHash: proof?.proofHash,
+      expectedProofHash: proof && typeof proof === 'object' ? jsTsProjectSemanticEquivalenceProofHash(proof) : undefined,
+      proofClaim: status === 'passed',
+      autoMergeClaim: false,
+      semanticEquivalenceClaim: status === 'passed'
+    })
+  };
+}
+
+function jsTsProjectSemanticEquivalenceExpectedBinding(id, input = {}) {
+  const sourceFileBindings = normalizeSourceFileBindings(input.fileResults ?? []);
+  const sourceSetHash = hashSemanticValue({ kind: 'frontier.lang.jsTsProjectSemanticEquivalenceSourceSet.v1', sourceFileBindings: sourceFileBindings.map(sourceBinding) });
+  const outputSetHash = hashSemanticValue({ kind: 'frontier.lang.jsTsProjectSemanticEquivalenceOutputSet.v1', sourceFileBindings: sourceFileBindings.map(outputBinding) });
+  return compactRecord({
+    schema: 'frontier.lang.jsTsProjectSemanticEquivalenceExpectedBinding.v1',
+    projectId: String(id),
+    language: firstLanguage(input),
+    sourceFileBindings,
+    sourceSetHash,
+    outputSetHash,
+    gates: {
+      diagnostics: gateBinding(input.outputDiagnosticsGate, 'diagnostics'),
+      declarations: gateBinding(input.outputDeclarationGate, 'declarations'),
+      quality: gateBinding(input.outputQualityGate, 'quality')
+    }
+  });
+}
+
+function semanticEquivalenceProofReasonCodes(proof, expected) {
+  if (!proof || typeof proof !== 'object' || Array.isArray(proof)) return ['semantic-equivalence-proof-structured-record-required'];
+  const reasons = [];
+  if (proof.schema !== ExternalSemanticEquivalenceSchema) reasons.push('semantic-equivalence-proof-schema-missing');
+  if (proof.kind !== ExternalSemanticEquivalenceKind) reasons.push('semantic-equivalence-proof-kind-missing');
+  if (!['passed', 'verified'].includes(proof.status)) reasons.push('semantic-equivalence-proof-status-not-passed');
+  if (proof.projectId !== expected.projectId) reasons.push('semantic-equivalence-proof-project-id-mismatch');
+  if (proof.language !== undefined && expected.language !== undefined && proof.language !== expected.language) reasons.push('semantic-equivalence-proof-language-mismatch');
+  reasons.push(...sourceBindingReasonCodes(proof.sourceFileBindings, expected.sourceFileBindings));
+  if (proof.sourceSetHash !== expected.sourceSetHash) reasons.push('semantic-equivalence-proof-source-set-hash-mismatch');
+  if (proof.outputSetHash !== expected.outputSetHash) reasons.push('semantic-equivalence-proof-output-set-hash-mismatch');
+  reasons.push(...gateReasonCodes('diagnostics', proof.gates?.diagnostics, expected.gates.diagnostics));
+  reasons.push(...gateReasonCodes('declaration', proof.gates?.declarations, expected.gates.declarations));
+  reasons.push(...gateReasonCodes('quality', proof.gates?.quality, expected.gates.quality));
+  if (!proof.proofHash) reasons.push('semantic-equivalence-proof-proof-hash-missing');
+  else if (proof.proofHash !== jsTsProjectSemanticEquivalenceProofHash(proof)) reasons.push('semantic-equivalence-proof-proof-hash-mismatch');
+  if (proof.claimKind !== 'external-semantic-equivalence' || proof.claimBoundary !== ExternalSemanticEquivalenceClaimBoundary || proof.semanticEquivalenceClaim !== true) reasons.push('semantic-equivalence-proof-claim-boundary-mismatch');
+  if (proof.autoMergeClaim !== false) reasons.push('semantic-equivalence-proof-auto-merge-claim-not-false');
+  return uniqueStrings(reasons);
+}
+
+function sourceBindingReasonCodes(proofBindings, expectedBindings) {
+  if (!Array.isArray(proofBindings) || proofBindings.length !== expectedBindings.length) return ['semantic-equivalence-proof-source-file-set-mismatch'];
+  const expectedByPath = new Map(expectedBindings.map((binding) => [binding.sourcePath, binding]));
+  const reasons = [];
+  for (const binding of normalizeSourceFileBindings(proofBindings)) {
+    const expected = expectedByPath.get(binding.sourcePath);
+    if (!expected) reasons.push('semantic-equivalence-proof-source-path-mismatch');
+    else for (const field of ['operation', 'baseHash', 'workerHash', 'headHash', 'outputHash', 'deletedOutput']) {
+      if (binding[field] !== expected[field]) reasons.push(`semantic-equivalence-proof-${field.replace(/[A-Z]/g, (char) => `-${char.toLowerCase()}`)}-mismatch`);
+    }
+  }
+  return reasons;
+}
+
+function gateReasonCodes(label, proofGate, expectedGate) {
+  if (!proofGate || !expectedGate) return [`semantic-equivalence-proof-${label}-gate-missing`];
+  const reasons = [];
+  if (proofGate.status !== 'passed' || expectedGate.status !== 'passed') reasons.push(`semantic-equivalence-proof-${label}-gate-status-not-passed`);
+  if (proofGate.id !== expectedGate.id || proofGate.hash !== expectedGate.hash) reasons.push(`semantic-equivalence-proof-${label}-gate-hash-mismatch`);
+  return reasons;
+}
+
+function jsTsProjectSemanticEquivalenceProofHash(proof = {}) {
+  return hashSemanticValue({
+    kind: 'frontier.lang.jsTsProjectSemanticEquivalenceProofHash.v1',
+    schema: proof.schema,
+    kindName: proof.kind,
+    status: proof.status,
+    verifier: proof.verifier,
+    command: proof.command,
+    artifactHash: proof.artifactHash,
+    projectId: proof.projectId,
+    language: proof.language,
+    sourceFileBindings: normalizeSourceFileBindings(proof.sourceFileBindings ?? []),
+    sourceSetHash: proof.sourceSetHash,
+    outputSetHash: proof.outputSetHash,
+    gates: normalizeProofGates(proof.gates),
+    claimKind: proof.claimKind,
+    claimBoundary: proof.claimBoundary,
+    semanticEquivalenceClaim: proof.semanticEquivalenceClaim,
+    autoMergeClaim: proof.autoMergeClaim
+  });
+}
+
+function normalizeSourceFileBindings(bindings = []) {
+  return bindings.map((file) => compactRecord({
+    sourcePath: file.sourcePath,
+    operation: file.operation,
+    baseHash: file.baseHash,
+    workerHash: file.workerHash,
+    headHash: file.headHash,
+    outputHash: file.outputHash,
+    deletedOutput: file.deletedOutput === true || (file.outputHash === undefined && file.status === 'merged') || undefined
+  })).sort((a, b) => String(a.sourcePath).localeCompare(String(b.sourcePath)));
+}
+
+function gateBinding(gate, kind) {
+  if (!gate) return undefined;
+  return compactRecord({
+    id: gate.id,
+    status: gate.status,
+    hash: gate.hash ?? hashSemanticValue({ kind: `frontier.lang.jsTsProjectSemanticEquivalenceGateHash.${kind}.v1`, id: gate.id, status: gate.status, summary: gate.summary, gates: gate.gates }),
+    gateIds: Array.isArray(gate.gates) ? gate.gates.map((entry) => entry.id).filter(Boolean) : undefined
+  });
+}
+
+function normalizeProofGates(gates = {}) {
+  return compactRecord({
+    diagnostics: compactGate(gates.diagnostics),
+    declarations: compactGate(gates.declarations),
+    quality: compactGate(gates.quality)
+  });
+}
+
+function compactGate(gate) { return gate ? compactRecord({ id: gate.id, status: gate.status, hash: gate.hash, gateIds: gate.gateIds }) : undefined; }
+function sourceBinding(binding) { return compactRecord({ sourcePath: binding.sourcePath, operation: binding.operation, baseHash: binding.baseHash, workerHash: binding.workerHash, headHash: binding.headHash }); }
+function outputBinding(binding) { return compactRecord({ sourcePath: binding.sourcePath, operation: binding.operation, outputHash: binding.outputHash, deletedOutput: binding.deletedOutput }); }
+function firstLanguage(input) { return input.language ?? (input.fileResults ?? []).find((file) => file.language)?.language ?? (input.files ?? []).find((file) => file.language)?.language; }
+function uniqueStrings(values) { return [...new Set(values.filter((value) => typeof value === 'string' && value.length > 0))]; }
+
+export {
+  ExternalSemanticEquivalenceClaimBoundary,
+  ExternalSemanticEquivalenceKind,
+  ExternalSemanticEquivalenceLevel,
+  ExternalSemanticEquivalenceSchema,
+  jsTsProjectSemanticEquivalenceExpectedBinding,
+  jsTsProjectSemanticEquivalenceProofHash,
+  semanticEquivalenceExternalEvidence,
+  semanticEquivalenceProofReasonCodes
+};