Resolving a Production Stack Trace Against a Source Map

// Minimal source-map resolver: VLQ decode + binary search by generated col.
// Source maps use base64 VLQ. This is the 30-line version we ship in CI.

const B64 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
const B64IDX = Object.fromEntries([...B64].map((c, i) => [c, i]));

function decodeVlq(str) {
    const out = [];
    let i = 0;
    while (i < str.length) {
        let value = 0, shift = 0, cont = 1;
        while (cont) {
            const d = B64IDX[str[i++]];
            cont = d & 32;
            value |= (d & 31) << shift;
            shift += 5;
        }
        const sign = value & 1;
        value >>= 1;
        out.push(sign ? -value : value);
    }
    return out;
}

function parseMappings(mappingsField, sources, names) {
    const lines = mappingsField.split(';');
    let srcIdx = 0, srcLine = 0, srcCol = 0, nameIdx = 0;
    return lines.map((line, generatedLine) => {
        let genCol = 0;
        return line.split(',').filter(Boolean).map((seg) => {
            const fields = decodeVlq(seg);
            genCol += fields[0];
            const result = { generatedLine, generatedColumn: genCol };
            if (fields.length >= 4) {
                srcIdx += fields[1];
                srcLine += fields[2];
                srcCol += fields[3];
                result.source = sources[srcIdx];
                result.originalLine = srcLine;
                result.originalColumn = srcCol;
                if (fields.length === 5) {
                    nameIdx += fields[4];
                    result.name = names[nameIdx];
                }
            }
            return result;
        });
    });
}

// Demo: map a one-line bundle back to source.
const sourceMap = {
    version: 3,
    sources: ['src/handler.ts'],
    names: ['handle'],
    mappings: 'AAAA,SAASA,EAAS,GAAS,OAAO,EAAI,EAAI,CAAC',
};
const lines = parseMappings(sourceMap.mappings, sourceMap.sources, sourceMap.names);
console.log('Segments on line 0:', lines[0].length);
console.log('First mapping:', lines[0][0]);
console.log('Function name segment:', lines[0].find((s) => s.name));

// Resolve a single "at file.js:LINE:COL" frame against decoded segments.
// Pre-decoded `lines` array comes from accordion 1. Re-run that decoder here.

const B64 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
const B64IDX = Object.fromEntries([...B64].map((c, i) => [c, i]));
function decodeVlq(str) {
    const out = []; let i = 0;
    while (i < str.length) {
        let value = 0, shift = 0, cont = 1;
        while (cont) {
            const d = B64IDX[str[i++]];
            cont = d & 32;
            value |= (d & 31) << shift;
            shift += 5;
        }
        const sign = value & 1;
        value >>= 1;
        out.push(sign ? -value : value);
    }
    return out;
}
function parseMappings(mappings, sources, names) {
    const out = mappings.split(';');
    let srcIdx = 0, srcLine = 0, srcCol = 0, nameIdx = 0;
    return out.map((line, gl) => {
        let gc = 0;
        return line.split(',').filter(Boolean).map((seg) => {
            const f = decodeVlq(seg);
            gc += f[0];
            const r = { generatedLine: gl, generatedColumn: gc };
            if (f.length >= 4) {
                srcIdx += f[1]; srcLine += f[2]; srcCol += f[3];
                r.source = sources[srcIdx];
                r.originalLine = srcLine;
                r.originalColumn = srcCol;
                if (f.length === 5) { nameIdx += f[4]; r.name = names[nameIdx]; }
            }
            return r;
        });
    });
}

function resolveFrame(decoded, line, column) {
    const segs = decoded[line] || [];
    let lo = 0, hi = segs.length - 1, best = null;
    while (lo <= hi) {
        const mid = (lo + hi) >> 1;
        if (segs[mid].generatedColumn <= column) {
            best = segs[mid];
            lo = mid + 1;
        } else {
            hi = mid - 1;
        }
    }
    return best;
}

const sm = {
    sources: ['src/handler.ts'],
    names: ['handle'],
    mappings: 'AAAA,SAASA,EAAS,GAAS,OAAO,EAAI,EAAI,CAAC',
};
const decoded = parseMappings(sm.mappings, sm.sources, sm.names);
const frame = resolveFrame(decoded, 0, 12);
console.log('Bundle 0:12 ->', frame);

// Walk a Node stack string and rewrite each frame with its source position.
// The regex covers "at fn (file:LINE:COL)" and "at file:LINE:COL".

const FRAME = /^\s*at\s+(?:(.+?)\s+\()?([^():]+):(\d+):(\d+)\)?\s*$/;

function rewriteStack(stackText, resolver) {
    return stackText.split('\n').map((line) => {
        const m = FRAME.exec(line);
        if (!m) return line;
        const [, fn, file, lineStr, colStr] = m;
        const original = resolver(file, parseInt(lineStr, 10), parseInt(colStr, 10));
        if (!original) return line;
        const fnLabel = fn ? `${fn} ` : '';
        return `    at ${fnLabel}(${original.source}:${original.originalLine + 1}:${original.originalColumn + 1})`;
    }).join('\n');
}

// Stub resolver returns a fixed mapping for /app/dist/bundle.js
function resolver(file, line, col) {
    if (!file.endsWith('bundle.js')) return null;
    if (line === 1 && col >= 100 && col <= 200) {
        return { source: 'src/handler.ts', originalLine: 41, originalColumn: 4 };
    }
    return null;
}

const stack = `Error: payment_failed
    at processPayment (/app/dist/bundle.js:1:140)
    at /app/dist/bundle.js:1:180
    at processTicksAndRejections (node:internal/process/task_queues:96:5)`;

console.log(rewriteStack(stack, resolver));