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

package/dist/js-ts-safe-project-merge-source-span-conflicts.js

@@ -0,0 +1,310 @@
+import { compactRecord } from './js-ts-safe-merge-context.js';
+
+function projectSourceSpanDeltaConflicts(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;
+  if (!baseGraph || !workerGraph || !headGraph) return [];
+  const ownershipBlockers = projectSourceOwnershipBlockerConflicts(projectGraphDelta);
+  const base = sourceSpanRecordsByIdentityKey(baseGraph.sourceSpanRecords);
+  const worker = sourceSpanRecordsByIdentityKey(workerGraph.sourceSpanRecords);
+  const head = sourceSpanRecordsByIdentityKey(headGraph.sourceSpanRecords);
+  const output = sourceSpanRecordsByIdentityKey(outputGraph?.sourceSpanRecords);
+  const keys = uniqueStrings([...base.keys(), ...worker.keys(), ...head.keys()]);
+  const deltaConflicts = keys.flatMap((identityKey) => {
+    const baseRecord = base.get(identityKey);
+    const workerRecord = worker.get(identityKey);
+    const headRecord = head.get(identityKey);
+    const fingerprints = [sourceSpanFingerprint(baseRecord), sourceSpanFingerprint(workerRecord), sourceSpanFingerprint(headRecord)];
+    if (fingerprints[0] === fingerprints[1] || fingerprints[0] === fingerprints[2] || fingerprints[1] === fingerprints[2]) return [];
+    return [sourceSpanConflict(identityKey, baseRecord, workerRecord, headRecord, output.get(identityKey))];
+  });
+  return [...ownershipBlockers, ...deltaConflicts];
+}
+
+function sourceSpanConflict(identityKey, baseRecord, workerRecord, headRecord, outputRecord) {
+  const sourcePath = workerRecord?.sourcePath ?? headRecord?.sourcePath ?? baseRecord?.sourcePath;
+  return {
+    code: 'project-source-span-delta-conflict',
+    gateId: 'project-graph-delta',
+    message: `Worker and head both changed source span ${JSON.stringify(identityKey)} in incompatible ways.`,
+    sourcePath,
+    details: compactRecord({
+      reasonCode: 'project-source-span-delta-conflict',
+      conflictKey: `project-graph-delta#source-span#${identityKey}`,
+      identityKey,
+      sourcePath,
+      base: sourceSpanDetails(baseRecord),
+      worker: sourceSpanDetails(workerRecord),
+      head: sourceSpanDetails(headRecord),
+      output: sourceSpanDetails(outputRecord)
+    })
+  };
+}
+
+function sourceSpanRecordsByIdentityKey(records = []) {
+  const result = new Map();
+  for (const record of records ?? []) {
+    if (!isTrackedSourceSpan(record)) continue;
+    const key = sourceSpanIdentityKey(record);
+    if (!key || result.has(key)) continue;
+    result.set(key, record);
+  }
+  return result;
+}
+
+function isTrackedSourceSpan(record) {
+  return record?.directive || record?.protected || record?.role === 'comment' || isCommentKind(record?.kind) || record?.kind === 'source-map-comment' || record?.kind === 'shebang';
+}
+
+function sourceSpanIdentityKey(record) {
+  return record?.identityKey
+    ?? record?.ownershipAnchorKey
+    ?? record?.stableId
+    ?? stableKey(['source-span', record?.sourcePath, record?.role, record?.kind, sourceSpanIdentityAnchor(record)]);
+}
+
+function sourceSpanFingerprint(record) {
+  return record ? stableKey([
+    record.stableHash,
+    record.textHash,
+    record.textLength,
+    record.directive,
+    record.protected,
+    record.trivia,
+    record.ownershipAnchorKey,
+    record.ownershipAnchorStatus,
+    record.parserTriviaExactnessStatus,
+    ...(record.parserTriviaExactnessBlockReasonCodes ?? []),
+    record.parserTriviaOwnershipStatus,
+    record.parserTriviaOwnershipRelation,
+    ...(record.parserTriviaOwnershipBlockReasonCodes ?? []),
+    record.sourceMapGeneratedBoundaryStatus,
+    record.sourceMapGeneratedBoundaryOwnershipStatus,
+    ...(record.sourceMapGeneratedBoundaryOwnershipKeys ?? []),
+    ...(record.sourceMapGeneratedBoundaryBlockReasonCodes ?? []),
+    generatedBoundaryPositionFingerprint(record)
+  ]) : undefined;
+}
+
+function sourceSpanDetails(record) {
+  if (!record) return undefined;
+  return compactRecord({
+    sourcePath: record.sourcePath,
+    stableId: record.stableId,
+    key: sourceSpanIdentityKey(record),
+    identityKey: record.identityKey,
+    role: record.role,
+    kind: record.kind,
+    ordinal: record.ordinal,
+    identityOccurrence: record.identityOccurrence,
+    startLine: record.sourceSpan?.startLine,
+    startColumn: record.sourceSpan?.startColumn,
+    textHash: record.textHash,
+    stableHash: record.stableHash,
+    signatureHash: record.signatureHash,
+    ownershipAnchorKey: record.ownershipAnchorKey,
+    ownershipAnchorHash: record.ownershipAnchorHash,
+    ownershipAnchorStatus: record.ownershipAnchorStatus,
+    ownershipBlockReasonCodes: record.ownershipBlockReasonCodes,
+    parserEvidence: record.parserEvidence,
+    losslessCst: record.losslessCst,
+    parserTriviaExactnessStatus: record.parserTriviaExactnessStatus,
+    exactParserTrivia: record.exactParserTrivia,
+    parserTriviaExactnessReasonCodes: record.parserTriviaExactnessReasonCodes,
+    parserTriviaExactnessBlockReasonCodes: record.parserTriviaExactnessBlockReasonCodes,
+    parserTriviaOwnershipStatus: record.parserTriviaOwnershipStatus,
+    parserTriviaOwnershipRelation: record.parserTriviaOwnershipRelation,
+    parserTriviaOwnershipReasonCodes: record.parserTriviaOwnershipReasonCodes,
+    parserTriviaOwnershipBlockReasonCodes: record.parserTriviaOwnershipBlockReasonCodes,
+    ...sourceMapGeneratedBoundaryDetails(record),
+    generatedBoundaryPositionKey: generatedBoundaryPositionFingerprint(record),
+    sourceHash: record.sourceHash,
+    start: record.start,
+    end: record.end,
+    directive: record.directive,
+    protected: record.protected,
+    trivia: record.trivia
+  });
+}
+
+function generatedBoundaryPositionFingerprint(record) {
+  if (record?.kind !== 'source-map-comment' && record?.ownershipAnchor?.anchorKind !== 'generated-source-boundary') return undefined;
+  const span = record.sourceSpan;
+  return stableKey(['generated-boundary-position', span?.startLine, span?.startColumn, span?.endLine, span?.endColumn]);
+}
+
+function sourceMapGeneratedBoundaryDetails(record) {
+  return compactRecord({
+    sourceMapGeneratedBoundaryStatus: record.sourceMapGeneratedBoundaryStatus,
+    sourceMapGeneratedBoundaryReadiness: record.sourceMapGeneratedBoundaryReadiness,
+    sourceMapGeneratedBoundaryAction: record.sourceMapGeneratedBoundaryAction,
+    sourceMapGeneratedBoundaryReviewRequired: record.sourceMapGeneratedBoundaryReviewRequired,
+    sourceMapGeneratedBoundaryExactBoundary: record.sourceMapGeneratedBoundaryExactBoundary,
+    sourceMapGeneratedBoundaryOwnershipStatus: record.sourceMapGeneratedBoundaryOwnershipStatus,
+    sourceMapGeneratedBoundaryOwnershipKeys: record.sourceMapGeneratedBoundaryOwnershipKeys,
+    sourceMapGeneratedBoundaryReasonCodes: record.sourceMapGeneratedBoundaryReasonCodes,
+    sourceMapGeneratedBoundaryBlockReasonCodes: record.sourceMapGeneratedBoundaryBlockReasonCodes,
+    sourceMapGeneratedBoundaryMissingInvariant: record.sourceMapGeneratedBoundaryMissingInvariant,
+    sourceMapRecordCount: record.sourceMapRecordCount,
+    sourceMapMappingCount: record.sourceMapMappingCount,
+    sourceMapIds: record.sourceMapIds,
+    sourceMapMappingIds: record.sourceMapMappingIds
+  });
+}
+
+function projectSourceOwnershipBlockerConflicts(projectGraphDelta) {
+  return uniqueSourceOwnershipBlockers([
+    ['base', projectGraphDelta?.stages?.base?.projectSymbolGraph],
+    ['worker', projectGraphDelta?.stages?.worker?.projectSymbolGraph],
+    ['head', projectGraphDelta?.stages?.head?.projectSymbolGraph],
+    ['output', projectGraphDelta?.stages?.output?.projectSymbolGraph]
+  ].flatMap(([stage, graph]) => [
+    ...sourceFileOwnershipBlockers(stage, graph?.sourceFileRecords),
+    ...sourceSpanOwnershipBlockers(stage, graph?.sourceSpanRecords),
+    ...sourceMapGeneratedBoundaryBlockers(stage, graph?.sourceFileRecords, graph?.sourceSpanRecords)
+  ]));
+}
+
+function sourceFileOwnershipBlockers(stage, records = []) {
+  return (records ?? [])
+    .filter((record) => record?.triviaOwnershipStatus === 'blocked' || (record?.triviaOwnershipBlockReasonCodes ?? []).length)
+    .map((record) => ({
+      code: 'project-source-trivia-ownership-blocked',
+      gateId: 'project-graph-delta',
+      message: `Project ${stage} source ${JSON.stringify(record.sourcePath ?? 'unknown')} lacks deterministic trivia ownership evidence.`,
+      sourcePath: record.sourcePath,
+      details: compactRecord({
+        reasonCode: 'project-source-trivia-ownership-blocked',
+        conflictKey: `project-graph-delta#source-trivia-ownership#${stage}#${record.sourcePath ?? record.id}`,
+        stage,
+        sourcePath: record.sourcePath,
+        sourceHash: record.sourceHash,
+        triviaOwnershipStatus: record.triviaOwnershipStatus,
+        triviaOwnershipReasonCodes: record.triviaOwnershipReasonCodes,
+        triviaOwnershipBlockReasonCodes: record.triviaOwnershipBlockReasonCodes,
+        parserEvidence: record.parserEvidence,
+        losslessCst: record.losslessCst,
+        parserTriviaExactnessStatus: record.parserTriviaExactnessStatus,
+        exactParserTrivia: record.exactParserTrivia,
+        parserTriviaExactnessReasonCodes: record.parserTriviaExactnessReasonCodes,
+        parserTriviaExactnessBlockReasonCodes: record.parserTriviaExactnessBlockReasonCodes,
+        parserTriviaOwnershipStatus: record.parserTriviaOwnershipStatus,
+        parserTriviaOwnershipRelation: record.parserTriviaOwnershipRelation,
+        parserTriviaOwnershipReasonCodes: record.parserTriviaOwnershipReasonCodes,
+        parserTriviaOwnershipBlockReasonCodes: record.parserTriviaOwnershipBlockReasonCodes,
+        ...sourceMapGeneratedBoundaryDetails(record),
+        roundtripHash: record.roundtripHash
+      })
+    }));
+}
+
+function sourceSpanOwnershipBlockers(stage, records = []) {
+  return (records ?? [])
+    .filter((record) => record?.ownershipAnchorStatus === 'blocked' || (record?.ownershipBlockReasonCodes ?? []).length)
+    .map((record) => ({
+      code: 'project-source-span-ownership-blocked',
+      gateId: 'project-graph-delta',
+      message: `Project ${stage} source span ${JSON.stringify(sourceSpanIdentityKey(record) ?? record.id ?? 'unknown')} lacks deterministic ownership evidence.`,
+      sourcePath: record.sourcePath,
+      details: compactRecord({
+        reasonCode: 'project-source-span-ownership-blocked',
+        conflictKey: `project-graph-delta#source-span-ownership#${stage}#${sourceSpanIdentityKey(record) ?? record.id}`,
+        stage,
+        identityKey: sourceSpanIdentityKey(record),
+        sourcePath: record.sourcePath,
+        role: record.role,
+        kind: record.kind,
+        ownershipAnchorStatus: record.ownershipAnchorStatus,
+        ownershipAnchorKey: record.ownershipAnchorKey,
+        ownershipAnchorHash: record.ownershipAnchorHash,
+        ownershipBlockReasonCodes: record.ownershipBlockReasonCodes,
+        parserEvidence: record.parserEvidence,
+        losslessCst: record.losslessCst,
+        parserTriviaExactnessStatus: record.parserTriviaExactnessStatus,
+        exactParserTrivia: record.exactParserTrivia,
+        parserTriviaExactnessReasonCodes: record.parserTriviaExactnessReasonCodes,
+        parserTriviaExactnessBlockReasonCodes: record.parserTriviaExactnessBlockReasonCodes,
+        ...sourceMapGeneratedBoundaryDetails(record),
+        roundtripHash: record.roundtripHash
+      })
+    }));
+}
+
+function sourceMapGeneratedBoundaryBlockers(stage, fileRecords = [], spanRecords = []) {
+  return [
+    ...(fileRecords ?? [])
+      .filter(hasBlockedSourceMapGeneratedBoundary)
+      .map((record) => sourceMapGeneratedBoundaryBlocker(stage, record, 'source-file')),
+    ...(spanRecords ?? [])
+      .filter((record) => record?.kind === 'source-map-comment' || record?.ownershipAnchor?.anchorKind === 'generated-source-boundary')
+      .filter(hasBlockedSourceMapGeneratedBoundary)
+      .map((record) => sourceMapGeneratedBoundaryBlocker(stage, record, 'source-span'))
+  ];
+}
+
+function hasBlockedSourceMapGeneratedBoundary(record) {
+  return record?.sourceMapGeneratedBoundaryStatus === 'blocked'
+    || record?.sourceMapGeneratedBoundaryOwnershipStatus === 'blocked'
+    || (record?.sourceMapGeneratedBoundaryBlockReasonCodes ?? []).length > 0;
+}
+
+function sourceMapGeneratedBoundaryBlocker(stage, record, recordKind) {
+  const identityKey = recordKind === 'source-span' ? sourceSpanIdentityKey(record) : record.sourcePath ?? record.id;
+  return {
+    code: 'project-generated-source-boundary-ownership-blocked',
+    gateId: 'project-graph-delta',
+    message: `Project ${stage} generated source boundary ${JSON.stringify(identityKey ?? 'unknown')} lacks deterministic source-map ownership evidence.`,
+    sourcePath: record.sourcePath,
+    details: compactRecord({
+      reasonCode: 'project-generated-source-boundary-ownership-blocked',
+      conflictKey: `project-graph-delta#generated-source-boundary-ownership#${stage}#${recordKind}#${identityKey ?? record.id}`,
+      stage,
+      recordKind,
+      identityKey,
+      sourcePath: record.sourcePath,
+      role: record.role,
+      kind: record.kind,
+      sourceHash: record.sourceHash,
+      ...sourceMapGeneratedBoundaryDetails(record),
+      roundtripHash: record.roundtripHash
+    })
+  };
+}
+
+function uniqueSourceOwnershipBlockers(conflicts) {
+  const seen = new Set();
+  return conflicts.filter((conflict) => {
+    const key = conflict.details?.conflictKey ?? JSON.stringify(conflict);
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+
+function sourceSpanIdentityAnchor(record) {
+  if (record?.directive) {
+    if (record.kind === 'runtime-directive') return 'runtime-directive-prologue';
+    if (record.kind === 'source-map-comment') return 'source-map-comment';
+    if (record.kind === 'typescript-reference') return 'typescript-reference';
+    return record.textHash ?? record.kind ?? 'directive';
+  }
+  if (record?.kind === 'source-map-comment') return 'source-map-comment';
+  if (record?.protected) return stableKey(['protected', record.textHash ?? record.kind]);
+  if (record?.trivia || record?.role === 'comment') return stableKey(['trivia', record.textHash ?? record.kind]);
+  return record?.textHash ?? record?.kind ?? record?.role;
+}
+
+function isCommentKind(kind) {
+  return kind === 'comment' || kind === 'jsdoc-comment' || kind === 'block-comment';
+}
+
+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 { projectSourceSpanDeltaConflicts };

package/dist/js-ts-safe-project-merge-source-span-roundtrip-proof.js

@@ -0,0 +1,172 @@
+import { createParserTriviaExactnessRecord } from './native-source-preservation-ownership.js';
+
+function sourceSpanRoundtripEvidence(id, fileResults, level, legacyLevel) {
+  const outputFiles = fileResults.filter((file) => typeof file.outputSourceText === 'string');
+  const changedOutputFiles = outputFiles.filter((file) => !hashMatchesBase(file));
+  const changedSourceResults = changedOutputFiles.filter((file) => file.result);
+  const facts = changedSourceResults.map(sourceSpanRoundtripFacts);
+  const failed = facts.filter((fact) => fact.status === 'failed');
+  const missing = facts.filter((fact) => fact.status === 'missing');
+  const admissionBlockingFailed = failed.filter((fact) => fact.roundtripProofAdmissionBlocker);
+  const requiredMissing = missing.filter((fact) => fact.roundtripProofRequired);
+  const parserTriviaExactness = parserTriviaExactnessSummary(facts);
+  const changedWithoutSourceResults = changedOutputFiles.filter((file) => !file.result && sourceSpanRoundtripRequired(file)).length;
+  const status = admissionBlockingFailed.length ? 'failed'
+    : changedWithoutSourceResults || requiredMissing.length ? 'skipped'
+      : changedOutputFiles.length ? 'passed' : 'skipped';
+  const missingSignal = status === 'skipped' && changedOutputFiles.length > 0 ? 'source-span-roundtrip-evidence-not-produced' : undefined;
+  return evidenceRecord({
+    id,
+    suffix: 'source_span_roundtrip',
+    level,
+    status,
+    scope: 'source-files',
+    summary: summaryFor(status, facts, changedOutputFiles),
+    metadata: {
+      legacyProofLevel: legacyLevel,
+      outputFiles: outputFiles.length,
+      changedOutputFiles: changedOutputFiles.length,
+      changedSourceResults: changedSourceResults.length,
+      passedSourceResults: facts.filter((fact) => fact.status === 'passed').length,
+      failedSourceResults: failed.length,
+      admissionBlockingFailedSourceResults: admissionBlockingFailed.length,
+      sourceSpanRoundtripAdmissionBlockerSourcePaths: admissionBlockingFailed.map((fact) => fact.sourcePath),
+      missingSourceResults: missing.length + Math.max(0, changedWithoutSourceResults),
+      missingRequiredSourceResults: requiredMissing.length + Math.max(0, changedWithoutSourceResults),
+      semanticReplayVerifiedFiles: facts.filter((fact) => fact.semanticArtifactsStatus === 'verified').length,
+      sourceSpanOperations: sumBy(facts, (fact) => fact.sourceSpanOperations),
+      projectionEdits: sumBy(facts, (fact) => fact.projectionEdits),
+      spanLinkedProjectionEdits: sumBy(facts, (fact) => fact.spanLinkedProjectionEdits),
+      replayVerifiedFiles: facts.filter((fact) => fact.replayOutputMatchesMerged).length,
+      parserTriviaExactnessStatus: parserTriviaExactness.status,
+      exactParserTriviaFiles: parserTriviaExactness.exact,
+      approximateParserTriviaFiles: parserTriviaExactness.approximate,
+      blockedParserTriviaFiles: parserTriviaExactness.blocked,
+      parserTriviaExactnessReasonCodes: parserTriviaExactness.reasonCodes,
+      parserTriviaExactnessBlockReasonCodes: parserTriviaExactness.blockReasonCodes,
+      missingSignal,
+      nextAction: missingSignal ? 'Supply verified semantic artifacts with source spans, projected edits, and clean replay output for every changed source file.' : undefined
+    }
+  });
+}
+
+function sourceSpanRoundtripFacts(file) {
+  const artifacts = file.semanticArtifacts ?? file.result?.semanticArtifacts;
+  const operations = Array.isArray(artifacts?.script?.operations) ? artifacts.script.operations : [];
+  const projectionEdits = Array.isArray(artifacts?.projection?.edits) ? artifacts.projection.edits : [];
+  const sourceSpanOperations = operations.filter(operationHasSourceSpan).length;
+  const spanLinkedProjectionEdits = projectionEdits.filter(editHasSourceSpan).length;
+  const gatesPassed = (file.result?.gates ?? []).every((gate) => gate.status === 'passed');
+  const projectedSourceMatchesMerged = artifacts?.summary?.projectedSourceMatchesMerged === true;
+  const replayOutputMatchesMerged = artifacts?.summary?.replayOutputMatchesMerged === true;
+  const parserTriviaExactness = parserTriviaExactnessForFile(file, artifacts);
+  const roundtripProofRequired = sourceSpanRoundtripRequired(file);
+  const status = parserTriviaExactness.status === 'blocked' || file.result?.status !== 'merged' || artifacts?.status === 'blocked'
+    ? 'failed'
+    : !artifacts || artifacts.status !== 'verified' || !gatesPassed || !projectedSourceMatchesMerged || !replayOutputMatchesMerged || !sourceSpanOperations || !spanLinkedProjectionEdits
+      ? 'missing'
+      : 'passed';
+  return {
+    sourcePath: file.sourcePath,
+    status,
+    semanticArtifactsStatus: artifacts?.status,
+    gatesPassed,
+    operations: operations.length,
+    sourceSpanOperations,
+    projectionEdits: projectionEdits.length,
+    spanLinkedProjectionEdits,
+    roundtripProofRequired,
+    roundtripProofAdmissionBlocker: roundtripProofRequired && status === 'failed',
+    projectedSourceMatchesMerged,
+    replayOutputMatchesMerged,
+    parserTriviaExactnessStatus: parserTriviaExactness.status,
+    exactParserTrivia: parserTriviaExactness.exactParserTrivia,
+    parserTriviaExactnessReasonCodes: parserTriviaExactness.reasonCodes,
+    parserTriviaExactnessBlockReasonCodes: parserTriviaExactness.blockReasonCodes
+  };
+}
+
+function parserTriviaExactnessForFile(file, artifacts) {
+  return createParserTriviaExactnessRecord(
+    file.parserTriviaExactness
+      ?? file.parserTriviaEvidence
+      ?? file.metadata?.parserTriviaExactness
+      ?? file.result?.metadata?.parserTriviaExactness
+      ?? artifacts?.metadata?.parserTriviaExactness,
+    {
+      sourcePath: file.sourcePath,
+      sourceHash: file.outputHash,
+      parserEvidence: artifacts?.metadata?.parserEvidence
+    }
+  );
+}
+
+function parserTriviaExactnessSummary(facts) {
+  const exact = facts.filter((fact) => fact.parserTriviaExactnessStatus === 'exact').length;
+  const blocked = facts.filter((fact) => fact.parserTriviaExactnessStatus === 'blocked').length;
+  const approximate = facts.filter((fact) => fact.parserTriviaExactnessStatus === 'approximate').length;
+  const reasonCodes = uniqueStrings(facts.flatMap((fact) => fact.parserTriviaExactnessReasonCodes ?? []));
+  const blockReasonCodes = uniqueStrings(facts.flatMap((fact) => fact.parserTriviaExactnessBlockReasonCodes ?? []));
+  return {
+    status: blocked ? 'blocked' : exact && exact === facts.length ? 'exact' : facts.length ? 'approximate' : 'absent',
+    exact,
+    approximate,
+    blocked,
+    reasonCodes,
+    blockReasonCodes
+  };
+}
+
+function summaryFor(status, facts, changedOutputFiles) {
+  if (status === 'passed') return `Verified source-span projection and replay roundtrip evidence for ${facts.filter((fact) => fact.status === 'passed').length} changed source file(s).`;
+  if (status === 'failed') return `Source-span projection or replay roundtrip evidence failed for ${facts.filter((fact) => fact.status === 'failed').length} changed source file(s).`;
+  return changedOutputFiles.length
+    ? 'Changed project output is missing source-span projection or replay roundtrip evidence.'
+    : 'No changed source output required source-span roundtrip evidence.';
+}
+
+function evidenceRecord(input) {
+  return {
+    id: `${input.id}_proof_${input.suffix}`,
+    kind: 'js-ts-project-merge-proof-evidence',
+    level: input.level,
+    status: input.status,
+    scope: input.scope,
+    claimKind: 'evidence',
+    evidenceOnly: true,
+    proofClaim: false,
+    autoMergeClaim: false,
+    semanticEquivalenceClaim: false,
+    summary: input.summary,
+    metadata: compactRecord({ ...(input.metadata ?? {}), proofClaim: false, autoMergeClaim: false, semanticEquivalenceClaim: false })
+  };
+}
+
+function operationHasSourceSpan(operation) {
+  return isSpan(operation?.anchor?.sourceSpan) || isSpan(operation?.spans?.worker) || isSpan(operation?.spans?.head) || isSpan(operation?.spans?.base);
+}
+function editHasSourceSpan(edit) {
+  return Number.isFinite(edit?.workerStart) && Number.isFinite(edit?.workerEnd)
+    || Number.isFinite(edit?.headStart) && Number.isFinite(edit?.headEnd)
+    || Number.isFinite(edit?.start) && Number.isFinite(edit?.end);
+}
+function hashMatchesBase(file) { return Boolean(file.baseHash) && file.outputHash === file.baseHash; }
+function sourceSpanRoundtripRequired(file) { return !preservesSingleChangedInput(file); }
+function preservesSingleChangedInput(file) {
+  const workerChanged = file.workerHash !== file.baseHash;
+  const headChanged = file.headHash !== file.baseHash;
+  if (workerChanged && !headChanged && file.outputHash === file.workerHash) return true;
+  if (headChanged && !workerChanged && file.outputHash === file.headHash) return true;
+  return workerChanged && headChanged && file.workerHash === file.headHash && file.outputHash === file.workerHash;
+}
+function isSpan(value) { return isOffsetSpan(value) || isLineColumnSpan(value); }
+function isOffsetSpan(value) { return Number.isFinite(value?.start) && Number.isFinite(value?.end); }
+function isLineColumnSpan(value) {
+  return Number.isFinite(value?.startLine) && Number.isFinite(value?.endLine)
+    && Number.isFinite(value?.startColumn) && Number.isFinite(value?.endColumn);
+}
+function sumBy(values, valueFor) { return values.reduce((total, value) => total + Number(valueFor(value) ?? 0), 0); }
+function compactRecord(record) { return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== undefined)); }
+function uniqueStrings(values) { return [...new Set(values.filter((value) => typeof value === 'string' && value.length > 0))]; }
+
+export { sourceSpanRoundtripEvidence };

package/dist/js-ts-safe-project-merge-split-merge-admission.js

@@ -0,0 +1,96 @@
+import {
+  createExactBranchProjectSemanticEditAdmissionFile,
+  summarizeProjectSemanticEditAdmissions
+} from './js-ts-safe-project-merge-admission.js';
+import { generatedProjectSourcePath } from './js-ts-safe-project-merge-split-merge-shapes.js';
+
+const splitMergeKinds = new Set(['module-split', 'module-merge', 'class-split', 'class-merge']);
+
+function maybeAdmitProjectSplitMergeFile(fileResult, file, input, classifications) {
+  if (!classifications.every((classification) => allowsProjectSplitMerge(input, classification))) return undefined;
+  if (!hasProjectSplitMergeAdmissionEvidence(input)) return undefined;
+  if (classifications.some((classification) => classification.details?.exactStructuralPartition === false)) return undefined;
+  if (classifications.some(classificationTouchesGeneratedOutputBoundary)) return undefined;
+  return createExactBranchProjectSemanticEditAdmissionFile({
+    fileResult,
+    file,
+    classifications,
+    admissionKind: 'js-ts-project-split-merge-admission',
+    action: 'apply-project-split-merge',
+    operation: 'merged-project-split-merge',
+    summaryKey: 'projectSplitMergeAdmissions',
+    evidenceKey: 'projectSplitMergeAdmissionEvidence',
+    metadataKey: 'projectSplitMergeAdmissions',
+    requireOtherBranchUnchanged: true,
+    requireBaseForOtherBranchUnchanged: false,
+    allowDeletedBranchOutput: true,
+    classificationFilter: (classification) => splitMergeKinds.has(classification.kind),
+    admissionFields: (classification) => ({ structuralEditKind: classification.kind }),
+    details: admittedSplitMergeDetails
+  });
+}
+
+function projectSplitMergeAdmissionSummary(admissions = []) {
+  return summarizeProjectSemanticEditAdmissions(admissions, {
+    totalKey: 'splitMergeAdmissions',
+    byKind: [
+      { key: 'moduleSplitAdmissions', property: 'structuralEditKind', value: 'module-split' },
+      { key: 'moduleMergeAdmissions', property: 'structuralEditKind', value: 'module-merge' },
+      { key: 'classSplitAdmissions', property: 'structuralEditKind', value: 'class-split' },
+      { key: 'classMergeAdmissions', property: 'structuralEditKind', value: 'class-merge' }
+    ],
+    evidenceIdsKey: 'splitMergeAdmissionEvidenceIds'
+  });
+}
+
+function allowsProjectSplitMerge(input, classification) {
+  if (input?.allowProjectSplitMerges === true || input?.allowSplitMerges === true) return true;
+  if (classification?.kind === 'module-split') return input?.allowProjectModuleSplits === true || input?.allowModuleSplits === true;
+  if (classification?.kind === 'module-merge') return input?.allowProjectModuleMerges === true || input?.allowModuleMerges === true;
+  if (classification?.kind === 'class-split') return input?.allowProjectClassSplits === true || input?.allowClassSplits === true;
+  if (classification?.kind === 'class-merge') return input?.allowProjectClassMerges === true || input?.allowClassMerges === true;
+  return false;
+}
+
+function hasProjectSplitMergeAdmissionEvidence(input = {}) {
+  return hasOutputProjectGraphEvidence(input)
+    && hasOutputDiagnosticsEvidence(input)
+    && hasOutputDeclarationEvidence(input);
+}
+
+function hasOutputProjectGraphEvidence(input = {}) {
+  return input.includeOutputProjectSymbolGraph === true;
+}
+
+function hasOutputDiagnosticsEvidence(input = {}) {
+  return input.requireOutputDiagnostics === true
+    || Object.hasOwn(input, 'outputDiagnostics')
+    || Boolean(input.typescript ?? input.ts ?? input.typescriptModule);
+}
+
+function hasOutputDeclarationEvidence(input = {}) {
+  return input.requireDeclarationOutput === true
+    || input.includeDeclarationOutput === true
+    || input.outputDeclarations !== undefined
+    || input.outputDeclarationFiles !== undefined;
+}
+
+function classificationTouchesGeneratedOutputBoundary(classification) {
+  return classification.details?.generatedOutputBoundary === true
+    || (classification.sourcePaths ?? []).some(generatedProjectSourcePath);
+}
+
+function admittedSplitMergeDetails(classification) {
+  return {
+    ...(classification.details ?? {}),
+    presentRequiredEvidence: classification.details?.requiredEvidence,
+    missingRequiredEvidence: []
+  };
+}
+
+export {
+  allowsProjectSplitMerge,
+  hasProjectSplitMergeAdmissionEvidence,
+  maybeAdmitProjectSplitMergeFile,
+  projectSplitMergeAdmissionSummary
+};