@shapeshift-labs/frontier-lang-compiler 0.2.105 → 0.2.107

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

@@ -6,24 +6,40 @@ export function semanticIndexFromNativeDeclarations(declarations, input, options
   const symbols = [];
   const occurrences = [];
   const relations = [];
-  const facts = [];
+  const facts = input.sourceHash ? [fileHashFact(documentId, input, evidenceId)] : [];
   const mappings = [];
   for (const declaration of declarations) {
     const symbolId = declaration.symbolId ?? `symbol:${input.language}:${declaration.role === 'import' ? 'import:' : ''}${caseSensitiveIdFragment(declaration.name)}`;
+    const normalizedDeclaration = {
+      ...declaration,
+      symbolId,
+      regionKind: declarationRegionKind(declaration)
+    };
     const occurrenceId = `occ_${idFragment(declaration.nativeNode.id)}_${declaration.role ?? 'definition'}`;
     const ownershipRegion = semanticOwnershipRegionForDeclaration(input, {
-      ...declaration,
+      ...normalizedDeclaration,
       nodeId: declaration.nativeNode.id,
       kind: declaration.nativeNode.kind,
       languageKind: declaration.nativeNode.languageKind,
       span: declaration.nativeNode.span,
       symbolId
     }, documentId);
+    const relationId = `rel_${idFragment(documentId)}_${idFragment(declaration.nativeNode.id)}`;
+    const moduleEdge = moduleEdgeForDeclaration(normalizedDeclaration, input, documentId, relationId, ownershipRegion);
+    const publicContractRegion = publicContractRegionForDeclaration(normalizedDeclaration, ownershipRegion, moduleEdge);
+    const reExportIdentity = reExportIdentityForDeclaration(normalizedDeclaration, input, documentId, relationId, ownershipRegion, moduleEdge);
+    const graphMetadata = {
+      ...(moduleEdge ? { moduleEdge } : {}),
+      ...(publicContractRegion ? { publicContract: true, publicContractRegionId: publicContractRegion.id } : {}),
+      ...(reExportIdentity ? { reExportIdentity } : {})
+    };
     declaration.nativeNode.metadata = {
       ...declaration.nativeNode.metadata,
+      ...declaration.metadata,
       ownershipRegionId: ownershipRegion.id,
       ownershipRegionKey: ownershipRegion.key,
-      ownershipRegionKind: ownershipRegion.regionKind
+      ownershipRegionKind: ownershipRegion.regionKind,
+      ...graphMetadata
     };
     symbols.push({
       id: symbolId,
@@ -32,13 +48,14 @@ export function semanticIndexFromNativeDeclarations(declarations, input, options
       kind: declaration.symbolKind,
       language: input.language,
       nativeAstNodeId: declaration.nativeNode.id,
-      signatureHash: hashSemanticValue([input.language, declaration.nativeNode.kind, declaration.name, declaration.nativeNode.fields ?? {}]),
+      signatureHash: declaration.signatureHash ?? hashSemanticValue([input.language, declaration.nativeNode.kind, declaration.name, declaration.nativeNode.fields ?? {}]),
       definitionSpan: declaration.nativeNode.span,
       metadata: {
         ...declaration.nativeNode.metadata,
         ownershipRegionId: ownershipRegion.id,
         ownershipRegionKey: ownershipRegion.key,
-        ownershipRegionKind: ownershipRegion.regionKind
+        ownershipRegionKind: ownershipRegion.regionKind,
+        ...graphMetadata
       }
     });
     occurrences.push({
@@ -47,13 +64,16 @@ export function semanticIndexFromNativeDeclarations(declarations, input, options
       symbolId,
       role: declaration.role ?? 'definition',
       span: declaration.nativeNode.span,
-      nativeAstNodeId: declaration.nativeNode.id
+      nativeAstNodeId: declaration.nativeNode.id,
+      ...(Object.keys(graphMetadata).length ? { metadata: graphMetadata } : {})
     });
     relations.push({
-      id: `rel_${idFragment(documentId)}_${idFragment(declaration.nativeNode.id)}`,
+      id: relationId,
       sourceId: documentId,
       predicate: relationPredicateForDeclaration(declaration),
-      targetId: symbolId
+      targetId: symbolId,
+      evidenceIds: [evidenceId],
+      ...(Object.keys(graphMetadata).length ? { metadata: graphMetadata } : {})
     });
     facts.push({
       id: `fact_${idFragment(declaration.nativeNode.id)}_kind`,
@@ -74,7 +94,7 @@ export function semanticIndexFromNativeDeclarations(declarations, input, options
         granularity: ownershipRegion.granularity,
         key: ownershipRegion.key
       }
-    });
+    }, ...projectSymbolGraphFacts({ moduleEdge, publicContractRegion, reExportIdentity, relationId, symbolId, evidenceId }));
     mappings.push({
       id: `map_${idFragment(declaration.nativeNode.id)}`,
       nativeAstNodeId: declaration.nativeNode.id,
@@ -95,12 +115,18 @@ export function semanticIndexFromNativeDeclarations(declarations, input, options
     status: 'passed',
     path: input.sourcePath,
     summary: `Normalized ${options.astFormat ?? options.parser} native AST with ${declarations.length} declaration(s).`,
-    metadata: {
-      parser: options.parser,
-      astFormat: options.astFormat,
-      language: input.language,
-      sourceHash: input.sourceHash
-    }
+      metadata: {
+        parser: options.parser,
+        astFormat: options.astFormat,
+        language: input.language,
+        sourceHash: input.sourceHash,
+        graphRecords: {
+          fileHashes: input.sourceHash ? 1 : 0,
+          moduleEdges: facts.filter((fact) => fact.predicate === 'moduleEdge').length,
+          reExportIdentities: facts.filter((fact) => fact.predicate === 'reExportIdentity').length,
+          publicContractRegions: facts.filter((fact) => fact.predicate === 'publicContractRegion').length
+        }
+      }
   }];
   return {
     semanticIndex: createSemanticIndexRecord({
@@ -119,10 +145,170 @@ export function semanticIndexFromNativeDeclarations(declarations, input, options
       metadata: {
         parser: options.parser,
         astFormat: options.astFormat,
-        coverage: 'native-ast-declarations'
+        coverage: 'native-ast-declarations',
+        graphCoverage: 'module-edge-declarations'
       }
     }),
     mappings,
     evidence
   };
 }
+
+function fileHashFact(documentId, input, evidenceId) {
+  return {
+    id: `fact_${idFragment(documentId)}_file_hash`,
+    predicate: 'fileHash',
+    subjectId: documentId,
+    value: { ...hashParts(input.sourceHash), sourcePath: input.sourcePath, language: input.language },
+    evidenceIds: [evidenceId]
+  };
+}
+
+function declarationRegionKind(declaration) {
+  if (declaration.regionKind) return declaration.regionKind;
+  if (declaration.role === 'import' || declaration.importPath) return 'import';
+  if (declaration.role === 'export' || declaration.exported || declaration.reExport) return 'export';
+  if (declaration.publicContract || declaration.metadata?.publicContract) return 'export';
+  return undefined;
+}
+
+function moduleEdgeForDeclaration(declaration, input, documentId, relationId, ownershipRegion) {
+  const role = declaration.role;
+  if (role !== 'import' && role !== 'export') return undefined;
+  const moduleSpecifier = moduleSpecifierForDeclaration(declaration);
+  const edgeKind = role === 'import' ? 'import' : moduleSpecifier || declaration.reExport ? 're-export' : 'export';
+  return compactRecord({
+    kind: 'frontier.lang.moduleEdge',
+    version: 1,
+    id: relationId,
+    edgeKind,
+    role,
+    sourceDocumentId: documentId,
+    sourcePath: input.sourcePath,
+    sourceHash: input.sourceHash,
+    moduleSpecifier,
+    symbolId: declaration.symbolId,
+    relationId,
+    ownershipRegionId: ownershipRegion.id,
+    ownershipRegionKey: ownershipRegion.key,
+    importKind: declaration.importKind ?? declaration.metadata?.importKind,
+    exportKind: declaration.exportKind ?? declaration.metadata?.exportKind,
+    importedName: declaration.importedName ?? declaration.metadata?.importedName,
+    exportedName: declaration.exportedName ?? declaration.metadata?.exportedName,
+    localName: declaration.localName ?? declaration.metadata?.localName,
+    namespace: declaration.namespace ?? declaration.metadata?.namespace,
+    isTypeOnly: declaration.isTypeOnly ?? declaration.metadata?.isTypeOnly,
+    isReExport: edgeKind === 're-export',
+    publicContract: publicContractForDeclaration(declaration, edgeKind)
+  });
+}
+
+function moduleSpecifierForDeclaration(declaration) {
+  return firstString(
+    declaration.moduleSpecifier,
+    declaration.importPath,
+    declaration.exportPath,
+    declaration.source,
+    declaration.metadata?.moduleSpecifier,
+    declaration.metadata?.importPath,
+    declaration.metadata?.exportPath,
+    declaration.metadata?.source,
+    declaration.symbolKind === 'module' ? declaration.name : undefined
+  );
+}
+
+function publicContractForDeclaration(declaration, edgeKind) {
+  return Boolean(
+    declaration.publicContract
+    || declaration.exported
+    || declaration.metadata?.publicContract
+    || declaration.metadata?.publicContractRegion
+    || declaration.role === 'export'
+    || edgeKind === 'export'
+    || edgeKind === 're-export'
+  );
+}
+
+function publicContractRegionForDeclaration(declaration, ownershipRegion, moduleEdge) {
+  if (!publicContractForDeclaration(declaration, moduleEdge?.edgeKind)) return undefined;
+  return {
+    ...ownershipRegion,
+    regionKind: declaration.publicContractRegionKind ?? declaration.metadata?.publicContractRegionKind ?? ownershipRegion.regionKind,
+    publicContract: true,
+    exportedName: declaration.exportedName ?? declaration.metadata?.exportedName,
+    moduleSpecifier: moduleEdge?.moduleSpecifier,
+    edgeKind: moduleEdge?.edgeKind
+  };
+}
+
+function reExportIdentityForDeclaration(declaration, input, documentId, relationId, ownershipRegion, moduleEdge) {
+  if (!moduleEdge?.isReExport && !declaration.reExport) return undefined;
+  return compactRecord({
+    kind: 'frontier.lang.reExportIdentity',
+    version: 1,
+    id: `reexport_${idFragment(relationId)}`,
+    sourceDocumentId: documentId,
+    sourcePath: input.sourcePath,
+    sourceHash: input.sourceHash,
+    moduleSpecifier: moduleEdge?.moduleSpecifier,
+    exportedName: declaration.exportedName ?? declaration.metadata?.exportedName,
+    importedName: declaration.importedName ?? declaration.metadata?.importedName,
+    localName: declaration.localName ?? declaration.metadata?.localName,
+    namespace: declaration.namespace ?? declaration.metadata?.namespace,
+    isTypeOnly: declaration.isTypeOnly ?? declaration.metadata?.isTypeOnly,
+    symbolId: declaration.symbolId,
+    relationId,
+    ownershipRegionId: ownershipRegion.id,
+    ownershipRegionKey: ownershipRegion.key,
+    publicContract: true
+  });
+}
+
+function projectSymbolGraphFacts({ moduleEdge, publicContractRegion, reExportIdentity, relationId, symbolId, evidenceId }) {
+  return [
+    moduleEdge ? {
+      id: `fact_${idFragment(relationId)}_module_edge`,
+      predicate: 'moduleEdge',
+      subjectId: relationId,
+      objectId: symbolId,
+      value: moduleEdge,
+      evidenceIds: [evidenceId]
+    } : undefined,
+    reExportIdentity ? {
+      id: `fact_${idFragment(relationId)}_re_export_identity`,
+      predicate: 'reExportIdentity',
+      subjectId: symbolId,
+      objectId: relationId,
+      value: reExportIdentity,
+      evidenceIds: [evidenceId]
+    } : undefined,
+    publicContractRegion ? {
+      id: `fact_${idFragment(symbolId)}_public_contract_region`,
+      predicate: 'publicContractRegion',
+      subjectId: symbolId,
+      objectId: publicContractRegion.id,
+      value: publicContractRegion,
+      evidenceIds: [evidenceId]
+    } : undefined
+  ].filter(Boolean);
+}
+
+function hashParts(sourceHash) {
+  const text = String(sourceHash);
+  const separator = text.indexOf(':');
+  return {
+    sourceHash: text,
+    ...(separator > 0 ? { algorithm: text.slice(0, separator), value: text.slice(separator + 1) } : { value: text })
+  };
+}
+
+function compactRecord(record) {
+  return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== undefined));
+}
+
+function firstString(...values) {
+  for (const value of values) {
+    if (value !== undefined && value !== null && String(value)) return String(value);
+  }
+  return undefined;
+}

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

@@ -1,14 +1,67 @@
-import{declarationRecord}from'./declarationRecord.js';import{namedDeclaration}from'./namedDeclaration.js';import{nativeNodeId}from'./nativeNodeId.js';import{stringFromTsExpression}from'./stringFromTsExpression.js';
-export function typeScriptDeclaration(node, kind, nativeNodeId, input) {
+import{hashSemanticValue}from'@shapeshift-labs/frontier-lang-kernel';import{idFragment}from'../../native-import-utils.js';
+import{declarationRecord}from'./declarationRecord.js';import{identifierName}from'./identifierName.js';import{namedDeclaration}from'./namedDeclaration.js';import{stringFromTsExpression}from'./stringFromTsExpression.js';
+export function typeScriptDeclaration(node, kind, nativeNodeId, input, options = {}) {
+  const enrich = (declaration, symbolNode = node.name ?? node) => enrichTypeScriptDeclaration(node, symbolNode, declaration, input, options);
   if (kind === 'ImportDeclaration' || kind === 'ImportEqualsDeclaration') {
     const name = stringFromTsExpression(node.moduleSpecifier) ?? stringFromTsExpression(node.externalModuleReference?.expression);
-    if (name) return declarationRecord(input, nativeNodeId, name, 'module', 'import');
+    if (name) return enrich(declarationRecord(input, nativeNodeId, name, 'module', 'import'), node.moduleSpecifier ?? node.externalModuleReference?.expression ?? node);
   }
-  if (kind === 'FunctionDeclaration') return namedDeclaration(input, nativeNodeId, node.name, 'function');
-  if (kind === 'ClassDeclaration') return namedDeclaration(input, nativeNodeId, node.name, 'class');
-  if (kind === 'InterfaceDeclaration') return namedDeclaration(input, nativeNodeId, node.name, 'interface');
-  if (kind === 'TypeAliasDeclaration' || kind === 'EnumDeclaration') return namedDeclaration(input, nativeNodeId, node.name, 'type');
-  if (kind === 'VariableDeclaration') return namedDeclaration(input, nativeNodeId, node.name, 'variable');
-  if (kind === 'MethodDeclaration' || kind === 'MethodSignature') return namedDeclaration(input, nativeNodeId, node.name, 'method');
+  if (kind === 'FunctionDeclaration') return enrich(namedDeclaration(input, nativeNodeId, node.name, 'function'));
+  if (kind === 'ClassDeclaration') return enrich(namedDeclaration(input, nativeNodeId, node.name, 'class'));
+  if (kind === 'InterfaceDeclaration') return enrich(namedDeclaration(input, nativeNodeId, node.name, 'interface'));
+  if (kind === 'TypeAliasDeclaration' || kind === 'EnumDeclaration') return enrich(namedDeclaration(input, nativeNodeId, node.name, 'type'));
+  if (kind === 'VariableDeclaration') return enrich(namedDeclaration(input, nativeNodeId, node.name, 'variable'));
+  if (kind === 'MethodDeclaration' || kind === 'MethodSignature') return enrich(namedDeclaration(input, nativeNodeId, node.name, 'method'));
   return undefined;
 }
+
+function enrichTypeScriptDeclaration(node, symbolNode, declaration, input, options) {
+  if (!declaration) return declaration;
+  const checker = options.typeChecker ?? options.checker ?? options.program?.getTypeChecker?.();
+  const symbol = safeCall(checker?.getSymbolAtLocation, checker, symbolNode) ?? safeCall(checker?.getSymbolAtLocation, checker, node.name);
+  if (!symbol) return declaration;
+  const aliasedSymbol = safeCall(checker?.getAliasedSymbol, checker, symbol);
+  const targetSymbol = aliasedSymbol && aliasedSymbol !== symbol ? aliasedSymbol : undefined;
+  const identitySymbol = targetSymbol ?? symbol;
+  const fullyQualifiedName = stringValue(safeCall(checker?.getFullyQualifiedName, checker, identitySymbol));
+  const localName = stringValue(symbol.escapedName ?? symbol.name) ?? declaration.name;
+  const targetName = targetSymbol ? stringValue(targetSymbol.escapedName ?? targetSymbol.name) : undefined;
+  const identity = fullyQualifiedName ?? targetName ?? localName;
+  const compilerSymbol = compactRecord({
+    parser: options.parser,
+    localName,
+    targetName,
+    fullyQualifiedName,
+    flags: numberValue(symbol.flags),
+    targetFlags: numberValue(targetSymbol?.flags),
+    declarations: Array.isArray(identitySymbol.declarations) ? identitySymbol.declarations.length : undefined,
+    aliased: Boolean(targetSymbol)
+  });
+  return {
+    ...declaration,
+    symbolId: `symbol:${input.language}:compiler:${declaration.role === 'import' ? 'import:' : ''}${idFragment(identity)}`,
+    signatureHash: hashSemanticValue([input.language, declaration.symbolKind, identity, compilerSymbol]),
+    metadata: {
+      ...declaration.metadata,
+      compilerSymbol,
+      compilerSymbolIdentityHash: hashSemanticValue(compilerSymbol)
+    }
+  };
+}
+
+function safeCall(fn, receiver, ...args) {
+  if (typeof fn !== 'function') return undefined;
+  try { return fn.apply(receiver, args); } catch { return undefined; }
+}
+
+function stringValue(value) {
+  return value === undefined || value === null || value === '' ? undefined : String(value);
+}
+
+function numberValue(value) {
+  return Number.isFinite(value) ? value : undefined;
+}
+
+function compactRecord(record) {
+  return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== undefined));
+}

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

@@ -33,6 +33,7 @@ export function visitTypeScriptAstNode(node, sourceFile, context, propertyPath,
     fields: primitiveTypeScriptFields(node, kind),
     children,
     metadata: {
+      ...declaration?.metadata,
       astFormat: context.options.astFormat,
       propertyPath,
       pos: numberOrUndefined(node.pos),

package/dist/js-ts-safe-merge-composed.js

@@ -5,6 +5,7 @@ import {
   jsTsSafeMergeGateOrder
 } from './js-ts-safe-merge-constants.js';
 import { safeMergeJsTsImportsAndDeclarations } from './js-ts-safe-merge.js';
+import { createJsTsSafeMergeSemanticArtifacts } from './js-ts-safe-merge-semantic-artifacts.js';
 import {
   applyJsTsPreparedMemberAdditions,
   neutralizeJsTsSafeMemberMergeSources
@@ -40,7 +41,7 @@ function safeMergeJsTsSource(input = {}) {
   const memberAdditions = memberNeutralization.analysis.preparedRegions.reduce((total, region) => (
     total + region.workerAddedKeys.length + region.headAddedKeys.length
   ), 0);
-  return {
+  const result = {
     ...topLevelResult,
     id: String(input.id ?? topLevelResult.id),
     mergedSourceText: memberApplication.sourceText,
@@ -65,6 +66,10 @@ function safeMergeJsTsSource(input = {}) {
       }
     }
   };
+  return {
+    ...result,
+    semanticArtifacts: createJsTsSafeMergeSemanticArtifacts(input, result)
+  };
 }
 
 function hasMemberMergePolicy(input) {

package/dist/js-ts-safe-merge-semantic-artifact-ledger.js

@@ -0,0 +1,197 @@
+import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
+import { idFragment } from './native-import-utils.js';
+import { detectLineEnding, normalizeLineEndings } from './js-ts-safe-merge-context.js';
+
+function createOperationsFromLedgers(context) {
+  const headByKey = new Map(context.head.entries.map((entry) => [entry.key, entry]));
+  return context.merged.entries.flatMap((entry, index) => {
+    const headEntry = headByKey.get(entry.key);
+    if (headEntry) {
+      if (sameEntryText(headEntry.text, entry.text)) return [];
+      return [operationRecord({
+        ...context,
+        index,
+        kind: entry.kind === 'import' ? 'jsTsReplaceImport' : 'jsTsReplaceDeclaration',
+        changeKind: 'modified',
+        entry,
+        headEntry,
+        insertion: undefined,
+        currentText: headEntry.text,
+        replacementText: entry.text
+      })];
+    }
+    return [operationRecord({
+      ...context,
+      index,
+      kind: entry.kind === 'import' ? 'jsTsInsertImport' : 'jsTsInsertDeclaration',
+      changeKind: 'added',
+      entry,
+      headEntry: undefined,
+      insertion: insertionAnchorForMergedEntry(entry, index, context),
+      currentText: '',
+      replacementText: insertionText(entry.text, context.head.sourceText)
+    })];
+  });
+}
+
+function operationRecord(input) {
+  const anchor = entryAnchor(input.entry, input.sourcePath, input.language);
+  const operation = {
+    id: `js_ts_safe_merge_op_${idFragment([input.id, input.index, input.entry.key].join(':'))}`,
+    kind: input.kind,
+    changeKind: input.changeKind,
+    anchor,
+    insertion: input.insertion,
+    spans: {
+      head: input.headEntry ? spanForEntry(input.headEntry) : undefined,
+      worker: spanForEntry(input.entry)
+    },
+    hashes: {
+      baseSourceHash: input.input.baseHash,
+      workerSourceHash: input.input.workerHash,
+      headSourceHash: input.input.headHash,
+      headTextHash: hashSemanticValue(input.currentText),
+      workerTextHash: hashSemanticValue(input.replacementText)
+    },
+    status: 'portable',
+    readiness: 'ready',
+    confidence: 1,
+    reasonCodes: ['js-ts-safe-merge-gates-passed', 'js-ts-ledger-source-edit'],
+    evidenceIds: [`evidence_${idFragment(input.id)}_js_ts_safe_merge_semantic_replay`],
+    metadata: {
+      autoMergeClaim: false,
+      semanticEquivalenceClaim: false,
+      ledgerKey: input.entry.key
+    }
+  };
+  return { ...operation, operationContentHash: hashSemanticValue(operation) };
+}
+
+function sourceEditForOperation(operation, order, headSourceText, mergedSourceText) {
+  const headStart = operation.spans.head?.start ?? insertionOffsetFromAnchor(operation.insertion, headSourceText);
+  const headEnd = operation.spans.head?.end ?? headStart;
+  const workerStart = operation.spans.worker?.start ?? 0;
+  const workerEnd = operation.spans.worker?.end ?? workerStart;
+  const current = headSourceText.slice(headStart, headEnd);
+  const replacementSpanText = mergedSourceText.slice(workerStart, workerEnd);
+  const replacement = operation.changeKind === 'added'
+    ? insertionText(replacementSpanText, headSourceText)
+    : replacementSpanText;
+  return {
+    operationId: operation.id,
+    order,
+    kind: operation.kind,
+    editKind: operation.changeKind === 'added' ? 'insert' : 'replace',
+    changeKind: operation.changeKind,
+    anchorKey: operation.anchor.key,
+    conflictKey: operation.anchor.conflictKey,
+    regionId: operation.anchor.regionId,
+    regionKind: operation.anchor.regionKind,
+    sourcePath: operation.anchor.sourcePath,
+    symbolId: operation.anchor.symbolId,
+    symbolName: operation.anchor.symbolName,
+    symbolKind: operation.anchor.symbolKind,
+    operationContentHash: operation.operationContentHash,
+    insertion: operation.insertion,
+    start: headStart,
+    end: headEnd,
+    workerStart,
+    workerEnd,
+    current,
+    replacement,
+    replacementSpanText
+  };
+}
+
+function insertionAnchorForMergedEntry(entry, index, context) {
+  const previous = nearestHeadEntry(context.merged.entries, context.head.entries, index, -1);
+  if (previous) return {
+    mode: 'after',
+    anchorKey: previous.key,
+    anchorSymbolName: entryName(previous),
+    anchorSymbolKind: entrySymbolKind(previous),
+    headSpan: spanForEntry(previous),
+    sourcePath: context.sourcePath
+  };
+  const next = nearestHeadEntry(context.merged.entries, context.head.entries, index, 1);
+  if (next) return {
+    mode: 'before',
+    anchorKey: next.key,
+    anchorSymbolName: entryName(next),
+    anchorSymbolKind: entrySymbolKind(next),
+    headSpan: spanForEntry(next),
+    sourcePath: context.sourcePath
+  };
+  return { mode: 'file-end', sourcePath: context.sourcePath };
+}
+
+function nearestHeadEntry(mergedEntries, headEntries, startIndex, step) {
+  const headByKey = new Map(headEntries.map((entry) => [entry.key, entry]));
+  for (let index = startIndex + step; index >= 0 && index < mergedEntries.length; index += step) {
+    const headEntry = headByKey.get(mergedEntries[index].key);
+    if (headEntry) return headEntry;
+  }
+  return undefined;
+}
+
+function insertionOffsetFromAnchor(insertion, sourceText) {
+  if (insertion?.mode === 'file-start') return 0;
+  if (insertion?.mode === 'file-end') return sourceText.length;
+  const span = insertion?.headSpan;
+  if (!span) return sourceText.length;
+  if (insertion.mode === 'before') return lineStartOffset(sourceText, span.start);
+  return lineEndOffset(sourceText, span.end);
+}
+
+function entryAnchor(entry, sourcePath, language) {
+  const name = entryName(entry);
+  const key = `source#${sourcePath ?? 'unknown'}#${entry.kind}#${name ?? entry.key}`;
+  return {
+    key,
+    conflictKey: key,
+    regionId: key,
+    regionKind: entry.kind === 'import' ? 'import' : 'declaration',
+    granularity: 'js-ts-ledger-entry',
+    language,
+    sourcePath,
+    symbolId: key,
+    symbolName: name,
+    symbolKind: entrySymbolKind(entry),
+    sourceSpan: spanForEntry(entry)
+  };
+}
+
+function entryName(entry) {
+  if (entry.kind === 'import') return entry.importInfo?.moduleSpecifier;
+  return entry.names?.join('|') ?? entry.key;
+}
+
+function entrySymbolKind(entry) {
+  if (entry.kind === 'import') return 'import';
+  return entry.declarationInfo?.declarationKind ?? entry.kind;
+}
+
+function spanForEntry(entry) {
+  return { start: entry.start, end: entry.end };
+}
+
+function insertionText(text, sourceText) {
+  const lineEnding = detectLineEnding(sourceText);
+  const normalized = normalizeLineEndings(String(text ?? '').trimEnd(), lineEnding);
+  return normalized.endsWith(lineEnding) ? normalized : `${normalized}${lineEnding}`;
+}
+
+function sameEntryText(left, right) {
+  return normalizeLineEndings(String(left ?? '').trim(), '\n') === normalizeLineEndings(String(right ?? '').trim(), '\n');
+}
+
+function lineStartOffset(sourceText, offset) {
+  return sourceText.lastIndexOf('\n', Math.max(0, offset - 1)) + 1;
+}
+
+function lineEndOffset(sourceText, offset) {
+  const lineEnd = sourceText.indexOf('\n', offset);
+  return lineEnd === -1 ? sourceText.length : lineEnd + 1;
+}
+
+export { createOperationsFromLedgers, sourceEditForOperation };