repoburg 1.3.254 → 1.3.256

package/daemon/dist/tabtape/store/store.spec.js

@@ -0,0 +1,485 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const zlib_1 = __importDefault(require("zlib"));
+const errors_1 = require("../errors");
+const log_1 = require("../log");
+const tmp_1 = require("../testing/tmp");
+const record_1 = require("./record");
+const segment_1 = require("./segment");
+const store_1 = require("./store");
+const stores = [];
+function openWith(opts) {
+    const s = store_1.Store.open({ ...opts, logger: log_1.silentLogger });
+    stores.push(s);
+    return s;
+}
+function openStore(dir, maxBytes, segmentBytes) {
+    return openWith({ dir, maxBytes, segmentBytes });
+}
+afterEach(async () => {
+    while (stores.length)
+        await stores.pop().close();
+    (0, tmp_1.cleanupTempDirs)();
+});
+function rec(ts, type, data) {
+    return (0, record_1.parseRecord)(`{"ts":${ts},"type":${JSON.stringify(type)},"data":${data}}`);
+}
+/** A record whose stored line is roughly n bytes long. */
+function padded(ts, n) {
+    return rec(ts, 'rrweb', `{"type":3,"pad":${JSON.stringify('x'.repeat(n))}}`);
+}
+async function stream(s, id) {
+    const parts = [];
+    await s.writeSession(id, (chunk) => {
+        parts.push(Buffer.from(chunk));
+    });
+    return Buffer.concat(parts);
+}
+async function readLines(s, id) {
+    const text = (await stream(s, id)).toString('utf8');
+    return text
+        .split('\n')
+        .filter(Boolean)
+        .map((l) => JSON.parse(l));
+}
+const tsList = (lines) => lines.map((l) => l.ts);
+function segmentFiles(dir, id) {
+    const out = { jsonl: [], gz: [], tmp: [] };
+    for (const name of fs_1.default.readdirSync(path_1.default.join(dir, 'sessions', id)).sort()) {
+        if (name.endsWith('.jsonl.gz.tmp'))
+            out.tmp.push(name);
+        else if (name.endsWith('.jsonl.gz'))
+            out.gz.push(name);
+        else if (name.endsWith('.jsonl'))
+            out.jsonl.push(name);
+    }
+    return out;
+}
+function fill(s, id, from, n, size) {
+    for (let i = 0; i < n; i++)
+        s.append(id, [padded(from + i, size)]);
+}
+describe('parseRecord', () => {
+    const cases = [
+        { name: 'valid', in: '{"ts":1,"type":"rrweb","data":{"type":2}}', ts: 1, type: 'rrweb' },
+        { name: 'fractional ts is rounded', in: '{"ts":1.6,"type":"network","data":{}}', ts: 2, type: 'network' },
+        { name: 'surrounding whitespace', in: '  {"ts": 5, "type": "event"}\r\n', ts: 5, type: 'event' },
+        { name: 'missing ts', in: '{"type":"rrweb"}', err: true },
+        { name: 'missing type', in: '{"ts":1}', err: true },
+        { name: 'sid is reserved', in: '{"sid":"x","ts":1,"type":"rrweb"}', err: true },
+        { name: 'not an object', in: '[1,2]', err: true },
+        { name: 'invalid json', in: '{"ts":1,"type":', err: true },
+        { name: 'empty', in: '', err: true },
+        { name: 'ts must be a number', in: '{"ts":"1","type":"x"}', err: true },
+        {
+            name: 'odd data shapes do not reject the record',
+            in: '{"ts":1,"type":"event","data":{"type":"x","status":"200","name":7}}',
+            ts: 1,
+            type: 'event',
+        },
+    ];
+    for (const c of cases) {
+        it(c.name, () => {
+            if (c.err) {
+                expect(() => (0, record_1.parseRecord)(c.in)).toThrow();
+                return;
+            }
+            const r = (0, record_1.parseRecord)(c.in);
+            expect([r.ts, r.type]).toEqual([c.ts, c.type]);
+        });
+    }
+    it('stores compact JSON', () => {
+        expect((0, record_1.parseRecord)('{ "ts" : 1, "type" : "x", "data" : { "a" : [1, 2] } }').raw).toBe('{"ts":1,"type":"x","data":{"a":[1,2]}}');
+    });
+});
+describe('readRecords', () => {
+    it('ignores blank lines and names the bad line', () => {
+        const recs = (0, record_1.readRecords)('{"ts":1,"type":"a"}\r\n\n{"ts":2,"type":"b"}');
+        expect(recs.map((r) => r.ts)).toEqual([1, 2]);
+        expect(() => (0, record_1.readRecords)('{"ts":1,"type":"a"}\nnope\n')).toThrow(/line 2/);
+    });
+});
+describe('Store', () => {
+    it('appends and reads back', async () => {
+        const s = openStore((0, tmp_1.tempDir)(), 1 << 20, 1 << 16);
+        s.start({ id: 's1', startedAt: 100, url: 'https://example.com/', title: 'Example' });
+        s.append('s1', [rec(101, 'rrweb', '{"type":4,"data":{"width":800}}'), rec(102, 'network', '{"url":"https://example.com/api","status":200}')]);
+        s.append('s1', [rec(103, 'console', '{"level":"log","text":"hi"}')]);
+        const lines = await readLines(s, 's1');
+        expect(tsList(lines)).toEqual([101, 102, 103]);
+        for (const l of lines)
+            expect(l.sid).toBe('s1');
+        expect(JSON.stringify(lines[1].data)).toBe('{"url":"https://example.com/api","status":200}');
+        const sess = s.get('s1');
+        expect([sess.url, sess.title, sess.startedAt]).toEqual(['https://example.com/', 'Example', 100]);
+        expect([sess.counts.total, sess.firstTs, sess.lastTs]).toEqual([3, 101, 103]);
+        expect(sess.bytes).toBeGreaterThan(0);
+        expect(sess.segments).toBe(1);
+    });
+    it('creates unknown sessions on append', () => {
+        const s = openStore((0, tmp_1.tempDir)(), 1 << 20, 1 << 16);
+        s.append('late', [rec(42, 'rrweb', '{"type":4}')]);
+        expect(s.get('late').startedAt).toBe(42);
+    });
+    it('rotates segments by size', async () => {
+        const dir = (0, tmp_1.tempDir)();
+        const s = openStore(dir, 1 << 20, 300);
+        for (let i = 0; i < 10; i++)
+            s.append('s1', [padded(i, 100)]);
+        expect(segmentFiles(dir, 's1').jsonl.length).toBeGreaterThanOrEqual(3);
+        expect(tsList(await readLines(s, 's1'))).toEqual([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);
+    });
+    it('evicts the oldest data first', async () => {
+        const maxBytes = 2000;
+        const s = openStore((0, tmp_1.tempDir)(), maxBytes, 400);
+        // ~160 bytes per line: each session fits the cap alone, both together do not.
+        for (let i = 0; i < 10; i++)
+            s.append('a', [padded(i, 100)]);
+        for (let i = 0; i < 10; i++)
+            s.append('b', [padded(100 + i, 100)]);
+        expect(s.stats().totalBytes).toBeLessThanOrEqual(maxBytes);
+        expect(s.get('b').truncated).toBeUndefined();
+        expect((await readLines(s, 'b')).length).toBe(10);
+        if (!s.has('a'))
+            return; // fully evicted is acceptable
+        expect(s.get('a').truncated).toBe(true);
+        const got = tsList(await readLines(s, 'a'));
+        expect(got.length).toBeGreaterThan(0);
+        expect(got.length).toBeLessThan(10);
+        expect(got[got.length - 1]).toBe(9);
+    });
+    it('removes fully evicted sessions', () => {
+        const dir = (0, tmp_1.tempDir)();
+        const s = openStore(dir, 1500, 300);
+        s.append('old', [padded(1, 100)]);
+        for (let i = 0; i < 20; i++)
+            s.append('new', [padded(10 + i, 100)]);
+        expect(() => s.get('old')).toThrow(errors_1.NotFoundError);
+        expect(fs_1.default.existsSync(path_1.default.join(dir, 'sessions', 'old'))).toBe(false);
+        expect(s.list().some((x) => x.id === 'old')).toBe(false);
+    });
+    it('never evicts the segment being written', async () => {
+        const s = openStore((0, tmp_1.tempDir)(), 200, 100);
+        s.append('s1', [padded(1, 500)]);
+        expect(tsList(await readLines(s, 's1'))).toEqual([1]);
+        s.append('s1', [padded(2, 500)]);
+        expect(tsList(await readLines(s, 's1'))).toEqual([2]);
+    });
+    it('restores sessions on reopen', async () => {
+        const dir = (0, tmp_1.tempDir)();
+        const s1 = store_1.Store.open({ dir, maxBytes: 1 << 20, segmentBytes: 1 << 16, logger: log_1.silentLogger });
+        s1.start({ id: 's1', startedAt: 5, url: 'https://a.test/' });
+        s1.append('s1', [rec(6, 'event', '{"name":"click"}'), rec(7, 'console', '{"level":"error"}')]);
+        s1.end('s1', 8);
+        const before = s1.get('s1');
+        await s1.close();
+        const s2 = openStore(dir, 1 << 20, 1 << 16);
+        const after = s2.get('s1');
+        expect(after.counts).toEqual(before.counts);
+        expect([after.endedAt, after.url, after.bytes]).toEqual([8, 'https://a.test/', before.bytes]);
+        expect(s2.stats().totalBytes).toBe(before.bytes);
+        s2.append('s1', [rec(9, 'event', '{"name":"click"}')]);
+        expect(segmentFiles(dir, 's1').jsonl.length).toBe(2);
+        expect(tsList(await readLines(s2, 's1'))).toEqual([6, 7, 9]);
+    });
+    it('repairs a partial tail on open', async () => {
+        const dir = (0, tmp_1.tempDir)();
+        const s1 = store_1.Store.open({ dir, maxBytes: 1 << 20, segmentBytes: 1 << 16, logger: log_1.silentLogger });
+        s1.append('s1', [rec(1, 'rrweb', '{}'), rec(2, 'rrweb', '{}')]);
+        await s1.close();
+        const files = segmentFiles(dir, 's1').jsonl;
+        expect(files.length).toBe(1);
+        fs_1.default.appendFileSync(path_1.default.join(dir, 'sessions', 's1', files[0]), '{"sid":"s1","ts":3,"type":"rr');
+        const s2 = openStore(dir, 1 << 20, 1 << 16);
+        expect(tsList(await readLines(s2, 's1'))).toEqual([1, 2]);
+    });
+    it('enforces a smaller budget on open', async () => {
+        const dir = (0, tmp_1.tempDir)();
+        const s1 = store_1.Store.open({ dir, maxBytes: 1 << 20, segmentBytes: 200, logger: log_1.silentLogger });
+        for (let i = 0; i < 20; i++)
+            s1.append('s1', [padded(i, 100)]);
+        await s1.close();
+        const s2 = openStore(dir, 600, 200);
+        expect(s2.stats().totalBytes).toBeLessThanOrEqual(600);
+        const got = tsList(await readLines(s2, 's1'));
+        expect(got.length).toBeGreaterThan(0);
+        expect(got[got.length - 1]).toBe(19);
+    });
+    it('counts what a session contains', () => {
+        const s = openStore((0, tmp_1.tempDir)(), 1 << 20, 1 << 16);
+        s.append('s1', [
+            rec(1, 'rrweb', '{"type":4,"data":{}}'),
+            rec(1, 'rrweb', '{"type":2,"data":{}}'),
+            rec(2, 'rrweb', '{"type":3,"data":{}}'),
+            rec(3, 'event', '{"name":"page_view","url":"https://a.test/","title":"A"}'),
+            rec(4, 'event', '{"name":"click","url":"https://a.test/"}'),
+            rec(5, 'event', '{"name":"page_view","url":"https://a.test/b","title":"B"}'),
+            rec(6, 'console', '{"level":"error","text":"boom"}'),
+            rec(7, 'console', '{"level":"log","text":"ok"}'),
+            rec(8, 'network', '{"status":500}'),
+            rec(9, 'network', '{"status":200}'),
+            rec(10, 'network', '{"status":0,"error":"Failed to fetch"}'),
+        ]);
+        const sess = s.get('s1');
+        expect(sess.counts).toEqual({
+            total: 11,
+            rrweb: 3,
+            network: 3,
+            console: 2,
+            events: 3,
+            snapshots: 1,
+            pages: 2,
+            clicks: 1,
+            errors: 1,
+            netErrors: 2,
+        });
+        expect([sess.url, sess.title, sess.lastUrl]).toEqual(['https://a.test/', 'A', 'https://a.test/b']);
+    });
+    it('ends and deletes sessions', async () => {
+        const dir = (0, tmp_1.tempDir)();
+        const s = openStore(dir, 1 << 20, 1 << 16);
+        s.append('s1', [rec(1, 'rrweb', '{}')]);
+        expect(s.end('s1', 99).endedAt).toBe(99);
+        s.delete('s1');
+        await expect(stream(s, 's1')).rejects.toThrow(errors_1.NotFoundError);
+        expect([s.stats().totalBytes, s.stats().sessions]).toEqual([0, 0]);
+        expect(fs_1.default.existsSync(path_1.default.join(dir, 'sessions', 's1'))).toBe(false);
+        expect(() => s.delete('s1')).toThrow(errors_1.NotFoundError);
+        expect(() => s.end('missing', 1)).toThrow(errors_1.NotFoundError);
+    });
+    it('rejects unsafe ids', () => {
+        const s = openStore((0, tmp_1.tempDir)(), 1 << 20, 1 << 16);
+        for (const id of ['', '../x', 'a/b', '.hidden', 'a'.repeat(65), 'a\n']) {
+            expect(() => s.append(id, [rec(1, 'rrweb', '{}')])).toThrow(errors_1.InvalidIDError);
+            expect(() => s.start({ id })).toThrow(errors_1.InvalidIDError);
+        }
+    });
+    it('lists newest first', () => {
+        const s = openStore((0, tmp_1.tempDir)(), 1 << 20, 1 << 16);
+        for (const st of [
+            { id: 'a', startedAt: 1 },
+            { id: 'c', startedAt: 3 },
+            { id: 'b', startedAt: 2 },
+        ]) {
+            s.start(st);
+        }
+        expect(s.list().map((x) => x.id)).toEqual(['c', 'b', 'a']);
+    });
+    it('never yields torn lines while appends and evictions run', async () => {
+        const maxBytes = 20000;
+        const s = openStore((0, tmp_1.tempDir)(), maxBytes, 2000);
+        const recs = Array.from({ length: 50 }, (_, i) => padded(i, 80));
+        const writers = [0, 1, 2, 3].map(async (w) => {
+            for (const r of recs) {
+                s.append(`s${w}`, [r]);
+                await new Promise((resolve) => setImmediate(resolve));
+            }
+        });
+        const readers = [0, 1].map(async () => {
+            for (let i = 0; i < 20; i++) {
+                for (const sess of s.list()) {
+                    let text;
+                    try {
+                        text = (await stream(s, sess.id)).toString('utf8');
+                    }
+                    catch (err) {
+                        if (err instanceof errors_1.NotFoundError)
+                            continue;
+                        throw err;
+                    }
+                    for (const line of text.split('\n').filter(Boolean))
+                        expect(() => JSON.parse(line)).not.toThrow();
+                }
+            }
+        });
+        await Promise.all([...writers, ...readers]);
+        expect(s.stats().totalBytes).toBeLessThanOrEqual(maxBytes);
+    });
+    it('notifies watchers of appends, ends and deletes', async () => {
+        const s = openStore((0, tmp_1.tempDir)(), 1 << 20, 1 << 10);
+        expect(() => s.watch('nope')).toThrow(errors_1.NotFoundError);
+        s.append('a', [rec(1, 'event', '{}')]);
+        const settled = async (p) => {
+            let done = false;
+            void p.then(() => (done = true));
+            await new Promise((r) => setImmediate(r));
+            return done;
+        };
+        let w = s.watch('a');
+        expect(await settled(w)).toBe(false);
+        s.append('a', [rec(2, 'event', '{}')]);
+        expect(await settled(w)).toBe(true);
+        w = s.watch('a');
+        s.end('a', 0);
+        expect(await settled(w)).toBe(true);
+        w = s.watch('a');
+        s.delete('a');
+        expect(await settled(w)).toBe(true);
+    });
+    it('keeps the user id and the worst vitals rating', () => {
+        const s = openStore((0, tmp_1.tempDir)(), 1 << 20, 1 << 10);
+        s.append('a', [
+            rec(1, 'event', '{"name":"identify","userId":"u_1"}'),
+            rec(2, 'perf', '{"kind":"vital","name":"LCP","rating":"needs-improvement"}'),
+            rec(3, 'perf', '{"kind":"vital","name":"CLS","rating":"good"}'),
+            rec(4, 'perf', '{"kind":"loaf","rating":"poor"}'),
+            rec(5, 'event', '{"name":"identify","userId":"u_2"}'),
+            rec(6, 'event', '{"name":"identify"}'),
+        ]);
+        const sess = s.get('a');
+        expect([sess.userId, sess.perf]).toEqual(['u_2', 'needs-improvement']);
+    });
+});
+describe('Store compression', () => {
+    it('is off by default', () => {
+        const dir = (0, tmp_1.tempDir)();
+        const s = openWith({ dir, maxBytes: 1 << 20, segmentBytes: 1 << 10 });
+        fill(s, 'a', 0, 20, 300);
+        s.end('a', 0);
+        const files = segmentFiles(dir, 'a');
+        expect(files.gz.length).toBe(0);
+        expect(files.jsonl.length).toBeGreaterThanOrEqual(2);
+        const st = s.stats();
+        expect(st.compress).toBe(store_1.COMPRESS_OFF);
+        expect(st.totalBytes).toBe(st.rawBytes);
+    });
+    it('rejects unknown modes', () => {
+        expect(() => store_1.Store.open({ dir: (0, tmp_1.tempDir)(), maxBytes: 1 << 20, segmentBytes: 1 << 10, compress: 'zstd', logger: log_1.silentLogger })).toThrow();
+    });
+    it('compresses closed segments', async () => {
+        const dir = (0, tmp_1.tempDir)();
+        const s = openWith({ dir, maxBytes: 1 << 20, segmentBytes: 1 << 10, compress: store_1.COMPRESS_GZIP });
+        fill(s, 'a', 0, 20, 300);
+        const before = await stream(s, 'a');
+        // Rotated segments are closed; the last one is still being written.
+        await (0, tmp_1.eventually)('rotated segments to be compressed', () => {
+            const f = segmentFiles(dir, 'a');
+            return f.jsonl.length === 1 && f.gz.length >= 2;
+        });
+        expect((await stream(s, 'a')).equals(before)).toBe(true);
+        s.end('a', 0);
+        await (0, tmp_1.eventually)("the ended session's last segment to be compressed", () => {
+            const f = segmentFiles(dir, 'a');
+            return f.jsonl.length === 0 && f.tmp.length === 0;
+        });
+        expect((await stream(s, 'a')).equals(before)).toBe(true);
+        const sess = s.get('a');
+        expect(sess.rawBytes).toBe(before.length);
+        expect(sess.bytes).toBeLessThan(sess.rawBytes);
+        const st = s.stats();
+        expect([st.rawBytes, st.totalBytes]).toEqual([before.length, sess.bytes]);
+        // Appending to an ended session opens a new plain segment.
+        s.append('a', [padded(100, 10)]);
+        expect(segmentFiles(dir, 'a').jsonl.length).toBe(1);
+    });
+    it('lets readers survive compression', async () => {
+        const dir = (0, tmp_1.tempDir)();
+        const s = openWith({ dir, maxBytes: 1 << 20, segmentBytes: 64 << 10, compress: store_1.COMPRESS_GZIP });
+        fill(s, 'a', 0, 10, 300); // the segment is compressed only once it closes
+        const { segments } = s.snapshot('a');
+        expect(segments.length).toBe(1);
+        const seg = segments[0];
+        // A reader that opened the plain file before compression keeps reading it.
+        const early = (0, segment_1.readSegment)(seg.path, 0, seg.size);
+        const first = await early.next();
+        expect(first.done).toBe(false);
+        s.end('a', 0);
+        await (0, tmp_1.eventually)('compression', () => segmentFiles(dir, 'a').gz.length === 1);
+        const parts = [first.value];
+        for await (const chunk of early)
+            parts.push(chunk);
+        const want = await stream(s, 'a');
+        expect(Buffer.concat(parts).equals(want)).toBe(true);
+        // The stale plain path from the snapshot still opens, at any offset.
+        for (const off of [0, 1, 500, seg.size - 1]) {
+            const got = [];
+            for await (const chunk of (0, segment_1.readSegment)(seg.path, off, seg.size - off))
+                got.push(chunk);
+            expect(Buffer.concat(got).equals(want.subarray(off))).toBe(true);
+        }
+    });
+    it('finishes an interrupted compression on open', async () => {
+        const dir = (0, tmp_1.tempDir)();
+        const sdir = path_1.default.join(dir, 'sessions', 'a');
+        fs_1.default.mkdirSync(sdir, { recursive: true });
+        const seg1 = Buffer.from('{"sid":"a","ts":1,"type":"event","data":{}}\n');
+        const seg2 = Buffer.from('{"sid":"a","ts":2,"type":"event","data":{}}\n');
+        // Crash after the rename, before the plain file was deleted.
+        fs_1.default.writeFileSync(path_1.default.join(sdir, '0000000000000001.jsonl'), seg1);
+        fs_1.default.writeFileSync(path_1.default.join(sdir, '0000000000000001.jsonl.gz'), zlib_1.default.gzipSync(seg1));
+        // Crash while writing the temporary file.
+        fs_1.default.writeFileSync(path_1.default.join(sdir, '0000000000000002.jsonl'), seg2);
+        fs_1.default.writeFileSync(path_1.default.join(sdir, '0000000000000002.jsonl.gz.tmp'), zlib_1.default.gzipSync(seg2).subarray(0, 10));
+        const s = openWith({ dir, maxBytes: 1 << 20, segmentBytes: 1 << 10 });
+        expect(segmentFiles(dir, 'a')).toEqual({ gz: ['0000000000000001.jsonl.gz'], jsonl: ['0000000000000002.jsonl'], tmp: [] });
+        expect((await stream(s, 'a')).equals(Buffer.concat([seg1, seg2]))).toBe(true);
+        expect(s.get('a').rawBytes).toBe(seg1.length + seg2.length);
+    });
+    it('can be turned on and off', async () => {
+        const dir = (0, tmp_1.tempDir)();
+        const base = { dir, maxBytes: 1 << 20, segmentBytes: 1 << 10, logger: log_1.silentLogger };
+        let s = store_1.Store.open(base);
+        fill(s, 'a', 0, 10, 300);
+        const want = await stream(s, 'a');
+        await s.close();
+        // Turned on: existing segments are compressed in the background.
+        s = store_1.Store.open({ ...base, compress: store_1.COMPRESS_GZIP });
+        await (0, tmp_1.eventually)('old segments to be compressed', () => {
+            const f = segmentFiles(dir, 'a');
+            return f.jsonl.length === 0 && f.gz.length > 0;
+        });
+        await s.close();
+        // Turned off: compressed segments are still read, new ones stay plain.
+        s = openWith({ dir, maxBytes: 1 << 20, segmentBytes: 1 << 10, compress: '' });
+        expect((await stream(s, 'a')).equals(want)).toBe(true);
+        s.append('a', [padded(100, 2000)]);
+        s.end('a', 0);
+        expect(segmentFiles(dir, 'a').jsonl.length).toBe(1);
+    });
+    it('counts the compressed size against the cap', async () => {
+        const run = async (compress) => {
+            const dir = (0, tmp_1.tempDir)();
+            const s = openWith({ dir, maxBytes: 20 << 10, segmentBytes: 2 << 10, compress });
+            for (let i = 0; i < 100; i++) {
+                const id = 's' + String.fromCharCode(97 + (i % 26)) + String.fromCharCode(97 + Math.floor(i / 26));
+                fill(s, id, i * 10, 4, 500);
+                s.end(id, 0);
+                if (compress) {
+                    // Let the worker keep up, like a real recording that is slower than gzip.
+                    await (0, tmp_1.eventually)('compression', () => {
+                        if (!s.has(id))
+                            return true;
+                        const f = segmentFiles(dir, id);
+                        return f.jsonl.length === 0 && f.tmp.length === 0;
+                    });
+                }
+            }
+            const st = s.stats();
+            return { kept: s.list().length, total: st.totalBytes, max: st.maxBytes };
+        };
+        const plain = await run('');
+        const gz = await run(store_1.COMPRESS_GZIP);
+        expect(plain.total).toBeLessThanOrEqual(plain.max);
+        expect(gz.total).toBeLessThanOrEqual(gz.max);
+        expect(gz.kept).toBeGreaterThanOrEqual(3 * plain.kept);
+    });
+    it('abandons the compression of a deleted segment', async () => {
+        const s = openWith({ dir: (0, tmp_1.tempDir)(), maxBytes: 1 << 20, segmentBytes: 1 << 10 });
+        const recs = Array.from({ length: 5 }, (_, i) => rec(i + 1, 'event', `{"pad":"${'x'.repeat(100)}"}`));
+        s.append('a', recs);
+        s.end('a', 0);
+        // Reach into the store: evict the segment while its compression runs.
+        const internals = s;
+        const seg = internals.sessions.get('a').segs[0];
+        seg.dropped = true;
+        await internals.compressSegment(seg);
+        expect(fs_1.default.existsSync(seg.path + '.gz.tmp')).toBe(false);
+        expect(fs_1.default.existsSync(seg.path + '.gz')).toBe(false);
+        expect([seg.gz, seg.broken]).toEqual([false, false]);
+    });
+});

package/daemon/dist/tabtape/testing/querytest.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stateRec = exports.ws = exports.loaf = exports.vital = exports.identify = exports.track = exports.consoleRec = exports.net = exports.submit = exports.change = exports.click = exports.pageView = exports.rrInc = exports.rrFull = exports.rrMeta = exports.UA = exports.T0 = void 0;
+exports.testStore = testStore;
+exports.closeTestStores = closeTestStores;
+exports.append = append;
+exports.start = start;
+/** Builds recorded sessions for tests, the way the extension posts them. */
+const log_1 = require("../log");
+const record_1 = require("../store/record");
+const store_1 = require("../store/store");
+const tmp_1 = require("./tmp");
+exports.T0 = 1759650432000;
+exports.UA = 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/141.0.0.0 Safari/537.36';
+const open = [];
+/** An empty store in a temporary directory; closed by closeTestStores(). */
+function testStore(opts = {}) {
+    const st = store_1.Store.open({ dir: (0, tmp_1.tempDir)(), maxBytes: 64 << 20, segmentBytes: 16 << 20, logger: log_1.silentLogger, ...opts });
+    open.push(st);
+    return st;
+}
+async function closeTestStores() {
+    while (open.length)
+        await open.pop().close();
+}
+/** Appends records like the extension posts them (key order ts, type, data). */
+function append(st, id, ...recs) {
+    st.append(id, recs.map((r) => (0, record_1.parseRecord)(`{"ts":${JSON.stringify(r.ts)},"type":${JSON.stringify(r.type)},"data":${JSON.stringify(r.data)}}`)));
+}
+/** Announces a session like the extension does. */
+function start(st, id, startedAt, url, title) {
+    st.start({ id, startedAt, url, title, userAgent: exports.UA });
+}
+const rrMeta = (ts, href, w, h) => ({
+    ts,
+    type: 'rrweb',
+    data: { type: 4, data: { href, width: w, height: h }, timestamp: ts },
+});
+exports.rrMeta = rrMeta;
+/** A (tiny) rrweb full snapshot. */
+const rrFull = (ts) => ({
+    ts,
+    type: 'rrweb',
+    data: { type: 2, data: { node: { type: 0, childNodes: [], id: 1 }, initialOffset: { left: 0, top: 0 } }, timestamp: ts },
+});
+exports.rrFull = rrFull;
+/** An rrweb incremental snapshot (a mouse move). */
+const rrInc = (ts) => ({
+    ts,
+    type: 'rrweb',
+    data: { type: 3, data: { source: 1, positions: [{ x: 1, y: 2, id: 1, timeOffset: 0 }] }, timestamp: ts },
+});
+exports.rrInc = rrInc;
+const pageView = (ts, kind, url, title) => ({
+    ts,
+    type: 'event',
+    data: { name: 'page_view', kind, url, title, viewport: { w: 1440, h: 900 } },
+});
+exports.pageView = pageView;
+const click = (ts, url, target) => ({
+    ts,
+    type: 'event',
+    data: { name: 'click', url, target, x: 10, y: 20 },
+});
+exports.click = click;
+/** A change event; masked hides the value. */
+const change = (ts, url, target, value, masked = false) => ({
+    ts,
+    type: 'event',
+    data: masked ? { name: 'change', url, target, masked: true } : { name: 'change', url, target, value },
+});
+exports.change = change;
+const submit = (ts, url, target) => ({
+    ts,
+    type: 'event',
+    data: { name: 'submit', url, target, method: 'POST' },
+});
+exports.submit = submit;
+const net = (ts, n) => ({ ts, type: 'network', data: n });
+exports.net = net;
+const consoleRec = (ts, c) => ({ ts, type: 'console', data: c });
+exports.consoleRec = consoleRec;
+/** A tabtape.track() event. */
+const track = (ts, url, event, props) => ({
+    ts,
+    type: 'event',
+    data: props ? { name: 'custom', url, event, props } : { name: 'custom', url, event },
+});
+exports.track = track;
+/** A tabtape.identify() event. */
+const identify = (ts, url, userId) => ({
+    ts,
+    type: 'event',
+    data: { name: 'identify', url, userId },
+});
+exports.identify = identify;
+/** A Web Vitals report. */
+const vital = (ts, name, value, rating, attribution) => ({
+    ts,
+    type: 'perf',
+    data: { kind: 'vital', name, value, rating, id: `v5-${name}`, ...(attribution ? { attribution } : {}) },
+});
+exports.vital = vital;
+/** A long animation frame starting at ts. */
+const loaf = (ts, duration, ...scripts) => ({
+    ts,
+    type: 'perf',
+    data: { kind: 'loaf', duration, blockingDuration: Math.max(duration - 50, 0), ...(scripts.length ? { scripts } : {}) },
+});
+exports.loaf = loaf;
+/** A WebSocket message of connection conn. */
+const ws = (ts, conn, dir, data) => ({
+    ts,
+    type: 'ws',
+    data: { conn, dir, opcode: 1, size: Buffer.byteLength(data), data },
+});
+exports.ws = ws;
+const stateRec = (ts, s) => ({ ts, type: 'state', data: s });
+exports.stateRec = stateRec;

package/daemon/dist/tabtape/testing/tmp.js

@@ -0,0 +1,33 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tempDir = tempDir;
+exports.cleanupTempDirs = cleanupTempDirs;
+exports.eventually = eventually;
+/** Temporary directories for tests, removed by cleanupTempDirs(). */
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const dirs = [];
+function tempDir(prefix = 'tabtape-test-') {
+    const dir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), prefix));
+    dirs.push(dir);
+    return dir;
+}
+function cleanupTempDirs() {
+    while (dirs.length) {
+        const dir = dirs.pop();
+        fs_1.default.rmSync(dir, { recursive: true, force: true });
+    }
+}
+/** Polls cond until it holds; background work (compression) needs a moment. */
+async function eventually(what, cond, timeoutMs = 5000) {
+    const deadline = Date.now() + timeoutMs;
+    while (!(await cond())) {
+        if (Date.now() > deadline)
+            throw new Error(`timed out waiting for ${what}`);
+        await new Promise((r) => setTimeout(r, 5));
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "repoburg",
-  "version": "1.3.254",
+  "version": "1.3.256",
   "description": "A local AI-powered software developer assistant that runs on your own machine.",
   "author": "Celal Ertug",
   "license": "SEE LICENSE IN LICENSE",
@@ -36,9 +36,10 @@
     "dev:daemon": "npm run dev -w daemon",
     "daemon:pane": "(cd agent-pane/backend && npm run build) && (cd agent-pane/frontend && npm run build) && npm run dev:daemon",
     "dev:agent-pane": "concurrently -n backend,frontend -c blue,green \"cd agent-pane/backend && npm run dev\" \"cd agent-pane/frontend && npm run dev\"",
+    "dev:tabtape": "cd tabtape && npm run dev -w ui",
     "jaeger:start": "docker run -d --rm --name jaeger -e COLLECTOR_OTLP_ENABLED=true -p 16686:16686 -p 4318:4318 jaegertracing/all-in-one:latest",
     "jaeger:stop": "docker stop jaeger",
-    "lo:build": "npm run build -w backend && npm run build -w website2 && (cd agent-pane/backend && npm run build) && (cd agent-pane/frontend && npm run build) && npm run build -w recorder && npm run build -w daemon &&  cd frontend && npm run build",
+    "lo:build": "npm run build -w backend && npm run build -w website2 && (cd agent-pane/backend && npm run build) && (cd agent-pane/frontend && npm run build) && npm run build -w recorder && (cd tabtape && npm run build) && npm run build -w daemon &&  cd frontend && npm run build",
     "lo:publish": "npm publish",
     "release": "npm version patch --no-git-tag-version && npm publish"
   },