repoburg 1.3.255 → 1.3.256

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

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RRWEB_META = exports.RRWEB_FULL_SNAPSHOT = void 0;
+exports.rrwebTypeOf = rrwebTypeOf;
+exports.parseRecord = parseRecord;
+exports.readRecords = readRecords;
+const errors_1 = require("../errors");
+/** rrweb's EventType.FullSnapshot. */
+exports.RRWEB_FULL_SNAPSHOT = 2;
+/** rrweb's EventType.Meta. */
+exports.RRWEB_META = 4;
+/** The rrweb event type of an rrweb record (2 = full snapshot, 4 = meta), or 0. */
+function rrwebTypeOf(r) {
+    return r.type === 'rrweb' ? r.sum.rrwebType : 0;
+}
+function isPlainObject(v) {
+    return typeof v === 'object' && v !== null && !Array.isArray(v);
+}
+/** Go's math.Round: halves away from zero. */
+function roundHalfAway(n) {
+    return Math.sign(n) * Math.round(Math.abs(n));
+}
+// Non-strings and non-numbers deliberately count as absent.
+const asString = (v) => (typeof v === 'string' ? v : '');
+const asInt = (v) => (typeof v === 'number' && Number.isFinite(v) ? Math.trunc(v) : 0);
+/**
+ * Extracts index fields from a record's data. Best effort: data that does not
+ * match the expected shape is still stored, it just does not contribute to
+ * the counters.
+ */
+function summarize(data) {
+    if (!isPlainObject(data)) {
+        return { rrwebType: 0, name: '', url: '', title: '', level: '', status: 0, err: '', userId: '', kind: '', rating: '' };
+    }
+    return {
+        rrwebType: asInt(data.type),
+        name: asString(data.name),
+        url: asString(data.url),
+        title: asString(data.title),
+        level: asString(data.level),
+        status: asInt(data.status),
+        err: asString(data.error),
+        userId: asString(data.userId),
+        kind: asString(data.kind),
+        rating: asString(data.rating),
+    };
+}
+/** Validates a single NDJSON line. */
+function parseRecord(input) {
+    const line = (typeof input === 'string' ? input : input.toString('utf8')).trim();
+    if (line === '' || line[0] !== '{')
+        throw new errors_1.RecordError('record must be a JSON object');
+    let v;
+    try {
+        v = JSON.parse(line);
+    }
+    catch (err) {
+        throw new errors_1.RecordError(`invalid JSON: ${err.message}`);
+    }
+    if (!isPlainObject(v))
+        throw new errors_1.RecordError('record must be a JSON object');
+    if (v.ts === undefined || v.ts === null)
+        throw new errors_1.RecordError('record has no "ts"');
+    if (typeof v.ts !== 'number' || !Number.isFinite(v.ts))
+        throw new errors_1.RecordError('decode record: "ts" must be a number');
+    if (v.type !== undefined && v.type !== null && typeof v.type !== 'string') {
+        throw new errors_1.RecordError('decode record: "type" must be a string');
+    }
+    if (!v.type)
+        throw new errors_1.RecordError('record has no "type"');
+    if (Object.prototype.hasOwnProperty.call(v, 'sid'))
+        throw new errors_1.RecordError('"sid" is set by the server');
+    return {
+        ts: roundHalfAway(v.ts),
+        type: v.type,
+        raw: JSON.stringify(v),
+        sum: summarize(v.data),
+    };
+}
+/**
+ * Parses an NDJSON body. Blank lines are ignored; any invalid line rejects
+ * the whole batch.
+ */
+function readRecords(body) {
+    const text = typeof body === 'string' ? body : body.toString('utf8');
+    const recs = [];
+    const lines = text.split('\n');
+    for (let i = 0; i < lines.length; i++) {
+        if (lines[i].trim() === '')
+            continue;
+        try {
+            recs.push(parseRecord(lines[i]));
+        }
+        catch (err) {
+            throw new errors_1.RecordError(`line ${i + 1}: ${err.message}`);
+        }
+    }
+    return recs;
+}

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

@@ -0,0 +1,267 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbortedError = exports.TMP_EXT = exports.GZ_EXT = exports.SEG_EXT = void 0;
+exports.segmentName = segmentName;
+exports.parseSegmentName = parseSegmentName;
+exports.readSegment = readSegment;
+exports.readSegmentBytes = readSegmentBytes;
+exports.gzipSizes = gzipSizes;
+exports.compressFile = compressFile;
+exports.syncDir = syncDir;
+exports.removeQuiet = removeQuiet;
+exports.repairTail = repairTail;
+/**
+ * Segment files. A segment is written as plain JSONL; once closed it may be
+ * compressed to <seq>.jsonl.gz through <seq>.jsonl.gz.tmp. Readers address
+ * data by uncompressed offsets, so both forms read the same.
+ */
+const fs_1 = __importDefault(require("fs"));
+const promises_1 = __importDefault(require("fs/promises"));
+const stream_1 = require("stream");
+const promises_2 = require("stream/promises");
+const zlib_1 = __importDefault(require("zlib"));
+const errors_1 = require("../errors");
+exports.SEG_EXT = '.jsonl';
+exports.GZ_EXT = '.gz';
+exports.TMP_EXT = '.tmp';
+const READ_CHUNK = 256 * 1024;
+function segmentName(seq) {
+    return String(seq).padStart(16, '0') + exports.SEG_EXT;
+}
+/** Recognizes "<seq>.jsonl", "<seq>.jsonl.gz" and "<seq>.jsonl.gz.tmp". */
+function parseSegmentName(name) {
+    let base;
+    let kind;
+    if (name.endsWith(exports.SEG_EXT + exports.GZ_EXT + exports.TMP_EXT)) {
+        base = name.slice(0, -(exports.SEG_EXT + exports.GZ_EXT + exports.TMP_EXT).length);
+        kind = 'temp';
+    }
+    else if (name.endsWith(exports.SEG_EXT + exports.GZ_EXT)) {
+        base = name.slice(0, -(exports.SEG_EXT + exports.GZ_EXT).length);
+        kind = 'gzip';
+    }
+    else if (name.endsWith(exports.SEG_EXT)) {
+        base = name.slice(0, -exports.SEG_EXT.length);
+        kind = 'plain';
+    }
+    else {
+        return null;
+    }
+    if (!/^\d+$/.test(base))
+        return null;
+    const seq = Number(base);
+    return Number.isSafeInteger(seq) ? { seq, kind } : null;
+}
+/**
+ * Reads up to `limit` uncompressed bytes of a segment, starting at the
+ * uncompressed offset `off`. `path` is a segment path as reported by a store
+ * snapshot: a segment compressed since then is found under its new name,
+ * because the .gz file is renamed into place before the plain file is
+ * removed. A reader that already opened the plain file keeps reading it.
+ * Throws an ENOENT error (see isNotExist) when the segment was deleted.
+ */
+async function* readSegment(path, off, limit) {
+    if (limit <= 0)
+        return;
+    if (!path.endsWith(exports.GZ_EXT)) {
+        let fh = null;
+        try {
+            fh = await promises_1.default.open(path, 'r');
+        }
+        catch (err) {
+            if (!(0, errors_1.isNotExist)(err))
+                throw err;
+            path += exports.GZ_EXT;
+        }
+        if (fh) {
+            try {
+                let pos = off;
+                let left = limit;
+                while (left > 0) {
+                    const n = Math.min(left, READ_CHUNK);
+                    const buf = Buffer.allocUnsafe(n);
+                    const { bytesRead } = await fh.read(buf, 0, n, pos);
+                    if (bytesRead === 0)
+                        break;
+                    pos += bytesRead;
+                    left -= bytesRead;
+                    yield bytesRead === n ? buf : buf.subarray(0, bytesRead);
+                }
+            }
+            finally {
+                await fh.close();
+            }
+            return;
+        }
+    }
+    yield* readGzip(path, off, limit);
+}
+/** Opens a read stream, rejecting (ENOENT: deleted) before any data flows. */
+function openReadStream(path, opts) {
+    return new Promise((resolve, reject) => {
+        const s = fs_1.default.createReadStream(path, opts);
+        const onError = (err) => reject(err);
+        s.once('error', onError);
+        s.once('open', () => {
+            s.off('error', onError);
+            resolve(s);
+        });
+    });
+}
+async function* readGzip(path, off, limit) {
+    const src = await openReadStream(path, { highWaterMark: 64 * 1024 });
+    const gunzip = zlib_1.default.createGunzip();
+    src.on('error', (err) => gunzip.destroy(err));
+    src.pipe(gunzip);
+    let skip = off;
+    let left = limit;
+    try {
+        for await (const piece of gunzip) {
+            let chunk = piece;
+            if (skip > 0) {
+                if (chunk.length <= skip) {
+                    skip -= chunk.length;
+                    continue;
+                }
+                chunk = chunk.subarray(skip);
+                skip = 0;
+            }
+            if (chunk.length > left)
+                chunk = chunk.subarray(0, left);
+            left -= chunk.length;
+            yield chunk;
+            if (left <= 0)
+                break;
+        }
+    }
+    finally {
+        src.destroy();
+        gunzip.destroy();
+    }
+}
+/** The first `limit` uncompressed bytes of a segment. */
+async function readSegmentBytes(path, limit) {
+    const parts = [];
+    for await (const chunk of readSegment(path, 0, limit))
+        parts.push(chunk);
+    return Buffer.concat(parts);
+}
+/**
+ * A compressed segment's size on disk and its uncompressed size, read from
+ * the gzip trailer (ISIZE, the size modulo 2^32; segments are far smaller).
+ */
+function gzipSizes(path) {
+    const fd = fs_1.default.openSync(path, 'r');
+    try {
+        const disk = fs_1.default.fstatSync(fd).size;
+        const MIN_GZIP = 18; // 10-byte header + 8-byte trailer
+        if (disk < MIN_GZIP)
+            throw new Error('not a gzip file: too short');
+        const head = Buffer.alloc(2);
+        fs_1.default.readSync(fd, head, 0, 2, 0);
+        if (head[0] !== 0x1f || head[1] !== 0x8b)
+            throw new Error('not a gzip file');
+        const tail = Buffer.alloc(4);
+        fs_1.default.readSync(fd, tail, 0, 4, disk - 4);
+        return { disk, raw: tail.readUInt32LE(0) };
+    }
+    finally {
+        fs_1.default.closeSync(fd);
+    }
+}
+/** Stops a compression whose segment was deleted or whose store is closing. */
+class AbortedError extends Error {
+    constructor() {
+        super('compression aborted');
+        this.name = 'AbortedError';
+    }
+}
+exports.AbortedError = AbortedError;
+/**
+ * Writes the first `size` bytes of src to dst as gzip, syncs dst to disk and
+ * returns its size. `stop` is checked before every chunk.
+ */
+async function compressFile(src, dst, size, stop) {
+    const reader = size > 0 ? await openReadStream(src, { start: 0, end: size - 1, highWaterMark: READ_CHUNK }) : stream_1.Readable.from([]);
+    let copied = 0;
+    const guard = new stream_1.Transform({
+        transform(chunk, _enc, cb) {
+            if (stop()) {
+                cb(new AbortedError());
+                return;
+            }
+            copied += chunk.length;
+            cb(null, chunk);
+        },
+    });
+    await (0, promises_2.pipeline)(reader, guard, zlib_1.default.createGzip(), fs_1.default.createWriteStream(dst, { mode: 0o644 }));
+    if (copied !== size)
+        throw new Error(`segment is ${copied} bytes, expected ${size}`);
+    const out = await promises_1.default.open(dst, 'r+');
+    try {
+        await out.sync();
+        return (await out.stat()).size;
+    }
+    finally {
+        await out.close();
+    }
+}
+/** Makes a rename in dir durable. Best effort: not every platform can sync a directory. */
+function syncDir(dir) {
+    try {
+        const fd = fs_1.default.openSync(dir, 'r');
+        try {
+            fs_1.default.fsyncSync(fd);
+        }
+        finally {
+            fs_1.default.closeSync(fd);
+        }
+    }
+    catch {
+        // best effort, see above
+    }
+}
+/** Removes a file that may not exist. */
+function removeQuiet(path) {
+    try {
+        fs_1.default.unlinkSync(path);
+    }
+    catch {
+        // cleanup of a file that may not exist
+    }
+}
+/** Truncates a partial last line left by an interrupted write and returns the resulting size. */
+function repairTail(path) {
+    const fd = fs_1.default.openSync(path, 'r+');
+    try {
+        const size = fs_1.default.fstatSync(fd).size;
+        if (size === 0)
+            return 0;
+        const last = Buffer.alloc(1);
+        fs_1.default.readSync(fd, last, 0, 1, size - 1);
+        if (last[0] === 0x0a)
+            return size;
+        const CHUNK = 64 * 1024;
+        const buf = Buffer.alloc(CHUNK);
+        for (let end = size; end > 0;) {
+            const start = Math.max(0, end - CHUNK);
+            const n = end - start;
+            fs_1.default.readSync(fd, buf, 0, n, start);
+            const i = buf.subarray(0, n).lastIndexOf(0x0a);
+            if (i >= 0) {
+                const repaired = start + i + 1;
+                fs_1.default.ftruncateSync(fd, repaired);
+                return repaired;
+            }
+            end = start;
+        }
+        fs_1.default.ftruncateSync(fd, 0);
+        return 0;
+    }
+    finally {
+        fs_1.default.closeSync(fd);
+    }
+}