p2s_mapper 1.0.0

package/dist/mappings.d.ts

@@ -0,0 +1,58 @@
+export interface AlignmentRow {
+    id: string;
+    seq: string;
+}
+/**
+ * A two-row alignment whose ROW ORDER IS A CONTRACT: row 0 is the transcript,
+ * row 1 is the structure. Every producer honors it — runLocalAlignment is
+ * always called as (transcript, structure), and the manual-import dialog tells
+ * the user to paste them in that order — and every consumer depends on it, but
+ * nothing in the type can enforce it, and swapping the two silently inverts
+ * every coordinate map. Read the rows through the accessors below rather than
+ * indexing, so a call site states which sequence it means.
+ */
+export interface PairwiseAlignment {
+    consensus: string;
+    alns: readonly [AlignmentRow, AlignmentRow];
+}
+export declare const transcriptAlignedSeq: (pa: PairwiseAlignment) => string;
+export declare const structureAlignedSeq: (pa: PairwiseAlignment) => string;
+/** Number of columns, gaps included. Both rows have this length by definition;
+ * `pairwiseAlignmentProblem` is what guarantees it. */
+export declare const alignmentLength: (pa: PairwiseAlignment) => number;
+/**
+ * Why a pairwise alignment can't be used, or undefined if it's usable. The two
+ * rows must be the same non-zero length — every coordinate map walks them in
+ * lockstep, so a ragged pair would map positions to nonsense. Callers that
+ * accept alignments from outside (the manual-import dialog) check this and
+ * report it; the internal map builders assert on it.
+ */
+export declare function pairwiseAlignmentProblem(pa: PairwiseAlignment): string | undefined;
+/**
+ * Why an externally supplied alignment does not describe these two sequences,
+ * or undefined if it does. The coordinate maps index the transcript and the
+ * structure by counting residues along each row, so a row whose residues are
+ * not the sequence being mapped (an alignment made against UniProt canonical
+ * for a different isoform, or against another chain) shifts every position
+ * after the first difference without any map noticing.
+ */
+export declare function pairwiseAlignmentSequenceProblem(pa: PairwiseAlignment, transcript: string, structure: string): string | undefined;
+export declare function structureSeqVsTranscriptSeqMap(pairwiseAlignment: PairwiseAlignment): {
+    structureSeqToTranscriptSeqPosition: Record<number, number>;
+    transcriptSeqToStructureSeqPosition: Record<number, number>;
+};
+/** Each 0-based structure position opposite a transcript residue, and whether
+ * the two residues are identical. */
+export declare function mappedStructureIdentity(pa: PairwiseAlignment): Map<number, boolean>;
+/**
+ * The alignment with each listed structure position taken out of its column,
+ * so both rows still spell their sequences and those residues map to nothing.
+ * An unmapped region, including the gap columns inside it, becomes its
+ * transcript residues against gaps, then gaps against its structure residues,
+ * rather than alternating column by column. Returns `pa` itself when nothing
+ * changes.
+ */
+export declare function unmapStructurePositions(pa: PairwiseAlignment, positions: ReadonlySet<number>): PairwiseAlignment;
+export declare function structurePositionToAlignmentMap(pairwiseAlignment: PairwiseAlignment): Record<number, number>;
+export declare function transcriptPositionToAlignmentMap(pairwiseAlignment: PairwiseAlignment): Record<number, number>;
+export declare function codonGenomeSpan(p2gCodon: Record<number, number[]>, proteinPos: number): readonly [number, number] | undefined;

package/dist/mappings.js

@@ -0,0 +1,193 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.alignmentLength = exports.structureAlignedSeq = exports.transcriptAlignedSeq = void 0;
+exports.pairwiseAlignmentProblem = pairwiseAlignmentProblem;
+exports.pairwiseAlignmentSequenceProblem = pairwiseAlignmentSequenceProblem;
+exports.structureSeqVsTranscriptSeqMap = structureSeqVsTranscriptSeqMap;
+exports.mappedStructureIdentity = mappedStructureIdentity;
+exports.unmapStructurePositions = unmapStructurePositions;
+exports.structurePositionToAlignmentMap = structurePositionToAlignmentMap;
+exports.transcriptPositionToAlignmentMap = transcriptPositionToAlignmentMap;
+exports.codonGenomeSpan = codonGenomeSpan;
+const g2p_mapper_1 = require("g2p_mapper");
+const transcriptAlignedSeq = (pa) => pa.alns[0].seq;
+exports.transcriptAlignedSeq = transcriptAlignedSeq;
+const structureAlignedSeq = (pa) => pa.alns[1].seq;
+exports.structureAlignedSeq = structureAlignedSeq;
+/** Number of columns, gaps included. Both rows have this length by definition;
+ * `pairwiseAlignmentProblem` is what guarantees it. */
+const alignmentLength = (pa) => (0, exports.transcriptAlignedSeq)(pa).length;
+exports.alignmentLength = alignmentLength;
+/**
+ * Why a pairwise alignment can't be used, or undefined if it's usable. The two
+ * rows must be the same non-zero length — every coordinate map walks them in
+ * lockstep, so a ragged pair would map positions to nonsense. Callers that
+ * accept alignments from outside (the manual-import dialog) check this and
+ * report it; the internal map builders assert on it.
+ */
+function pairwiseAlignmentProblem(pa) {
+    const transcript = (0, exports.transcriptAlignedSeq)(pa);
+    const structure = (0, exports.structureAlignedSeq)(pa);
+    if (transcript.length === 0 || structure.length === 0) {
+        return 'The aligned sequences must not be empty';
+    }
+    if (transcript.length !== structure.length) {
+        return `The two aligned sequences must be the same length (got ${transcript.length} and ${structure.length})`;
+    }
+    return undefined;
+}
+const ungapped = (row) => row.replaceAll('-', '').toUpperCase();
+/**
+ * Why an externally supplied alignment does not describe these two sequences,
+ * or undefined if it does. The coordinate maps index the transcript and the
+ * structure by counting residues along each row, so a row whose residues are
+ * not the sequence being mapped (an alignment made against UniProt canonical
+ * for a different isoform, or against another chain) shifts every position
+ * after the first difference without any map noticing.
+ */
+function pairwiseAlignmentSequenceProblem(pa, transcript, structure) {
+    const t = ungapped((0, exports.transcriptAlignedSeq)(pa));
+    const s = ungapped((0, exports.structureAlignedSeq)(pa));
+    if (t !== transcript.toUpperCase()) {
+        return `The first sequence is not this transcript's translation (${t.length} vs ${transcript.length} residues)`;
+    }
+    if (s !== structure.toUpperCase()) {
+        return `The second sequence is not the mapped chain's sequence (${s.length} vs ${structure.length} residues)`;
+    }
+    return undefined;
+}
+function structureSeqVsTranscriptSeqMap(pairwiseAlignment) {
+    const problem = pairwiseAlignmentProblem(pairwiseAlignment);
+    if (problem) {
+        throw new Error(problem);
+    }
+    const structureSeq = (0, exports.structureAlignedSeq)(pairwiseAlignment);
+    const transcriptSeq = (0, exports.transcriptAlignedSeq)(pairwiseAlignment);
+    let j = 0;
+    let k = 0;
+    const structureSeqToTranscriptSeqPosition = {};
+    const transcriptSeqToStructureSeqPosition = {};
+    for (let i = 0; i < structureSeq.length; i++) {
+        const inStructure = structureSeq[i] !== '-';
+        const inTranscript = transcriptSeq[i] !== '-';
+        if (inStructure && inTranscript) {
+            structureSeqToTranscriptSeqPosition[j] = k;
+            transcriptSeqToStructureSeqPosition[k] = j;
+        }
+        if (inStructure) {
+            j++;
+        }
+        if (inTranscript) {
+            k++;
+        }
+    }
+    return {
+        structureSeqToTranscriptSeqPosition,
+        transcriptSeqToStructureSeqPosition,
+    };
+}
+/** Each 0-based structure position opposite a transcript residue, and whether
+ * the two residues are identical. */
+function mappedStructureIdentity(pa) {
+    const transcript = (0, exports.transcriptAlignedSeq)(pa);
+    const structure = (0, exports.structureAlignedSeq)(pa);
+    const mapped = new Map();
+    for (let i = 0, j = 0; i < structure.length; i++) {
+        if (structure[i] !== '-') {
+            if (transcript[i] !== '-') {
+                mapped.set(j, transcript[i].toUpperCase() === structure[i].toUpperCase());
+            }
+            j++;
+        }
+    }
+    return mapped;
+}
+/**
+ * The alignment with each listed structure position taken out of its column,
+ * so both rows still spell their sequences and those residues map to nothing.
+ * An unmapped region, including the gap columns inside it, becomes its
+ * transcript residues against gaps, then gaps against its structure residues,
+ * rather than alternating column by column. Returns `pa` itself when nothing
+ * changes.
+ */
+function unmapStructurePositions(pa, positions) {
+    const transcript = (0, exports.transcriptAlignedSeq)(pa);
+    const structure = (0, exports.structureAlignedSeq)(pa);
+    const t = [];
+    const s = [];
+    const c = [];
+    const runT = [];
+    const runS = [];
+    const flushRun = () => {
+        t.push(...runT, ...runS.map(() => '-'));
+        s.push(...runT.map(() => '-'), ...runS);
+        c.push(...runT.map(() => ' '), ...runS.map(() => ' '));
+        runT.length = 0;
+        runS.length = 0;
+    };
+    let j = 0;
+    let changed = false;
+    for (let i = 0; i < structure.length; i++) {
+        const inStructure = structure[i] !== '-';
+        const inTranscript = transcript[i] !== '-';
+        if (inStructure && inTranscript && positions.has(j)) {
+            runT.push(transcript[i]);
+            runS.push(structure[i]);
+            changed = true;
+        }
+        else if (runT.length > 0 && !(inStructure && inTranscript)) {
+            if (inTranscript) {
+                runT.push(transcript[i]);
+            }
+            if (inStructure) {
+                runS.push(structure[i]);
+            }
+        }
+        else {
+            flushRun();
+            t.push(transcript[i]);
+            s.push(structure[i]);
+            c.push(pa.consensus[i] ?? ' ');
+        }
+        if (inStructure) {
+            j++;
+        }
+    }
+    flushRun();
+    return changed
+        ? {
+            consensus: c.join(''),
+            alns: [
+                { ...pa.alns[0], seq: t.join('') },
+                { ...pa.alns[1], seq: s.join('') },
+            ],
+        }
+        : pa;
+}
+function seqPositionToAlignmentMap(seq) {
+    const map = {};
+    for (let i = 0, j = 0; i < seq.length; i++) {
+        if (seq[i] !== '-') {
+            map[j] = i;
+            j++;
+        }
+    }
+    return map;
+}
+function structurePositionToAlignmentMap(pairwiseAlignment) {
+    return seqPositionToAlignmentMap((0, exports.structureAlignedSeq)(pairwiseAlignment));
+}
+function transcriptPositionToAlignmentMap(pairwiseAlignment) {
+    return seqPositionToAlignmentMap((0, exports.transcriptAlignedSeq)(pairwiseAlignment));
+}
+// Enclosing 0-based half-open [start, end) genome span for a codon. getCodonRanges
+// returns the codon's separate genomic pieces (multiple when it straddles an
+// exon/intron boundary); this collapses them to the outer span for navigation
+// and highlighting. undefined when the protein position isn't mapped.
+function codonGenomeSpan(p2gCodon, proteinPos) {
+    const ranges = (0, g2p_mapper_1.getCodonRanges)(p2gCodon, proteinPos);
+    return ranges && ranges.length > 0
+        ? [Math.min(...ranges.map(r => r[0])), Math.max(...ranges.map(r => r[1]))]
+        : undefined;
+}
+//# sourceMappingURL=mappings.js.map

package/dist/mappings.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mappings.js","sourceRoot":"","sources":["../src/mappings.ts"],"names":[],"mappings":"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"}

package/dist/package.json

@@ -0,0 +1 @@
+{"type": "commonjs"}

package/dist/pairwiseAlignment.d.ts

@@ -0,0 +1,35 @@
+import type { PairwiseAlignment } from './mappings.ts';
+import type { AlignmentAlgorithm } from './types.ts';
+interface AlignmentResult {
+    alignedSeq1: string;
+    alignedSeq2: string;
+    score: number;
+}
+/**
+ * Ceiling on the dynamic-programming table, in cells. Both algorithms are
+ * O(m*n) time and hold one byte of traceback per cell, so this bounds the
+ * alignment at ~40 MB and roughly a second of main-thread work. Without it a
+ * titin-sized transcript or a long nucleic-acid chain locks up or OOMs the tab.
+ * Callers that have several candidates to align should check `alignmentTooLarge`
+ * and skip the oversized ones rather than let this throw.
+ */
+export declare const MAX_ALIGNMENT_CELLS = 40000000;
+export declare function alignmentTooLarge(len1: number, len2: number): boolean;
+/**
+ * Needleman-Wunsch global alignment algorithm
+ * Aligns entire sequences end-to-end
+ */
+export declare function needlemanWunsch(seq1: string, seq2: string, gapOpen?: number, gapExtend?: number): AlignmentResult;
+/**
+ * Smith-Waterman local alignment algorithm
+ * Finds the best local alignment between subsequences
+ */
+export declare function smithWaterman(seq1: string, seq2: string, gapOpen?: number, gapExtend?: number): AlignmentResult;
+/** The score of a sequence aligned to itself with no gaps. */
+export declare function selfScore(seq: string): number;
+export declare function scoredAlignment(seq1: string, seq2: string, algorithm: AlignmentAlgorithm): {
+    alignment: PairwiseAlignment;
+    score: number;
+};
+export declare function runLocalAlignment(seq1: string, seq2: string, algorithm: AlignmentAlgorithm): PairwiseAlignment;
+export {};

package/dist/pairwiseAlignment.js

@@ -0,0 +1,337 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_ALIGNMENT_CELLS = void 0;
+exports.alignmentTooLarge = alignmentTooLarge;
+exports.needlemanWunsch = needlemanWunsch;
+exports.smithWaterman = smithWaterman;
+exports.selfScore = selfScore;
+exports.scoredAlignment = scoredAlignment;
+exports.runLocalAlignment = runLocalAlignment;
+// BLOSUM62 scoring matrix — standard 20 amino acids + B, Z, X, *
+// prettier-ignore
+const AMINO_ACIDS = ['A', 'R', 'N', 'D', 'C', 'Q', 'E', 'G', 'H', 'I', 'L', 'K', 'M', 'F', 'P', 'S', 'T', 'W', 'Y', 'V', 'B', 'Z', 'X', '*'];
+// prettier-ignore
+const BLOSUM62_RAW = [
+    //  A   R   N   D   C   Q   E   G   H   I   L   K   M   F   P   S   T   W   Y   V   B   Z   X   *
+    [4, -1, -2, -2, 0, -1, -1, 0, -2, -1, -1, -1, -1, -2, -1, 1, 0, -3, -2, 0, -2, -1, 0, -4], // A
+    [-1, 5, 0, -2, -3, 1, 0, -2, 0, -3, -2, 2, -1, -3, -2, -1, -1, -3, -2, -3, -1, 0, -1, -4], // R
+    [-2, 0, 6, 1, -3, 0, 0, 0, 1, -3, -3, 0, -2, -3, -2, 1, 0, -4, -2, -3, 3, 0, -1, -4], // N
+    [-2, -2, 1, 6, -3, 0, 2, -1, -1, -3, -4, -1, -3, -3, -1, 0, -1, -4, -3, -3, 4, 1, -1, -4], // D
+    [0, -3, -3, -3, 9, -3, -4, -3, -3, -1, -1, -3, -1, -2, -3, -1, -1, -2, -2, -1, -3, -3, -2, -4], // C
+    [-1, 1, 0, 0, -3, 5, 2, -2, 0, -3, -2, 1, 0, -3, -1, 0, -1, -2, -1, -2, 0, 3, -1, -4], // Q
+    [-1, 0, 0, 2, -4, 2, 5, -2, 0, -3, -3, 1, -2, -3, -1, 0, -1, -3, -2, -2, 1, 4, -1, -4], // E
+    [0, -2, 0, -1, -3, -2, -2, 6, -2, -4, -4, -2, -3, -3, -2, 0, -2, -2, -3, -3, -1, -2, -1, -4], // G
+    [-2, 0, 1, -1, -3, 0, 0, -2, 8, -3, -3, -1, -2, -1, -2, -1, -2, -2, 2, -3, 0, 0, -1, -4], // H
+    [-1, -3, -3, -3, -1, -3, -3, -4, -3, 4, 2, -3, 1, 0, -3, -2, -1, -3, -1, 3, -3, -3, -1, -4], // I
+    [-1, -2, -3, -4, -1, -2, -3, -4, -3, 2, 4, -2, 2, 0, -3, -2, -1, -2, -1, 1, -4, -3, -1, -4], // L
+    [-1, 2, 0, -1, -3, 1, 1, -2, -1, -3, -2, 5, -1, -3, -1, 0, -1, -3, -2, -2, 0, 1, -1, -4], // K
+    [-1, -1, -2, -3, -1, 0, -2, -3, -2, 1, 2, -1, 5, 0, -2, -1, -1, -1, -1, 1, -3, -1, -1, -4], // M
+    [-2, -3, -3, -3, -2, -3, -3, -3, -1, 0, 0, -3, 0, 6, -4, -2, -2, 1, 3, -1, -3, -3, -1, -4], // F
+    [-1, -2, -2, -1, -3, -1, -1, -2, -2, -3, -3, -1, -2, -4, 7, -1, -1, -4, -3, -2, -2, -1, -2, -4], // P
+    [1, -1, 1, 0, -1, 0, 0, 0, -1, -2, -2, 0, -1, -2, -1, 4, 1, -3, -2, -2, 0, 0, 0, -4], // S
+    [0, -1, 0, -1, -1, -1, -1, -2, -2, -1, -1, -1, -1, -2, -1, 1, 5, -2, -2, 0, -1, -1, 0, -4], // T
+    [-3, -3, -4, -4, -2, -2, -3, -2, -2, -3, -2, -3, -1, 1, -4, -3, -2, 11, 2, -3, -4, -3, -2, -4], // W
+    [-2, -2, -2, -3, -2, -1, -2, -3, 2, -1, -1, -2, -1, 3, -3, -2, -2, 2, 7, -1, -3, -2, -1, -4], // Y
+    [0, -3, -3, -3, -1, -2, -2, -3, -3, 3, 1, -2, 1, -1, -2, -2, 0, -3, -1, 4, -3, -2, -1, -4], // V
+    [-2, -1, 3, 4, -3, 0, 1, -1, 0, -3, -4, 0, -3, -3, -2, 0, -1, -4, -3, -3, 4, 1, -1, -4], // B
+    [-1, 0, 0, 1, -3, 3, 4, -2, 0, -3, -3, 1, -1, -3, -1, 0, -1, -3, -2, -2, 1, 4, -1, -4], // Z
+    [0, -1, -1, -1, -2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -2, 0, 0, -2, -1, -1, -1, -1, -1, -4], // X
+    [-4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, 1], // *
+];
+// Score of a residue pair that isn't in the matrix at all.
+const UNKNOWN_PAIR_SCORE = -4;
+// The DP reads the matrix once per cell, so both the residue→row lookup and the
+// matrix itself are flat typed arrays keyed by char code: charCodeToRow maps
+// 'a'/'A' to the same row, and unknown residues to -1 (scored as unknown).
+const N_AA = AMINO_ACIDS.length;
+const charCodeToRow = new Int8Array(128).fill(-1);
+for (let i = 0; i < N_AA; i++) {
+    const aa = AMINO_ACIDS[i];
+    charCodeToRow[aa.charCodeAt(0)] = i;
+    charCodeToRow[aa.toLowerCase().charCodeAt(0)] = i;
+}
+const BLOSUM62 = new Int8Array(N_AA * N_AA);
+for (let i = 0; i < N_AA; i++) {
+    for (let j = 0; j < N_AA; j++) {
+        BLOSUM62[i * N_AA + j] = BLOSUM62_RAW[i][j];
+    }
+}
+const rowOf = (c) => {
+    const code = c.charCodeAt(0);
+    return code < 128 ? charCodeToRow[code] : -1;
+};
+function getScore(a, b) {
+    const i = rowOf(a);
+    const j = rowOf(b);
+    return i < 0 || j < 0 ? UNKNOWN_PAIR_SCORE : BLOSUM62[i * N_AA + j];
+}
+// Default gap penalties (matching EMBOSS defaults)
+const GAP_OPEN = -10;
+const GAP_EXTEND = -0.5;
+/**
+ * Ceiling on the dynamic-programming table, in cells. Both algorithms are
+ * O(m*n) time and hold one byte of traceback per cell, so this bounds the
+ * alignment at ~40 MB and roughly a second of main-thread work. Without it a
+ * titin-sized transcript or a long nucleic-acid chain locks up or OOMs the tab.
+ * Callers that have several candidates to align should check `alignmentTooLarge`
+ * and skip the oversized ones rather than let this throw.
+ */
+exports.MAX_ALIGNMENT_CELLS = 40_000_000;
+function alignmentTooLarge(len1, len2) {
+    return (len1 + 1) * (len2 + 1) > exports.MAX_ALIGNMENT_CELLS;
+}
+function assertAlignable(len1, len2) {
+    if (alignmentTooLarge(len1, len2)) {
+        throw new Error(`Sequences too long to align (${len1} x ${len2} residues exceeds the ${exports.MAX_ALIGNMENT_CELLS} cell limit)`);
+    }
+}
+// Traceback states. Each cell stores, for each of the three matrices, which
+// matrix its best predecessor came from — 2 bits per matrix, packed into one
+// byte. Storing pointers instead of re-deriving them by comparing scores keeps
+// traceback exact under Float32 rounding and lets the score matrices collapse
+// to two rows.
+const FROM_M = 0;
+const FROM_IX = 1;
+const FROM_IY = 2;
+// Smith-Waterman only: the local alignment restarts here, so traceback stops.
+const FROM_NONE = 3;
+const M_SHIFT = 0;
+const IX_SHIFT = 2;
+const IY_SHIFT = 4;
+const readPointer = (trace, at, shift) => ((trace[at] >> shift) & 0b11);
+/**
+ * Fill the affine-gap DP tables for both algorithms; `local` switches
+ * Needleman-Wunsch (global, ends at the corner) to Smith-Waterman (restarts at
+ * 0, ends at the best-scoring cell). Only the previous and current score rows
+ * are kept — the full traceback lives in the packed `trace` byte array.
+ */
+function fillMatrices(seq1, seq2, gapOpen, gapExtend, local) {
+    const m = seq1.length;
+    const n = seq2.length;
+    assertAlignable(m, n);
+    const width = n + 1;
+    const trace = new Uint8Array((m + 1) * width);
+    // Row 0. Global: only M[0][0] is reachable and Iy[0][j] is the leading-gap
+    // base case. Local: M starts at 0 everywhere, gaps are unreachable.
+    let prevM = new Float32Array(width);
+    let prevIx = new Float32Array(width).fill(-Infinity);
+    let prevIy = new Float32Array(width).fill(-Infinity);
+    let curM = new Float32Array(width);
+    let curIx = new Float32Array(width);
+    let curIy = new Float32Array(width);
+    if (!local) {
+        prevM.fill(-Infinity);
+        prevM[0] = 0;
+        for (let j = 1; j <= n; j++) {
+            prevIy[j] = gapOpen + (j - 1) * gapExtend;
+        }
+    }
+    let bestScore = local ? 0 : -Infinity;
+    let bestI = 0;
+    let bestJ = 0;
+    let bestMatrix = FROM_M;
+    // Resolve seq2 to matrix rows once instead of once per cell.
+    const cols = new Int8Array(n);
+    for (let j = 0; j < n; j++) {
+        cols[j] = rowOf(seq2[j]);
+    }
+    for (let i = 1; i <= m; i++) {
+        // Column 0, mirroring row 0.
+        curM[0] = local ? 0 : -Infinity;
+        curIx[0] = local ? -Infinity : gapOpen + (i - 1) * gapExtend;
+        curIy[0] = -Infinity;
+        const rowBase = i * width;
+        const scoreRow = rowOf(seq1[i - 1]);
+        const scoreBase = scoreRow * N_AA;
+        for (let j = 1; j <= n; j++) {
+            const col = cols[j - 1];
+            const matchScore = scoreRow < 0 || col < 0
+                ? UNKNOWN_PAIR_SCORE
+                : BLOSUM62[scoreBase + col];
+            const dM = prevM[j - 1];
+            const dIx = prevIx[j - 1];
+            const dIy = prevIy[j - 1];
+            // Ties resolve M > Ix > Iy, matching the previous implementation.
+            const bestDiag = Math.max(dM, dIx, dIy);
+            const diagFrom = bestDiag === dM ? FROM_M : bestDiag === dIx ? FROM_IX : FROM_IY;
+            const mScore = bestDiag + matchScore;
+            const restart = local && mScore <= 0;
+            curM[j] = restart ? 0 : mScore;
+            const openIx = prevM[j] + gapOpen;
+            const extendIx = prevIx[j] + gapExtend;
+            curIx[j] = Math.max(openIx, extendIx);
+            const openIy = curM[j - 1] + gapOpen;
+            const extendIy = curIy[j - 1] + gapExtend;
+            curIy[j] = Math.max(openIy, extendIy);
+            trace[rowBase + j] =
+                ((restart ? FROM_NONE : diagFrom) << M_SHIFT) |
+                    ((openIx >= extendIx ? FROM_M : FROM_IX) << IX_SHIFT) |
+                    ((openIy >= extendIy ? FROM_M : FROM_IY) << IY_SHIFT);
+            if (local) {
+                const cellMax = Math.max(curM[j], curIx[j], curIy[j]);
+                if (cellMax > bestScore) {
+                    bestScore = cellMax;
+                    bestI = i;
+                    bestJ = j;
+                    bestMatrix =
+                        cellMax === curM[j]
+                            ? FROM_M
+                            : cellMax === curIx[j]
+                                ? FROM_IX
+                                : FROM_IY;
+                }
+            }
+        }
+        ;
+        [prevM, curM] = [curM, prevM];
+        [prevIx, curIx] = [curIx, prevIx];
+        [prevIy, curIy] = [curIy, prevIy];
+    }
+    if (local) {
+        return {
+            trace,
+            width,
+            score: bestScore,
+            startI: bestI,
+            startJ: bestJ,
+            startMatrix: bestMatrix,
+        };
+    }
+    // prev* now holds row m.
+    const finalM = prevM[n];
+    const finalIx = prevIx[n];
+    const finalIy = prevIy[n];
+    const score = Math.max(finalM, finalIx, finalIy);
+    return {
+        trace,
+        width,
+        score,
+        startI: m,
+        startJ: n,
+        startMatrix: score === finalM ? FROM_M : score === finalIx ? FROM_IX : FROM_IY,
+    };
+}
+/**
+ * Walk the packed traceback back to an edge. Rows are built back-to-front into
+ * arrays and reversed once, rather than prepending onto a string per residue
+ * (which is quadratic in the alignment length).
+ */
+function traceback(seq1, seq2, filled) {
+    const { trace, width, startI, startJ, score } = filled;
+    // Reversed: pushing here is prepending to the final string.
+    const out1 = [];
+    const out2 = [];
+    // Residues past the aligned region (the whole sequences when the local
+    // alignment is empty) hang off the end as gaps.
+    for (let k = seq1.length; k > startI; k--) {
+        out1.push(seq1[k - 1]);
+        out2.push('-');
+    }
+    for (let k = seq2.length; k > startJ; k--) {
+        out1.push('-');
+        out2.push(seq2[k - 1]);
+    }
+    let i = startI;
+    let j = startJ;
+    let matrix = filled.startMatrix;
+    while (i > 0 && j > 0) {
+        const at = i * width + j;
+        if (matrix === FROM_M) {
+            const next = readPointer(trace, at, M_SHIFT);
+            if (next === FROM_NONE) {
+                break;
+            }
+            out1.push(seq1[i - 1]);
+            out2.push(seq2[j - 1]);
+            matrix = next;
+            i--;
+            j--;
+        }
+        else if (matrix === FROM_IX) {
+            out1.push(seq1[i - 1]);
+            out2.push('-');
+            matrix = readPointer(trace, at, IX_SHIFT);
+            i--;
+        }
+        else {
+            out1.push('-');
+            out2.push(seq2[j - 1]);
+            matrix = readPointer(trace, at, IY_SHIFT);
+            j--;
+        }
+    }
+    // Whatever is left runs into an edge, so it can only be gaps.
+    while (i > 0) {
+        out1.push(seq1[i - 1]);
+        out2.push('-');
+        i--;
+    }
+    while (j > 0) {
+        out1.push('-');
+        out2.push(seq2[j - 1]);
+        j--;
+    }
+    return {
+        alignedSeq1: out1.reverse().join(''),
+        alignedSeq2: out2.reverse().join(''),
+        score,
+    };
+}
+/**
+ * Needleman-Wunsch global alignment algorithm
+ * Aligns entire sequences end-to-end
+ */
+function needlemanWunsch(seq1, seq2, gapOpen = GAP_OPEN, gapExtend = GAP_EXTEND) {
+    return traceback(seq1, seq2, fillMatrices(seq1, seq2, gapOpen, gapExtend, false));
+}
+/**
+ * Smith-Waterman local alignment algorithm
+ * Finds the best local alignment between subsequences
+ */
+function smithWaterman(seq1, seq2, gapOpen = GAP_OPEN, gapExtend = GAP_EXTEND) {
+    return traceback(seq1, seq2, fillMatrices(seq1, seq2, gapOpen, gapExtend, true));
+}
+function buildConsensus(alignedSeq1, alignedSeq2) {
+    const chars = [];
+    for (let i = 0; i < alignedSeq1.length; i++) {
+        const a = alignedSeq1[i];
+        const b = alignedSeq2[i];
+        if (a !== '-' && b !== '-' && a.toUpperCase() === b.toUpperCase()) {
+            chars.push('|');
+        }
+        else if (a !== '-' && b !== '-' && getScore(a, b) > 0) {
+            chars.push(':');
+        }
+        else {
+            chars.push(' ');
+        }
+    }
+    return chars.join('');
+}
+/** The score of a sequence aligned to itself with no gaps. */
+function selfScore(seq) {
+    let score = 0;
+    for (const c of seq) {
+        score += getScore(c, c);
+    }
+    return score;
+}
+function scoredAlignment(seq1, seq2, algorithm) {
+    const { alignedSeq1, alignedSeq2, score } = algorithm === 'smith_waterman'
+        ? smithWaterman(seq1, seq2)
+        : needlemanWunsch(seq1, seq2);
+    return {
+        alignment: {
+            consensus: buildConsensus(alignedSeq1, alignedSeq2),
+            alns: [
+                { id: 'a', seq: alignedSeq1 },
+                { id: 'b', seq: alignedSeq2 },
+            ],
+        },
+        score,
+    };
+}
+function runLocalAlignment(seq1, seq2, algorithm) {
+    return scoredAlignment(seq1, seq2, algorithm).alignment;
+}
+//# sourceMappingURL=pairwiseAlignment.js.map