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

package/dist/js-ts-safe-project-merge-jsx-render-branch-proof.js

@@ -0,0 +1,189 @@
+import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
+import { compactRecord } from './js-ts-safe-merge-context.js';
+
+const JsxRenderReturnBranchRoute = Object.freeze({
+  routeId: 'prove-jsx-render-return-branch-arm-preservation',
+  routeLane: 'jsx-static-render-return-branches',
+  routeNext: 'supply-jsx-render-return-branch-proof'
+});
+
+function jsxRenderReturnBranchProofAssessment(input, options = {}) {
+  const delta = jsxRenderReturnBranchDelta(input);
+  if (!delta) return undefined;
+  const proof = jsxRenderReturnBranchProofFor(delta, options);
+  const reasonCodes = [];
+  if (!proof) reasonCodes.push('jsx-render-return-branch-proof-missing');
+  else {
+    if (proof.status !== 'passed' && proof.status !== 'verified') reasonCodes.push('jsx-render-return-branch-proof-status-not-passed');
+    if (proof.schema !== 'frontier.lang.jsxRenderReturnBranchProof.v1' && proof.kind !== 'frontier.lang.jsxRenderReturnBranchProof') reasonCodes.push('jsx-render-return-branch-proof-schema-missing');
+    if (proof.sourcePath !== delta.sourcePath) reasonCodes.push('jsx-render-return-branch-proof-source-path-mismatch');
+    for (const stage of ['base', 'worker', 'head', 'output']) {
+      if (proof[`${stage}SourceHash`] !== delta[`${stage}SourceHash`]) reasonCodes.push('jsx-render-return-branch-proof-source-hash-mismatch');
+    }
+    if (proof.identityKey !== undefined && proof.identityKey !== delta.identityKey) reasonCodes.push('jsx-render-return-branch-proof-identity-mismatch');
+    if (proof.publicOwnerName !== delta.publicOwnerName || proof.tagName !== delta.tagName || proof.tagKey !== delta.tagKey) reasonCodes.push('jsx-render-return-branch-proof-identity-mismatch');
+    if (proof.returnOrdinal !== delta.returnOrdinal || proof.returnKind !== delta.returnKind || proof.branchControlKind !== delta.branchControlKind) reasonCodes.push('jsx-render-return-branch-proof-branch-kind-unsupported');
+    if (delta.nonRenderRiskPresent) reasonCodes.push('jsx-render-return-branch-proof-non-render-risk-present');
+    if (delta.branchCountUnsupported) reasonCodes.push('jsx-render-return-branch-proof-branch-count-unsupported');
+    reasonCodes.push(...branchReasonCodes(delta, proof));
+    if (proof.branchArmPreservationHash !== delta.branchArmPreservationHash) reasonCodes.push('jsx-render-return-branch-proof-output-signature-mismatch');
+    if (proof.autoMergeClaim !== false || proof.semanticEquivalenceClaim !== false || proof.runtimeEquivalenceClaim !== false
+      || proof.renderEquivalenceClaim !== false || proof.branchArmPreservationClaim !== true
+      || proof.claimScope !== 'static-render-return-branch-arm-preservation-only') {
+      reasonCodes.push('jsx-render-return-branch-proof-claim-flags-missing');
+    }
+  }
+  const status = proof && reasonCodes.length === 0 ? 'passed' : proof ? 'failed' : 'missing';
+  return {
+    status,
+    ...JsxRenderReturnBranchRoute,
+    reasonCodes: uniqueStrings(reasonCodes),
+    record: compactRecord({
+      schema: 'frontier.lang.jsxRenderReturnBranchProofAssessment.v1',
+      status,
+      proofStatus: proof?.status,
+      proofId: proof?.id,
+      proofHash: proof?.proofHash,
+      ...JsxRenderReturnBranchRoute,
+      reasonCodes: uniqueStrings(reasonCodes),
+      expected: delta,
+      autoMergeClaim: false,
+      semanticEquivalenceClaim: false,
+      runtimeEquivalenceClaim: false,
+      renderEquivalenceClaim: false,
+      branchArmPreservationClaim: status === 'passed'
+    })
+  };
+}
+
+function jsxRenderReturnBranchDelta({ identityKey, baseRecord, workerRecord, headRecord, outputRecord } = {}) {
+  const records = { base: baseRecord, worker: workerRecord, head: headRecord, output: outputRecord };
+  const branches = Object.fromEntries(Object.entries(records).map(([stage, record]) => [stage, singleBranch(record)]));
+  if (!Object.values(records).some((record) => hasBranchUnsupported(record))) return undefined;
+  const outputBranch = branches.output;
+  const branchControlKind = firstString(outputBranch?.branchControlKind, branches.worker?.branchControlKind, branches.head?.branchControlKind, branches.base?.branchControlKind);
+  if (branchControlKind !== 'conditional-expression' && branchControlKind !== 'logical-expression') return undefined;
+  const sourcePath = firstString(outputRecord?.sourcePath, workerRecord?.sourcePath, headRecord?.sourcePath, baseRecord?.sourcePath);
+  const delta = compactRecord({
+    schema: 'frontier.lang.jsxRenderReturnBranchDelta.v1',
+    identityKey,
+    sourcePath,
+    publicOwnerName: firstString(outputRecord?.publicOwnerName, workerRecord?.publicOwnerName, headRecord?.publicOwnerName, baseRecord?.publicOwnerName),
+    tagName: firstString(outputRecord?.tagName, workerRecord?.tagName, headRecord?.tagName, baseRecord?.tagName),
+    tagKey: firstString(outputRecord?.tagKey, workerRecord?.tagKey, headRecord?.tagKey, baseRecord?.tagKey),
+    baseSourceHash: baseRecord?.sourceHash,
+    workerSourceHash: workerRecord?.sourceHash,
+    headSourceHash: headRecord?.sourceHash,
+    outputSourceHash: outputRecord?.sourceHash,
+    returnOrdinal: outputBranch?.ordinal,
+    returnKind: outputBranch?.returnKind,
+    branchControlKind,
+    nonRenderRiskPresent: nonRenderRiskPresent(outputRecord ?? workerRecord ?? headRecord ?? baseRecord) || undefined,
+    branchCountUnsupported: Object.values(branches).some((branch) => !branch) || undefined,
+    base: branchSummary(branches.base),
+    worker: branchSummary(branches.worker),
+    head: branchSummary(branches.head),
+    output: branchSummary(branches.output)
+  });
+  return { ...delta, branchArmPreservationHash: jsxRenderReturnBranchProofHash(delta) };
+}
+
+function branchReasonCodes(delta, proof) {
+  if (delta.branchControlKind === 'conditional-expression') return conditionalBranchReasonCodes(delta, proof);
+  if (delta.branchControlKind === 'logical-expression') return logicalBranchReasonCodes(delta, proof);
+  return ['jsx-render-return-branch-proof-branch-kind-unsupported'];
+}
+
+function conditionalBranchReasonCodes(delta, proof) {
+  const reasons = [];
+  if (proof.conditionHash !== delta.base?.conditionHash || proof.outputConditionHash !== delta.output?.conditionHash) reasons.push('jsx-render-return-branch-proof-condition-hash-mismatch');
+  if (proof.consequentOrigin === undefined || proof.alternateOrigin === undefined) reasons.push('jsx-render-return-branch-proof-output-arm-origin-missing');
+  if (proof.outputConsequentHash !== delta.output?.consequentHash || proof.outputAlternateHash !== delta.output?.alternateHash) reasons.push('jsx-render-return-branch-proof-arm-hash-mismatch');
+  if (proof.consequentHash !== armHash(delta, proof.consequentOrigin, 'consequentHash')) reasons.push('jsx-render-return-branch-proof-arm-hash-mismatch');
+  if (proof.alternateHash !== armHash(delta, proof.alternateOrigin, 'alternateHash')) reasons.push('jsx-render-return-branch-proof-arm-hash-mismatch');
+  if (delta.output?.consequentHash !== armHash(delta, proof.consequentOrigin, 'consequentHash')) reasons.push('jsx-render-return-branch-proof-arm-hash-mismatch');
+  if (delta.output?.alternateHash !== armHash(delta, proof.alternateOrigin, 'alternateHash')) reasons.push('jsx-render-return-branch-proof-arm-hash-mismatch');
+  return reasons;
+}
+
+function logicalBranchReasonCodes(delta, proof) {
+  const reasons = [];
+  if (proof.operator !== delta.output?.operator) reasons.push('jsx-render-return-branch-proof-branch-kind-unsupported');
+  if (proof.leftOrigin === undefined || proof.rightOrigin === undefined) reasons.push('jsx-render-return-branch-proof-output-arm-origin-missing');
+  if (proof.outputLeftHash !== delta.output?.leftHash || proof.outputRightHash !== delta.output?.rightHash) reasons.push('jsx-render-return-branch-proof-arm-hash-mismatch');
+  if (proof.leftHash !== armHash(delta, proof.leftOrigin, 'leftHash')) reasons.push('jsx-render-return-branch-proof-logical-guard-hash-mismatch');
+  if (proof.rightHash !== armHash(delta, proof.rightOrigin, 'rightHash')) reasons.push('jsx-render-return-branch-proof-arm-hash-mismatch');
+  if (delta.output?.leftHash !== armHash(delta, proof.leftOrigin, 'leftHash')) reasons.push('jsx-render-return-branch-proof-logical-guard-hash-mismatch');
+  if (delta.output?.rightHash !== armHash(delta, proof.rightOrigin, 'rightHash')) reasons.push('jsx-render-return-branch-proof-arm-hash-mismatch');
+  return reasons;
+}
+
+function jsxRenderReturnBranchProofFor(delta, options = {}) {
+  return [
+    options.jsxRenderReturnBranchProof,
+    ...(Array.isArray(options.jsxRenderReturnBranchProofs) ? options.jsxRenderReturnBranchProofs : [])
+  ].filter(Boolean).find((proof) => proof.identityKey === delta.identityKey || (
+    proof.sourcePath === delta.sourcePath && proof.publicOwnerName === delta.publicOwnerName && proof.tagKey === delta.tagKey
+  ));
+}
+
+function jsxRenderReturnBranchProofHash(delta) {
+  return hashSemanticValue({
+    kind: 'frontier.lang.jsxRenderReturnBranchProof.expected.v1',
+    identityKey: delta.identityKey,
+    sourcePath: delta.sourcePath,
+    publicOwnerName: delta.publicOwnerName,
+    tagName: delta.tagName,
+    tagKey: delta.tagKey,
+    baseSourceHash: delta.baseSourceHash,
+    workerSourceHash: delta.workerSourceHash,
+    headSourceHash: delta.headSourceHash,
+    outputSourceHash: delta.outputSourceHash,
+    returnOrdinal: delta.returnOrdinal,
+    returnKind: delta.returnKind,
+    branchControlKind: delta.branchControlKind,
+    base: delta.base,
+    worker: delta.worker,
+    head: delta.head,
+    output: delta.output
+  });
+}
+
+function singleBranch(record) {
+  const returns = Array.isArray(record?.renderReturnRecords) ? record.renderReturnRecords : [];
+  if (returns.length !== 1) return undefined;
+  const item = returns[0];
+  const branch = item.conditionalBranchRecord ?? item.logicalBranchRecord;
+  return branch ? { ...item, ...branch } : undefined;
+}
+
+function branchSummary(branch) {
+  if (!branch) return undefined;
+  return compactRecord({
+    ordinal: branch.ordinal,
+    returnKind: branch.returnKind,
+    branchControlKind: branch.branchControlKind,
+    conditionHash: branch.conditionHash,
+    consequentHash: branch.consequentHash,
+    alternateHash: branch.alternateHash,
+    operator: branch.operator,
+    leftHash: branch.leftHash,
+    rightHash: branch.rightHash,
+    signatureHash: branch.signatureHash
+  });
+}
+
+function nonRenderRiskPresent(record) {
+  return (record?.renderRiskKinds ?? []).some((kind) => kind !== 'render-return-boundary' && kind !== 'render-return-branch-control-flow');
+}
+function hasBranchUnsupported(record) { return (record?.renderRiskReasonCodes ?? []).includes('jsx-render-return-branch-unsupported'); }
+function armHash(delta, origin, field) { return ['base', 'worker', 'head', 'output'].includes(origin) ? delta[origin]?.[field] : undefined; }
+function firstString(...values) { return values.find((value) => typeof value === 'string' && value.length > 0); }
+function uniqueStrings(values) { return [...new Set(values.filter((value) => typeof value === 'string' && value.length > 0))]; }
+
+export {
+  JsxRenderReturnBranchRoute,
+  jsxRenderReturnBranchDelta,
+  jsxRenderReturnBranchProofAssessment,
+  jsxRenderReturnBranchProofHash
+};

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

@@ -0,0 +1,310 @@
+const ProjectMergeMissingSignals = Object.freeze({
+  outputDiagnosticsGate: 'output-diagnostics-gate-not-run',
+  declarationGate: 'declaration-gate-not-run',
+  qualityGates: 'quality-gates-not-run',
+  focusedTestGate: 'focused-test-gate-not-run',
+  projectGraphEvidence: 'project-graph-evidence-not-included',
+  projectGraphDeltaEvidence: 'project-graph-delta-evidence-not-included',
+  sourceSpanRoundtrip: 'source-span-roundtrip-evidence-not-produced',
+  semanticArtifacts: 'semantic-artifacts-not-produced',
+  semanticEditReplayProof: 'semantic-edit-replay-proof-not-produced',
+  semanticEditReplayOutputMismatch: 'semantic-edit-replay-proof-output-mismatch',
+  unsupportedJsTsSurface: 'unsupported-js-ts-surface-proof-not-available',
+  semanticEquivalenceProof: 'semantic-equivalence-proof-not-available'
+});
+
+const ProjectMergeMissingEvidenceRoutes = Object.freeze({
+  [ProjectMergeMissingSignals.outputDiagnosticsGate]: route('run-output-diagnostics', 'project-output', 'supply-output-diagnostics'),
+  [ProjectMergeMissingSignals.declarationGate]: route('emit-output-declarations', 'project-output', 'supply-declaration-output'),
+  [ProjectMergeMissingSignals.qualityGates]: route('attach-quality-gates', 'quality-gates', 'attach-passing-quality-gates'),
+  [ProjectMergeMissingSignals.focusedTestGate]: route('attach-focused-test-gate', 'quality-gates', 'attach-focused-test-gate'),
+  [ProjectMergeMissingSignals.projectGraphEvidence]: route('include-project-graph-delta', 'project-graph', 'include-project-graph-delta'),
+  [ProjectMergeMissingSignals.projectGraphDeltaEvidence]: route('include-project-graph-delta', 'project-graph', 'include-project-graph-delta'),
+  [ProjectMergeMissingSignals.sourceSpanRoundtrip]: route('produce-source-span-roundtrip-evidence', 'source-files', 'supply-source-span-roundtrip-evidence'),
+  [ProjectMergeMissingSignals.semanticArtifacts]: route('produce-semantic-artifacts', 'source-files', 'produce-semantic-edit-artifacts'),
+  [ProjectMergeMissingSignals.semanticEditReplayProof]: route('produce-semantic-edit-replay-proof', 'source-files', 'run-semantic-edit-replay-diagnostics'),
+  [ProjectMergeMissingSignals.semanticEditReplayOutputMismatch]: route('reject-semantic-edit-replay-output-mismatch', 'source-files', 'inspect-semantic-edit-replay-output-binding'),
+  [ProjectMergeMissingSignals.unsupportedJsTsSurface]: route('prove-unsupported-js-ts-surface', 'semantic-proof', 'supply-unsupported-surface-evidence'),
+  [ProjectMergeMissingSignals.semanticEquivalenceProof]: route('external-semantic-equivalence-proof', 'semantic-proof', 'attach-external-equivalence-proof')
+});
+
+const ProjectMergeAdmissionMatrixRows = Object.freeze([
+  matrixRow('parser-source-span-trivia', 'partial', ['source-span-roundtrip'], [ProjectMergeMissingSignals.sourceSpanRoundtrip, ProjectMergeMissingSignals.semanticArtifacts]),
+  matrixRow('scope-use-def-graph', 'partial', ['project-graph-delta'], [ProjectMergeMissingSignals.projectGraphEvidence, ProjectMergeMissingSignals.projectGraphDeltaEvidence]),
+  matrixRow('module-export-import-graph', 'partial', ['project-graph-delta'], [ProjectMergeMissingSignals.projectGraphEvidence, ProjectMergeMissingSignals.projectGraphDeltaEvidence]),
+  matrixRow('type-public-api-graph', 'partial', ['declaration-output-stable', 'project-graph-delta'], [ProjectMergeMissingSignals.declarationGate, ProjectMergeMissingSignals.projectGraphEvidence, ProjectMergeMissingSignals.projectGraphDeltaEvidence]),
+  matrixRow('jsx-tsx-element-prop-graph', 'partial', ['project-graph-delta', 'focused-test-passed'], [ProjectMergeMissingSignals.projectGraphEvidence, ProjectMergeMissingSignals.projectGraphDeltaEvidence, ProjectMergeMissingSignals.qualityGates, ProjectMergeMissingSignals.focusedTestGate]),
+  matrixRow('control-flow-effect-graph', 'partial', ['source-span-roundtrip', 'focused-test-passed'], [ProjectMergeMissingSignals.sourceSpanRoundtrip, ProjectMergeMissingSignals.semanticArtifacts, ProjectMergeMissingSignals.qualityGates, ProjectMergeMissingSignals.focusedTestGate]),
+  matrixRow('generic-semantic-edit-admission', 'partial', ['source-span-roundtrip', 'semantic-edit-replay-clean'], [ProjectMergeMissingSignals.sourceSpanRoundtrip, ProjectMergeMissingSignals.semanticArtifacts, ProjectMergeMissingSignals.semanticEditReplayProof, ProjectMergeMissingSignals.semanticEditReplayOutputMismatch]),
+  matrixRow('unsupported-js-ts-surface-coverage', 'partial', ['unsupported-js-ts-surface-review'], [ProjectMergeMissingSignals.unsupportedJsTsSurface]),
+  matrixRow('semantic-equivalence-proof', 'bounded-evidence', ['semantic-equivalence-external', 'semantic-equivalence-unknown'], [ProjectMergeMissingSignals.semanticEquivalenceProof]),
+  matrixRow('cross-file-symbol-rename', 'partial', ['diagnostics-clean', 'declaration-output-stable', 'project-graph-delta'], [ProjectMergeMissingSignals.outputDiagnosticsGate, ProjectMergeMissingSignals.declarationGate, ProjectMergeMissingSignals.projectGraphEvidence, ProjectMergeMissingSignals.projectGraphDeltaEvidence]),
+  matrixRow('symbol-move-between-files', 'partial', ['diagnostics-clean', 'declaration-output-stable', 'project-graph-delta'], [ProjectMergeMissingSignals.outputDiagnosticsGate, ProjectMergeMissingSignals.declarationGate, ProjectMergeMissingSignals.projectGraphEvidence, ProjectMergeMissingSignals.projectGraphDeltaEvidence]),
+  matrixRow('split-merge-modules-classes', 'partial', ['diagnostics-clean', 'declaration-output-stable', 'project-graph-delta'], [ProjectMergeMissingSignals.outputDiagnosticsGate, ProjectMergeMissingSignals.declarationGate, ProjectMergeMissingSignals.projectGraphEvidence, ProjectMergeMissingSignals.projectGraphDeltaEvidence]),
+  matrixRow('real-repo-benchmark-suite', 'partial', ['manifest-metadata-validated', 'local-checkout-metadata-proof', 'dependency-install-not-run-default', 'repository-commands-not-run-default'], [ProjectMergeMissingSignals.qualityGates, ProjectMergeMissingSignals.focusedTestGate]),
+  matrixRow('telemetry-confidence-routing', 'partial', ['semantic-equivalence-external', 'semantic-equivalence-unknown'], [ProjectMergeMissingSignals.semanticEquivalenceProof])
+]);
+
+function missingEvidenceItems(summary, context = {}) {
+  const items = [];
+  if (!context.hasProjectGraphEvidence) items.push(missingEvidenceItem({
+    code: ProjectMergeMissingSignals.projectGraphEvidence,
+    scope: 'project-graph',
+    kind: 'project-graph-delta',
+    proofLevel: 'project-graph-evidence',
+    action: 'review',
+    relatedSignals: [ProjectMergeMissingSignals.projectGraphDeltaEvidence],
+    summary: 'Include project graph delta evidence before applying broad project merges so public contract, source span, compiler type, runtime region, scope/use-def, JSX prop, re-export, import-attribute, and import-target gaps are checked.',
+    suggestedInput: { includeProjectGraphDelta: true }
+  }));
+  else if (!summary.projectGraphDeltaEvidenceIncluded) items.push(missingEvidenceItem({
+    code: ProjectMergeMissingSignals.projectGraphDeltaEvidence,
+    scope: 'project-graph',
+    kind: 'project-graph-delta',
+    proofLevel: 'project-graph-delta',
+    action: 'review',
+    summary: 'Output project graph evidence was available, but graph-delta evidence was not included for broad semantic gap checks across base, worker, head, and output.',
+    suggestedInput: { includeProjectGraphDelta: true }
+  }));
+  if (!context.outputDiagnosticsGate) items.push(missingEvidenceItem({
+    code: ProjectMergeMissingSignals.outputDiagnosticsGate,
+    scope: 'project-output',
+    kind: 'diagnostics',
+    proofLevel: 'diagnostics-clean',
+    action: 'review',
+    summary: 'Run or supply output diagnostics so syntax/type diagnostic conflicts can block unsafe project output.',
+    suggestedInput: { requireOutputDiagnostics: true, outputDiagnostics: [] }
+  }));
+  if (!context.outputDeclarationGate) items.push(missingEvidenceItem({
+    code: ProjectMergeMissingSignals.declarationGate,
+    scope: 'project-output',
+    kind: 'declaration-output',
+    proofLevel: 'declaration-output-stable',
+    action: 'review',
+    summary: 'Run or supply declaration output evidence so public declaration drift is checked before apply.',
+    suggestedInput: { includeDeclarationOutput: true }
+  }));
+  if (!context.outputQualityGate) items.push(missingEvidenceItem({
+    code: ProjectMergeMissingSignals.qualityGates,
+    scope: 'quality-gates',
+    kind: 'quality-gate',
+    proofLevel: 'focused-test-passed',
+    action: 'review',
+    relatedSignals: [ProjectMergeMissingSignals.focusedTestGate],
+    summary: 'Attach focused lint, build, or test gate evidence before treating the project merge as evidence-complete.',
+    suggestedInput: { testGates: [{ id: 'focused', status: 'passed', command: 'node test/smoke/<focused>.mjs' }] }
+  }));
+  else if (!Number(context.outputQualityGate.summary?.test ?? 0)) items.push(missingEvidenceItem({
+    code: ProjectMergeMissingSignals.focusedTestGate,
+    scope: 'quality-gates',
+    kind: 'quality-gate',
+    proofLevel: 'focused-test-passed',
+    action: 'review',
+    summary: 'Quality gate evidence was supplied without a focused test gate; attach at least one passing focused test for the changed project behavior.',
+    suggestedInput: { testGates: [{ id: 'focused', status: 'passed', command: 'node test/smoke/<focused>.mjs' }] }
+  }));
+  if (!summary.semanticArtifactFiles) items.push(missingEvidenceItem({
+    code: ProjectMergeMissingSignals.semanticArtifacts,
+    scope: 'source-files',
+    kind: 'semantic-artifacts',
+    proofLevel: 'parser-roundtrip',
+    action: 'review',
+    summary: 'No semantic edit artifacts were produced for source files, so parser/projection/replay evidence cannot support automatic apply.'
+  }));
+  if (summary.semanticArtifactFiles && summary.proofSemanticEditReplayCleanStatus !== 'passed') items.push(missingEvidenceItem({
+    code: ProjectMergeMissingSignals.semanticEditReplayProof,
+    scope: 'source-files',
+    kind: 'semantic-edit-replay',
+    proofLevel: 'semantic-edit-replay-clean',
+    action: 'review',
+    summary: 'Semantic edit artifacts were produced, but clean replay proof was not available for every semantic edit candidate.'
+  }));
+  if (summary.semanticEquivalenceLevel === 'semantic-equivalence-unknown') items.push(missingEvidenceItem({
+    code: ProjectMergeMissingSignals.semanticEquivalenceProof,
+    scope: 'project',
+    kind: 'semantic-equivalence',
+    proofLevel: 'semantic-equivalence-unknown',
+    action: 'review',
+    summary: 'Executable semantic equivalence is still unknown; keep semanticEquivalenceClaim false and require human or external proof for equivalence claims.'
+  }));
+  return items;
+}
+
+function missingEvidenceSignals(items = []) {
+  return uniqueStrings(items.flatMap((item) => [item.code, ...(item.relatedSignals ?? [])]));
+}
+
+function confidenceRecommendedAction(status, failedEvidence, missingEvidence, options = {}) {
+  if (status !== 'merged' || failedEvidence > 0) {
+    return shouldRecommendRerun(missingEvidence, options) ? 'rerun' : 'block';
+  }
+  return missingEvidence.length ? 'review' : 'apply';
+}
+
+function compactMissingEvidenceTelemetry(items = []) {
+  return {
+    total: items.length,
+    byScope: countField(items, 'scope'),
+    byKind: countField(items, 'kind'),
+    byStatus: countField(items, 'status'),
+    byAction: countField(items, 'action'),
+    byRoute: countRoute(items),
+    byLane: countRoute(items, 'lane')
+  };
+}
+
+function createProjectMergeAdmissionMatrixAudit(summary = {}, missingEvidence = [], proofEvidence = undefined) {
+  const surfaces = ProjectMergeAdmissionMatrixRows.map((row) => matrixAuditSurface(row, summary, missingEvidence, proofEvidence));
+  const missingRouteItems = surfaces.flatMap((surface) => (surface.missingRouteIds ?? []).map((routeId) => ({ routeId })));
+  const semanticEquivalenceLevel = summary.semanticEquivalenceLevel ?? proofEvidence?.summary?.semanticEquivalenceLevel ?? 'semantic-equivalence-unknown';
+  return compactRecord({
+    kind: 'frontier.lang.jsTsProjectMergeAdmissionMatrixAudit',
+    version: 1,
+    schema: 'frontier.lang.jsTsProjectMergeAdmissionMatrixAudit.v1',
+    total: surfaces.length,
+    partialRows: surfaces.filter((surface) => surface.status === 'partial').length,
+    missingRows: surfaces.filter((surface) => (surface.missingSignals ?? []).length).length,
+    semanticEquivalenceLevel,
+    semanticEquivalenceUnknown: semanticEquivalenceLevel === 'semantic-equivalence-unknown',
+    autoMergeClaim: false,
+    semanticEquivalenceClaim: semanticEquivalenceLevel !== 'semantic-equivalence-unknown',
+    routeIds: uniqueStrings(surfaces.flatMap((surface) => surface.routeIds ?? [])),
+    missingRouteIds: uniqueStrings(surfaces.flatMap((surface) => surface.missingRouteIds ?? [])),
+    byRoute: countRoute(missingRouteItems),
+    surfaces
+  });
+}
+
+function prioritizedMissingEvidence(proofEvidenceMissing = [], policyMissing = []) {
+  const combined = uniqueMissingEvidence([...proofEvidenceMissing, ...policyMissing]);
+  return [
+    ...combined.filter((item) => !isSemanticEquivalenceMissing(item)),
+    ...combined.filter(isSemanticEquivalenceMissing)
+  ];
+}
+
+function missingEvidenceRouteForSignal(signal) {
+  return ProjectMergeMissingEvidenceRoutes[signal];
+}
+
+function missingEvidenceItem(input) {
+  const route = input.route ?? missingEvidenceRouteForSignal(input.code);
+  return compactRecord({
+    code: input.code,
+    kind: input.kind,
+    scope: input.scope,
+    status: 'missing',
+    action: input.action ?? 'review',
+    proofLevel: input.proofLevel,
+    route,
+    routeId: route?.id,
+    routeLane: route?.lane,
+    routeNext: route?.next,
+    relatedSignals: input.relatedSignals,
+    summary: input.summary,
+    suggestedInput: input.suggestedInput,
+    autoMergeClaim: false,
+    semanticEquivalenceClaim: false
+  });
+}
+
+function matrixAuditSurface(row, summary, missingEvidence, proofEvidence) {
+  const routeIds = matrixRouteIds(row.signals);
+  const activeMissing = missingEvidence.filter((item) => matrixRowMatchesMissingEvidence(row, routeIds, item));
+  const missingRouteIds = uniqueStrings(activeMissing.flatMap((item) => [item.routeId, item.route?.id]));
+  return compactRecord({
+    surface: row.surface,
+    status: row.status,
+    proofLevels: row.proofLevels,
+    proofStatuses: matrixProofStatuses(row.proofLevels, summary, proofEvidence),
+    routeIds,
+    missingSignals: missingEvidenceSignals(activeMissing),
+    missingRouteIds,
+    nextMissingRouteId: missingRouteIds[0],
+    semanticEquivalenceClaim: row.surface === 'semantic-equivalence-proof' && summary.semanticEquivalenceClaim === true
+  });
+}
+
+function matrixRowMatchesMissingEvidence(row, routeIds, item) {
+  return row.signals.includes(item?.code)
+    || (item?.relatedSignals ?? []).some((signal) => row.signals.includes(signal))
+    || row.proofLevels.includes(item?.proofLevel)
+    || routeIds.includes(item?.routeId ?? item?.route?.id);
+}
+
+function matrixProofStatuses(proofLevels, summary, proofEvidence) {
+  return Object.fromEntries(proofLevels.map((level) => [level, matrixProofStatus(level, summary, proofEvidence)]));
+}
+
+function matrixProofStatus(level, summary, proofEvidence) {
+  const levelStatuses = proofEvidence?.summary?.levelStatuses ?? summary.proofEvidenceLevelStatuses ?? {};
+  if (levelStatuses[level]) return levelStatuses[level];
+  if (level === 'project-graph-delta') return summary.projectGraphDeltaEvidenceIncluded ? (summary.projectGraphDeltaConflicts ? 'failed' : 'passed') : 'missing';
+  if (level === 'project-graph-evidence') return summary.projectGraphConflicts ? 'failed' : summary.projectGraphDeltaEvidenceIncluded ? 'passed' : 'missing';
+  if (level === 'semantic-artifacts') return summary.semanticArtifactFiles ? 'present' : 'missing';
+  return 'absent';
+}
+
+function matrixRouteIds(signals) {
+  return uniqueStrings(signals.map((signal) => missingEvidenceRouteForSignal(signal)?.id));
+}
+
+function matrixRow(surface, status, proofLevels, signals) {
+  return Object.freeze({ surface, status, proofLevels, signals });
+}
+
+function uniqueStrings(values) {
+  return [...new Set(values.filter((value) => typeof value === 'string' && value.length > 0))];
+}
+
+function uniqueMissingEvidence(items) {
+  const seen = new Set();
+  return items.filter((item) => {
+    const key = item?.code ?? item?.proofLevel ?? item?.summary;
+    if (!key || seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+
+function countField(items, field) {
+  const counts = {};
+  for (const item of items) if (item?.[field]) counts[item[field]] = (counts[item[field]] ?? 0) + 1;
+  return counts;
+}
+
+function countRoute(items, field = 'id') {
+  const counts = {};
+  for (const item of items) {
+    const key = field === 'lane' ? item?.routeLane ?? item?.route?.lane : item?.routeId ?? item?.route?.id;
+    if (key) counts[key] = (counts[key] ?? 0) + 1;
+  }
+  return counts;
+}
+
+function route(id, lane, next) { return Object.freeze({ id, lane, next }); }
+function shouldRecommendRerun(missingEvidence = [], options = {}) {
+  const rerunReasonCodes = new Set((options.rerunReasonCodes ?? []).filter(Boolean));
+  if (!rerunReasonCodes.size) return false;
+  const reasonCodes = (options.reasonCodes ?? []).filter(Boolean);
+  if (reasonCodes.length) return reasonCodes.every((code) => rerunReasonCodes.has(code));
+  return missingEvidence[0]?.action === 'rerun-gate' && missingEvidence[0]?.kind === 'quality-gate';
+}
+function isSemanticEquivalenceMissing(item) {
+  return item?.proofLevel === 'semantic-equivalence-unknown'
+    || item?.code === ProjectMergeMissingSignals.semanticEquivalenceProof;
+}
+
+function compactRecord(record) {
+  return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== undefined));
+}
+
+export {
+  compactMissingEvidenceTelemetry,
+  confidenceRecommendedAction,
+  createProjectMergeAdmissionMatrixAudit,
+  missingEvidenceItems,
+  missingEvidenceRouteForSignal,
+  missingEvidenceSignals,
+  prioritizedMissingEvidence
+};