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

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
+};

package/dist/js-ts-safe-project-merge-move-rename.js

@@ -0,0 +1,209 @@
+import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
+import { compactRecord } from './js-ts-safe-merge-context.js';
+import {
+  TypeScriptRefactorEvidenceMissingCode,
+  typeScriptRefactorEvidenceRecordsFromClassifications,
+  withTypeScriptRefactorEvidence
+} from './internal/index-impl/typeScriptCompilerFacts.js';
+import { classifyProjectSymbolMoves } from './js-ts-safe-project-merge-symbol-move.js';
+import { maybeAdmitProjectSymbolMoveFile, projectSymbolMoveAdmissionSummary } from './js-ts-safe-project-merge-symbol-move-admission.js';
+
+const requiredEvidence = [
+  'path-lineage-evidence',
+  'import-export-rewrite-evidence',
+  'output-diagnostics-gate',
+  'output-declaration-gate'
+];
+
+function classifyProjectMoveRenames(files, input = {}, projectId = 'js_ts_project_safe_merge') {
+  const fileMoveRenames = [
+    ...classifyBranchMoveRenames(files, 'worker'),
+    ...classifyBranchMoveRenames(files, 'head')
+  ];
+  const classifications = [
+    ...fileMoveRenames,
+    ...classifyProjectSymbolMoves(input, files, projectId, fileMoveRenames)
+  ];
+  const byPath = new Map();
+  for (const classification of classifications) {
+    for (const sourcePath of classification.sourcePaths) {
+      const entries = byPath.get(sourcePath) ?? [];
+      entries.push(classification);
+      byPath.set(sourcePath, entries);
+    }
+  }
+  return { classifications, byPath, summary: projectMoveRenameSummary(classifications) };
+}
+
+function applyProjectMoveRenameClassifications(fileResults, projectMoveRenames, files = [], input = {}) {
+  if (!projectMoveRenames?.byPath?.size) return fileResults;
+  const filesByPath = new Map(files.map((file) => [file.sourcePath, file]));
+  const admissions = [];
+  const applied = fileResults.map((fileResult) => {
+    const classifications = projectMoveRenames.byPath.get(fileResult.sourcePath);
+    const file = filesByPath.get(fileResult.sourcePath);
+    const evidenceClassifications = classifications?.length
+      ? withTypeScriptRefactorEvidence(input, classifications, files)
+      : classifications;
+    const admission = evidenceClassifications?.length && file
+      ? maybeAdmitProjectSymbolMoveFile(fileResult, file, input, evidenceClassifications)
+      : undefined;
+    if (admission) admissions.push(...admission.admissions);
+    return admission?.fileResult ?? (evidenceClassifications?.length ? blockedMoveRenameFile(fileResult, evidenceClassifications) : fileResult);
+  });
+  projectMoveRenames.admissionSummary = projectSymbolMoveAdmissionSummary(admissions);
+  return applied;
+}
+
+function classifyBranchMoveRenames(files, branch) {
+  const sourceField = branch === 'worker' ? 'workerSourceText' : 'headSourceText';
+  const deletedFlag = branch === 'worker' ? 'workerDeleted' : 'headDeleted';
+  const otherSourceField = branch === 'worker' ? 'headSourceText' : 'workerSourceText';
+  const deleted = files
+    .filter((file) => typeof file.baseSourceText === 'string' && file[deletedFlag] === true)
+    .map((file) => ({ file, hash: hashText(file.baseSourceText) }))
+    .sort((left, right) => comparePath(left.file.sourcePath, right.file.sourcePath));
+  const addedByHash = new Map();
+  for (const file of files) {
+    if (typeof file.baseSourceText === 'string' || typeof file[sourceField] !== 'string') continue;
+    if (typeof file[otherSourceField] === 'string') continue;
+    const hash = hashText(file[sourceField]);
+    const entries = addedByHash.get(hash) ?? [];
+    entries.push(file);
+    addedByHash.set(hash, entries);
+  }
+  const used = new Set();
+  const results = [];
+  for (const deletion of deleted) {
+    const candidates = (addedByHash.get(deletion.hash) ?? []).filter((file) => !used.has(file.sourcePath));
+    if (candidates.length !== 1) continue;
+    const added = candidates[0];
+    used.add(added.sourcePath);
+    results.push(fileMoveRenameClassification(branch, deletion.file, added, deletion.hash));
+  }
+  return results;
+}
+
+function fileMoveRenameClassification(branch, fromFile, toFile, sourceHash) {
+  const code = `project-${branch}-file-move-rename-blocked`;
+  return {
+    kind: 'file-move-rename',
+    branch,
+    code,
+    operation: `blocked-${branch}-file-move-rename`,
+    sourcePaths: uniqueStrings([fromFile.sourcePath, toFile.sourcePath]),
+    details: compactRecord({
+      reasonCode: code,
+      conflictKey: `project-file-move-rename#${branch}#${fromFile.sourcePath}#${toFile.sourcePath}#${sourceHash}`,
+      branch,
+      fromSourcePath: fromFile.sourcePath,
+      toSourcePath: toFile.sourcePath,
+      movementKind: movementKind(fromFile.sourcePath, toFile.sourcePath),
+      sourceHash,
+      requiredEvidence
+    })
+  };
+}
+
+function blockedMoveRenameFile(fileResult, classifications) {
+  const typeScriptRefactorAdmissionEvidence = typeScriptRefactorEvidenceRecordsFromClassifications(classifications);
+  const conflicts = classifications.map((classification) => ({
+    code: classification.code,
+    gateId: 'project-move-rename-classifier',
+    message: classifierMessage(classification),
+    sourcePath: fileResult.sourcePath,
+    details: compactRecord({
+      ...classification.details,
+      sourcePath: fileResult.sourcePath,
+      pathRole: classification.pathRoles?.[fileResult.sourcePath]
+    })
+  }));
+  const reasonCodes = uniqueStrings(classifications.map((classification) => classification.code));
+  const conflictKeys = uniqueStrings([
+    ...(fileResult.conflictKeys ?? []),
+    ...conflicts.map((conflict) => conflict.details?.conflictKey)
+  ]);
+  return compactRecord({
+    kind: 'frontier.lang.jsTsProjectSafeMergeFile',
+    version: 1,
+    sourcePath: fileResult.sourcePath,
+    language: fileResult.language,
+    status: 'blocked',
+    operation: blockedOperation(classifications),
+    baseHash: fileResult.baseHash,
+    workerHash: fileResult.workerHash,
+    headHash: fileResult.headHash,
+    result: fileResult.result,
+    conflicts,
+    admission: {
+      status: 'blocked',
+      action: 'human-review',
+      reviewRequired: true,
+      autoApplyCandidate: false,
+      autoMergeClaim: false,
+      semanticEquivalenceClaim: false,
+      reasonCodes,
+      conflictKeys
+    },
+    summary: compactRecord({
+      ...(isPlainObject(fileResult.summary) ? fileResult.summary : {}),
+      conflicts: conflicts.length,
+      typeScriptRefactorAdmissionEvidence: nonEmptyArray(typeScriptRefactorAdmissionEvidence),
+      projectMoveRenameClassifications: classifications.map((classification) => classification.details)
+    }),
+    conflictKeys
+  });
+}
+
+function projectMoveRenameSummary(classifications) {
+  return {
+    classifications: classifications.length,
+    fileMoveRenames: classifications.filter((classification) => classification.kind === 'file-move-rename').length,
+    symbolMoves: classifications.filter((classification) => classification.kind === 'exported-symbol-move' || classification.kind === 'imported-symbol-move').length,
+    exportedSymbolMoves: classifications.filter((classification) => classification.kind === 'exported-symbol-move').length,
+    importedSymbolMoves: classifications.filter((classification) => classification.kind === 'imported-symbol-move').length,
+    reasonCodes: uniqueStrings(classifications.map((classification) => classification.code))
+  };
+}
+
+function classifierMessage(classification) {
+  if (classification.code === TypeScriptRefactorEvidenceMissingCode) {
+    return `Project ${classification.branch} symbol move requires caller-supplied TypeScript refactor reference evidence.`;
+  }
+  if (classification.kind === 'exported-symbol-move') {
+    return `Project ${classification.branch} exported symbol move requires lineage, import/export rewrite, diagnostics, and declaration evidence.`;
+  }
+  if (classification.kind === 'imported-symbol-move') {
+    return `Project ${classification.branch} imported symbol move requires lineage, import/export rewrite, diagnostics, and declaration evidence.`;
+  }
+  return `Project ${classification.branch} file move/rename requires path lineage, rewrite, diagnostics, and declaration evidence.`;
+}
+
+function blockedOperation(classifications) {
+  const operations = uniqueStrings(classifications.map((classification) => classification.operation));
+  return operations.length === 1 ? operations[0] : 'blocked-project-move-rename';
+}
+
+function movementKind(fromPath, toPath) {
+  const fromName = String(fromPath ?? '').split('/').pop();
+  const toName = String(toPath ?? '').split('/').pop();
+  if (fromName === toName) return 'move';
+  if (dirname(fromPath) === dirname(toPath)) return 'rename';
+  return 'move-rename';
+}
+
+function dirname(path) {
+  const text = String(path ?? '');
+  const slash = text.lastIndexOf('/');
+  return slash === -1 ? '' : text.slice(0, slash);
+}
+
+function hashText(text) { return typeof text === 'string' ? hashSemanticValue(text) : undefined; }
+function comparePath(left, right) { return String(left ?? '').localeCompare(String(right ?? '')); }
+function isPlainObject(value) { return Boolean(value && typeof value === 'object' && !Array.isArray(value)); }
+function nonEmptyArray(value) { return Array.isArray(value) && value.length ? value : undefined; }
+function uniqueStrings(values) {
+  return [...new Set(values.filter((value) => typeof value === 'string' && value.length > 0))];
+}
+
+export { applyProjectMoveRenameClassifications, classifyProjectMoveRenames };

package/dist/js-ts-safe-project-merge-proof-conflicts.js

@@ -0,0 +1,44 @@
+function projectProofEvidenceConflicts(proofEvidence) {
+  return (proofEvidence?.records ?? [])
+    .filter((record) => record?.status === 'failed' && record.level === 'source-span-roundtrip' && Number(record.metadata?.admissionBlockingFailedSourceResults ?? 0) > 0)
+    .map(sourceSpanRoundtripProofConflict);
+}
+
+function sourceSpanRoundtripProofConflict(record) {
+  return {
+    code: 'project-source-span-roundtrip-proof-failed',
+    gateId: 'project-proof-evidence',
+    message: 'Project source-span roundtrip proof failed; output source admission requires review.',
+    sourcePath: record.metadata?.sourcePath,
+    severity: 'error',
+    details: compactRecord({
+      reasonCode: 'project-source-span-roundtrip-proof-failed',
+      conflictKey: `project-proof#${record.level}`,
+      proofLevel: record.level,
+      evidenceId: record.id,
+      scope: record.scope,
+      status: record.status,
+      summary: record.summary,
+      outputFiles: record.metadata?.outputFiles,
+      changedOutputFiles: record.metadata?.changedOutputFiles,
+      changedSourceResults: record.metadata?.changedSourceResults,
+      failedSourceResults: record.metadata?.failedSourceResults,
+      admissionBlockingFailedSourceResults: record.metadata?.admissionBlockingFailedSourceResults,
+      sourceSpanRoundtripAdmissionBlockerSourcePaths: record.metadata?.sourceSpanRoundtripAdmissionBlockerSourcePaths,
+      missingSourceResults: record.metadata?.missingSourceResults,
+      missingRequiredSourceResults: record.metadata?.missingRequiredSourceResults,
+      sourceSpanOperations: record.metadata?.sourceSpanOperations,
+      projectionEdits: record.metadata?.projectionEdits,
+      spanLinkedProjectionEdits: record.metadata?.spanLinkedProjectionEdits,
+      parserTriviaExactnessStatus: record.metadata?.parserTriviaExactnessStatus,
+      parserTriviaExactnessReasonCodes: record.metadata?.parserTriviaExactnessReasonCodes,
+      parserTriviaExactnessBlockReasonCodes: record.metadata?.parserTriviaExactnessBlockReasonCodes,
+      autoMergeClaim: false,
+      semanticEquivalenceClaim: false
+    })
+  };
+}
+
+function compactRecord(record) { return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== undefined && (!Array.isArray(value) || value.length > 0))); }
+
+export { projectProofEvidenceConflicts };