@shapeshift-labs/frontier-lang-compiler 0.2.85 → 0.2.87

package/dist/declarations/semantic-edit-script.d.ts

@@ -66,6 +66,9 @@ export interface SemanticEditScriptOperation {
   readonly reanchor?: {
     readonly fromAnchorKey?: string;
     readonly toAnchorKey?: string;
+    readonly toSourcePath?: string;
+    readonly toSymbolName?: string;
+    readonly toSymbolKind?: string;
     readonly lineageStatus?: string;
     readonly traversedEventIds?: readonly string[];
   };
@@ -138,6 +141,11 @@ export interface SemanticEditProjectionEdit {
   readonly regionId?: string;
   readonly regionKind?: string;
   readonly sourcePath?: string;
+  readonly originalSourcePath?: string;
+  readonly targetAnchorKey?: string;
+  readonly targetSourcePath?: string;
+  readonly targetSymbolName?: string;
+  readonly targetSymbolKind?: string;
   readonly symbolId?: string;
   readonly symbolName?: string;
   readonly symbolKind?: string;
@@ -188,6 +196,7 @@ export interface ProjectSemanticEditScriptToSourceOptions {
   readonly script: SemanticEditScript;
   readonly workerSourceText: string;
   readonly headSourceText: string;
+  readonly headSourcePath?: string;
   readonly metadata?: Record<string, unknown>;
 }
 
@@ -207,6 +216,7 @@ export interface CreateSemanticEditScriptOptions {
   readonly workerSourceText?: string;
   readonly afterSourceText?: string;
   readonly headSourceText?: string;
+  readonly headSourcePath?: string;
   readonly currentSourceText?: string;
   readonly baseSourceHash?: string;
   readonly workerSourceHash?: string;

package/dist/declarations/semantic-patch-bundle.d.ts

@@ -7,6 +7,7 @@ import type {
   SourceSpan
 } from '@shapeshift-labs/frontier-lang-kernel';
 import type { NativeSourceChangeKind, NativeSourceChangeSet } from './native-diff.js';
+import type { SemanticEditProjection, SemanticEditScript } from './semantic-edit-script.js';
 
 export type SemanticPatchBundleAdmissionStatus = 'proposed' | 'queued' | 'admitted' | 'needs-review' | 'blocked' | 'rejected' | string;
 
@@ -102,6 +103,13 @@ export interface SemanticPatchBundleRecordIndex {
   readonly proofIds: readonly string[];
   readonly historyIds: readonly string[];
   readonly semanticOperationIds: readonly string[];
+  readonly semanticEditScriptIds: readonly string[];
+  readonly semanticEditProjectionIds: readonly string[];
+  readonly semanticEditKeys: readonly string[];
+  readonly semanticIdentityHashes: readonly string[];
+  readonly sourceIdentityHashes: readonly string[];
+  readonly operationContentHashes: readonly string[];
+  readonly editContentHashes: readonly string[];
   readonly patchIds: readonly string[];
   readonly mergeCandidateIds: readonly string[];
   readonly readinesses: readonly string[];
@@ -127,6 +135,8 @@ export interface SemanticPatchBundleRecord {
   readonly proofIds: readonly string[];
   readonly historyIds: readonly string[];
   readonly semanticOperationIds: readonly string[];
+  readonly semanticEditScriptIds: readonly string[];
+  readonly semanticEditProjectionIds: readonly string[];
   readonly admission: SemanticPatchBundleAdmission;
   readonly index: SemanticPatchBundleRecordIndex;
   readonly summary: {
@@ -136,6 +146,9 @@ export interface SemanticPatchBundleRecord {
     readonly proofIds: number;
     readonly historyIds: number;
     readonly semanticOperations: number;
+    readonly semanticEditScripts: number;
+    readonly semanticEditProjections: number;
+    readonly semanticEditProjectionEdits: number;
     readonly reviewRequired: boolean;
     readonly autoMergeClaim: false;
   };
@@ -164,6 +177,10 @@ export interface CreateSemanticPatchBundleRecordOptions {
   readonly historyIds?: readonly string[] | string;
   readonly semanticOperationId?: string;
   readonly semanticOperationIds?: readonly string[] | string;
+  readonly semanticEditScript?: SemanticEditScript;
+  readonly semanticEditScripts?: readonly SemanticEditScript[] | SemanticEditScript;
+  readonly semanticEditProjection?: SemanticEditProjection;
+  readonly semanticEditProjections?: readonly SemanticEditProjection[] | SemanticEditProjection;
   readonly conflictKeys?: readonly string[] | string;
   readonly admission?: Partial<SemanticPatchBundleAdmission>;
   readonly metadata?: Record<string, unknown>;
@@ -206,6 +223,20 @@ export interface SemanticPatchBundleRecordQuery {
   readonly historyIds?: readonly string[];
   readonly semanticOperationId?: string | readonly string[];
   readonly semanticOperationIds?: readonly string[];
+  readonly semanticEditScriptId?: string | readonly string[];
+  readonly semanticEditScriptIds?: readonly string[];
+  readonly semanticEditProjectionId?: string | readonly string[];
+  readonly semanticEditProjectionIds?: readonly string[];
+  readonly semanticEditKey?: string | readonly string[];
+  readonly semanticEditKeys?: readonly string[];
+  readonly semanticIdentityHash?: string | readonly string[];
+  readonly semanticIdentityHashes?: readonly string[];
+  readonly sourceIdentityHash?: string | readonly string[];
+  readonly sourceIdentityHashes?: readonly string[];
+  readonly operationContentHash?: string | readonly string[];
+  readonly operationContentHashes?: readonly string[];
+  readonly editContentHash?: string | readonly string[];
+  readonly editContentHashes?: readonly string[];
   readonly readiness?: SemanticMergeReadiness | string | readonly string[];
   readonly readinesses?: readonly string[];
   readonly admissionStatus?: SemanticPatchBundleAdmissionStatus | readonly string[];

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

@@ -25,7 +25,7 @@ export function projectSemanticEditScriptToSource(input = {}) {
     id: input.id ?? `semantic_edit_projection_${idFragment(script.id ?? script.hash ?? 'script')}`,
     scriptId: script.id,
     status: blocked ? 'blocked' : 'projected',
-    sourcePath: script.sourcePath,
+    sourcePath: input.headSourcePath ?? projectedSourcePath(script, edits),
     language: script.language,
     baseHash: script.baseHash,
     workerHash: script.workerHash,
@@ -54,8 +54,9 @@ export function projectSemanticEditScriptToSource(input = {}) {
 }
 
 function sourceEditForOperation(operation, workerSourceText, headSourceText) {
+  const identity = projectionIdentity(operation);
   if (operation.status === 'already-applied') {
-    return { ok: true, value: { ...semanticEditIdentity(operation), operationId: operation.id, start: 0, end: 0, replacement: '', current: '', alreadyApplied: true } };
+    return { ok: true, value: { ...identity, operationId: operation.id, start: 0, end: 0, replacement: '', current: '', alreadyApplied: true } };
   }
   if (operation.status !== 'portable') return { ok: false, reasonCodes: [`operation-not-portable:${operation.id}`] };
   const workerOffsets = spanOffsets(workerSourceText, operation.spans?.worker);
@@ -78,7 +79,7 @@ function sourceEditForOperation(operation, workerSourceText, headSourceText) {
     ok: true,
     value: {
       operationId: operation.id,
-      ...semanticEditIdentity(operation),
+      ...identity,
       start: headOffsets.start,
       end: headOffsets.end,
       workerStart: workerOffsets.start,
@@ -89,6 +90,11 @@ function sourceEditForOperation(operation, workerSourceText, headSourceText) {
   };
 }
 
+function projectionIdentity(operation) {
+  const identity = semanticEditIdentity(operation);
+  return { ...identity, sourcePath: operation.reanchor?.toSourcePath ?? identity.sourcePath };
+}
+
 function projectionEditRecord(edit) {
   const deletedTextHash = hashSemanticValue(edit.current);
   const replacementTextHash = hashSemanticValue(edit.replacement);
@@ -103,6 +109,11 @@ function projectionEditRecord(edit) {
     regionId: edit.regionId,
     regionKind: edit.regionKind,
     sourcePath: edit.sourcePath,
+    originalSourcePath: edit.originalSourcePath,
+    targetAnchorKey: edit.targetAnchorKey,
+    targetSourcePath: edit.targetSourcePath,
+    targetSymbolName: edit.targetSymbolName,
+    targetSymbolKind: edit.targetSymbolKind,
     symbolId: edit.symbolId,
     symbolName: edit.symbolName,
     symbolKind: edit.symbolKind,
@@ -136,6 +147,11 @@ function semanticEditIdentity(operation) {
     regionId: anchor.regionId,
     regionKind: anchor.regionKind,
     sourcePath: anchor.sourcePath,
+    originalSourcePath: operation.reanchor?.toSourcePath ? anchor.sourcePath : undefined,
+    targetAnchorKey: operation.reanchor?.toAnchorKey,
+    targetSourcePath: operation.reanchor?.toSourcePath,
+    targetSymbolName: operation.reanchor?.toSymbolName,
+    targetSymbolKind: operation.reanchor?.toSymbolKind,
     symbolId: anchor.symbolId,
     symbolName: anchor.symbolName,
     symbolKind: anchor.symbolKind,
@@ -152,6 +168,10 @@ function applySourceEdits(sourceText, edits) {
     .reduce((text, edit) => text.slice(0, edit.start) + edit.replacement + text.slice(edit.end), sourceText);
 }
 
+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 };

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

@@ -92,12 +92,15 @@ function classifyMissingHeadAnchor(input) {
     ? resolveSemanticLineage(input.context.headLineage.lineageMap, { anchorKey: input.anchorKey })
     : undefined;
   if (resolved?.status === 'resolved' && resolved.currentAnchors.length === 1) {
-    return editStatus('needs-port', 'needs-review', 0.72, ['anchor-moved-or-renamed'], {
-      fromAnchorKey: input.anchorKey,
-      toAnchorKey: resolved.currentAnchors[0].key,
-      lineageStatus: resolved.status,
-      traversedEventIds: resolved.traversedEventIds
-    }, resolved.evidenceIds);
+    const target = resolved.currentAnchors[0];
+    const reanchor = reanchorRecord(input.anchorKey, target, resolved);
+    if (target.bodyHash && input.baseSymbol?.spanHash && target.bodyHash === input.baseSymbol.spanHash) {
+      return editStatus('portable', 'ready', 0.86, ['anchor-reanchored-head-matches-base'], reanchor, resolved.evidenceIds);
+    }
+    if (target.bodyHash && input.workerSymbol?.spanHash && target.bodyHash === input.workerSymbol.spanHash) {
+      return editStatus('already-applied', 'ready', 0.87, ['anchor-reanchored-head-matches-worker'], reanchor, resolved.evidenceIds);
+    }
+    return editStatus('needs-port', 'needs-review', 0.72, ['anchor-moved-or-renamed'], reanchor, resolved.evidenceIds);
   }
   if (resolved?.status === 'ambiguous') {
     return editStatus('blocked', 'blocked', 0.1, ['anchor-lineage-ambiguous'], { fromAnchorKey: input.anchorKey, lineageStatus: resolved.status }, resolved.evidenceIds);
@@ -112,6 +115,18 @@ function editStatus(status, readiness, confidence, reasonCodes, reanchor, eviden
   return { status, readiness, confidence, reasonCodes, reanchor, evidenceIds };
 }
 
+function reanchorRecord(fromAnchorKey, target, resolved) {
+  return {
+    fromAnchorKey,
+    toAnchorKey: target.key,
+    toSourcePath: target.sourcePath,
+    toSymbolName: target.symbolName,
+    toSymbolKind: target.kind,
+    lineageStatus: resolved.status,
+    traversedEventIds: resolved.traversedEventIds
+  };
+}
+
 function admissionStatus(summary) {
   if (summary.operations === 0) return 'evidence-only';
   if (summary.blocked > 0) return 'blocked';

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

@@ -132,8 +132,9 @@ function semanticEditOperation(region, index, context, input) {
   const anchorKey = region.key ?? region.conflictKey ?? region.id;
   const baseSymbol = context.baseSymbols.get(anchorKey);
   const workerSymbol = context.workerSymbols.get(anchorKey);
-  const headSymbol = context.headSymbols.get(anchorKey);
-  const classification = classifySemanticEdit({ region, anchorKey, baseSymbol, workerSymbol, headSymbol, context });
+  const directHeadSymbol = context.headSymbols.get(anchorKey);
+  const classification = classifySemanticEdit({ region, anchorKey, baseSymbol, workerSymbol, headSymbol: directHeadSymbol, context });
+  const headSymbol = directHeadSymbol ?? reanchoredHeadSymbol(context, classification);
   const kind = semanticEditOperationKind(region);
   const baseText = spanText(context.base, baseSymbol?.sourceSpan ?? region.metadata?.changedRegionProjection?.before?.sourceSpan ?? region.sourceSpan);
   const workerText = spanText(context.worker, workerSymbol?.sourceSpan ?? region.metadata?.changedRegionProjection?.after?.sourceSpan ?? region.sourceSpan);
@@ -192,6 +193,11 @@ function semanticEditOperation(region, index, context, input) {
   });
 }
 
+function reanchoredHeadSymbol(context, classification) {
+  const targetKey = classification.reanchor?.toAnchorKey;
+  return targetKey ? context.headSymbols.get(targetKey) : undefined;
+}
+
 function semanticEditIdentityRecord(input) {
   return {
     kind: input.kind,

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

@@ -6,6 +6,9 @@ export function createSemanticPatchBundleRecord(input={},options={}){
   const source=input?.changeSet??input;
   const patch=options.patch??source.patch??source.semanticPatch??source.patchBundle;
   const mergeCandidate=options.mergeCandidate??source.mergeCandidate??source.candidate;
+  const semanticEditScripts=array(options.semanticEditScripts??source.semanticEditScripts??source.semanticEditScript);
+  const semanticEditProjections=array(options.semanticEditProjections??source.semanticEditProjections??source.semanticEditProjection);
+  const semanticEditIndex=semanticEditRecordIndex(semanticEditScripts,semanticEditProjections,source);
   const regionInputs=array(options.changedRegions??source.changedRegions??source.regions);
   const sourceMapLinks=normalizeSourceMapLinks([
     ...array(options.sourceMapLinks??source.sourceMapLinks),
@@ -17,7 +20,7 @@ export function createSemanticPatchBundleRecord(input={},options={}){
     sourceRef(source.before,'before',source.beforeHash),
     sourceRef(source.after,'after',source.afterHash)
   ],source);
-  const evidenceRecords=[...array(options.evidence??source.evidence),...array(patch?.evidence),...array(mergeCandidate?.evidence)];
+  const evidenceRecords=[...array(options.evidence??source.evidence),...array(patch?.evidence),...array(mergeCandidate?.evidence),...semanticEditScripts.flatMap((script)=>array(script.evidence))];
   const patchId=firstString(options.patchId,source.patchId,patch?.id,mergeCandidate?.patchId);
   const mergeCandidateId=firstString(options.mergeCandidateId,source.mergeCandidateId,mergeCandidate?.id);
   const baseHash=firstString(options.baseHash,source.baseHash,source.beforeHash,patch?.baseHash,mergeCandidate?.baseHash,...sources.map((item)=>item.baseHash));
@@ -27,7 +30,7 @@ export function createSemanticPatchBundleRecord(input={},options={}){
   const evidenceIds=uniqueStrings([...strings(options.evidenceIds),...strings(source.evidenceIds),...evidenceRecords.map((record)=>record?.id),...strings(mergeCandidate?.evidenceIds)]);
   const proofIds=uniqueStrings([...strings(options.proofIds),...strings(source.proofIds),...evidenceRecords.filter((record)=>record?.kind==='proof').map((record)=>record.id),...strings(mergeCandidate?.proofIds)]);
   const historyIds=uniqueStrings([...strings(options.historyIds),...strings(options.historyId),...strings(source.historyIds),...strings(source.historyId)]);
-  const semanticOperationIds=uniqueStrings([...strings(options.semanticOperationIds),...strings(options.semanticOperationId),...strings(source.semanticOperationIds),...strings(source.semanticOperationId),...strings(patch?.semanticOperationIds),...strings(mergeCandidate?.semanticOperationIds)]);
+  const semanticOperationIds=uniqueStrings([...strings(options.semanticOperationIds),...strings(options.semanticOperationId),...strings(source.semanticOperationIds),...strings(source.semanticOperationId),...strings(patch?.semanticOperationIds),...strings(mergeCandidate?.semanticOperationIds),...semanticEditIndex.semanticEditOperationIds]);
   const conflictKeys=uniqueStrings([
     ...strings(options.conflictKeys),
     ...strings(source.conflictKeys),
@@ -40,7 +43,7 @@ export function createSemanticPatchBundleRecord(input={},options={}){
     ??`semantic_patch_bundle_${idFragment(firstString(source.id,patchId,mergeCandidateId,source.sourcePath,source.language,'record'))}`;
   const language=options.language??source.language??mergeCandidate?.language??sources.find((item)=>item.language)?.language;
   const sourcePath=options.sourcePath??source.sourcePath??mergeCandidate?.sourcePath??sources.find((item)=>item.sourcePath)?.sourcePath;
-  const index=recordIndex({baseHash,targetHash,sources,changedRegions,sourceMapLinks,evidenceIds,proofIds,historyIds,semanticOperationIds,patchId,mergeCandidateId,admission});
+  const index=recordIndex({baseHash,targetHash,sources,changedRegions,sourceMapLinks,evidenceIds,proofIds,historyIds,semanticOperationIds,patchId,mergeCandidateId,admission,semanticEditIndex});
   return{
     kind:'frontier.lang.semanticPatchBundleRecord',
     version:1,
@@ -60,15 +63,18 @@ export function createSemanticPatchBundleRecord(input={},options={}){
     proofIds,
     historyIds,
     semanticOperationIds,
+    semanticEditScriptIds:semanticEditIndex.semanticEditScriptIds,
+    semanticEditProjectionIds:semanticEditIndex.semanticEditProjectionIds,
     admission,
     index,
-    summary:{changedRegions:changedRegions.length,sourceMapLinks:sourceMapLinks.length,evidenceIds:evidenceIds.length,proofIds:proofIds.length,historyIds:historyIds.length,semanticOperations:semanticOperationIds.length,reviewRequired:admission.reviewRequired,autoMergeClaim:admission.autoMergeClaim},
+    summary:{changedRegions:changedRegions.length,sourceMapLinks:sourceMapLinks.length,evidenceIds:evidenceIds.length,proofIds:proofIds.length,historyIds:historyIds.length,semanticOperations:semanticOperationIds.length,semanticEditScripts:semanticEditScripts.length,semanticEditProjections:semanticEditProjections.length,semanticEditProjectionEdits:semanticEditIndex.semanticEditProjectionEditCount,reviewRequired:admission.reviewRequired,autoMergeClaim:admission.autoMergeClaim},
     metadata:compactRecord({
       sourceChangeSetId:source.kind==='frontier.lang.nativeSourceChangeSet'?source.id:undefined,
       patchRisk:patch?.risk,
       nativeChangeSummary:source.summary,
       changedRegionProjectionSummary:source.metadata?.changedRegionProjectionSummary,
       semanticMergeConflictSummary:source.metadata?.semanticMergeConflictSummary,
+      semanticEditSummary:semanticEditSummary(semanticEditIndex),
       ...options.metadata
     })
   };
@@ -190,14 +196,15 @@ function normalizeAdmission(input={},context){
 }
 
 function recordIndex(parts){
+  const semanticEditIndex=parts.semanticEditIndex??semanticEditRecordIndex([],[]);
   return{
     baseHashes:uniqueStrings([parts.baseHash,...parts.sources.map((item)=>item.baseHash)]),
     targetHashes:uniqueStrings([parts.targetHash,...parts.sources.map((item)=>item.targetHash)]),
     sourceHashes:uniqueStrings(parts.sources.map((item)=>item.sourceHash)),
-    sourcePaths:uniqueStrings(parts.sources.map((item)=>item.sourcePath)),
-    regionKeys:uniqueStrings(parts.changedRegions.map((region)=>region.key)),
+    sourcePaths:uniqueStrings([...parts.sources.map((item)=>item.sourcePath),...semanticEditIndex.projectedSourcePaths]),
+    regionKeys:uniqueStrings([...parts.changedRegions.map((region)=>region.key),...semanticEditIndex.anchorKeys]),
     regionKinds:uniqueStrings(parts.changedRegions.map((region)=>region.regionKind)),
-    conflictKeys:uniqueStrings(parts.changedRegions.flatMap((region)=>[region.conflictKey,...array(region.admission?.conflictKeys)])),
+    conflictKeys:uniqueStrings([...parts.changedRegions.flatMap((region)=>[region.conflictKey,...array(region.admission?.conflictKeys)]),...semanticEditIndex.conflictKeys]),
     sourceMapIds:uniqueStrings([...parts.sourceMapLinks.map((link)=>link.sourceMapId),...parts.changedRegions.flatMap((region)=>region.sourceMapIds??[])]),
     sourceMapMappingIds:uniqueStrings([...parts.sourceMapLinks.map((link)=>link.sourceMapMappingId),...parts.changedRegions.flatMap((region)=>region.sourceMapMappingIds??[])]),
     sourceMapLinkIds:uniqueStrings(parts.sourceMapLinks.map((link)=>link.id)),
@@ -205,6 +212,13 @@ function recordIndex(parts){
     proofIds:parts.proofIds,
     historyIds:parts.historyIds,
     semanticOperationIds:uniqueStrings(parts.semanticOperationIds),
+    semanticEditScriptIds:semanticEditIndex.semanticEditScriptIds,
+    semanticEditProjectionIds:semanticEditIndex.semanticEditProjectionIds,
+    semanticEditKeys:semanticEditIndex.semanticEditKeys,
+    semanticIdentityHashes:semanticEditIndex.semanticIdentityHashes,
+    sourceIdentityHashes:semanticEditIndex.sourceIdentityHashes,
+    operationContentHashes:semanticEditIndex.operationContentHashes,
+    editContentHashes:semanticEditIndex.editContentHashes,
     patchIds:uniqueStrings([parts.patchId]),
     mergeCandidateIds:uniqueStrings([parts.mergeCandidateId]),
     readinesses:uniqueStrings([parts.admission.readiness,...parts.changedRegions.map((region)=>region.admission?.readiness)]),
@@ -231,11 +245,48 @@ function matchesRecord(record,query){
     &&matchAny(queryValues(query.proofId,query.proofIds),index.proofIds)
     &&matchAny(queryValues(query.historyId,query.historyIds),index.historyIds)
     &&matchAny(queryValues(query.semanticOperationId,query.semanticOperationIds),index.semanticOperationIds)
+    &&matchAny(queryValues(query.semanticEditScriptId,query.semanticEditScriptIds),index.semanticEditScriptIds)
+    &&matchAny(queryValues(query.semanticEditProjectionId,query.semanticEditProjectionIds),index.semanticEditProjectionIds)
+    &&matchAny(queryValues(query.semanticEditKey,query.semanticEditKeys),index.semanticEditKeys)
+    &&matchAny(queryValues(query.semanticIdentityHash,query.semanticIdentityHashes),index.semanticIdentityHashes)
+    &&matchAny(queryValues(query.sourceIdentityHash,query.sourceIdentityHashes),index.sourceIdentityHashes)
+    &&matchAny(queryValues(query.operationContentHash,query.operationContentHashes),index.operationContentHashes)
+    &&matchAny(queryValues(query.editContentHash,query.editContentHashes),index.editContentHashes)
     &&matchAny(queryValues(query.readiness,query.readinesses),index.readinesses)
     &&matchAny(queryValues(query.admissionStatus,query.admissionStatuses),index.admissionStatuses);
 }
 
 function admissionStatusForReadiness(readiness){return readiness==='blocked'?'blocked':readiness==='needs-review'?'needs-review':'proposed';}
+function semanticEditRecordIndex(scripts,projections,source={}){
+  const operations=scripts.flatMap((script)=>array(script.operations));
+  const edits=projections.flatMap((projection)=>array(projection.edits));
+  const index=source.index??{};
+  return{
+    semanticEditScriptIds:uniqueStrings([...strings(source.semanticEditScriptIds),...strings(source.semanticEditScriptId),...strings(index.semanticEditScriptIds),...scripts.map((script)=>script.id)]),
+    semanticEditProjectionIds:uniqueStrings([...strings(source.semanticEditProjectionIds),...strings(source.semanticEditProjectionId),...strings(index.semanticEditProjectionIds),...projections.map((projection)=>projection.id)]),
+    semanticEditOperationIds:uniqueStrings([...strings(source.semanticOperationIds),...strings(index.semanticOperationIds),...operations.map((operation)=>operation.id)]),
+    semanticEditProjectionEditCount:edits.length,
+    semanticEditKeys:uniqueStrings([...strings(source.semanticEditKeys),...strings(index.semanticEditKeys),...operations.map((operation)=>operation.semanticKey),...edits.map((edit)=>edit.semanticKey)]),
+    semanticIdentityHashes:uniqueStrings([...strings(source.semanticIdentityHashes),...strings(index.semanticIdentityHashes),...operations.map((operation)=>operation.semanticIdentityHash),...edits.map((edit)=>edit.semanticIdentityHash)]),
+    sourceIdentityHashes:uniqueStrings([...strings(source.sourceIdentityHashes),...strings(index.sourceIdentityHashes),...operations.map((operation)=>operation.sourceIdentityHash),...edits.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)]),
+    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])])
+  };
+}
+function semanticEditSummary(index){
+  if(!index.semanticEditScriptIds.length&&!index.semanticEditProjectionIds.length)return undefined;
+  return compactRecord({
+    scriptIds:index.semanticEditScriptIds,
+    projectionIds:index.semanticEditProjectionIds,
+    semanticEditKeys:index.semanticEditKeys,
+    operationContentHashes:index.operationContentHashes,
+    editContentHashes:index.editContentHashes,
+    projectedSourcePaths:index.projectedSourcePaths
+  });
+}
 function queryValues(...values){return uniqueStrings(values.flatMap((value)=>strings(value)));}
 function matchAny(filters,values){if(filters.length===0)return true;const valueSet=new Set(strings(values));return filters.some((filter)=>valueSet.has(filter));}
 function array(value){if(value===undefined||value===null)return[];return Array.isArray(value)?value:[value];}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shapeshift-labs/frontier-lang-compiler",
-  "version": "0.2.85",
+  "version": "0.2.87",
   "description": "Compiler facade for Frontier Lang source documents and language projection adapters.",
   "type": "module",
   "main": "./dist/index.js",