@shapeshift-labs/frontier-lang-compiler 0.2.98 → 0.2.100

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

@@ -1,6 +1,14 @@
 import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
 import { idFragment, uniqueStrings } from '../../native-import-utils.js';
 import { semanticEditIdentityFields } from './semanticEditIdentityRecords.js';
+import {
+  insertionOffset,
+  insertionReplacement,
+  projectionCoveredContainerOperationIds,
+  removalRange,
+  scopedBodyReplacement,
+  spanOffsets
+} from './semanticEditSourceRanges.js';
 import { applySourceEdits, dedupeSourceEdits, validateSourceEdits } from './semanticSourceEditDedupe.js';
 
 export function projectSemanticEditScriptToSource(input = {}) {
@@ -9,22 +17,25 @@ export function projectSemanticEditScriptToSource(input = {}) {
   const headSourceText = input.headSourceText;
   const reasonCodes = [];
   if (!script) throw new Error('projectSemanticEditScriptToSource requires a script');
-  if (script.admission?.status !== 'auto-merge-candidate') reasonCodes.push('script-not-auto-merge-candidate');
   if (typeof workerSourceText !== 'string') reasonCodes.push('missing-worker-source-text');
   if (typeof headSourceText !== 'string') reasonCodes.push('missing-head-source-text');
   const edits = [];
   const coveredOperationIds = [];
+  const projectionCoveredOperationIds = projectionCoveredContainerOperationIds(script.operations ?? [], workerSourceText);
   for (const [index, operation] of (script.operations ?? []).entries()) {
-    if (operation.status === 'covered') {
+    if (operation.status === 'covered' || projectionCoveredOperationIds.has(operation.id)) {
       coveredOperationIds.push(operation.id);
       continue;
     }
-    const edit = sourceEditForOperation(operation, workerSourceText, headSourceText, index);
+    const edit = sourceEditForOperation(operation, workerSourceText, headSourceText, index, input.headSourcePath);
     if (edit.ok) edits.push(edit.value);
     else reasonCodes.push(...edit.reasonCodes);
   }
   const deduped = dedupeSourceEdits(edits);
   reasonCodes.push(...validateSourceEdits(deduped.edits));
+  if (script.admission?.status !== 'auto-merge-candidate' && (reasonCodes.length > 0 || (!edits.length && !coveredOperationIds.length))) {
+    reasonCodes.push('script-not-auto-merge-candidate');
+  }
   const blocked = reasonCodes.length > 0;
   const sourceText = blocked ? undefined : applySourceEdits(headSourceText, deduped.edits);
   const core = {
@@ -62,8 +73,8 @@ export function projectSemanticEditScriptToSource(input = {}) {
   return { ...core, hash: hashSemanticValue(core) };
 }
 
-function sourceEditForOperation(operation, workerSourceText, headSourceText, order) {
-  const identity = projectionIdentity(operation);
+function sourceEditForOperation(operation, workerSourceText, headSourceText, order, headSourcePath) {
+  const identity = projectionIdentity(operation, headSourcePath);
   if (operation.status === 'already-applied') {
     return { ok: true, value: { ...identity, operationId: operation.id, order, start: 0, end: 0, replacement: '', current: '', alreadyApplied: true } };
   }
@@ -80,16 +91,23 @@ function sourceEditForOperation(operation, workerSourceText, headSourceText, ord
   if (!workerOffsets) reasons.push(`worker-span-not-resolvable:${operation.id}`);
   if (!headOffsets) reasons.push(`head-span-not-resolvable:${operation.id}`);
   if (reasons.length) return { ok: false, reasonCodes: reasons };
-  const replacement = workerSourceText.slice(workerOffsets.start, workerOffsets.end);
-  const current = headSourceText.slice(headOffsets.start, headOffsets.end);
-  if (operation.hashes?.workerTextHash && hashSemanticValue(replacement) !== operation.hashes.workerTextHash) {
+  const anchorReplacement = workerSourceText.slice(workerOffsets.start, workerOffsets.end);
+  const anchorCurrent = headSourceText.slice(headOffsets.start, headOffsets.end);
+  if (operation.hashes?.workerTextHash && hashSemanticValue(anchorReplacement) !== operation.hashes.workerTextHash) {
     reasons.push(`worker-span-hash-mismatch:${operation.id}`);
   }
   const expectedHeadHash = operation.hashes?.headTextHash ?? operation.hashes?.baseTextHash;
-  if (expectedHeadHash && hashSemanticValue(current) !== expectedHeadHash) {
+  if (expectedHeadHash && hashSemanticValue(anchorCurrent) !== expectedHeadHash) {
     reasons.push(`head-span-hash-mismatch:${operation.id}`);
   }
   if (reasons.length) return { ok: false, reasonCodes: reasons };
+  const scoped = scopedBodyReplacement(operation, headSourceText, workerSourceText, headOffsets, workerOffsets);
+  const replacement = scoped
+    ? workerSourceText.slice(scoped.worker.start, scoped.worker.end)
+    : anchorReplacement;
+  const current = scoped
+    ? headSourceText.slice(scoped.head.start, scoped.head.end)
+    : anchorCurrent;
   return {
     ok: true,
     value: {
@@ -97,10 +115,17 @@ function sourceEditForOperation(operation, workerSourceText, headSourceText, ord
       order,
       ...identity,
       editKind: 'replace',
-      start: headOffsets.start,
-      end: headOffsets.end,
-      workerStart: workerOffsets.start,
-      workerEnd: workerOffsets.end,
+      sourceRangeKind: scoped?.sourceRangeKind,
+      start: scoped?.head.start ?? headOffsets.start,
+      end: scoped?.head.end ?? headOffsets.end,
+      workerStart: scoped?.worker.start ?? workerOffsets.start,
+      workerEnd: scoped?.worker.end ?? workerOffsets.end,
+      headAnchorStart: scoped ? headOffsets.start : undefined,
+      headAnchorEnd: scoped ? headOffsets.end : undefined,
+      workerAnchorStart: scoped ? workerOffsets.start : undefined,
+      workerAnchorEnd: scoped ? workerOffsets.end : undefined,
+      anchorDeletedTextHash: scoped ? hashSemanticValue(anchorCurrent) : undefined,
+      anchorReplacementTextHash: scoped ? hashSemanticValue(anchorReplacement) : undefined,
       replacement,
       current
     }
@@ -165,9 +190,16 @@ function insertionEditForOperation(operation, identity, workerSourceText, headSo
   };
 }
 
-function projectionIdentity(operation) {
+function projectionIdentity(operation, headSourcePath) {
   const identity = semanticEditIdentity(operation);
-  return { ...identity, sourcePath: operation.reanchor?.toSourcePath ?? identity.sourcePath };
+  const sourcePath = operation.reanchor?.toSourcePath ?? headSourcePath ?? operation.insertion?.sourcePath ?? identity.sourcePath;
+  const originalSourcePath = sourcePath && identity.sourcePath && sourcePath !== identity.sourcePath
+    ? identity.sourcePath
+    : identity.originalSourcePath;
+  const targetSourcePath = sourcePath && sourcePath !== identity.sourcePath
+    ? sourcePath
+    : identity.targetSourcePath;
+  return { ...identity, sourcePath, originalSourcePath, targetSourcePath };
 }
 
 function projectionEditRecord(edit) {
@@ -197,18 +229,27 @@ function projectionEditRecord(edit) {
     operationContentHash: edit.operationContentHash,
     editContentHash: hashSemanticValue(compactRecord({
       semanticIdentityHash: identity.semanticIdentityHash,
+      sourceRangeKind: edit.sourceRangeKind,
       deletedTextHash,
       replacementTextHash,
       status: edit.alreadyApplied ? 'already-applied' : 'applied'
     })),
+    sourceRangeKind: edit.sourceRangeKind,
     headStart: edit.start,
     headEnd: edit.end,
     workerStart: edit.workerStart,
     workerEnd: edit.workerEnd,
+    editOrder: edit.order,
+    headAnchorStart: edit.headAnchorStart,
+    headAnchorEnd: edit.headAnchorEnd,
+    workerAnchorStart: edit.workerAnchorStart,
+    workerAnchorEnd: edit.workerAnchorEnd,
     deletedBytes: edit.current.length,
     replacementBytes: edit.replacement.length,
     deletedTextHash,
     replacementTextHash,
+    anchorDeletedTextHash: edit.anchorDeletedTextHash,
+    anchorReplacementTextHash: edit.anchorReplacementTextHash,
     replacementSpanTextHash: hashSemanticValue(edit.replacementSpanText ?? edit.replacement),
     insertionMode: edit.insertion?.mode,
     insertionAnchorKey: edit.insertion?.anchorKey,
@@ -247,55 +288,6 @@ function projectedSourcePath(script, edits) {
   return edits.map((edit) => edit.sourcePath).find(Boolean) ?? script.sourcePath;
 }
 
-function spanOffsets(sourceText, span) {
-  if (typeof sourceText !== 'string' || !span) return undefined;
-  if (typeof span.start === 'number' && typeof span.end === 'number' && span.end >= span.start) return { start: span.start, end: span.end };
-  if (typeof span.startLine !== 'number') return undefined;
-  const lineStarts = [0];
-  for (let index = 0; index < sourceText.length; index += 1) if (sourceText[index] === '\n') lineStarts.push(index + 1);
-  const startLine = Math.max(1, span.startLine);
-  const endLine = Math.max(startLine, typeof span.endLine === 'number' ? span.endLine : startLine);
-  const start = lineStarts[startLine - 1];
-  const endLineStart = lineStarts[endLine - 1];
-  if (start === undefined || endLineStart === undefined) return undefined;
-  const startColumn = Math.max(1, span.startColumn ?? 1) - 1;
-  const lineEnd = lineStarts[endLine] === undefined ? sourceText.length : lineStarts[endLine] - 1;
-  const endColumn = span.endColumn === undefined ? lineEnd - endLineStart : Math.max(1, span.endColumn) - 1;
-  return { start: start + startColumn, end: endLineStart + endColumn };
-}
-
-function insertionOffset(sourceText, insertion) {
-  if (typeof sourceText !== 'string') return { ok: false, reasonCodes: ['missing-head-source-text'] };
-  const mode = insertion?.mode;
-  if (mode === 'file-start') return { ok: true, offset: 0 };
-  if (mode === 'file-end') return { ok: true, offset: sourceText.length };
-  const range = spanOffsets(sourceText, insertion?.headSpan);
-  if (!range) return { ok: false, reasonCodes: ['insertion-anchor-not-resolvable'] };
-  if (mode === 'before') return { ok: true, offset: range.start };
-  if (mode === 'after') return { ok: true, offset: afterLineOffset(sourceText, range.end) };
-  return { ok: false, reasonCodes: ['insertion-mode-unsupported'] };
-}
-
-function removalRange(sourceText, span) {
-  const range = { ...span };
-  if (range.end < sourceText.length && sourceText[range.end] === '\n') range.end += 1;
-  else if (range.start > 0 && sourceText[range.start - 1] === '\n') range.start -= 1;
-  return range;
-}
-
-function insertionReplacement(text, sourceText, offset) {
-  let replacement = String(text ?? '');
-  if (offset > 0 && sourceText[offset - 1] !== '\n') replacement = `\n${replacement}`;
-  if (offset < sourceText.length && !replacement.endsWith('\n')) replacement += '\n';
-  if (offset === sourceText.length && sourceText && !sourceText.endsWith('\n')) replacement = `\n${replacement}`;
-  if (offset === sourceText.length && !replacement.endsWith('\n')) replacement += '\n';
-  return replacement;
-}
-
-function afterLineOffset(sourceText, offset) {
-  return sourceText[offset] === '\n' ? offset + 1 : offset;
-}
-
 function compactRecord(value) {
   return Object.fromEntries(Object.entries(value ?? {}).filter(([, entry]) => entry !== undefined && (!Array.isArray(entry) || entry.length > 0)));
 }

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

@@ -3,6 +3,7 @@ import { idFragment, normalizeNativeLanguageId, uniqueStrings } from '../../nati
 import { createSemanticImportSidecar } from './createSemanticImportSidecar.js';
 import { mapDiffSymbols } from './mapDiffSymbols.js';
 import { normalizeNativeDiffImport } from './normalizeNativeDiffImport.js';
+import { afterLineOffset, bodyContentRange, spanOffsets } from './semanticEditSourceRanges.js';
 
 export function replaySemanticEditProjection(input = {}) {
   const projection = input.projection ?? input.semanticEditProjection;
@@ -17,7 +18,7 @@ export function replaySemanticEditProjection(input = {}) {
     ? currentSymbolIndex({ currentSourceText, sourcePath, language, parser: input.parser })
     : [];
   const edits = projection.status === 'projected' && typeof currentSourceText === 'string'
-    ? (projection.edits ?? []).map((edit) => replayProjectionEdit(edit, { currentSourceText, currentSymbols }))
+    ? (projection.edits ?? []).map((edit, index) => replayProjectionEdit(projectionEditWithOrder(edit, index), { currentSourceText, currentSymbols }))
     : [];
   const status = replayStatus(reasonCodes, edits, projection);
   const outputSourceText = replayOutputSource(status, currentSourceText, edits);
@@ -54,14 +55,23 @@ function replayProjectionEdit(edit, context) {
   if (edit.status === 'already-applied') return replayEditRecord(edit, 'already-applied', undefined, ['projection-edit-already-applied']);
   if (typeof edit.replacementText !== 'string') return replayEditRecord(edit, 'blocked', undefined, ['missing-replacement-text']);
   if (edit.editKind === 'insert') return replayInsertionEdit(edit, context);
-  const offset = checkRange(edit, { start: edit.headStart, end: edit.headEnd }, context.currentSourceText, 'head-offset');
-  if (offset) return replayEditRecord(edit, offset.status, offset.range, [offset.reason]);
+  const headRange = { start: edit.headStart, end: edit.headEnd };
+  const offset = checkRange(edit, headRange, context.currentSourceText, 'head-offset');
   const symbol = findCurrentSymbol(edit, context.currentSymbols);
-  const spanRange = spanOffsets(context.currentSourceText, symbol?.sourceSpan);
-  const anchored = checkRange(edit, spanRange, context.currentSourceText, 'current-symbol-anchor');
+  const spanRange = currentSymbolEditRange(edit, spanOffsets(context.currentSourceText, symbol?.sourceSpan), context.currentSourceText);
+  if (symbol && spanRange && !sameRange(headRange, spanRange)) {
+    const moved = checkRange(edit, spanRange, context.currentSourceText, currentSymbolRangeLabel(edit));
+    if (moved) return replayEditRecord(edit, moved.status, moved.range, [moved.reason, 'offset-reanchored-by-symbol']);
+    if (edit.editKind === 'delete' && offset && rangesOverlap(headRange, spanRange)) {
+      return replayEditRecord(edit, offset.status, offset.range, [offset.reason]);
+    }
+    return replayEditRecord(edit, 'conflict', spanRange, [`${currentSymbolRangeLabel(edit)}-content-mismatch`]);
+  }
+  if (offset) return replayEditRecord(edit, offset.status, offset.range, [offset.reason]);
+  const anchored = checkRange(edit, spanRange, context.currentSourceText, currentSymbolRangeLabel(edit));
   if (anchored) return replayEditRecord(edit, anchored.status, anchored.range, [anchored.reason, 'offset-reanchored-by-symbol']);
   return replayEditRecord(edit, symbol ? 'conflict' : 'stale', spanRange, [
-    symbol ? 'current-symbol-anchor-content-mismatch' : 'current-symbol-anchor-missing'
+    symbol ? `${currentSymbolRangeLabel(edit)}-content-mismatch` : 'current-symbol-anchor-missing'
   ]);
 }
 
@@ -70,6 +80,9 @@ function replayInsertionEdit(edit, context) {
   const insertedRange = spanOffsets(context.currentSourceText, inserted?.sourceSpan);
   const already = checkRange(edit, insertedRange, context.currentSourceText, 'current-inserted-symbol');
   if (already?.status === 'already-applied') return replayEditRecord(edit, 'already-applied', already.range, [already.reason]);
+  if (inserted && insertedRange) {
+    return replayEditRecord(edit, 'conflict', insertedRange, ['current-inserted-symbol-content-mismatch']);
+  }
   const anchor = findInsertionAnchorSymbol(edit, context.currentSymbols);
   const range = insertionRange(edit, anchor, context.currentSourceText);
   if (range) return replayEditRecord(edit, 'applied', range, [anchor ? 'current-insertion-anchor' : `current-${edit.insertionMode}`]);
@@ -97,6 +110,8 @@ function replayEditRecord(edit, status, range, reasonCodes) {
     sourceIdentityHash: edit.sourceIdentityHash,
     editContentHash: edit.editContentHash,
     editKind: edit.editKind,
+    editOrder: edit.editOrder,
+    sourceRangeKind: edit.sourceRangeKind,
     sourcePath: edit.targetSourcePath ?? edit.sourcePath,
     symbolName: edit.targetSymbolName ?? edit.symbolName,
     symbolKind: edit.targetSymbolKind ?? edit.symbolKind,
@@ -143,12 +158,21 @@ function insertionRange(edit, anchor, sourceText) {
   if (!anchorRange) return undefined;
   if (edit.insertionMode === 'before') return { start: anchorRange.start, end: anchorRange.start };
   if (edit.insertionMode === 'after') {
-    const offset = sourceText[anchorRange.end] === '\n' ? anchorRange.end + 1 : anchorRange.end;
-    return { start: offset, end: offset };
+    return { start: afterLineOffset(sourceText, anchorRange.end), end: afterLineOffset(sourceText, anchorRange.end) };
   }
   return undefined;
 }
 
+function currentSymbolEditRange(edit, symbolRange, sourceText) {
+  if (!symbolRange) return undefined;
+  if (edit.sourceRangeKind === 'body-content') return bodyContentRange(sourceText, symbolRange);
+  return symbolRange;
+}
+
+function currentSymbolRangeLabel(edit) {
+  return edit.sourceRangeKind === 'body-content' ? 'current-symbol-body' : 'current-symbol-anchor';
+}
+
 function replayStatus(reasonCodes, edits, projection) {
   if (reasonCodes.some((reason) => reason !== 'current-source-hash-mismatch')) return 'blocked';
   if (!edits.length && !(projection.edits ?? []).length) return 'evidence-only';
@@ -189,10 +213,25 @@ function replayOutputSource(status, sourceText, edits) {
   if (status === 'already-applied') return sourceText;
   if (status !== 'accepted-clean') return undefined;
   return edits.filter((edit) => edit.status === 'applied')
-    .sort((left, right) => right.start - left.start)
+    .sort(replaySourceEditSort)
     .reduce((text, edit) => text.slice(0, edit.start) + editReplacement(edit, edits) + text.slice(edit.end), sourceText);
 }
 
+function replaySourceEditSort(left, right) {
+  return right.start - left.start || right.end - left.end || (right.editOrder ?? 0) - (left.editOrder ?? 0);
+}
+
+function projectionEditWithOrder(edit, index) {
+  return {
+    ...edit,
+    editOrder: typeof edit.editOrder === 'number'
+      ? edit.editOrder
+      : typeof edit.order === 'number'
+        ? edit.order
+        : index
+  };
+}
+
 function editReplacement(edit, edits) {
   return edits.find((candidate) => candidate.operationId === edit.operationId)?.replacementText ?? '';
 }
@@ -205,19 +244,12 @@ function baseReasonCodes(projection, currentSourceText) {
   ]);
 }
 
-function spanOffsets(sourceText, span) {
-  if (typeof sourceText !== 'string' || !span) return undefined;
-  if (typeof span.start === 'number' && typeof span.end === 'number' && span.end >= span.start) return { start: span.start, end: span.end };
-  if (typeof span.startLine !== 'number') return undefined;
-  const starts = [0];
-  for (let index = 0; index < sourceText.length; index += 1) if (sourceText[index] === '\n') starts.push(index + 1);
-  const startLine = Math.max(1, span.startLine);
-  const endLine = Math.max(startLine, typeof span.endLine === 'number' ? span.endLine : startLine);
-  const lineStart = starts[startLine - 1];
-  const endLineStart = starts[endLine - 1];
-  if (lineStart === undefined || endLineStart === undefined) return undefined;
-  const lineEnd = starts[endLine] === undefined ? sourceText.length : starts[endLine] - 1;
-  return { start: lineStart + Math.max(0, (span.startColumn ?? 1) - 1), end: endLineStart + (span.endColumn === undefined ? lineEnd - endLineStart : Math.max(0, span.endColumn - 1)) };
+function sameRange(left, right) {
+  return left?.start === right?.start && left?.end === right?.end;
+}
+
+function rangesOverlap(left, right) {
+  return Boolean(left && right && left.start < right.end && right.start < left.end);
 }
 
 function isJavaScriptLike(language) { return language === 'javascript' || language === 'typescript'; }

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

@@ -0,0 +1,220 @@
+import { normalizeSemanticMergeReadiness, uniqueStrings } from '../../native-import-utils.js';
+
+export const SemanticEditBundleAdmissionStatuses = Object.freeze([
+  'none',
+  'ready',
+  'already-applied',
+  'needs-review',
+  'stale',
+  'conflict',
+  'blocked'
+]);
+
+export function createSemanticEditBundleAdmission(input = {}, options = {}) {
+  const scripts = array(input.semanticEditScripts ?? input.scripts ?? input.semanticEditScript);
+  const projections = array(input.semanticEditProjections ?? input.projections ?? input.semanticEditProjection);
+  const replays = array(input.semanticEditReplays ?? input.replays ?? input.semanticEditReplay);
+  const evidence = evidenceRecords(input, options);
+  const summary = summarizeSemanticEditBundle(scripts, projections, replays, evidence);
+  const computedStatus = semanticEditBundleStatus(summary);
+  const status = safeStatus(input.status ?? options.status, computedStatus, summary);
+  const readiness = normalizeSemanticMergeReadiness(input.readiness ?? options.readiness ?? readinessForStatus(status))
+    ?? input.readiness ?? options.readiness ?? readinessForStatus(status);
+  const positiveAutoApplyCandidate = status === 'ready' && hasPositiveAutoMergeProof(summary);
+  const computedReviewRequired = !['ready', 'already-applied', 'none'].includes(status) || (status === 'ready' && !positiveAutoApplyCandidate);
+  return compactRecord({
+    status,
+    action: safeAction(input.action ?? options.action, status, positiveAutoApplyCandidate),
+    readiness,
+    reviewRequired: input.reviewRequired === true || computedReviewRequired,
+    autoApplyCandidate: input.autoApplyCandidate === false ? false : positiveAutoApplyCandidate,
+    autoMergeClaim: false,
+    semanticEquivalenceClaim: false,
+    reasonCodes: uniqueStrings([
+      ...strings(input.reasonCodes),
+      ...strings(options.reasonCodes),
+      ...summary.reasonCodes,
+      ...derivedReasonCodes(summary, status)
+    ].filter(Boolean)),
+    sourcePaths: summary.sourcePaths,
+    scriptIds: summary.scriptIds,
+    projectionIds: summary.projectionIds,
+    replayIds: summary.replayIds,
+    summary,
+    metadata: input.metadata ?? options.metadata
+  });
+}
+
+function summarizeSemanticEditBundle(scripts, projections, replays, evidence) {
+  const scriptStatusEntries = scripts.map((script) => script.admission?.status);
+  const projectionStatusEntries = projections.flatMap((projection) => [projection.status, projection.admission?.status]);
+  const replayStatusEntries = replays.map((replay) => replay.status);
+  const scriptStatuses = uniqueStrings(strings(scriptStatusEntries));
+  const projectionStatuses = uniqueStrings(strings(projectionStatusEntries));
+  const replayStatuses = uniqueStrings(strings(replayStatusEntries));
+  const replayActions = uniqueStrings(strings(replays.map((replay) => replay.admission?.action)));
+  const evidenceSummary = summarizeEvidence(evidence);
+  return {
+    scripts: scripts.length,
+    projections: projections.length,
+    replays: replays.length,
+    files: sourcePaths(scripts, projections, replays).length,
+    portableScripts: scripts.filter((script) => script.admission?.status === 'auto-merge-candidate').length,
+    portableProjections: projections.filter((projection) => projection.status === 'projected' && projection.admission?.status === 'auto-merge-candidate').length,
+    acceptedClean: replays.filter((replay) => replay.status === 'accepted-clean').length,
+    alreadyApplied: replays.filter((replay) => replay.status === 'already-applied').length,
+    conflicts: countStatuses(scriptStatusEntries, replayStatusEntries, ['conflict']),
+    stale: countStatuses(scriptStatusEntries, replayStatusEntries, ['stale']),
+    blocked: countStatuses(scriptStatusEntries, projectionStatusEntries, replayStatusEntries, ['blocked']),
+    needsReview: countStatuses(scriptStatusEntries, replayStatusEntries, ['needs-port', 'evidence-only']),
+    projected: projections.filter((projection) => projection.status === 'projected').length,
+    projectionBlocked: projections.filter((projection) => projection.status === 'blocked').length,
+    scriptStatuses,
+    projectionStatuses,
+    replayStatuses,
+    replayActions,
+    sourcePaths: sourcePaths(scripts, projections, replays),
+    scriptIds: uniqueStrings(scripts.map((script) => script.id)),
+    projectionIds: uniqueStrings(projections.map((projection) => projection.id)),
+    replayIds: uniqueStrings(replays.map((replay) => replay.id)),
+    evidenceIds: evidenceSummary.evidenceIds,
+    passedTestEvidence: evidenceSummary.passed,
+    failedTestEvidence: evidenceSummary.failed,
+    conflictEvidence: evidenceSummary.conflict,
+    staleEvidence: evidenceSummary.stale,
+    reasonCodes: uniqueStrings([
+      ...scripts.flatMap((script) => strings(script.admission?.reasonCodes)),
+      ...projections.flatMap((projection) => strings(projection.admission?.reasonCodes)),
+      ...replays.flatMap((replay) => strings(replay.admission?.reasonCodes)),
+      ...evidenceSummary.reasonCodes
+    ])
+  };
+}
+
+function semanticEditBundleStatus(summary) {
+  const total = summary.scripts + summary.projections + summary.replays;
+  if (summary.blocked || summary.projectionBlocked || summary.failedTestEvidence) return 'blocked';
+  if (summary.conflicts || summary.conflictEvidence) return 'conflict';
+  if (summary.stale || summary.staleEvidence) return 'stale';
+  if (total === 0) return 'none';
+  if (!summary.replays || summary.needsReview) return 'needs-review';
+  if (summary.acceptedClean === 0 && summary.alreadyApplied === summary.replays) return 'already-applied';
+  return hasPositiveAutoMergeProof(summary) ? 'ready' : 'needs-review';
+}
+
+function derivedReasonCodes(summary, status) {
+  return [
+    summary.scripts && !summary.projections ? 'semantic-edit-projection-missing' : undefined,
+    (summary.scripts || summary.projections) && !summary.replays ? 'semantic-edit-replay-missing' : undefined,
+    summary.scripts && summary.portableScripts !== summary.scripts ? 'semantic-edit-script-not-portable' : undefined,
+    summary.projections && summary.portableProjections !== summary.projections ? 'semantic-edit-projection-not-portable' : undefined,
+    summary.acceptedClean && !summary.passedTestEvidence ? 'semantic-edit-tests-passed-evidence-missing' : undefined,
+    summary.failedTestEvidence ? 'semantic-edit-tests-failed' : undefined,
+    summary.conflictEvidence ? 'semantic-edit-conflict-evidence' : undefined,
+    summary.staleEvidence ? 'semantic-edit-stale-evidence' : undefined,
+    status === 'ready' ? 'semantic-edit-replay-accepted-clean' : undefined,
+    status === 'ready' ? 'semantic-edit-positive-auto-merge-proof' : undefined,
+    status === 'already-applied' ? 'semantic-edit-replay-already-applied' : undefined,
+    status === 'blocked' ? 'semantic-edit-blocked' : undefined,
+    status === 'conflict' ? 'semantic-edit-conflict' : undefined,
+    status === 'stale' ? 'semantic-edit-stale' : undefined
+  ];
+}
+
+function hasPositiveAutoMergeProof(summary) {
+  return summary.acceptedClean > 0 &&
+    summary.acceptedClean + summary.alreadyApplied === summary.replays &&
+    summary.scripts > 0 &&
+    summary.projections > 0 &&
+    summary.portableScripts === summary.scripts &&
+    summary.portableProjections === summary.projections &&
+    summary.passedTestEvidence > 0 &&
+    summary.failedTestEvidence === 0 &&
+    summary.conflictEvidence === 0 &&
+    summary.staleEvidence === 0;
+}
+
+function readinessForStatus(status) {
+  if (['ready', 'already-applied'].includes(status)) return 'ready';
+  if (['blocked', 'conflict'].includes(status)) return 'blocked';
+  return 'needs-review';
+}
+
+function actionForStatus(status) {
+  if (status === 'ready') return 'admit';
+  if (status === 'already-applied') return 'skip';
+  if (status === 'none') return 'none';
+  if (status === 'stale') return 'rerun-semantic-import';
+  if (status === 'blocked' || status === 'conflict') return 'block';
+  return 'review';
+}
+
+function safeStatus(requested, computed, summary) {
+  if (!requested) return computed;
+  if (requested === 'ready' && !hasPositiveAutoMergeProof(summary)) return computed;
+  if (requested === 'already-applied' && computed !== 'already-applied') return computed;
+  if (['blocked', 'conflict', 'stale'].includes(requested)) return requested;
+  return computed;
+}
+
+function safeAction(requested, status, positiveAutoApplyCandidate) {
+  if (requested === 'admit' && !positiveAutoApplyCandidate) return actionForStatus(status);
+  if (requested === 'skip' && status !== 'already-applied') return actionForStatus(status);
+  return requested ?? actionForStatus(status);
+}
+
+function sourcePaths(scripts, projections, replays) {
+  return uniqueStrings(strings([
+    ...scripts.map((script) => script.sourcePath),
+    ...projections.map((projection) => projection.sourcePath),
+    ...projections.flatMap((projection) => array(projection.edits).flatMap((edit) => [edit.sourcePath, edit.targetSourcePath])),
+    ...replays.map((replay) => replay.sourcePath),
+    ...replays.flatMap((replay) => array(replay.edits).map((edit) => edit.sourcePath))
+  ]));
+}
+
+function countStatuses(...args) {
+  const statuses = args.slice(0, -1).flatMap((value) => strings(value));
+  const needles = new Set(args.at(-1));
+  return statuses.filter((status) => needles.has(status)).length;
+}
+
+function evidenceRecords(...sources) {
+  return sources.flatMap((source) => [
+    ...array(source?.evidence),
+    ...array(source?.testEvidence),
+    ...array(source?.testResults),
+    ...array(source?.gateEvidence),
+    ...array(source?.proofEvidence)
+  ]).filter(Boolean);
+}
+
+function summarizeEvidence(evidence) {
+  const testLike = evidence.filter(isAutoMergeTestEvidence);
+  const conflict = evidence.filter((record) => evidenceStatus(record, ['conflict', 'conflicted']) || record?.metadata?.conflict === true || strings(record?.reasonCodes ?? record?.reasons).some((reason) => reason.toLowerCase().includes('conflict')));
+  const stale = evidence.filter((record) => evidenceStatus(record, ['stale']) || record?.metadata?.stale === true || strings(record?.reasonCodes ?? record?.reasons).some((reason) => reason.toLowerCase().includes('stale')));
+  const failed = testLike.filter((record) => evidenceStatus(record, ['failed', 'failure', 'error', 'blocked', 'rejected']));
+  const passed = testLike.filter((record) => evidenceStatus(record, ['passed', 'ok', 'success', 'succeeded', 'accepted', 'verified']));
+  return {
+    evidenceIds: uniqueStrings(evidence.map((record) => record.id)),
+    passed: passed.length,
+    failed: failed.length,
+    conflict: conflict.length,
+    stale: stale.length,
+    reasonCodes: uniqueStrings(evidence.flatMap((record) => strings(record.reasonCodes ?? record.reasons)))
+  };
+}
+
+function isAutoMergeTestEvidence(record) {
+  const kind = String(record?.kind ?? record?.type ?? '').toLowerCase();
+  return ['test', 'tests', 'proof', 'gate', 'verification', 'check'].includes(kind);
+}
+
+function evidenceStatus(record, statuses) {
+  const status = String(record?.status ?? record?.outcome ?? '').toLowerCase();
+  return statuses.includes(status);
+}
+
+function array(value) { if (value === undefined || value === null) return []; return Array.isArray(value) ? value : [value]; }
+function strings(value) { return array(value).map((entry) => String(entry ?? '')).filter(Boolean); }
+function compactRecord(value) { return Object.fromEntries(Object.entries(value ?? {}).filter(([, entry]) => entry !== undefined && (!Array.isArray(entry) || entry.length > 0))); }

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

@@ -15,16 +15,16 @@ export function semanticEditRecordIndex(scripts, projections, replays, source =
     semanticEditReplayEditCount: replayEdits.length,
     semanticEditReplayStatuses: uniqueStrings([...strings(source.semanticEditReplayStatuses), ...strings(index.semanticEditReplayStatuses), ...strings(summary.replayStatuses), ...replays.map((replay) => replay.status)]),
     semanticEditReplayActions: uniqueStrings([...strings(source.semanticEditReplayActions), ...strings(index.semanticEditReplayActions), ...strings(summary.replayActions), ...replays.map((replay) => replay.admission?.action)]),
-    semanticEditReplayCurrentHashes: uniqueStrings([...strings(source.semanticEditReplayCurrentHashes), ...strings(index.semanticEditReplayCurrentHashes), ...replays.map((replay) => replay.currentHash)]),
-    semanticEditReplayOutputHashes: uniqueStrings([...strings(source.semanticEditReplayOutputHashes), ...strings(index.semanticEditReplayOutputHashes), ...replays.map((replay) => replay.outputHash)]),
-    semanticEditKeys: uniqueStrings([...strings(source.semanticEditKeys), ...strings(index.semanticEditKeys), ...operations.map((operation) => operation.semanticKey), ...edits.map((edit) => edit.semanticKey), ...replayEdits.map((edit) => edit.semanticKey)]),
-    semanticIdentityHashes: uniqueStrings([...strings(source.semanticIdentityHashes), ...strings(index.semanticIdentityHashes), ...operations.map((operation) => operation.semanticIdentityHash), ...edits.map((edit) => edit.semanticIdentityHash), ...replayEdits.map((edit) => edit.semanticIdentityHash)]),
-    sourceIdentityHashes: uniqueStrings([...strings(source.sourceIdentityHashes), ...strings(index.sourceIdentityHashes), ...operations.map((operation) => operation.sourceIdentityHash), ...edits.map((edit) => edit.sourceIdentityHash), ...replayEdits.map((edit) => edit.sourceIdentityHash)]),
-    operationContentHashes: uniqueStrings([...strings(source.operationContentHashes), ...strings(index.operationContentHashes), ...operations.map((operation) => operation.operationContentHash), ...edits.map((edit) => edit.operationContentHash)]),
-    editContentHashes: uniqueStrings([...strings(source.editContentHashes), ...strings(index.editContentHashes), ...edits.map((edit) => edit.editContentHash), ...replayEdits.map((edit) => edit.editContentHash)]),
-    anchorKeys: uniqueStrings([...operations.map((operation) => operation.anchor?.key), ...edits.map((edit) => edit.anchorKey)]),
-    conflictKeys: uniqueStrings([...operations.map((operation) => operation.anchor?.conflictKey), ...edits.map((edit) => edit.conflictKey)]),
-    projectedSourcePaths: uniqueStrings([...projections.map((projection) => projection.sourcePath), ...edits.flatMap((edit) => [edit.sourcePath, edit.targetSourcePath]), ...replays.map((replay) => replay.sourcePath), ...replayEdits.map((edit) => edit.sourcePath)])
+    semanticEditReplayCurrentHashes: uniqueStrings([...strings(source.semanticEditReplayCurrentHashes), ...strings(index.semanticEditReplayCurrentHashes), ...strings(summary.replayCurrentHashes), ...strings(summary.semanticEditReplayCurrentHashes), ...replays.map((replay) => replay.currentHash)]),
+    semanticEditReplayOutputHashes: uniqueStrings([...strings(source.semanticEditReplayOutputHashes), ...strings(index.semanticEditReplayOutputHashes), ...strings(summary.replayOutputHashes), ...strings(summary.semanticEditReplayOutputHashes), ...replays.map((replay) => replay.outputHash)]),
+    semanticEditKeys: uniqueStrings([...strings(source.semanticEditKeys), ...strings(index.semanticEditKeys), ...strings(summary.semanticEditKeys), ...operations.map((operation) => operation.semanticKey), ...edits.map((edit) => edit.semanticKey), ...replayEdits.map((edit) => edit.semanticKey)]),
+    semanticIdentityHashes: uniqueStrings([...strings(source.semanticIdentityHashes), ...strings(index.semanticIdentityHashes), ...strings(summary.semanticIdentityHashes), ...operations.map((operation) => operation.semanticIdentityHash), ...edits.map((edit) => edit.semanticIdentityHash), ...replayEdits.map((edit) => edit.semanticIdentityHash)]),
+    sourceIdentityHashes: uniqueStrings([...strings(source.sourceIdentityHashes), ...strings(index.sourceIdentityHashes), ...strings(summary.sourceIdentityHashes), ...operations.map((operation) => operation.sourceIdentityHash), ...edits.map((edit) => edit.sourceIdentityHash), ...replayEdits.map((edit) => edit.sourceIdentityHash)]),
+    operationContentHashes: uniqueStrings([...strings(source.operationContentHashes), ...strings(index.operationContentHashes), ...strings(summary.operationContentHashes), ...operations.map((operation) => operation.operationContentHash), ...edits.map((edit) => edit.operationContentHash), ...replayEdits.map((edit) => edit.operationContentHash)]),
+    editContentHashes: uniqueStrings([...strings(source.editContentHashes), ...strings(index.editContentHashes), ...strings(summary.editContentHashes), ...edits.map((edit) => edit.editContentHash), ...replayEdits.map((edit) => edit.editContentHash)]),
+    anchorKeys: uniqueStrings([...strings(source.anchorKeys), ...strings(index.anchorKeys), ...strings(summary.anchorKeys), ...operations.map((operation) => operation.anchor?.key), ...edits.map((edit) => edit.anchorKey), ...replayEdits.map((edit) => edit.anchorKey)]),
+    conflictKeys: uniqueStrings([...strings(source.conflictKeys), ...strings(index.conflictKeys), ...strings(summary.conflictKeys), ...operations.map((operation) => operation.anchor?.conflictKey), ...edits.map((edit) => edit.conflictKey), ...replayEdits.map((edit) => edit.conflictKey)]),
+    projectedSourcePaths: uniqueStrings([...strings(source.projectedSourcePaths), ...strings(index.projectedSourcePaths), ...strings(summary.projectedSourcePaths), ...projections.map((projection) => projection.sourcePath), ...edits.flatMap((edit) => [edit.sourcePath, edit.targetSourcePath]), ...replays.map((replay) => replay.sourcePath), ...replayEdits.map((edit) => edit.sourcePath)])
   };
 }
 
@@ -36,9 +36,15 @@ export function semanticEditSummary(index) {
     replayIds: index.semanticEditReplayIds,
     replayStatuses: index.semanticEditReplayStatuses,
     replayActions: index.semanticEditReplayActions,
+    replayCurrentHashes: index.semanticEditReplayCurrentHashes,
+    replayOutputHashes: index.semanticEditReplayOutputHashes,
     semanticEditKeys: index.semanticEditKeys,
+    semanticIdentityHashes: index.semanticIdentityHashes,
+    sourceIdentityHashes: index.sourceIdentityHashes,
     operationContentHashes: index.operationContentHashes,
     editContentHashes: index.editContentHashes,
+    anchorKeys: index.anchorKeys,
+    conflictKeys: index.conflictKeys,
     projectedSourcePaths: index.projectedSourcePaths,
     replayEditCount: index.semanticEditReplayEditCount
   });