repoburg 1.3.255 → 1.3.256

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

@@ -0,0 +1,846 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Store = exports.COMPRESS_GZIP = exports.COMPRESS_OFF = void 0;
+exports.validID = validID;
+/**
+ * Persists recorded browser sessions as JSONL files.
+ *
+ * Layout on disk:
+ *
+ *   <dir>/sessions/<id>/meta.json          session index entry
+ *   <dir>/sessions/<id>/<seq>.jsonl        event segments, one JSON object per line
+ *   <dir>/sessions/<id>/<seq>.jsonl.gz     closed segments, with compress "gzip"
+ *
+ * Segment numbers come from one global, monotonically increasing sequence.
+ * The combined size of all segments on disk is capped: when an append pushes
+ * the total over the cap, segments are deleted lowest sequence first — the
+ * oldest data across all sessions goes first. The data directory therefore
+ * behaves like a ring buffer that never splits a line.
+ *
+ * A segment is closed when it reaches the segment size, when its session ends
+ * or after two minutes without writes; a closed segment is never written
+ * again. With compression on, one background worker gzips closed segments.
+ *
+ * State changes run synchronously (one event loop: no locks needed); reads
+ * and compression stream asynchronously. Appends write complete lines in one
+ * synchronous call, so a segment's size always ends at a line boundary.
+ */
+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("./record");
+const segment_1 = require("./segment");
+const ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9_-]{0,63}$/;
+/** Whether id is acceptable as a session id (and buffer key). */
+function validID(id) {
+    return typeof id === 'string' && ID_PATTERN.test(id);
+}
+const SESSIONS_DIR = 'sessions';
+const META_NAME = 'meta.json';
+/** How long a session's segment stays open without writes. */
+const IDLE_CLOSE_MS = 2 * 60000;
+/** How often the compression worker closes idle segments. */
+const IDLE_CHECK_MS = 30000;
+exports.COMPRESS_OFF = 'off';
+exports.COMPRESS_GZIP = 'gzip';
+function emptyCounts() {
+    return { total: 0, rrweb: 0, network: 0, console: 0, events: 0, snapshots: 0, pages: 0, clicks: 0, errors: 0, netErrors: 0 };
+}
+function emptyMeta(id, startedAt = 0) {
+    return {
+        id,
+        startedAt,
+        endedAt: 0,
+        firstTs: 0,
+        lastTs: 0,
+        lastWriteAt: 0,
+        url: '',
+        title: '',
+        lastUrl: '',
+        userAgent: '',
+        source: '',
+        userId: '',
+        perf: '',
+        truncated: false,
+        counts: emptyCounts(),
+    };
+}
+const num = (v) => (typeof v === 'number' && Number.isFinite(v) ? Math.trunc(v) : 0);
+const str = (v) => (typeof v === 'string' ? v : '');
+/** Reads a meta.json document, ignoring fields of the wrong type. */
+function metaFromJSON(id, v) {
+    const m = emptyMeta(id);
+    if (typeof v !== 'object' || v === null)
+        return m;
+    const o = v;
+    m.startedAt = num(o.startedAt);
+    m.endedAt = num(o.endedAt);
+    m.firstTs = num(o.firstTs);
+    m.lastTs = num(o.lastTs);
+    m.lastWriteAt = num(o.lastWriteAt);
+    m.url = str(o.url);
+    m.title = str(o.title);
+    m.lastUrl = str(o.lastUrl);
+    m.userAgent = str(o.userAgent);
+    m.source = str(o.source);
+    m.userId = str(o.userId);
+    m.perf = str(o.perf);
+    m.truncated = o.truncated === true;
+    if (typeof o.counts === 'object' && o.counts !== null) {
+        const c = o.counts;
+        for (const key of Object.keys(m.counts))
+            m.counts[key] = num(c[key]);
+    }
+    return m;
+}
+/** The session as the API shows it: empty fields left out. */
+function viewOf(sess) {
+    const m = sess.meta;
+    const out = { id: m.id, startedAt: m.startedAt };
+    if (m.endedAt)
+        out.endedAt = m.endedAt;
+    if (m.firstTs)
+        out.firstTs = m.firstTs;
+    if (m.lastTs)
+        out.lastTs = m.lastTs;
+    if (m.lastWriteAt)
+        out.lastWriteAt = m.lastWriteAt;
+    if (m.url)
+        out.url = m.url;
+    if (m.title)
+        out.title = m.title;
+    if (m.lastUrl)
+        out.lastUrl = m.lastUrl;
+    if (m.userAgent)
+        out.userAgent = m.userAgent;
+    if (m.source)
+        out.source = m.source;
+    if (m.userId)
+        out.userId = m.userId;
+    if (m.perf)
+        out.perf = m.perf;
+    if (m.truncated)
+        out.truncated = true;
+    out.counts = { ...m.counts };
+    let bytes = 0;
+    let raw = 0;
+    for (const seg of sess.segs) {
+        bytes += seg.disk;
+        raw += seg.size;
+    }
+    out.bytes = bytes;
+    out.rawBytes = raw;
+    out.segments = sess.segs.length;
+    return out;
+}
+/** Web Vitals ratings in order; unknown ratings rank lowest. */
+function ratingRank(r) {
+    switch (r) {
+        case 'good':
+            return 1;
+        case 'needs-improvement':
+            return 2;
+        case 'poor':
+            return 3;
+    }
+    return 0;
+}
+function apply(m, r) {
+    const c = m.counts;
+    c.total++;
+    if (m.firstTs === 0 || r.ts < m.firstTs)
+        m.firstTs = r.ts;
+    m.lastTs = Math.max(m.lastTs, r.ts);
+    const s = r.sum;
+    switch (r.type) {
+        case 'rrweb':
+            c.rrweb++;
+            if (s.rrwebType === record_1.RRWEB_FULL_SNAPSHOT)
+                c.snapshots++;
+            break;
+        case 'network':
+            c.network++;
+            if (s.status >= 400 || s.err !== '')
+                c.netErrors++;
+            break;
+        case 'console':
+            c.console++;
+            if (s.level === 'error')
+                c.errors++;
+            break;
+        case 'event':
+            c.events++;
+            switch (s.name) {
+                case 'page_view':
+                    c.pages++;
+                    m.url = m.url || s.url;
+                    m.title = m.title || s.title;
+                    m.lastUrl = s.url;
+                    break;
+                case 'click':
+                    c.clicks++;
+                    break;
+                case 'identify':
+                    m.userId = s.userId || m.userId;
+                    break;
+            }
+            break;
+        case 'perf':
+            if (s.kind === 'vital' && ratingRank(s.rating) > ratingRank(m.perf))
+                m.perf = s.rating;
+            break;
+    }
+}
+/**
+ * Renders records as lines, injecting the session id as the first field.
+ * ids are validated, so they never need JSON escaping.
+ */
+function encode(id, recs) {
+    const prefix = `{"sid":"${id}",`;
+    let out = '';
+    for (const r of recs)
+        out += prefix + r.raw.slice(1) + '\n'; // raw is a non-empty object
+    return Buffer.from(out, 'utf8');
+}
+function minTS(recs) {
+    let m = recs[0].ts;
+    for (const r of recs)
+        m = Math.min(m, r.ts);
+    return m;
+}
+function deferred() {
+    let resolve;
+    const promise = new Promise((r) => {
+        resolve = r;
+    });
+    return { promise, resolve };
+}
+/** Writes all of buf; on failure the error carries the bytes written before it. */
+function writeAll(fd, buf) {
+    let n = 0;
+    try {
+        while (n < buf.length)
+            n += fs_1.default.writeSync(fd, buf, n, buf.length - n);
+        return { n, err: null };
+    }
+    catch (err) {
+        return { n, err };
+    }
+}
+class Store {
+    constructor(opts) {
+        this.opts = opts;
+        this.closing = false;
+        this.wakeFn = null;
+        this.loop = null;
+        this.lastIdleCheck = Date.now();
+        this.sessions = new Map();
+        /** Every segment on disk, oldest (lowest seq) first. */
+        this.segments = [];
+        /** Bytes on disk. */
+        this.total = 0;
+        /** Uncompressed bytes. */
+        this.raw = 0;
+        this.nextSeq = 1;
+        /** Closed segments waiting for compression. */
+        this.queue = [];
+        this.root = path_1.default.join(opts.dir, SESSIONS_DIR);
+        this.log = opts.logger ?? (0, log_1.consoleLogger)();
+        this.now = opts.now ?? Date.now;
+        this.compress = opts.compress === exports.COMPRESS_GZIP;
+        this.idleCheckMs = opts.idleCheckMs ?? IDLE_CHECK_MS;
+    }
+    /**
+     * Loads the data directory, repairing partial trailing lines and enforcing
+     * the size cap, and starts the compression worker.
+     */
+    static open(options) {
+        if (!options.dir)
+            throw new Error('store: dir is required');
+        if (!(options.maxBytes > 0))
+            throw new Error('store: maxBytes must be positive');
+        if (!(options.segmentBytes > 0) || options.segmentBytes > options.maxBytes) {
+            throw new Error('store: segmentBytes must be positive and no larger than maxBytes');
+        }
+        let compress = options.compress ?? '';
+        if (compress === '')
+            compress = exports.COMPRESS_OFF;
+        if (compress !== exports.COMPRESS_OFF && compress !== exports.COMPRESS_GZIP) {
+            throw new Error(`store: unknown compression "${compress}" (use "${exports.COMPRESS_OFF}" or "${exports.COMPRESS_GZIP}")`);
+        }
+        const s = new Store({ ...options, compress });
+        fs_1.default.mkdirSync(s.root, { recursive: true, mode: 0o755 });
+        s.load();
+        s.enforceBudget(null);
+        if (s.compress) {
+            // No segment is open yet: every plain one is closed.
+            for (const seg of s.segments)
+                s.enqueue(seg);
+            s.loop = s.compressLoop();
+        }
+        return s;
+    }
+    load() {
+        for (const e of fs_1.default.readdirSync(this.root, { withFileTypes: true })) {
+            if (!e.isDirectory() || !validID(e.name))
+                continue;
+            let sess;
+            try {
+                sess = this.loadSession(e.name);
+            }
+            catch (err) {
+                this.log.warn('skipping unreadable session', { session: e.name, err });
+                continue;
+            }
+            this.sessions.set(sess.meta.id, sess);
+            this.segments.push(...sess.segs);
+        }
+        this.segments.sort((a, b) => a.seq - b.seq);
+        for (const seg of this.segments) {
+            this.total += seg.disk;
+            this.raw += seg.size;
+            this.nextSeq = Math.max(this.nextSeq, seg.seq + 1);
+        }
+    }
+    loadSession(id) {
+        const dir = path_1.default.join(this.root, id);
+        let meta = emptyMeta(id);
+        try {
+            const text = fs_1.default.readFileSync(path_1.default.join(dir, META_NAME), 'utf8');
+            try {
+                meta = metaFromJSON(id, JSON.parse(text));
+            }
+            catch (err) {
+                this.log.warn('ignoring corrupt session meta', { session: id, err });
+            }
+        }
+        catch (err) {
+            if (!(0, errors_1.isNotExist)(err))
+                throw new Error(`read meta: ${(0, errors_1.errorMessage)(err)}`);
+        }
+        const sess = { meta, dir, segs: this.loadSegments(id, dir), cur: null, fd: null, lastWrite: 0, changed: null };
+        if (sess.meta.startedAt === 0) {
+            try {
+                sess.meta.startedAt = Math.trunc(fs_1.default.statSync(dir).mtimeMs);
+            }
+            catch {
+                // keep 0
+            }
+        }
+        return sess;
+    }
+    /**
+     * Lists a session's segments. It finishes what a crash interrupted:
+     * leftover .tmp files are deleted, and when both forms of a segment exist
+     * the .gz is complete (it is renamed into place only after it is synced to
+     * disk), so the plain file is deleted.
+     */
+    loadSegments(id, dir) {
+        const gz = new Map();
+        const plain = new Map();
+        for (const e of fs_1.default.readdirSync(dir, { withFileTypes: true })) {
+            const parsed = (0, segment_1.parseSegmentName)(e.name);
+            if (!parsed || e.isDirectory())
+                continue;
+            const p = path_1.default.join(dir, e.name);
+            switch (parsed.kind) {
+                case 'temp':
+                    fs_1.default.unlinkSync(p);
+                    break;
+                case 'gzip':
+                    try {
+                        const { disk, raw } = (0, segment_1.gzipSizes)(p);
+                        gz.set(parsed.seq, newSegment(parsed.seq, id, p, raw, disk, true));
+                    }
+                    catch (err) {
+                        this.log.warn('ignoring unreadable compressed segment', { path: p, err });
+                    }
+                    break;
+                case 'plain':
+                    plain.set(parsed.seq, p);
+                    break;
+            }
+        }
+        const segs = [...gz.values()];
+        for (const [seq, p] of plain) {
+            if (gz.has(seq)) {
+                fs_1.default.unlinkSync(p);
+                continue;
+            }
+            const size = (0, segment_1.repairTail)(p);
+            if (size === 0) {
+                fs_1.default.unlinkSync(p);
+                continue;
+            }
+            segs.push(newSegment(seq, id, p, size, size, false));
+        }
+        return segs.sort((a, b) => a.seq - b.seq);
+    }
+    /**
+     * Creates the session if needed and records what the recorder knows about
+     * it. Calling it again for the same id only fills missing fields.
+     */
+    start(info) {
+        if (!validID(info.id))
+            throw new errors_1.InvalidIDError();
+        const sess = this.sessionFor(info.id, info.startedAt ?? 0);
+        const m = sess.meta;
+        if (info.startedAt && info.startedAt > 0 && info.startedAt < m.startedAt)
+            m.startedAt = info.startedAt;
+        m.url = m.url || (info.url ?? '');
+        m.title = m.title || (info.title ?? '');
+        m.userAgent = m.userAgent || (info.userAgent ?? '');
+        m.source = m.source || (info.source ?? '');
+        this.saveMeta(sess);
+        return viewOf(sess);
+    }
+    /**
+     * Writes records to the session, creating it when it does not exist, then
+     * evicts the oldest segments if the size cap is exceeded. Returns the
+     * number of bytes written.
+     */
+    append(id, recs) {
+        if (!validID(id))
+            throw new errors_1.InvalidIDError();
+        if (recs.length === 0)
+            return 0;
+        const buf = encode(id, recs);
+        const sess = this.sessionFor(id, minTS(recs));
+        const seg = this.openSegment(sess);
+        const { n, err } = writeAll(sess.fd, buf);
+        seg.size += n;
+        seg.disk += n;
+        this.total += n;
+        this.raw += n;
+        sess.lastWrite = this.now();
+        if (err) {
+            // A short write leaves a partial line behind. Stop appending to this
+            // segment; open() repairs the tail on the next start.
+            seg.broken = true;
+            this.closeFile(sess);
+            this.notify(sess);
+            throw new Error(`write segment: ${(0, errors_1.errorMessage)(err)}`);
+        }
+        for (const r of recs)
+            apply(sess.meta, r);
+        sess.meta.lastWriteAt = sess.lastWrite;
+        this.notify(sess);
+        if (seg.size >= this.opts.segmentBytes)
+            this.closeFile(sess);
+        this.enforceBudget(seg);
+        this.closeIdle();
+        // seg is never evicted, so sess is still indexed here.
+        this.saveMeta(sess);
+        return n;
+    }
+    /** Marks the session as finished. */
+    end(id, endedAt) {
+        const sess = this.sessions.get(id);
+        if (!sess)
+            throw new errors_1.NotFoundError();
+        sess.meta.endedAt = endedAt > 0 ? endedAt : this.now();
+        this.closeFile(sess);
+        this.notify(sess);
+        this.saveMeta(sess);
+        return viewOf(sess);
+    }
+    /**
+     * Resolves at the session's next change: an append, its end, or the ring
+     * buffer or a delete removing data. Take it before reading so that no
+     * change is missed.
+     */
+    watch(id) {
+        const sess = this.sessions.get(id);
+        if (!sess)
+            throw new errors_1.NotFoundError();
+        if (!sess.changed)
+            sess.changed = deferred();
+        return sess.changed.promise;
+    }
+    notify(sess) {
+        if (sess.changed) {
+            sess.changed.resolve();
+            sess.changed = null;
+        }
+    }
+    /** One session. */
+    get(id) {
+        const sess = this.sessions.get(id);
+        if (!sess)
+            throw new errors_1.NotFoundError();
+        return viewOf(sess);
+    }
+    /** Whether the session exists. */
+    has(id) {
+        return this.sessions.has(id);
+    }
+    /** All sessions, newest first. */
+    list() {
+        const out = [...this.sessions.values()].map(viewOf);
+        return out.sort((a, b) => b.startedAt - a.startedAt || (b.id < a.id ? -1 : b.id > a.id ? 1 : 0));
+    }
+    /** Removes a session and its files. */
+    delete(id) {
+        const sess = this.sessions.get(id);
+        if (!sess)
+            throw new errors_1.NotFoundError();
+        this.closeFile(sess);
+        for (const seg of sess.segs) {
+            seg.dropped = true;
+            this.total -= seg.disk;
+            this.raw -= seg.size;
+        }
+        this.segments = this.segments.filter((seg) => seg.session !== id);
+        this.sessions.delete(id);
+        this.notify(sess);
+        try {
+            fs_1.default.rmSync(sess.dir, { recursive: true, force: true });
+        }
+        catch (err) {
+            throw new Error(`remove session: ${(0, errors_1.errorMessage)(err)}`);
+        }
+    }
+    /**
+     * The session's index entry and its segments, oldest first. Segments can
+     * be evicted after the snapshot is taken; readers treat a missing file as
+     * empty.
+     */
+    snapshot(id) {
+        const sess = this.sessions.get(id);
+        if (!sess)
+            throw new errors_1.NotFoundError();
+        return {
+            session: viewOf(sess),
+            segments: sess.segs.map((seg) => ({ seq: seg.seq, path: seg.path, size: seg.size })),
+        };
+    }
+    /**
+     * Streams the session's lines, oldest first, to sink. Throws NotFoundError
+     * before writing anything if the session does not exist. Segments evicted
+     * while streaming are skipped.
+     */
+    async writeSession(id, sink) {
+        // Sizes only cover complete writes, so reading up to them never yields
+        // a torn line even while appends continue.
+        const { segments } = this.snapshot(id);
+        let total = 0;
+        for (const p of segments) {
+            try {
+                for await (const chunk of (0, segment_1.readSegment)(p.path, 0, p.size)) {
+                    total += chunk.length;
+                    const pending = sink(chunk);
+                    if (pending)
+                        await pending;
+                }
+            }
+            catch (err) {
+                if ((0, errors_1.isNotExist)(err))
+                    continue; // evicted after the snapshot was taken
+                throw err;
+            }
+        }
+        return total;
+    }
+    /** Ring buffer usage. */
+    stats() {
+        return {
+            dir: this.opts.dir,
+            totalBytes: this.total,
+            rawBytes: this.raw,
+            maxBytes: this.opts.maxBytes,
+            segmentBytes: this.opts.segmentBytes,
+            compress: this.opts.compress,
+            sessions: this.sessions.size,
+            segments: this.segments.length,
+        };
+    }
+    /**
+     * Stops the compression worker (a compression in progress is abandoned and
+     * redone on the next start) and closes open segment files.
+     */
+    async close() {
+        if (!this.closing) {
+            this.closing = true;
+            this.wakeFn?.();
+        }
+        await this.loop;
+        const errors = [];
+        for (const sess of this.sessions.values()) {
+            if (sess.fd === null)
+                continue;
+            try {
+                fs_1.default.closeSync(sess.fd);
+            }
+            catch (err) {
+                errors.push(`close ${sess.cur?.path}: ${(0, errors_1.errorMessage)(err)}`);
+            }
+            sess.fd = null;
+            sess.cur = null;
+        }
+        if (errors.length)
+            throw new Error(errors.join('; '));
+    }
+    sessionFor(id, startedAt) {
+        const existing = this.sessions.get(id);
+        if (existing)
+            return existing;
+        const dir = path_1.default.join(this.root, id);
+        try {
+            fs_1.default.mkdirSync(dir, { recursive: true, mode: 0o755 });
+        }
+        catch (err) {
+            throw new Error(`create session dir: ${(0, errors_1.errorMessage)(err)}`);
+        }
+        const sess = {
+            meta: emptyMeta(id, startedAt > 0 ? startedAt : this.now()),
+            dir,
+            segs: [],
+            cur: null,
+            fd: null,
+            lastWrite: 0,
+            changed: null,
+        };
+        this.sessions.set(id, sess);
+        return sess;
+    }
+    openSegment(sess) {
+        if (sess.fd !== null && sess.cur)
+            return sess.cur;
+        const seq = this.nextSeq;
+        const p = path_1.default.join(sess.dir, (0, segment_1.segmentName)(seq));
+        let fd;
+        try {
+            fd = fs_1.default.openSync(p, 'ax', 0o644);
+        }
+        catch (err) {
+            throw new Error(`create segment: ${(0, errors_1.errorMessage)(err)}`);
+        }
+        this.nextSeq++;
+        const seg = newSegment(seq, sess.meta.id, p, 0, 0, false);
+        this.segments.push(seg); // seq only grows, order is kept
+        sess.segs.push(seg);
+        sess.cur = seg;
+        sess.fd = fd;
+        return seg;
+    }
+    /** Closes the session's open segment for good and queues it for compression. */
+    closeFile(sess) {
+        if (sess.fd === null)
+            return;
+        const seg = sess.cur;
+        try {
+            fs_1.default.closeSync(sess.fd);
+        }
+        catch (err) {
+            this.log.warn('close segment', { path: seg.path, err });
+            seg.broken = true;
+        }
+        sess.fd = null;
+        sess.cur = null;
+        this.enqueue(seg);
+    }
+    /**
+     * Bounds the number of open files when sessions are left running without
+     * an explicit end (closed tab, crashed browser).
+     */
+    closeIdle() {
+        const cutoff = this.now() - IDLE_CLOSE_MS;
+        for (const sess of this.sessions.values()) {
+            if (sess.fd !== null && sess.lastWrite < cutoff)
+                this.closeFile(sess);
+        }
+    }
+    /** Deletes the oldest segments until the total fits the cap. keep, the segment just written, is never deleted. */
+    enforceBudget(keep) {
+        while (this.total > this.opts.maxBytes) {
+            const i = this.segments.findIndex((seg) => seg !== keep);
+            if (i < 0)
+                return;
+            this.evict(i);
+        }
+    }
+    evict(i) {
+        const seg = this.segments[i];
+        this.segments.splice(i, 1);
+        this.total -= seg.disk;
+        this.raw -= seg.size;
+        seg.dropped = true;
+        const sess = this.sessions.get(seg.session);
+        if (sess.cur === seg)
+            this.closeFile(sess);
+        try {
+            fs_1.default.unlinkSync(seg.path);
+        }
+        catch (err) {
+            if (!(0, errors_1.isNotExist)(err))
+                this.log.warn('evict segment', { path: seg.path, err });
+        }
+        sess.segs = sess.segs.filter((x) => x !== seg);
+        this.log.debug('ring buffer evicted segment', { session: seg.session, seq: seg.seq, bytes: seg.size });
+        this.notify(sess);
+        if (sess.segs.length === 0) {
+            this.sessions.delete(seg.session);
+            try {
+                fs_1.default.rmSync(sess.dir, { recursive: true, force: true });
+            }
+            catch (err) {
+                this.log.warn('remove evicted session', { session: seg.session, err });
+            }
+            return;
+        }
+        sess.meta.truncated = true;
+        try {
+            this.saveMeta(sess);
+        }
+        catch (err) {
+            this.log.warn('save session meta', { session: seg.session, err });
+        }
+    }
+    saveMeta(sess) {
+        const tmp = path_1.default.join(sess.dir, META_NAME + '.tmp');
+        try {
+            fs_1.default.writeFileSync(tmp, JSON.stringify(viewOf(sess)), { mode: 0o644 });
+        }
+        catch (err) {
+            throw new Error(`write meta: ${(0, errors_1.errorMessage)(err)}`);
+        }
+        try {
+            fs_1.default.renameSync(tmp, path_1.default.join(sess.dir, META_NAME));
+        }
+        catch (err) {
+            throw new Error(`commit meta: ${(0, errors_1.errorMessage)(err)}`);
+        }
+    }
+    // ---------- compression ----------
+    /**
+     * The single compression worker. It also closes idle segments, so a
+     * session that stops writing is compressed even when no other session
+     * writes. It runs until close().
+     */
+    async compressLoop() {
+        while (!this.closing) {
+            const seg = this.nextJob();
+            if (seg) {
+                await this.compressSegment(seg);
+                continue;
+            }
+            await this.sleep(this.idleCheckMs);
+            if (this.closing)
+                return;
+            if (Date.now() - this.lastIdleCheck >= this.idleCheckMs) {
+                this.lastIdleCheck = Date.now();
+                this.closeIdle();
+            }
+        }
+    }
+    /** Waits for a wake-up (a queued segment, close) or ms. */
+    sleep(ms) {
+        return new Promise((resolve) => {
+            const timer = setTimeout(() => {
+                this.wakeFn = null;
+                resolve();
+            }, ms);
+            timer.unref?.();
+            this.wakeFn = () => {
+                clearTimeout(timer);
+                this.wakeFn = null;
+                resolve();
+            };
+        });
+    }
+    /** Queues a closed segment for compression. */
+    enqueue(seg) {
+        if (!this.compress || seg.gz || seg.queued || seg.broken || seg.dropped)
+            return;
+        seg.queued = true;
+        this.queue.push(seg);
+        this.wakeFn?.();
+    }
+    nextJob() {
+        if (this.closing)
+            return null;
+        while (this.queue.length > 0) {
+            const seg = this.queue.shift();
+            if (seg.dropped) {
+                seg.queued = false;
+                continue;
+            }
+            return seg; // stays queued until compressSegment is done
+        }
+        return null;
+    }
+    /**
+     * Replaces a closed plain segment with a gzip copy: write
+     * <seq>.jsonl.gz.tmp, sync it, rename it to <seq>.jsonl.gz, then delete the
+     * plain file. Appends are not blocked. A crash at any point leaves either
+     * the plain file, or both files (and the next open deletes the plain one).
+     */
+    async compressSegment(seg) {
+        const src = seg.path;
+        const size = seg.size;
+        const dst = (src.endsWith(segment_1.SEG_EXT) ? src.slice(0, -segment_1.SEG_EXT.length) : src) + segment_1.SEG_EXT + segment_1.GZ_EXT;
+        const tmp = dst + segment_1.TMP_EXT;
+        const stop = () => seg.dropped || this.closing;
+        let disk = 0;
+        let err = null;
+        try {
+            disk = await (0, segment_1.compressFile)(src, tmp, size, stop);
+        }
+        catch (e) {
+            err = e;
+        }
+        seg.queued = false;
+        if (!err && stop())
+            err = new segment_1.AbortedError();
+        if (!err) {
+            try {
+                fs_1.default.renameSync(tmp, dst);
+            }
+            catch (e) {
+                err = e;
+            }
+        }
+        if (err) {
+            // A deleted segment or a closing store is not a failure.
+            const failed = !(err instanceof segment_1.AbortedError) && !(0, errors_1.isNotExist)(err);
+            if (failed)
+                seg.broken = true; // keep the plain file; do not retry
+            (0, segment_1.removeQuiet)(tmp);
+            if (failed)
+                this.log.warn('compress segment', { path: src, err });
+            return;
+        }
+        this.total += disk - seg.disk;
+        seg.path = dst;
+        seg.disk = disk;
+        seg.gz = true;
+        const sess = this.sessions.get(seg.session);
+        if (sess) {
+            try {
+                this.saveMeta(sess);
+            }
+            catch (e) {
+                this.log.warn('save session meta', { session: seg.session, err: e });
+            }
+        }
+        // Readers that opened the plain file keep reading it; new readers find
+        // the .gz (see readSegment).
+        (0, segment_1.syncDir)(path_1.default.dirname(dst));
+        try {
+            fs_1.default.unlinkSync(src);
+        }
+        catch (e) {
+            if (!(0, errors_1.isNotExist)(e))
+                this.log.warn("remove compressed segment's plain copy", { path: src, err: e });
+        }
+        this.log.debug('compressed segment', { path: dst, bytes: size, disk });
+    }
+}
+exports.Store = Store;
+function newSegment(seq, session, p, size, disk, gz) {
+    return { seq, session, path: p, size, disk, gz, broken: false, queued: false, dropped: false };
+}