@storyteller-platform/align 0.1.8 → 0.1.10

package/dist/errorAlign/backtraceGraph.js

@@ -0,0 +1,270 @@
+import "../chunk-BIEQXUOY.js";
+import assert from "node:assert";
+import { range } from "itertools";
+import {
+  Counter,
+  END_DELIMITER,
+  OP_TYPE_COMBO_MAP,
+  START_DELIMITER,
+  reversed
+} from "./utils.js";
+class Node {
+  constructor(hypIndex, refIndex) {
+    this.hypIndex = hypIndex;
+    this.refIndex = refIndex;
+  }
+  children = /* @__PURE__ */ new Map();
+  parents = /* @__PURE__ */ new Map();
+  get index() {
+    return [this.hypIndex, this.refIndex];
+  }
+  /**
+   * Get the offset index of th enode so indices match the hypothesis and reference strings.
+   *
+   * Root will be at (-1, -1).
+   */
+  get offsetIndex() {
+    return [this.hypIndex - 1, this.refIndex - 1];
+  }
+  /**
+   * Check if the node is a terminal node (i.e., it has no children).
+   */
+  get isTerminal() {
+    return this.children.size === 0;
+  }
+  /**
+   * Check if the node is a root node (i.e., it has no parents).
+   */
+  get isRoot() {
+    return this.parents.size === 0;
+  }
+}
+class NodeMap {
+  map;
+  constructor(entries) {
+    const keyedEntries = entries == null ? void 0 : entries.map(
+      ([index, node]) => [`${index[0]}-${index[1]}`, { index, node }]
+    );
+    this.map = new Map(keyedEntries);
+  }
+  get([hypIndex, refIndex]) {
+    var _a;
+    const key = `${hypIndex}-${refIndex}`;
+    return (_a = this.map.get(key)) == null ? void 0 : _a.node;
+  }
+  set([hypIndex, refIndex], node) {
+    const key = `${hypIndex}-${refIndex}`;
+    this.map.set(key, { index: [hypIndex, refIndex], node });
+  }
+  has([hypIndex, refIndex]) {
+    const key = `${hypIndex}-${refIndex}`;
+    return this.map.has(key);
+  }
+  *entries() {
+    for (const { index, node } of this.map.values()) {
+      yield [index, node];
+    }
+  }
+  *values() {
+    for (const { node } of this.map.values()) {
+      yield node;
+    }
+  }
+}
+class BacktraceGraph {
+  constructor(backtrackMatrix) {
+    this.backtrackMatrix = backtrackMatrix;
+    this.hypDim = backtrackMatrix.length;
+    this.refDim = backtrackMatrix[0].length;
+    this.hypMaxIndex = this.hypDim - 1;
+    this.refMaxIndex = this.refDim - 1;
+  }
+  hypDim;
+  refDim;
+  hypMaxIndex;
+  refMaxIndex;
+  _nodes = null;
+  /**
+   * Get the nodes in the graph.
+   */
+  get nodes() {
+    if (this._nodes) return this._nodes;
+    const terminalNode = new Node(this.hypMaxIndex, this.refMaxIndex);
+    this._nodes = new NodeMap([[terminalNode.index, terminalNode]]);
+    for (const index of this.iterTopologicalOrder({ reverse: true })) {
+      if (this._nodes.has(index) && (index[0] !== 0 || index[1] !== 0)) {
+        this.addParentsFromBacktrace(index);
+      }
+    }
+    this._nodes = new NodeMap(
+      Array.from(this._nodes.entries()).toSorted(([[a1, a2]], [[b1, b2]]) => {
+        if (a1 === b1) return a2 - b2;
+        return a1 - b1;
+      })
+    );
+    return this._nodes;
+  }
+  /**
+   * Get the node at the given index.
+   *
+   * @param hypIndex Hyp/row index.
+   * @param refIndex Ref/column index.
+   */
+  getNode(hypIndex, refIndex) {
+    return this.nodes.get([hypIndex, refIndex]);
+  }
+  /**
+   * Get the set of all node indices in the graph.
+   */
+  getNodeSet() {
+    const transitions = /* @__PURE__ */ new Set();
+    for (const node of this.nodes.values()) {
+      transitions.add(node.offsetIndex);
+    }
+    return transitions;
+  }
+  /**
+   * Get a path through the graph.
+   *
+   * @param sample If true, sample a path randomly based on transition probabilities.
+   *               Otherwise, return the first path deterministically.
+   * @returns A list of nodes representing the path.
+   */
+  getPath({ sample } = { sample: false }) {
+    let node = this.getNode(0, 0);
+    assert(node == null ? void 0 : node.isRoot, "The node at (-1, -1) was expected to be a root node.");
+    const path = [];
+    while (!node.isTerminal) {
+      const opType = sample ? choose(Array.from(node.children.keys())) : (
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        node.children.keys().next().value
+      );
+      node = node.children.get(opType);
+      path.push([opType, node]);
+    }
+  }
+  /**
+   * Get nodes that can only be accounted for by a match.
+   *
+   * @returns A list of index tuples representing the unambiguous node matches.
+   */
+  getUnambiguousNodeMatches() {
+    const matchIndices = /* @__PURE__ */ new Set();
+    const matchPerToken = {
+      ref: new Counter(),
+      hyp: new Counter()
+    };
+    const refOpTypes = /* @__PURE__ */ new Set(["MATCH", "SUBSTITUTE", "DELETE"]);
+    const hypOpTypes = /* @__PURE__ */ new Set(["MATCH", "SUBSTITUTE", "INSERT"]);
+    for (const [[hypIndex, refIndex], node] of this.nodes.entries()) {
+      if (node.parents.size === 1 && node.parents.has("MATCH")) {
+        matchIndices.add([hypIndex, refIndex]);
+      }
+      if (refOpTypes.intersection(node.parents).size) {
+        matchPerToken.ref.set(refIndex, matchPerToken.ref.get(refIndex) + 1);
+      }
+      if (hypOpTypes.intersection(node.parents).size) {
+        matchPerToken.hyp.set(hypIndex, matchPerToken.hyp.get(hypIndex) + 1);
+      }
+    }
+    const unambiguousMatches = [];
+    for (const [hypIndex, refIndex] of matchIndices) {
+      if (matchPerToken.ref.get(refIndex) === 1 && matchPerToken.hyp.get(hypIndex) === 1) {
+        unambiguousMatches.push([hypIndex - 1, refIndex - 1]);
+      }
+    }
+    return unambiguousMatches.toSorted(([_a, a], [_b, b]) => a - b);
+  }
+  /**
+   * Get word spans (i.e., <...>) that are unambiguously matched.
+   *
+   * That is, there is only one subpath that can account for the span using MATCH operations.
+   * Other subpaths that include INSERT, DELETE, SUBSTITUTE operations are not considered.
+   *
+   * @returns A list of index tuples representing the end node of unambiguous span matches.
+   */
+  getUnambiguousTokenSpanMatches(ref) {
+    var _a;
+    ref = "_" + ref;
+    const monoMatchEndNodes = /* @__PURE__ */ new Set();
+    const refIndexes = new Counter();
+    const hypIndexes = new Counter();
+    for (const [[hypIndex, refIndex], node] of this.nodes.entries()) {
+      if (!node.parents.has("MATCH") || ref[refIndex] !== START_DELIMITER)
+        continue;
+      let _refIndex = refIndex + 1;
+      let _hypIndex = hypIndex + 1;
+      while (true) {
+        const _index = [_hypIndex, _refIndex];
+        if (!this.nodes.has(_index)) {
+          break;
+        }
+        if (!((_a = this.nodes.get(_index)) == null ? void 0 : _a.parents)) {
+          break;
+        }
+        if (ref[_refIndex] === END_DELIMITER) {
+          const endIndex = _index;
+          monoMatchEndNodes.add(endIndex);
+          refIndexes.set(_refIndex, refIndexes.get(_refIndex) + 1);
+          hypIndexes.set(_hypIndex, hypIndexes.get(_hypIndex) + 1);
+          break;
+        }
+        _refIndex += 1;
+        _hypIndex += 1;
+      }
+    }
+    return new Set(
+      Array.from(monoMatchEndNodes).filter(([h, r]) => hypIndexes.get(h) === 1 && refIndexes.get(r) === 1).map(([h, r]) => [h - 1, r - 1])
+    );
+  }
+  /**
+   * Create a parent node based on the index of the current node and the operation type.
+   */
+  parentNodeFromOpType(index, opType) {
+    const hypIndex = opType !== "DELETE" ? index[0] - 1 : index[0];
+    const refIndex = opType !== "INSERT" ? index[1] - 1 : index[1];
+    const parentIndex = [hypIndex, refIndex];
+    const nodes = this._nodes;
+    assert(!!nodes, "Called parentIndexFromOpType before instantiating _nodes");
+    if (!nodes.has(parentIndex)) {
+      nodes.set(parentIndex, new Node(...parentIndex));
+    }
+    return nodes.get(parentIndex);
+  }
+  /**
+   * Iterate through the nodes in topological order.
+   */
+  *iterTopologicalOrder({ reverse } = { reverse: false }) {
+    for (const i of reverse ? reversed(range(this.hypDim)) : range(this.hypDim)) {
+      for (const j of reverse ? reversed(range(this.refDim)) : range(this.refDim)) {
+        yield [i, j];
+      }
+    }
+  }
+  /**
+   * Add parents to the node at the given index based on the backtrace matrix.
+   */
+  addParentsFromBacktrace(index) {
+    var _a;
+    const node = (_a = this._nodes) == null ? void 0 : _a.get(index);
+    assert(
+      !!node,
+      `Node at index ${index.toString()} does not exist in the graph.`
+    );
+    const opTypeComboCode = this.backtrackMatrix[node.hypIndex][node.refIndex];
+    const opTypeCombo = OP_TYPE_COMBO_MAP[opTypeComboCode];
+    for (const opType of opTypeCombo) {
+      const parentNode = this.parentNodeFromOpType(node.index, opType);
+      node.parents.set(opType, parentNode);
+      parentNode.children.set(opType, node);
+    }
+  }
+}
+function choose(choices) {
+  const index = Math.round(Math.random() * choices.length);
+  return choices[index];
+}
+export {
+  BacktraceGraph,
+  Node
+};

package/dist/errorAlign/beamSearch.cjs

@@ -0,0 +1,302 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var beamSearch_exports = {};
+__export(beamSearch_exports, {
+  Path: () => Path,
+  errorAlignBeamSearch: () => errorAlignBeamSearch
+});
+module.exports = __toCommonJS(beamSearch_exports);
+var import_node_assert = __toESM(require("node:assert"), 1);
+var import_hash = require("./hash.cjs");
+var import_utils = require("./utils.cjs");
+const INT64_MASK = (1n << 64n) - 1n;
+const SORT_ID_BASE = 146527n;
+class Path {
+  constructor(src) {
+    this.src = src;
+  }
+  refIndex = -1;
+  hypIndex = -1;
+  lastHypIndex = -1;
+  lastRefIndex = -1;
+  closedCost = 0;
+  openCost = 0;
+  atUnambiguousMatchNode = false;
+  endIndices = [];
+  sortId = 0n;
+  /**
+   * Get the ID of the path used for pruning.
+   */
+  get pruneId() {
+    return (0, import_hash.hash)([
+      this.hypIndex,
+      this.refIndex,
+      this.lastHypIndex,
+      this.lastRefIndex
+    ]);
+  }
+  /**
+   * Get the cost of the path.
+   */
+  get cost() {
+    const isSub = isSubstitution(
+      this.hypIndex,
+      this.refIndex,
+      this.lastHypIndex,
+      this.lastRefIndex
+    );
+    return this.closedCost + this.openCost + (isSub ? this.openCost : 0);
+  }
+  /**
+   * Get the normalized cost of the path.
+   */
+  get normCost() {
+    const cost = this.cost;
+    if (cost === 0) return 0;
+    return cost / (this.refIndex + this.hypIndex + 3);
+  }
+  /**
+   * Get the current node index of the path.
+   */
+  get index() {
+    return [this.hypIndex, this.refIndex];
+  }
+  /**
+   * Check if the path has reached the terminal node.
+   */
+  get atEnd() {
+    return this.hypIndex === this.src.hypMaxIndex && this.refIndex === this.src.refMaxIndex;
+  }
+  /**
+   * Update the sort ID for path ordering. Ensures identical behavior as C++ implementation.
+   */
+  updateSortId(t) {
+    this.sortId = this.sortId * SORT_ID_BASE + t & INT64_MASK;
+  }
+}
+function* expand(parent) {
+  const deletePath = addDelete(parent);
+  if (deletePath) yield deletePath;
+  const insertPath = addInsert(parent);
+  if (insertPath) yield insertPath;
+  const subOrMatchPath = addSubstitutionOrMatch(parent);
+  if (subOrMatchPath) yield subOrMatchPath;
+}
+function addSubstitutionOrMatch(parent) {
+  if (parent.refIndex >= parent.src.refMaxIndex || parent.hypIndex >= parent.src.hypMaxIndex) {
+    return null;
+  }
+  let child = transitionToChildNode(parent, {
+    refStep: 1,
+    hypStep: 1
+  });
+  const isMatch = parent.src.ref[child.refIndex] === parent.src.hyp[child.hypIndex];
+  if (!isMatch) {
+    const refIsDelimiter = parent.src.refCharTypes[child.refIndex] === 0;
+    const hypIsDelimiter = parent.src.hypCharTypes[child.hypIndex] === 0;
+    if (refIsDelimiter || hypIsDelimiter) return null;
+  }
+  if (parent.src.ref[child.refIndex] === import_utils.START_DELIMITER) {
+    endInsertionSegment(child, parent.hypIndex, parent.refIndex);
+  }
+  if (!isMatch) {
+    const isBacktrace = parent.src.backtraceNodeSet.has(parent.index);
+    const isLetterTypeMatch = parent.src.refCharTypes[child.refIndex] === parent.src.hypCharTypes[child.hypIndex];
+    child.openCost += isLetterTypeMatch ? 2 : 3;
+    child.openCost += isBacktrace ? 0 : 1;
+  }
+  if (child.src.ref[child.refIndex] === import_utils.END_DELIMITER) {
+    child = endSegment(child);
+  }
+  return child;
+}
+function addInsert(parent) {
+  if (parent.refIndex >= parent.src.refMaxIndex) {
+    return null;
+  }
+  let child = transitionToChildNode(parent, {
+    refStep: 1,
+    hypStep: 0
+  });
+  if (parent.src.ref[child.refIndex] === import_utils.START_DELIMITER) {
+    endInsertionSegment(child, parent.hypIndex, parent.refIndex);
+  }
+  const isBacktrace = parent.src.backtraceNodeSet.has(parent.index);
+  const isDelimiter = parent.src.refCharTypes[child.refIndex] === 0;
+  child.openCost += isDelimiter ? 1 : 2;
+  child.openCost += isBacktrace || isDelimiter ? 0 : 1;
+  if (child.src.ref[child.refIndex] === import_utils.END_DELIMITER) {
+    child = endSegment(child);
+  }
+  return child;
+}
+function addDelete(parent) {
+  if (parent.hypIndex >= parent.src.hypMaxIndex) {
+    return null;
+  }
+  const child = transitionToChildNode(parent, { refStep: 0, hypStep: 1 });
+  const isBacktrace = parent.src.backtraceNodeSet.has(parent.index);
+  const isDelimiter = parent.src.hypCharTypes[child.hypIndex] === 0;
+  child.openCost += isDelimiter ? 1 : 2;
+  child.openCost += isBacktrace || isDelimiter ? 0 : 1;
+  if (child.src.hyp[child.hypIndex] === import_utils.END_DELIMITER) {
+    endInsertionSegment(child, child.hypIndex, child.refIndex);
+  }
+  return child;
+}
+function resetSegmentVariables(path, hypIndex, refIndex) {
+  path.closedCost += path.openCost;
+  const isSub = isSubstitution(
+    hypIndex,
+    refIndex,
+    path.lastHypIndex,
+    path.lastRefIndex
+  );
+  path.closedCost += isSub ? path.openCost : 0;
+  path.lastHypIndex = hypIndex;
+  path.lastRefIndex = refIndex;
+  path.openCost = 0;
+}
+function endInsertionSegment(path, hypIndex, refIndex) {
+  const hypSlice = (0, import_utils.translateSlice)(
+    [path.lastHypIndex + 1, hypIndex + 1],
+    path.src.hypIndexMap
+  );
+  const refIsEmpty = refIndex === path.lastRefIndex;
+  if (hypSlice && refIsEmpty) {
+    path.endIndices = path.endIndices.concat([
+      [path.hypIndex, path.refIndex, path.openCost]
+    ]);
+    resetSegmentVariables(path, hypIndex, refIndex);
+  }
+}
+function endSegment(path) {
+  const hypSlice = (0, import_utils.translateSlice)(
+    [path.lastHypIndex + 1, path.hypIndex + 1],
+    path.src.hypIndexMap
+  );
+  const refSlice = (0, import_utils.translateSlice)(
+    [path.lastRefIndex + 1, path.refIndex + 1],
+    path.src.refIndexMap
+  );
+  (0, import_node_assert.default)(!!refSlice);
+  const hypIsEmpty = path.hypIndex === path.lastHypIndex;
+  if (hypIsEmpty) {
+    path.endIndices = path.endIndices.concat([
+      [path.hypIndex, path.refIndex, path.openCost]
+    ]);
+  } else {
+    if (!hypSlice) {
+      return null;
+    }
+    const isMatchSegment = path.openCost === 0;
+    path.atUnambiguousMatchNode = isMatchSegment && path.src.unambiguousMatches.has(path.index);
+    path.endIndices = path.endIndices.concat([
+      [path.hypIndex, path.refIndex, path.openCost]
+    ]);
+  }
+  resetSegmentVariables(path, path.hypIndex, path.refIndex);
+  return path;
+}
+function transitionToChildNode(parent, { refStep, hypStep }) {
+  const child = new Path(parent.src);
+  child.refIndex = parent.refIndex + refStep;
+  child.hypIndex = parent.hypIndex + hypStep;
+  child.lastHypIndex = parent.lastHypIndex;
+  child.lastRefIndex = parent.lastRefIndex;
+  child.closedCost = parent.closedCost;
+  child.openCost = parent.openCost;
+  child.atUnambiguousMatchNode = false;
+  child.endIndices = parent.endIndices;
+  child.sortId = parent.sortId;
+  child.updateSortId(BigInt(refStep + refStep + hypStep));
+  return child;
+}
+function isSubstitution(hypIndex, refIndex, lastHypIndex, lastRefIndex) {
+  return !(refIndex === lastRefIndex || hypIndex === lastHypIndex);
+}
+function errorAlignBeamSearch(src, beamSize = 100) {
+  var _a;
+  const startPath = new Path(src);
+  let beam = [startPath];
+  let pruneMap = {};
+  const ended = [];
+  while (beam.length > 0) {
+    const newBeam = {};
+    for (const path of beam) {
+      if (path.atEnd) {
+        ended.push(path);
+        continue;
+      }
+      for (const newPath of expand(path)) {
+        const newPathCost = newPath.cost;
+        const newPathPruneId = newPath.pruneId;
+        if (newPathPruneId in pruneMap) {
+          if (newPathCost > pruneMap[newPathPruneId]) {
+            continue;
+          }
+        }
+        pruneMap[newPathPruneId] = newPathCost;
+        if (!(newPathPruneId in newBeam) || newPathCost < newBeam[newPathPruneId].cost) {
+          newBeam[newPathPruneId] = newPath;
+        }
+      }
+    }
+    const newBeamPaths = Object.values(newBeam).toSorted((a, b) => {
+      if (a.normCost === b.normCost) {
+        const comp = a.sortId - b.sortId;
+        if (comp < 0n) return -1;
+        if (comp > 0n) return 1;
+        return 0;
+      }
+      return a.normCost - b.normCost;
+    });
+    beam = newBeamPaths.slice(0, beamSize);
+    if ((_a = beam[0]) == null ? void 0 : _a.atUnambiguousMatchNode) {
+      beam = beam.slice(0, 1);
+      pruneMap = {};
+    }
+  }
+  const [result] = ended.toSorted((a, b) => {
+    if (a.cost === b.cost) {
+      const comp = a.sortId - b.sortId;
+      if (comp < 0n) return -1;
+      if (comp > 0n) return 1;
+      return 0;
+    }
+    return a.cost - b.cost;
+  });
+  (0, import_node_assert.default)(!!result);
+  return result;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Path,
+  errorAlignBeamSearch
+});

package/dist/errorAlign/beamSearch.d.cts

@@ -0,0 +1,53 @@
+import { Index } from './backtraceGraph.cjs';
+import { SubgraphMetadata } from './graphMetadata.cjs';
+import './utils.cjs';
+
+/**
+ * Class to represent a graph path.
+ */
+declare class Path {
+    src: SubgraphMetadata;
+    refIndex: number;
+    hypIndex: number;
+    lastHypIndex: number;
+    lastRefIndex: number;
+    closedCost: number;
+    openCost: number;
+    atUnambiguousMatchNode: boolean;
+    endIndices: [number, number, number][];
+    sortId: bigint;
+    constructor(src: SubgraphMetadata);
+    /**
+     * Get the ID of the path used for pruning.
+     */
+    get pruneId(): number;
+    /**
+     * Get the cost of the path.
+     */
+    get cost(): number;
+    /**
+     * Get the normalized cost of the path.
+     */
+    get normCost(): number;
+    /**
+     * Get the current node index of the path.
+     */
+    get index(): Index;
+    /**
+     * Check if the path has reached the terminal node.
+     */
+    get atEnd(): boolean;
+    /**
+     * Update the sort ID for path ordering. Ensures identical behavior as C++ implementation.
+     */
+    updateSortId(t: bigint): void;
+}
+/**
+ * Perform beam search to align reference and hypothesis texts for a given source.
+ *
+ * @param src The source metadata for alignment.
+ * @param beamSize The size of the beam for beam search. Defaults to 100.
+ */
+declare function errorAlignBeamSearch(src: SubgraphMetadata, beamSize?: number): Path;
+
+export { Path, errorAlignBeamSearch };

package/dist/errorAlign/beamSearch.d.ts

@@ -0,0 +1,53 @@
+import { Index } from './backtraceGraph.js';
+import { SubgraphMetadata } from './graphMetadata.js';
+import './utils.js';
+
+/**
+ * Class to represent a graph path.
+ */
+declare class Path {
+    src: SubgraphMetadata;
+    refIndex: number;
+    hypIndex: number;
+    lastHypIndex: number;
+    lastRefIndex: number;
+    closedCost: number;
+    openCost: number;
+    atUnambiguousMatchNode: boolean;
+    endIndices: [number, number, number][];
+    sortId: bigint;
+    constructor(src: SubgraphMetadata);
+    /**
+     * Get the ID of the path used for pruning.
+     */
+    get pruneId(): number;
+    /**
+     * Get the cost of the path.
+     */
+    get cost(): number;
+    /**
+     * Get the normalized cost of the path.
+     */
+    get normCost(): number;
+    /**
+     * Get the current node index of the path.
+     */
+    get index(): Index;
+    /**
+     * Check if the path has reached the terminal node.
+     */
+    get atEnd(): boolean;
+    /**
+     * Update the sort ID for path ordering. Ensures identical behavior as C++ implementation.
+     */
+    updateSortId(t: bigint): void;
+}
+/**
+ * Perform beam search to align reference and hypothesis texts for a given source.
+ *
+ * @param src The source metadata for alignment.
+ * @param beamSize The size of the beam for beam search. Defaults to 100.
+ */
+declare function errorAlignBeamSearch(src: SubgraphMetadata, beamSize?: number): Path;
+
+export { Path, errorAlignBeamSearch };