@gmod/gbz-base 2.2.0 → 2.3.0

package/dist/subgraph.js

@@ -1,7 +1,21 @@
-import { ENDMARKER, edgeIsCanonical, encodeNode, entryOrientation, entrySide, exitOrientation, exitSide, flipNode, flipSide, isReverse, nodeId, nodeOrientation, pathIsCanonical, } from "./gbwt/node.js";
+import { ENDMARKER, edgeIsCanonical, encodeNode, entryOrientation, entrySide, exitOrientation, exitSide, flipNode, flipSide, isReverse, nodeId, nodeOrientation, pathEndsAreCanonical, pathIsCanonical, } from "./gbwt/node.js";
 import { gfaHeaderLines, sha256Hex, subgraphName } from "./graphName.js";
 import { weightedLcs } from "./lcs.js";
 import { formatPathName } from "./pathName.js";
+export class SubgraphLimitError extends Error {
+    name = 'SubgraphLimitError';
+    limit;
+    windowBp;
+    walkedBp;
+    constructor(limit, walk) {
+        super(walk === undefined
+            ? `Subgraph size limit of ${limit} nodes exceeded`
+            : `Subgraph size limit of ${limit} nodes exceeded ${walk.walkedBp} bp into a ${walk.windowBp} bp window`);
+        this.limit = limit;
+        this.windowBp = walk?.windowBp;
+        this.walkedBp = walk?.walkedBp;
+    }
+}
 function sideBefore(a, b) {
     return (a[0] < b[0] ||
         (a[0] === b[0] && (a[1] < b[1] || (a[1] === b[1] && a[2] < b[2]))));
@@ -58,20 +72,122 @@ class SideQueue {
 function posKey(pos) {
     return `${pos.node}:${pos.offset}`;
 }
+function joinable(a, b) {
+    const insertion = b.identity.hapStart - a.identity.hapEnd;
+    const deletion = a.strand === '+' ? b.refStart - a.refEnd : a.refStart - b.refEnd;
+    return a.strand === b.strand && insertion >= 0 && deletion >= 0
+        ? { insertion, deletion }
+        : undefined;
+}
+function joinPair(a, b, gap) {
+    const [left, right] = a.strand === '+' ? [a, b] : [b, a];
+    const edits = left.edits.map(([op, len]) => [op, len]);
+    appendGap(edits, gap.insertion, gap.deletion);
+    for (const [op, len] of right.edits) {
+        appendEdit(edits, op, len);
+    }
+    const walkForward = a.identity.walkForward;
+    const [first, second] = walkForward ? [a, b] : [b, a];
+    return {
+        strand: a.strand,
+        refStart: left.refStart,
+        refEnd: right.refEnd,
+        edits,
+        weight: undefined,
+        path: [...first.path, ...second.path],
+        start: first.start,
+        identity: {
+            pathHandle: a.identity.pathHandle,
+            name: a.identity.name,
+            hapStart: a.identity.hapStart,
+            hapEnd: b.identity.hapEnd,
+            walkForward,
+        },
+    };
+}
+function joinSiblings(fragments) {
+    if (fragments.some(f => f.weight !== undefined)) {
+        return fragments;
+    }
+    const byPath = new Map();
+    fragments.forEach((fragment, index) => {
+        if (fragment.identity) {
+            const siblings = byPath.get(fragment.identity.pathHandle);
+            if (siblings) {
+                siblings.push(index);
+            }
+            else {
+                byPath.set(fragment.identity.pathHandle, [index]);
+            }
+        }
+    });
+    const joined = new Map();
+    const consumed = new Set();
+    for (const siblings of byPath.values()) {
+        siblings.sort((x, y) => fragments[x].identity.hapStart - fragments[y].identity.hapStart);
+        let head = siblings[0];
+        let current = fragments[head];
+        for (const index of siblings.slice(1)) {
+            const next = fragments[index];
+            const gap = joinable(current, next);
+            if (gap) {
+                current = joinPair(current, next, gap);
+                consumed.add(index);
+            }
+            else {
+                joined.set(head, current);
+                head = index;
+                current = next;
+            }
+        }
+        joined.set(head, current);
+    }
+    return fragments.flatMap((fragment, index) => consumed.has(index) ? [] : [joined.get(index) ?? fragment]);
+}
+function pathPosition(info, k) {
+    return { node: info.path[k], offset: info.offsets[k] };
+}
+const SCAN_GAP = 4096;
+function handleRuns(sortedHandles) {
+    const runs = [];
+    for (const handle of sortedHandles) {
+        const last = runs[runs.length - 1];
+        if (last && handle - last[1] <= SCAN_GAP) {
+            last[1] = handle;
+        }
+        else {
+            runs.push([handle, handle]);
+        }
+    }
+    return runs;
+}
 export class Subgraph {
     records = new Map();
     paths = [];
+    twinStarts = new Set();
     refId;
     refPath;
     refHandle;
     refInterval;
     refIndexCache;
     refPrefixCache;
+    walkedBp;
     stats = {
         orderedAlignments: 0,
         lcsAlignments: 0,
         identificationSteps: 0,
         identificationFetches: 0,
+        identification: {
+            interval: 0,
+            scans: [],
+            windowSamples: 0,
+            fragmentLengths: [],
+            companionSeeks: 0,
+            companionMisses: 0,
+            graphLookups: 0,
+            graphFetches: 0,
+            chains: [],
+        },
     };
     db;
     limit;
@@ -115,7 +231,7 @@ export class Subgraph {
     async addNode(id) {
         this.signal?.throwIfAborted();
         if (this.limit !== undefined && this.nodeCount >= this.limit) {
-            throw new Error(`Subgraph size limit of ${this.limit} nodes exceeded`);
+            throw new SubgraphLimitError(this.limit);
         }
         const forward = await this.db.getRecord(encodeNode(id, 'forward'));
         const reverse = await this.db.getRecord(encodeNode(id, 'reverse'));
@@ -132,6 +248,7 @@ export class Subgraph {
     }
     clearPaths() {
         this.paths = [];
+        this.twinStarts.clear();
         this.refId = undefined;
         this.refPath = undefined;
         this.refHandle = undefined;
@@ -190,10 +307,35 @@ export class Subgraph {
         active.push(record.sequenceLen - nodeOffset - 1, id, exitSide(orientation));
         return this.insertContext(active, context);
     }
+    async prefetchReferenceWalk(reference, len) {
+        const last = await this.db.indexedPosition(reference.handle, reference.position.seqOffset + len);
+        if (last) {
+            const a = reference.position.handle;
+            const b = last.pos.node;
+            await this.db.prefetchRecords(Math.min(a, b), Math.max(a, b) + 1);
+        }
+    }
     async aroundInterval(start, len, context) {
         if (len === 0) {
             throw new Error('Interval length must be greater than 0');
         }
+        this.walkedBp = 0;
+        try {
+            return await this.walkInterval(start, len, context);
+        }
+        catch (error) {
+            throw error instanceof SubgraphLimitError && error.windowBp === undefined
+                ? new SubgraphLimitError(error.limit, {
+                    windowBp: len,
+                    walkedBp: this.walkedBp,
+                })
+                : error;
+        }
+    }
+    get referenceWalkedBp() {
+        return this.walkedBp;
+    }
+    async walkInterval(start, len, context) {
         let pos = { node: start.handle, offset: start.gbwtOffset };
         let offset = start.nodeOffset;
         let remaining = len;
@@ -201,6 +343,7 @@ export class Subgraph {
         for (;;) {
             const id = nodeId(pos.node);
             const orientation = nodeOrientation(pos.node);
+            this.walkedBp = len - remaining;
             await this.ensureNode(id);
             const record = this.record(pos.node);
             if (offset >= record.sequenceLen) {
@@ -221,6 +364,7 @@ export class Subgraph {
             offset = 0;
             remaining -= distanceToNext;
         }
+        this.walkedBp = len;
         return this.insertContext(active, context);
     }
     async aroundNodes(nodes, context) {
@@ -420,64 +564,126 @@ export class Subgraph {
         this.refPath = reference?.name;
         this.refHandle = reference?.handle;
         const handles = this.sortedHandles();
-        const successors = new Map();
-        for (const handle of handles) {
-            const { nodes, offsets } = this.record(handle).gbwt().decompressArrays();
-            successors.set(handle, {
-                nodes,
-                offsets,
-                hasPredecessor: new Uint8Array(nodes.length),
-            });
+        const count = handles.length;
+        const indexOf = new Map();
+        handles.forEach((handle, i) => indexOf.set(handle, i));
+        const nextIndex = [];
+        const nextOffset = [];
+        const hasPredecessor = [];
+        const seqLen = new Int32Array(count);
+        for (let i = 0; i < count; i++) {
+            const record = this.record(handles[i]);
+            const { nodes, offsets } = record.gbwt().decompressArrays();
+            seqLen[i] = record.sequenceLen;
+            nextIndex.push(nodes);
+            nextOffset.push(offsets);
+            hasPredecessor.push(new Uint8Array(nodes.length));
         }
-        for (const handle of handles) {
-            const { nodes, offsets } = successors.get(handle);
-            for (let i = 0; i < nodes.length; i++) {
-                const entry = successors.get(nodes[i]);
-                if (entry) {
-                    entry.hasPredecessor[offsets[i]] = 1;
+        for (let i = 0; i < count; i++) {
+            const nodes = nextIndex[i];
+            const offsets = nextOffset[i];
+            for (let k = 0; k < nodes.length; k++) {
+                const j = indexOf.get(nodes[k]);
+                if (j === undefined) {
+                    nodes[k] = -1;
+                }
+                else {
+                    nodes[k] = j;
+                    hasPredecessor[j][offsets[k]] = 1;
                 }
             }
         }
+        const refIndex = refPos === undefined ? undefined : indexOf.get(refPos.handle);
+        const refGbwtOffset = refPos?.gbwtOffset;
         let refOffset;
-        for (const handle of handles) {
-            const entries = successors.get(handle);
-            for (let offset = 0; offset < entries.nodes.length; offset++) {
-                if (entries.hasPredecessor[offset] === 0) {
-                    let currNode = handle;
-                    let currOffset = offset;
-                    let isRef = false;
-                    const path = [];
-                    const positions = [];
-                    let len = 0;
-                    while (currNode !== undefined) {
-                        if (currNode === refPos?.handle &&
-                            currOffset === refPos.gbwtOffset) {
-                            this.refId = this.paths.length;
-                            refOffset = path.length;
-                            isRef = true;
-                        }
-                        path.push(currNode);
-                        positions.push({ node: currNode, offset: currOffset });
-                        len += this.record(currNode).sequenceLen;
-                        const step = successors.get(currNode);
-                        const nextNode = step.nodes[currOffset];
-                        const nextOffset = step.offsets[currOffset];
-                        if (nextNode !== ENDMARKER && successors.has(nextNode)) {
-                            currNode = nextNode;
-                            currOffset = nextOffset;
+        const walk = (i, offset, path) => {
+            const offsets = [];
+            let steps = 0;
+            let len = 0;
+            let refAt = -1;
+            let cur = i;
+            let off = offset;
+            for (;;) {
+                if (cur === refIndex && off === refGbwtOffset) {
+                    refAt = steps;
+                }
+                if (path) {
+                    path.push(handles[cur]);
+                    offsets.push(off);
+                }
+                steps += 1;
+                len += seqLen[cur];
+                const next = nextIndex[cur][off];
+                if (next < 0) {
+                    break;
+                }
+                off = nextOffset[cur][off];
+                cur = next;
+            }
+            return { offsets, len, refAt, last: cur };
+        };
+        const keep = (path, offsets, len, refAt) => {
+            if (refAt >= 0) {
+                this.refId = this.paths.length;
+                refOffset = refAt;
+            }
+            this.paths.push({
+                path,
+                offsets,
+                len,
+                weight: undefined,
+                identity: undefined,
+            });
+        };
+        const twinsExpected = new Int32Array(count);
+        const refMayStartReversed = refIndex !== undefined && isReverse(handles[refIndex]);
+        for (let i = 0; i < count; i++) {
+            const first = handles[i];
+            if (!isReverse(first)) {
+                const starts = hasPredecessor[i];
+                for (let offset = 0; offset < starts.length; offset++) {
+                    if (starts[offset] === 0) {
+                        const path = [];
+                        const { offsets, len, refAt, last } = walk(i, offset, path);
+                        const lastHandle = handles[last];
+                        if (refAt >= 0 || pathEndsAreCanonical(first, lastHandle)) {
+                            keep(path, offsets, len, refAt);
+                            if (!isReverse(lastHandle)) {
+                                const twinRecord = indexOf.get(flipNode(lastHandle));
+                                twinsExpected[twinRecord] = twinsExpected[twinRecord] + 1;
+                            }
                         }
                         else {
-                            currNode = undefined;
+                            this.twinStarts.add(posKey({ node: first, offset }));
                         }
                     }
-                    if (isRef || pathIsCanonical(path)) {
-                        this.paths.push({
-                            path,
-                            positions,
-                            len,
-                            weight: undefined,
-                            identity: undefined,
-                        });
+                }
+            }
+        }
+        for (let i = 0; i < count; i++) {
+            const first = handles[i];
+            if (isReverse(first)) {
+                const starts = hasPredecessor[i];
+                let startCount = 0;
+                for (const flag of starts) {
+                    if (flag === 0) {
+                        startCount += 1;
+                    }
+                }
+                const allTwins = !refMayStartReversed && startCount === twinsExpected[i];
+                for (let offset = 0; offset < starts.length; offset++) {
+                    if (starts[offset] === 0) {
+                        const bare = allTwins ? undefined : walk(i, offset, undefined);
+                        if (bare &&
+                            (bare.refAt >= 0 ||
+                                pathEndsAreCanonical(first, handles[bare.last]))) {
+                            const path = [];
+                            const { offsets, len, refAt } = walk(i, offset, path);
+                            keep(path, offsets, len, refAt);
+                        }
+                        else {
+                            this.twinStarts.add(posKey({ node: first, offset }));
+                        }
                     }
                 }
             }
@@ -538,32 +744,66 @@ export class Subgraph {
             throw new Error('The database has no HaplotypeSamples table; run gbz-haplotype-index on it');
         }
         const interval = (await this.db.haplotypeSampleInterval()) ?? 4096;
-        const handles = this.sortedHandles();
-        const minHandle = handles[0];
-        const maxHandle = handles[handles.length - 1];
-        if (minHandle === undefined || maxHandle === undefined) {
+        const runs = handleRuns(this.sortedHandles());
+        if (runs.length === 0) {
             return;
         }
         const samples = new Map();
-        for (const sample of await this.db.haplotypeSamplesInRange(minHandle, maxHandle)) {
-            samples.set(posKey(sample), sample);
+        for (const [first, last] of runs) {
+            for (const sample of await this.db.haplotypeSamplesInRange(first, last)) {
+                samples.set(posKey(sample), sample);
+            }
         }
+        const scanned = (handle) => {
+            let lo = 0;
+            let hi = runs.length - 1;
+            while (lo < hi) {
+                const mid = (lo + hi + 1) >> 1;
+                if (runs[mid][0] <= handle) {
+                    lo = mid;
+                }
+                else {
+                    hi = mid - 1;
+                }
+            }
+            const run = runs[lo];
+            return run[0] <= handle && handle <= run[1];
+        };
         const starts = new Map();
         this.paths.forEach((info, index) => {
-            const first = info.positions[0];
-            if (first && index !== this.refId) {
-                starts.set(posKey(first), index);
+            if (info.path.length > 0 && index !== this.refId) {
+                starts.set(posKey(pathPosition(info, 0)), index);
+            }
+        });
+        const identification = this.stats.identification;
+        identification.interval = interval;
+        identification.scans = runs;
+        identification.windowSamples = samples.size;
+        this.paths.forEach((info, index) => {
+            if (index !== this.refId) {
+                identification.fragmentLengths.push(info.len);
             }
         });
-        const recordAt = this.recordReader(() => {
+        const readRecord = this.recordReader(() => {
             this.stats.identificationFetches += 1;
+            identification.graphFetches += 1;
         });
-        const sampleAt = async (pos) => {
-            if (pos.node >= minHandle && pos.node <= maxHandle) {
+        const recordAt = (handle) => {
+            identification.graphLookups += 1;
+            return readRecord(handle);
+        };
+        const sampleAt = async (pos, chain) => {
+            if (scanned(pos.node)) {
                 return samples.get(posKey(pos));
             }
             this.stats.identificationFetches += 1;
-            return this.db.haplotypeSampleAt(pos.node, pos.offset);
+            identification.companionSeeks += 1;
+            chain.seeks += 1;
+            const sample = await this.db.haplotypeSampleAt(pos.node, pos.offset);
+            if (!sample) {
+                identification.companionMisses += 1;
+            }
+            return sample;
         };
         const names = new Map();
         const nameOf = async (pathHandle) => {
@@ -607,6 +847,16 @@ export class Subgraph {
             }
             const chain = [];
             const visited = new Set();
+            const record = {
+                fragments: 0,
+                steps: 0,
+                seeks: 0,
+                reentries: 0,
+                twinLandings: 0,
+                end: 'endmarker',
+                pathHandle: undefined,
+            };
+            identification.chains.push(record);
             let anchor;
             let counter = 0;
             let current = start;
@@ -615,13 +865,16 @@ export class Subgraph {
                 this.signal?.throwIfAborted();
                 if (current !== undefined) {
                     if (visited.has(current)) {
+                        record.end = 'cycle';
                         break;
                     }
                     visited.add(current);
                     const info = this.paths[current];
                     chain.push({ index: current, startBp: counter });
+                    record.fragments += 1;
                     let bp = counter;
-                    for (const position of info.positions) {
+                    for (let k = 0; k < info.path.length; k++) {
+                        const position = pathPosition(info, k);
                         const sample = samples.get(posKey(position));
                         const nodeLen = this.record(position.node).sequenceLen;
                         if (sample) {
@@ -632,40 +885,54 @@ export class Subgraph {
                     }
                     counter += info.len;
                     if (anchor) {
+                        record.end = 'in-fragment sample';
                         break;
                     }
-                    const last = info.positions[info.positions.length - 1];
+                    const last = pathPosition(info, info.path.length - 1);
                     pos = this.record(last.node).gbwt().lf(last.offset);
                     current = undefined;
                 }
                 if (pos === undefined || pos.node === ENDMARKER) {
+                    record.end = 'endmarker';
                     break;
                 }
-                const known = starts.get(posKey(pos));
+                const key = posKey(pos);
+                const known = starts.get(key);
                 if (known !== undefined) {
                     const identity = this.paths[known].identity;
                     if (identity) {
                         anchor = anchorFromIdentity(identity, counter);
+                        record.end = 'identified sibling';
                         break;
                     }
                     current = known;
                     continue;
                 }
-                const sample = await sampleAt(pos);
-                const record = await recordAt(pos.node);
+                if (this.records.has(pos.node)) {
+                    record.reentries += 1;
+                }
+                if (this.twinStarts.has(key)) {
+                    record.twinLandings += 1;
+                }
+                const sample = await sampleAt(pos, record);
+                const node = await recordAt(pos.node);
                 if (sample) {
-                    anchor = anchorFromSample(sample, counter, record.sequenceLen);
+                    anchor = anchorFromSample(sample, counter, node.sequenceLen);
+                    record.end = 'out-of-window sample';
                     break;
                 }
                 this.stats.identificationSteps += 1;
+                record.steps += 1;
                 if (counter - chain[chain.length - 1].startBp >
-                    4 * interval + 4 * record.sequenceLen) {
+                    4 * interval + 4 * node.sequenceLen) {
+                    record.end = 'bound';
                     break;
                 }
-                counter += record.sequenceLen;
-                pos = record.gbwt().lf(pos.offset);
+                counter += node.sequenceLen;
+                pos = node.gbwt().lf(pos.offset);
             }
             if (anchor) {
+                record.pathHandle = anchor.pathHandle;
                 const name = await nameOf(anchor.pathHandle);
                 for (const { index, startBp } of chain) {
                     const info = this.paths[index];
@@ -807,30 +1074,7 @@ export class Subgraph {
             suffix = refLen - prefix;
         }
         appendEdit(edits, 'M', prefix);
-        const pathMiddle = pathLen - prefix - suffix;
-        const refMiddle = refLen - prefix - suffix;
-        if (pathMiddle === 0) {
-            appendEdit(edits, 'D', refMiddle);
-        }
-        else if (refMiddle === 0) {
-            appendEdit(edits, 'I', pathMiddle);
-        }
-        else {
-            const mismatch = Math.min(pathMiddle, refMiddle);
-            const mismatchIndel = 4 * mismatch +
-                gapPenalty(pathMiddle - mismatch) +
-                gapPenalty(refMiddle - mismatch);
-            const insertionDeletion = gapPenalty(pathMiddle) + gapPenalty(refMiddle);
-            if (mismatchIndel <= insertionDeletion) {
-                appendEdit(edits, 'M', mismatch);
-                appendEdit(edits, 'I', pathMiddle - mismatch);
-                appendEdit(edits, 'D', refMiddle - mismatch);
-            }
-            else {
-                appendEdit(edits, 'I', pathMiddle);
-                appendEdit(edits, 'D', refMiddle);
-            }
-        }
+        appendGap(edits, pathLen - prefix - suffix, refLen - prefix - suffix);
         appendEdit(edits, 'M', suffix);
     }
     sharedWeight(path, ref) {
@@ -854,18 +1098,30 @@ export class Subgraph {
         const lcs = ordered ??
             weightedLcs(path, ref, handle => this.record(handle).sequenceLen)[0];
         const edits = [];
+        const refPrefix = this.refPrefix(ref);
+        const alignGap = (pathFrom, pathTo, refFrom, refTo) => {
+            if (pathFrom === pathTo) {
+                appendEdit(edits, 'D', refPrefix[refTo] - refPrefix[refFrom]);
+            }
+            else if (refFrom === refTo) {
+                appendEdit(edits, 'I', this.pathLen(path.slice(pathFrom, pathTo)));
+            }
+            else {
+                this.align(path.slice(pathFrom, pathTo), ref.slice(refFrom, refTo), edits);
+            }
+        };
         let matched = 0;
         let pathOffset = 0;
         let refOffset = 0;
         for (const [nextPath, nextRef] of lcs) {
-            this.align(path.slice(pathOffset, nextPath), ref.slice(refOffset, nextRef), edits);
+            alignGap(pathOffset, nextPath, refOffset, nextRef);
             const nodeLen = this.record(path[nextPath]).sequenceLen;
             appendEdit(edits, 'M', nodeLen);
             matched += nodeLen;
             pathOffset = nextPath + 1;
             refOffset = nextRef + 1;
         }
-        this.align(path.slice(pathOffset), ref.slice(refOffset), edits);
+        alignGap(pathOffset, path.length, refOffset, ref.length);
         return { edits, matched };
     }
     alignment(pathIndex) {
@@ -914,7 +1170,7 @@ export class Subgraph {
         }
         const ref = this.paths[this.refId].path;
         const refTotal = this.refPrefix(ref)[ref.length];
-        const result = [];
+        const fragments = [];
         this.paths.forEach((info, index) => {
             if (index === this.refId) {
                 return;
@@ -936,36 +1192,40 @@ export class Subgraph {
             const alongReference = identity
                 ? (identity.orientation === 'forward') !== flipped
                 : !flipped;
-            const span = {
+            fragments.push({
                 strand: alongReference ? '+' : '-',
                 refStart: reference.start + leading,
                 refEnd: reference.start + refTotal - trailing,
-                cigar: edits
-                    .slice(first, last)
-                    .map(([op, len]) => `${len}${op}`)
-                    .join(''),
+                edits: edits.slice(first, last),
                 weight: info.weight,
                 path: info.path,
-                start: info.positions[0],
-            };
-            if (identity) {
-                const hapStart = identity.name.fragment + identity.hapStart;
-                const hapEnd = identity.name.fragment + identity.hapEnd;
-                result.push({
+                start: pathPosition(info, 0),
+                identity: identity === undefined
+                    ? undefined
+                    : {
+                        pathHandle: identity.pathHandle,
+                        name: identity.name,
+                        hapStart: identity.name.fragment + identity.hapStart,
+                        hapEnd: identity.name.fragment + identity.hapEnd,
+                        walkForward: identity.orientation === 'forward',
+                    },
+            });
+        });
+        return joinSiblings(fragments).map(fragment => {
+            const { edits, identity, ...rest } = fragment;
+            const span = { ...rest, cigar: cigarOf(edits) };
+            return identity
+                ? {
                     ...span,
                     resolved: true,
                     name: identity.name,
-                    label: formatPathName({ ...identity.name, fragment: hapStart }, hapEnd),
+                    label: formatPathName({ ...identity.name, fragment: identity.hapStart }, identity.hapEnd),
                     pathHandle: identity.pathHandle,
-                    hapStart,
-                    hapEnd,
-                });
-            }
-            else {
-                result.push({ ...span, resolved: false });
-            }
+                    hapStart: identity.hapStart,
+                    hapEnd: identity.hapEnd,
+                }
+                : { ...span, resolved: false };
         });
-        return result;
     }
     canonicalEdges(id) {
         const edges = [];
@@ -1140,4 +1400,31 @@ function appendEdit(edits, op, len) {
 function gapPenalty(len) {
     return len === 0 ? 0 : 6 + (len - 1);
 }
+function appendGap(edits, pathMiddle, refMiddle) {
+    if (pathMiddle === 0) {
+        appendEdit(edits, 'D', refMiddle);
+    }
+    else if (refMiddle === 0) {
+        appendEdit(edits, 'I', pathMiddle);
+    }
+    else {
+        const mismatch = Math.min(pathMiddle, refMiddle);
+        const mismatchIndel = 4 * mismatch +
+            gapPenalty(pathMiddle - mismatch) +
+            gapPenalty(refMiddle - mismatch);
+        const insertionDeletion = gapPenalty(pathMiddle) + gapPenalty(refMiddle);
+        if (mismatchIndel <= insertionDeletion) {
+            appendEdit(edits, 'M', mismatch);
+            appendEdit(edits, 'I', pathMiddle - mismatch);
+            appendEdit(edits, 'D', refMiddle - mismatch);
+        }
+        else {
+            appendEdit(edits, 'I', pathMiddle);
+            appendEdit(edits, 'D', refMiddle);
+        }
+    }
+}
+function cigarOf(edits) {
+    return edits.map(([op, len]) => `${len}${op}`).join('');
+}
 //# sourceMappingURL=subgraph.js.map