repoburg 1.3.255 → 1.3.256

package/daemon/dist/tabtape/api/ws.js

@@ -0,0 +1,166 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FollowUpgrade = void 0;
+exports.allowedOrigin = allowedOrigin;
+const ws_1 = require("ws");
+const follow_1 = require("./follow");
+const http_1 = require("./http");
+const STALL_MS = 60000;
+function reject(socket, status, text, message) {
+    const body = message + '\n';
+    socket.write(`HTTP/1.1 ${status} ${text}\r\nConnection: close\r\nContent-Type: text/plain; charset=utf-8\r\nContent-Length: ${Buffer.byteLength(body)}\r\n\r\n${body}`);
+    socket.destroy();
+}
+/** The page's origin must be the one serving it (the replay UI) or the extension. */
+function allowedOrigin(req) {
+    const origin = req.headers.origin;
+    if (origin === undefined)
+        return true; // not a browser
+    if (origin.startsWith('chrome-extension://'))
+        return true;
+    let u;
+    try {
+        u = new URL(origin);
+    }
+    catch {
+        return false;
+    }
+    const host = (req.headers.host ?? '').toLowerCase();
+    return (u.protocol === 'http:' || u.protocol === 'https:') && u.host.toLowerCase() === host;
+}
+class FollowUpgrade {
+    constructor(opts) {
+        this.opts = opts;
+        this.wss = new ws_1.WebSocketServer({ noServer: true, perMessageDeflate: false, maxPayload: 64 * 1024 });
+        const mount = opts.mount.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        this.pattern = new RegExp(`^${mount}/api/sessions/([^/?#]+)/events/?$`);
+    }
+    /** Whether the upgrade request is tabtape's. */
+    matches(req) {
+        const url = req.url ?? '';
+        return url === this.opts.mount || url.startsWith(this.opts.mount + '/') || url.startsWith(this.opts.mount + '?');
+    }
+    handle(req, socket, head) {
+        if (!(0, http_1.loopbackHost)(req.headers.host) || (0, http_1.viaTunnel)(req)) {
+            reject(socket, 403, 'Forbidden', 'forbidden host');
+            return;
+        }
+        if (!allowedOrigin(req)) {
+            reject(socket, 403, 'Forbidden', 'forbidden origin');
+            return;
+        }
+        const pathname = (req.url ?? '').split('?')[0];
+        const m = this.pattern.exec(pathname);
+        if (!m) {
+            reject(socket, 404, 'Not Found', 'not found');
+            return;
+        }
+        let id;
+        try {
+            id = decodeURIComponent(m[1]);
+        }
+        catch {
+            reject(socket, 400, 'Bad Request', 'invalid session id');
+            return;
+        }
+        this.wss.handleUpgrade(req, socket, head, (ws) => {
+            void this.run(ws, id);
+        });
+    }
+    async run(ws, id) {
+        const { st, followers, stop, logger } = this.opts;
+        if (!st.has(id)) {
+            ws.close(4404, 'session not found');
+            return;
+        }
+        if (!followers.acquire(id)) {
+            ws.close(4429, `too many live viewers (at most ${followers.max})`);
+            return;
+        }
+        try {
+            const out = wsOut(ws);
+            const end = await (0, follow_1.follow)(st, id, out, stop, this.opts.keepAliveMs);
+            switch (end) {
+                case 'ended':
+                    ws.close(1000, 'ended');
+                    break;
+                case 'gone':
+                    ws.close(1000, 'session deleted');
+                    break;
+                case 'stopped':
+                    ws.close(1001, 'server shutting down');
+                    break;
+                case 'left':
+                    if (ws.readyState === ws_1.WebSocket.OPEN)
+                        ws.terminate();
+                    break;
+            }
+        }
+        catch (err) {
+            logger.warn('live viewer failed', { session: id, err });
+            if (ws.readyState === ws_1.WebSocket.OPEN)
+                ws.close(1011, 'internal error');
+        }
+        finally {
+            followers.release(id);
+        }
+    }
+    close() {
+        this.wss.close();
+    }
+}
+exports.FollowUpgrade = FollowUpgrade;
+/** Sends complete lines only: segment chunks may end inside a line. */
+function wsOut(ws) {
+    let parts = [];
+    let partsLen = 0;
+    const left = new Promise((resolve) => {
+        ws.once('close', () => resolve());
+        ws.once('error', () => resolve());
+    });
+    const send = (data) => new Promise((resolve, rejectSend) => {
+        if (ws.readyState !== ws_1.WebSocket.OPEN) {
+            rejectSend(new http_1.ClientGoneError());
+            return;
+        }
+        const timer = setTimeout(() => {
+            ws.terminate();
+            rejectSend(new http_1.ClientGoneError('client stopped reading'));
+        }, STALL_MS);
+        ws.send(data, { binary: false }, (err) => {
+            clearTimeout(timer);
+            if (err)
+                rejectSend(err);
+            else
+                resolve();
+        });
+    });
+    return {
+        left,
+        write(chunk) {
+            const nl = chunk.lastIndexOf(0x0a);
+            if (nl < 0) {
+                parts.push(chunk);
+                partsLen += chunk.length;
+                return;
+            }
+            const head = chunk.subarray(0, nl + 1);
+            const message = partsLen ? Buffer.concat([...parts, head], partsLen + head.length) : head;
+            parts = nl + 1 < chunk.length ? [chunk.subarray(nl + 1)] : [];
+            partsLen = parts.length ? parts[0].length : 0;
+            return send(message);
+        },
+        flush() {
+            if (!partsLen)
+                return;
+            const message = Buffer.concat(parts, partsLen);
+            parts = [];
+            partsLen = 0;
+            return send(message);
+        },
+        keepAlive() {
+            if (ws.readyState === ws_1.WebSocket.OPEN)
+                ws.ping();
+        },
+    };
+}

package/daemon/dist/tabtape/buffer/buffer.js

@@ -0,0 +1,347 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BufferStore = exports.DEFAULT_WINDOW_MS = void 0;
+exports.newSessionID = newSessionID;
+/**
+ * Keeps the last minutes of tabs in buffer mode, apart from the recordings:
+ * the extension streams allow-listed tabs here continuously, and "save"
+ * copies the last N minutes of one tab into a normal session.
+ *
+ * Layout: <dir>/<key>/<seq>.jsonl. A tab's data is split into segments that
+ * each start at an rrweb checkout (Meta event + full snapshot), so a save can
+ * start at any segment and still replay. Segments that are no longer needed
+ * for the tab's window are deleted as new ones arrive, and the combined size
+ * of all buffers is capped (oldest segments first). Buffers are ephemeral:
+ * the directory is cleared on start.
+ */
+const crypto_1 = __importDefault(require("crypto"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const errors_1 = require("../errors");
+const log_1 = require("../log");
+const record_1 = require("../store/record");
+const segment_1 = require("../store/segment");
+const store_1 = require("../store/store");
+/** The buffered time when the extension does not say. */
+exports.DEFAULT_WINDOW_MS = 2 * 60000;
+const MIN_WINDOW_MS = 30000;
+const MAX_WINDOW_MS = 30 * 60000;
+/** Buffers whose tab stopped sending (browser closed or crashed) are deleted. */
+const IDLE_EXPIRY_MS = 10 * 60000;
+/** Saved records are appended to the session in batches of about this size. */
+const COPY_BATCH = 4 << 20;
+class BufferStore {
+    constructor(opts) {
+        this.opts = opts;
+        this.bufs = new Map();
+        /** All segments, oldest first. */
+        this.segments = [];
+        this.total = 0;
+        this.nextSeq = 1;
+        this.log = opts.logger ?? (0, log_1.consoleLogger)();
+        this.now = opts.now ?? Date.now;
+    }
+    /** Clears dir and returns an empty store. */
+    static open(opts) {
+        if (!opts.dir || !(opts.maxBytes > 0))
+            throw new Error('buffer: dir and maxBytes are required');
+        fs_1.default.rmSync(opts.dir, { recursive: true, force: true });
+        fs_1.default.mkdirSync(opts.dir, { recursive: true, mode: 0o755 });
+        return new BufferStore(opts);
+    }
+    /**
+     * Adds records to a tab's buffer, creating it if needed. windowMs is how
+     * much the tab keeps (0 keeps the current or default window); userAgent
+     * describes the browser for saved sessions.
+     */
+    append(key, recs, windowMs, userAgent) {
+        if (!(0, store_1.validID)(key))
+            throw new errors_1.InvalidIDError();
+        this.expire();
+        const b = this.bufferFor(key);
+        if (windowMs > 0)
+            b.windowMs = Math.min(Math.max(windowMs, MIN_WINDOW_MS), MAX_WINDOW_MS);
+        b.ua = userAgent || b.ua;
+        b.lastWrite = this.now();
+        for (const r of recs) {
+            if ((0, record_1.rrwebTypeOf)(r) === record_1.RRWEB_META || !b.cur)
+                this.rotate(b);
+            const cur = b.cur;
+            const line = Buffer.from(r.raw + '\n', 'utf8');
+            let n = 0;
+            try {
+                while (n < line.length)
+                    n += fs_1.default.writeSync(b.fd, line, n, line.length - n);
+            }
+            catch (err) {
+                cur.size += n;
+                this.total += n;
+                this.closeFile(b);
+                throw new Error(`write buffer: ${(0, errors_1.errorMessage)(err)}`);
+            }
+            cur.size += n;
+            this.total += n;
+            if (cur.firstTs === 0 || r.ts < cur.firstTs)
+                cur.firstTs = r.ts;
+            cur.lastTs = Math.max(cur.lastTs, r.ts);
+            if (r.type === 'event')
+                notePage(b, r.raw);
+        }
+        this.retain(b);
+        this.enforceBudget(b.cur);
+    }
+    bufferFor(key) {
+        const existing = this.bufs.get(key);
+        if (existing)
+            return existing;
+        const dir = path_1.default.join(this.opts.dir, key);
+        try {
+            fs_1.default.mkdirSync(dir, { recursive: true, mode: 0o755 });
+        }
+        catch (err) {
+            throw new Error(`create buffer: ${(0, errors_1.errorMessage)(err)}`);
+        }
+        const b = { key, dir, segs: [], cur: null, fd: null, windowMs: exports.DEFAULT_WINDOW_MS, url: '', title: '', ua: '', lastWrite: 0 };
+        this.bufs.set(key, b);
+        return b;
+    }
+    rotate(b) {
+        this.closeFile(b);
+        const seq = this.nextSeq;
+        const p = path_1.default.join(b.dir, `${String(seq).padStart(16, '0')}.jsonl`);
+        let fd;
+        try {
+            fd = fs_1.default.openSync(p, 'ax', 0o644);
+        }
+        catch (err) {
+            throw new Error(`create buffer segment: ${(0, errors_1.errorMessage)(err)}`);
+        }
+        this.nextSeq++;
+        const seg = { seq, key: b.key, path: p, size: 0, firstTs: 0, lastTs: 0 };
+        this.segments.push(seg);
+        b.segs.push(seg);
+        b.cur = seg;
+        b.fd = fd;
+    }
+    closeFile(b) {
+        if (b.fd === null)
+            return;
+        try {
+            fs_1.default.closeSync(b.fd);
+        }
+        catch (err) {
+            this.log.warn('close buffer segment', { path: b.cur?.path, err });
+        }
+        b.fd = null;
+        b.cur = null;
+    }
+    /** Deletes segments a save can no longer need: a segment goes once the next one starts early enough to cover the whole window. */
+    retain(b) {
+        const cutoff = this.now() - b.windowMs;
+        while (b.segs.length > 1 && b.segs[1].firstTs <= cutoff)
+            this.remove(b.segs[0]);
+    }
+    enforceBudget(keep) {
+        while (this.total > this.opts.maxBytes) {
+            const seg = this.segments.find((s) => s !== keep);
+            if (!seg)
+                return;
+            this.remove(seg);
+        }
+    }
+    remove(seg) {
+        const b = this.bufs.get(seg.key);
+        if (b && b.cur === seg)
+            this.closeFile(b);
+        try {
+            fs_1.default.unlinkSync(seg.path);
+        }
+        catch (err) {
+            if (!(0, errors_1.isNotExist)(err))
+                this.log.warn('delete buffer segment', { path: seg.path, err });
+        }
+        this.total -= seg.size;
+        this.segments = this.segments.filter((x) => x !== seg);
+        if (b)
+            b.segs = b.segs.filter((x) => x !== seg);
+    }
+    expire() {
+        const cutoff = this.now() - IDLE_EXPIRY_MS;
+        for (const [key, b] of [...this.bufs]) {
+            if (b.lastWrite < cutoff)
+                this.deleteBuffer(key);
+        }
+    }
+    /** Removes a buffer and its files. */
+    delete(key) {
+        if (!this.bufs.has(key))
+            throw new errors_1.BufferNotFoundError();
+        this.deleteBuffer(key);
+    }
+    deleteBuffer(key) {
+        const b = this.bufs.get(key);
+        this.closeFile(b);
+        for (const seg of [...b.segs])
+            this.remove(seg);
+        this.bufs.delete(key);
+        try {
+            fs_1.default.rmSync(b.dir, { recursive: true, force: true });
+        }
+        catch (err) {
+            this.log.warn('delete buffer', { key, err });
+        }
+    }
+    /** Every buffer, most recently written first. */
+    list() {
+        this.expire();
+        return [...this.bufs.values()].map(infoOf).sort((a, b) => b.lastWriteAt - a.lastWriteAt);
+    }
+    /** The combined size of all buffers. */
+    stats() {
+        return { buffers: this.bufs.size, bytes: this.total, maxBytes: this.opts.maxBytes };
+    }
+    /**
+     * Copies the buffer's last window into a new session of st and returns it.
+     * The copy starts at the newest checkout at or before now − window (or at
+     * the start of a younger buffer), so it covers at least the window and
+     * replays from a full snapshot. A marker event records the moment of
+     * saving.
+     */
+    async save(key, st, opts = {}) {
+        const b = this.bufs.get(key);
+        if (!b)
+            throw new errors_1.BufferNotFoundError();
+        if (b.segs.length === 0)
+            throw new errors_1.BufferEmptyError();
+        const windowMs = opts.windowMs && opts.windowMs > 0 ? opts.windowMs : b.windowMs;
+        const now = this.now();
+        const cutoff = now - windowMs;
+        let first = 0;
+        b.segs.forEach((seg, i) => {
+            if (seg.firstTs <= cutoff)
+                first = i;
+        });
+        // Sizes are taken now: appends that arrive while copying are not part of the save.
+        const segs = b.segs.slice(first).map((seg) => ({ path: seg.path, size: seg.size }));
+        const id = newSessionID(now);
+        st.start({ id, startedAt: b.segs[first].firstTs, url: b.url, title: b.title, userAgent: b.ua, source: 'buffer' });
+        try {
+            for (const seg of segs)
+                await copySegment(seg.path, seg.size, id, st);
+        }
+        catch (err) {
+            try {
+                st.delete(id); // best effort: do not leave half a session behind
+            }
+            catch {
+                // already gone
+            }
+            throw err;
+        }
+        const marker = (0, record_1.parseRecord)(`{"ts":${now},"type":"event","data":{"name":"marker","label":"Saved from buffer mode"}}`);
+        st.append(id, [marker]);
+        return opts.continue ? st.get(id) : st.end(id, now);
+    }
+    /** Closes open files. */
+    close() {
+        for (const b of this.bufs.values())
+            this.closeFile(b);
+    }
+}
+exports.BufferStore = BufferStore;
+/** Keeps the buffer's URL and title in step with page views. */
+function notePage(b, raw) {
+    if (!raw.includes('"page_view"'))
+        return;
+    try {
+        const ev = JSON.parse(raw);
+        const d = ev.data;
+        if (d && d.name === 'page_view') {
+            b.url = typeof d.url === 'string' ? d.url : '';
+            b.title = (typeof d.title === 'string' && d.title) || b.title;
+        }
+    }
+    catch {
+        // not a record we understand
+    }
+}
+function infoOf(b) {
+    let bytes = 0;
+    let firstTs = 0;
+    let lastTs = 0;
+    for (const seg of b.segs) {
+        bytes += seg.size;
+        if (firstTs === 0 || seg.firstTs < firstTs)
+            firstTs = seg.firstTs;
+        lastTs = Math.max(lastTs, seg.lastTs);
+    }
+    return {
+        key: b.key,
+        ...(b.url ? { url: b.url } : {}),
+        ...(b.title ? { title: b.title } : {}),
+        windowMs: b.windowMs,
+        ...(firstTs ? { firstTs } : {}),
+        ...(lastTs ? { lastTs } : {}),
+        durationMs: Math.max(lastTs - firstTs, 0),
+        bytes,
+        segments: b.segs.length,
+        lastWriteAt: b.lastWrite,
+    };
+}
+/** Copies a buffer segment's complete lines into the session; damaged lines are skipped. */
+async function copySegment(p, size, id, st) {
+    let batch = [];
+    let batchBytes = 0;
+    const flush = () => {
+        if (batch.length === 0)
+            return;
+        st.append(id, batch);
+        batch = [];
+        batchBytes = 0;
+    };
+    let rest = Buffer.alloc(0);
+    const take = (line) => {
+        if (line.length === 0)
+            return;
+        let r;
+        try {
+            r = (0, record_1.parseRecord)(line);
+        }
+        catch {
+            return; // a damaged line; the rest is still worth saving
+        }
+        batch.push(r);
+        batchBytes += r.raw.length;
+        if (batchBytes >= COPY_BATCH)
+            flush();
+    };
+    try {
+        for await (const chunk of (0, segment_1.readSegment)(p, 0, size)) {
+            let data = rest.length ? Buffer.concat([rest, chunk]) : chunk;
+            let nl = data.indexOf(0x0a);
+            while (nl >= 0) {
+                take(data.subarray(0, nl));
+                data = data.subarray(nl + 1);
+                nl = data.indexOf(0x0a);
+            }
+            rest = Buffer.from(data);
+        }
+    }
+    catch (err) {
+        if ((0, errors_1.isNotExist)(err))
+            return; // deleted meanwhile
+        throw new Error(`read buffer segment: ${(0, errors_1.errorMessage)(err)}`);
+    }
+    take(rest);
+    flush();
+}
+/** Follows the extension's format: YYYYMMDD-HHMMSS-xxxxxx (local time). */
+function newSessionID(now) {
+    const d = new Date(now);
+    const p = (n, w = 2) => String(n).padStart(w, '0');
+    const stamp = `${d.getFullYear()}${p(d.getMonth() + 1)}${p(d.getDate())}-${p(d.getHours())}${p(d.getMinutes())}${p(d.getSeconds())}`;
+    return `${stamp}-${crypto_1.default.randomBytes(3).toString('hex')}`;
+}

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

@@ -0,0 +1,137 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+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 errors_1 = require("../errors");
+const log_1 = require("../log");
+const reader_1 = require("../query/reader");
+const record_1 = require("../store/record");
+const qt = __importStar(require("../testing/querytest"));
+const tmp_1 = require("../testing/tmp");
+const buffer_1 = require("./buffer");
+let clock = 0;
+const stores = [];
+function open(maxBytes) {
+    clock = 1759650432000;
+    const dir = path_1.default.join((0, tmp_1.tempDir)(), 'buffer');
+    const b = buffer_1.BufferStore.open({ dir, maxBytes, logger: log_1.silentLogger, now: () => clock });
+    stores.push(b);
+    return { b, dir };
+}
+afterEach(async () => {
+    while (stores.length)
+        stores.pop().close();
+    await qt.closeTestStores();
+    (0, tmp_1.cleanupTempDirs)();
+});
+const rec = (line) => (0, record_1.parseRecord)(line);
+/** Appends one second of a tab: a checkout every 30 s, a click every second. */
+function tick(b, key, sec) {
+    const ts = clock;
+    const recs = [];
+    if (sec % 30 === 0) {
+        recs.push(rec(`{"ts":${ts},"type":"rrweb","data":{"type":4,"data":{"href":"http://localhost/","width":800,"height":600},"timestamp":${ts}}}`), rec(`{"ts":${ts},"type":"rrweb","data":{"type":2,"data":{"node":{"type":0,"childNodes":[],"id":1}},"timestamp":${ts}}}`));
+    }
+    if (sec === 0)
+        recs.push(rec(`{"ts":${ts},"type":"event","data":{"name":"page_view","kind":"load","url":"http://localhost/shop","title":"Shop"}}`));
+    recs.push(rec(`{"ts":${ts},"type":"event","data":{"name":"click","url":"http://localhost/shop","target":{"tag":"button","selector":"button","text":"s${sec}"}}}`));
+    b.append(key, recs, 2 * 60000, 'UA/1');
+    clock += 1000;
+}
+describe('BufferStore', () => {
+    it('keeps only the window', () => {
+        const { b, dir } = open(100 << 20);
+        for (let sec = 0; sec < 15 * 60; sec++)
+            tick(b, 'tab-1', sec);
+        const info = b.list()[0];
+        // Window 2:00 plus at most one checkout interval.
+        expect(info.durationMs).toBeGreaterThanOrEqual(120000);
+        expect(info.durationMs).toBeLessThanOrEqual(150000);
+        expect(fs_1.default.readdirSync(path_1.default.join(dir, 'tab-1')).length).toBe(info.segments);
+        expect(info.segments).toBeLessThanOrEqual(6);
+        expect([info.url, info.title]).toEqual(['http://localhost/shop', 'Shop']);
+    });
+    it('saves the last minutes', async () => {
+        const { b } = open(100 << 20);
+        const st = qt.testStore();
+        for (let sec = 0; sec < 5 * 60; sec++)
+            tick(b, 'tab-1', sec);
+        const sess = await b.save('tab-1', st);
+        const dur = (sess.endedAt ?? 0) - sess.startedAt;
+        expect(sess.source).toBe('buffer');
+        expect(sess.userAgent).toBe('UA/1');
+        expect(dur).toBeGreaterThanOrEqual(120000);
+        expect(dur).toBeLessThanOrEqual(151000);
+        const v = await new reader_1.Reader(st).view(sess.id);
+        expect(v.replayable).toBe(true);
+        expect(v.lines[0].rr).toBe(reader_1.RR_META);
+        expect(v.lines[v.lines.length - 1].ev?.name).toBe('marker');
+        // Saving does not stop the buffer.
+        tick(b, 'tab-1', 300);
+        expect(b.list().length).toBe(1);
+    });
+    it('saves a young buffer and can continue', async () => {
+        const { b } = open(100 << 20);
+        const st = qt.testStore();
+        for (let sec = 0; sec < 40; sec++)
+            tick(b, 'tab-1', sec);
+        const sess = await b.save('tab-1', st, { continue: true });
+        expect(sess.endedAt).toBeUndefined();
+        expect(sess.counts.clicks).toBe(40);
+    });
+    it('keeps to its budget and deletes buffers', async () => {
+        const { b, dir } = open(20000);
+        for (let sec = 0; sec < 200; sec++) {
+            tick(b, 'tab-1', sec);
+            tick(b, 'tab-2', sec);
+        }
+        expect(b.stats().bytes).toBeLessThanOrEqual(20000 + 2000);
+        b.delete('tab-1');
+        expect(fs_1.default.existsSync(path_1.default.join(dir, 'tab-1'))).toBe(false);
+        expect(() => b.delete('tab-1')).toThrow(errors_1.BufferNotFoundError);
+        await expect(b.save('nope', qt.testStore())).rejects.toThrow(errors_1.BufferNotFoundError);
+        expect(() => b.append('../x', [], 0, '')).toThrow(errors_1.InvalidIDError);
+    });
+    it('expires idle buffers', () => {
+        const { b } = open(100 << 20);
+        tick(b, 'tab-1', 0);
+        clock += 11 * 60000;
+        expect(b.list()).toEqual([]);
+    });
+});