repoburg 1.3.254 → 1.3.256

package/daemon/dist/tabtape/query/format.js

@@ -0,0 +1,195 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clock = clock;
+exports.clockShort = clockShort;
+exports.replayLink = replayLink;
+exports.browserLabel = browserLabel;
+exports.splitURL = splitURL;
+exports.origin = origin;
+exports.targetText = targetText;
+exports.targetTag = targetTag;
+exports.fieldName = fieldName;
+exports.oneLine = oneLine;
+exports.clip = clip;
+exports.firstLine = firstLine;
+exports.fmtMs = fmtMs;
+exports.fmtBytes = fmtBytes;
+exports.formatTime = formatTime;
+const pad = (n, w = 2) => String(n).padStart(w, '0');
+/** An offset as mm:ss.mmm (h:mm:ss.mmm past an hour). */
+function clock(ms) {
+    const t = Math.max(Math.trunc(ms), 0);
+    const s = Math.floor(t / 1000);
+    const milli = t % 1000;
+    const h = Math.floor(s / 3600);
+    const m = Math.floor((s % 3600) / 60);
+    if (h > 0)
+        return `${h}:${pad(m)}:${pad(s % 60)}.${pad(milli, 3)}`;
+    return `${pad(m)}:${pad(s % 60)}.${pad(milli, 3)}`;
+}
+/** An offset as mm:ss (h:mm:ss past an hour). */
+function clockShort(ms) {
+    const s = Math.floor(Math.max(Math.trunc(ms), 0) / 1000);
+    const h = Math.floor(s / 3600);
+    const m = Math.floor((s % 3600) / 60);
+    if (h > 0)
+        return `${h}:${pad(m)}:${pad(s % 60)}`;
+    return `${pad(m)}:${pad(s % 60)}`;
+}
+/** Opens the replay UI at an offset. */
+function replayLink(base, id, offset) {
+    return `${base.replace(/\/+$/, '')}/#/s/${id}?t=${Math.max(Math.trunc(offset), 0)}`;
+}
+const RE_EDGE = /Edg\/(\d+)/;
+const RE_OPERA = /OPR\/(\d+)/;
+const RE_CHROME = /Chrome\/(\d+)/;
+/** Turns a user agent into "Chrome 141 · macOS", like the UI. */
+function browserLabel(ua) {
+    if (!ua)
+        return '';
+    let browser = 'Browser';
+    let m;
+    if ((m = RE_EDGE.exec(ua)))
+        browser = `Edge ${m[1]}`;
+    else if ((m = RE_OPERA.exec(ua)))
+        browser = `Opera ${m[1]}`;
+    else if ((m = RE_CHROME.exec(ua)))
+        browser = `Chrome ${m[1]}`;
+    if (ua.includes('Mac OS X'))
+        return `${browser} · macOS`;
+    if (ua.includes('Windows'))
+        return `${browser} · Windows`;
+    if (ua.includes('Linux'))
+        return `${browser} · Linux`;
+    return browser;
+}
+function parseURL(raw) {
+    try {
+        return new URL(raw);
+    }
+    catch {
+        return null;
+    }
+}
+/** The host and the path with query and fragment; no host means the raw string as the path. */
+function splitURL(raw) {
+    const u = parseURL(raw);
+    if (!u || !u.host)
+        return { host: '', path: raw };
+    return { host: u.host, path: u.pathname + u.search + u.hash || '/' };
+}
+/** scheme://host of a URL, or "" if it has none. */
+function origin(raw) {
+    const u = parseURL(raw);
+    if (!u || !u.host)
+        return '';
+    return `${u.protocol.replace(/:$/, '')}://${u.host}`;
+}
+/** The visible label of an element, if it has one. */
+function targetText(t) {
+    if (!t)
+        return '';
+    return t.text || t.ariaLabel || t.title || t.alt || t.placeholder || '';
+}
+/** A short tag#id description of an element. */
+function targetTag(t) {
+    if (!t)
+        return 'element';
+    return t.id ? `${t.tag}#${t.id}` : t.tag;
+}
+/** Names a form field: its name, id, label or placeholder. */
+function fieldName(t) {
+    if (!t)
+        return '';
+    return t.name || t.id || t.ariaLabel || t.placeholder || t.testId || '';
+}
+/** Collapses whitespace and clips to n characters. */
+function oneLine(s, n) {
+    return clip(s.replace(/[\t\n\f\r ]+/g, ' ').trim(), n);
+}
+/** Shortens s to at most n characters (code points), ending in "…" when cut. */
+function clip(s, n) {
+    if (s.length <= n)
+        return s; // UTF-16 length >= code points
+    const keep = Math.max(n - 1, 0);
+    let count = 0;
+    let cut = 0;
+    let i = 0;
+    for (const ch of s) {
+        count++;
+        i += ch.length;
+        if (count === keep)
+            cut = i;
+        if (count > n)
+            return s.slice(0, cut) + '…';
+    }
+    return s;
+}
+/** The first line of s. */
+function firstLine(s) {
+    const i = s.indexOf('\n');
+    return i < 0 ? s : s.slice(0, i);
+}
+/** A duration in milliseconds like the UI: "412 ms", "1.24 s". */
+function fmtMs(ms) {
+    if (ms < 1000)
+        return `${ms.toFixed(0)} ms`;
+    if (ms < 10000)
+        return `${(ms / 1000).toFixed(2)} s`;
+    return `${(ms / 1000).toFixed(1)} s`;
+}
+/** A size like the UI: "812 B", "1.2 KB", "3.4 MB". */
+function fmtBytes(n) {
+    if (n < 1024)
+        return `${n.toFixed(0)} B`;
+    if (n < 1024 * 1024)
+        return `${(n / 1024).toFixed(1)} KB`;
+    if (n < 1024 * 1024 * 1024)
+        return `${(n / 1024 / 1024).toFixed(1)} MB`;
+    return `${(n / 1024 / 1024 / 1024).toFixed(2)} GB`;
+}
+const formatters = new Map();
+/** Building a formatter costs far more than using one: keep one per time zone. */
+function formatterFor(timeZone) {
+    const key = timeZone ?? '';
+    let f = formatters.get(key);
+    if (!f) {
+        f = new Intl.DateTimeFormat('en-US', {
+            timeZone,
+            year: 'numeric',
+            month: '2-digit',
+            day: '2-digit',
+            hour: '2-digit',
+            minute: '2-digit',
+            hourCycle: 'h23',
+        });
+        formatters.set(key, f);
+    }
+    return f;
+}
+/** Formats epoch ms in a time zone (default: the machine's) with a pattern of YYYY, MM, DD, HH, mm, MMM, D. */
+function formatTime(ms, pattern, timeZone) {
+    const parts = formatterFor(timeZone).formatToParts(new Date(ms));
+    const get = (type) => parts.find((p) => p.type === type)?.value ?? '';
+    const months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
+    const month = Number(get('month'));
+    return pattern.replace(/YYYY|MMM|MM|DD|HH|mm|D/g, (tok) => {
+        switch (tok) {
+            case 'YYYY':
+                return get('year');
+            case 'MMM':
+                return months[month - 1] ?? '';
+            case 'MM':
+                return get('month');
+            case 'DD':
+                return get('day');
+            case 'D':
+                return String(Number(get('day')));
+            case 'HH':
+                return get('hour');
+            case 'mm':
+                return get('minute');
+        }
+        return tok;
+    });
+}

package/daemon/dist/tabtape/query/network.js

@@ -0,0 +1,133 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.failureReason = failureReason;
+exports.cookieReasons = cookieReasons;
+exports.timingText = timingText;
+exports.framesText = framesText;
+exports.remoteIP = remoteIP;
+/**
+ * Network failure texts. The sentences match the replay UI
+ * (tabtape/ui/src/lib/network.ts), so a failure reads the same in the Network
+ * tab, MCP results and reproduction steps.
+ */
+const format_1 = require("./format");
+const CORS_ERRORS = {
+    MissingAllowOriginHeader: 'CORS: the response has no Access-Control-Allow-Origin header',
+    AllowOriginMismatch: "CORS: Access-Control-Allow-Origin does not match this page's origin",
+    MultipleAllowOriginValues: 'CORS: the response has more than one Access-Control-Allow-Origin value',
+    InvalidAllowOriginValue: 'CORS: Access-Control-Allow-Origin has an invalid value',
+    WildcardOriginNotAllowed: 'CORS: Access-Control-Allow-Origin is * but the request sends credentials',
+    InvalidAllowCredentials: 'CORS: Access-Control-Allow-Credentials must be true for a request with credentials',
+    PreflightInvalidStatus: 'CORS: the preflight request did not succeed (HTTP status not 2xx)',
+    PreflightMissingAllowOriginHeader: 'CORS: the preflight response has no Access-Control-Allow-Origin header',
+    PreflightAllowOriginMismatch: "CORS: the preflight's Access-Control-Allow-Origin does not match this page's origin",
+    MethodDisallowedByPreflightResponse: 'CORS: the preflight does not allow this method',
+    HeaderDisallowedByPreflightResponse: 'CORS: the preflight does not allow this header',
+    PreflightDisallowedRedirect: 'CORS: the preflight was redirected, which is not allowed',
+    DisallowedByMode: 'CORS: the request mode does not allow cross-origin responses',
+    CorsDisabledScheme: 'CORS: cross-origin requests are not supported for this URL scheme',
+};
+const BLOCKED_REASONS = {
+    'mixed-content': 'Blocked: mixed content (an http:// request from an https:// page)',
+    csp: "Blocked by the page's Content Security Policy",
+    inspector: 'Blocked by DevTools request blocking',
+    'subresource-filter': "Blocked by Chrome's ad filter",
+    'content-type': "Blocked: the response's Content-Type is not allowed here",
+    origin: "Blocked: the request's origin is not allowed",
+};
+const own = (m, k) => Object.prototype.hasOwnProperty.call(m, k) ? m[k] : undefined;
+/**
+ * Why a request failed, in one sentence: the CORS check or the reason Chrome
+ * blocked it (deep mode), else the error text. Empty for requests that did
+ * not fail at the transport level.
+ */
+function failureReason(n) {
+    const c = n.corsErrorStatus;
+    if (c && c.corsError) {
+        let s = own(CORS_ERRORS, c.corsError) ?? `CORS error: ${c.corsError}`;
+        if (c.failedParameter)
+            s += ` (${c.failedParameter})`;
+        return s;
+    }
+    const r = n.blockedReason;
+    if (r) {
+        const s = own(BLOCKED_REASONS, r);
+        if (s)
+            return s;
+        if (r.startsWith('corp-'))
+            return "Blocked by the response's Cross-Origin-Resource-Policy header";
+        if (r.startsWith('coep-'))
+            return 'Blocked by Cross-Origin-Embedder-Policy';
+        return `Blocked by Chrome (${r})`;
+    }
+    return n.error;
+}
+const COOKIE_REASONS = {
+    SameSiteNoneInsecure: 'SameSite=None requires Secure',
+    SecureOnly: 'Secure cookie on an insecure connection',
+    SameSiteLax: 'SameSite=Lax: not sent on cross-site requests',
+    SameSiteStrict: 'SameSite=Strict: not sent on cross-site requests',
+    SameSiteUnspecifiedTreatedAsLax: 'no SameSite attribute (treated as Lax)',
+    DomainMismatch: 'domain does not match',
+    NotOnPath: 'path does not match',
+    UserPreferences: "blocked by the user's cookie settings",
+    ThirdPartyPhaseout: 'third-party cookies are blocked',
+    ThirdPartyBlockedInFirstPartySet: 'third-party cookies are blocked',
+    SyntaxError: 'invalid Set-Cookie syntax',
+    InvalidDomain: 'invalid Domain attribute',
+    InvalidPrefix: 'invalid __Secure-/__Host- prefix',
+    OverwriteSecure: 'would overwrite a Secure cookie',
+    SchemeNotSupported: 'URL scheme does not support cookies',
+};
+/** Chrome's reasons for blocking a cookie, e.g. "SameSite=None requires Secure [SameSiteNoneInsecure]". */
+function cookieReasons(codes) {
+    return codes
+        .map((c) => {
+        const s = own(COOKIE_REASONS, c);
+        return s ? `${s} [${c}]` : c;
+    })
+        .join('; ');
+}
+/** A deep mode request's timing phases, e.g. "DNS 12 ms · connect 30 ms (TLS 18 ms) · wait 120 ms · download 4 ms". */
+function timingText(t) {
+    if (!t)
+        return '';
+    const parts = [];
+    const add = (name, v) => {
+        if (v !== undefined && v > 0)
+            parts.push(`${name} ${(0, format_1.fmtMs)(v)}`);
+    };
+    add('queued', t.blocked);
+    add('DNS', t.dns);
+    if (t.connect !== undefined && t.connect > 0) {
+        let s = `connect ${(0, format_1.fmtMs)(t.connect)}`;
+        if (t.ssl !== undefined && t.ssl > 0)
+            s += ` (TLS ${(0, format_1.fmtMs)(t.ssl)})`;
+        parts.push(s);
+    }
+    add('send', t.send);
+    add('wait', t.wait);
+    add('download', t.receive);
+    return parts.join(' · ');
+}
+/** Summarizes a WebSocket connection, e.g. "3↑ 3↓ messages, 1.2 KB". */
+function framesText(f) {
+    if (!f)
+        return '';
+    let s = `${f.sent}↑ ${f.received}↓ messages, ${(0, format_1.fmtBytes)(f.sentBytes + f.receivedBytes)}`;
+    if (f.dropped > 0)
+        s += `, ${f.dropped} not recorded (over 200/s)`;
+    if (f.dataOmitted > 0)
+        s += `, ${f.dataOmitted} without data (over 1 MB/s)`;
+    return s;
+}
+/** The address part of a remote address ("ip:port", "[v6]:port"). */
+function remoteIP(addr) {
+    const v6 = /^\[([^\]]*)\]:\d*$/.exec(addr);
+    if (v6)
+        return v6[1];
+    const i = addr.indexOf(':');
+    if (i >= 0 && i === addr.lastIndexOf(':'))
+        return addr.slice(0, i);
+    return addr.replace(/^[[\]]+|[[\]]+$/g, '');
+}

package/daemon/dist/tabtape/query/perf.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.vitalValue = vitalValue;
+exports.vitalText = vitalText;
+exports.baseName = baseName;
+exports.longestScript = longestScript;
+exports.sortedJSON = sortedJSON;
+exports.propsText = propsText;
+/** Web Vitals and long animation frame texts. */
+const format_1 = require("./format");
+/** A metric's value; CLS has no unit. */
+function vitalValue(name, value) {
+    return name === 'CLS' ? value.toFixed(2) : (0, format_1.fmtMs)(value);
+}
+/** Describes a report, e.g. "INP 612 ms (poor) on button#slow". */
+function vitalText(p) {
+    let s = `${p.name} ${vitalValue(p.name, p.value)} (${p.rating})`;
+    if (p.attribution && p.attribution.target)
+        s += ` on ${p.attribution.target}`;
+    return s;
+}
+/** The path of a URL; relative URLs are taken as they are, without query or fragment. */
+function urlPath(raw) {
+    try {
+        const u = new URL(raw);
+        try {
+            return decodeURIComponent(u.pathname);
+        }
+        catch {
+            return u.pathname;
+        }
+    }
+    catch {
+        return raw.split(/[?#]/, 1)[0];
+    }
+}
+/** Like Go's path.Base. */
+function baseName(p) {
+    const trimmed = p.replace(/\/+$/, '');
+    if (trimmed === '')
+        return '/';
+    return trimmed.slice(trimmed.lastIndexOf('/') + 1);
+}
+/** Names the longest script of a long animation frame, e.g. "slow.js handleClick"; empty when the frame has none. */
+function longestScript(p) {
+    if (!p.scripts || p.scripts.length === 0)
+        return '';
+    const s = p.scripts[0];
+    let name = s.url;
+    const path = s.url ? urlPath(s.url) : '';
+    if (path !== '' && path !== '/')
+        name = baseName(path);
+    const parts = [name, s.fn].filter(Boolean);
+    if (parts.length > 0)
+        return parts.join(' ');
+    return s.invoker;
+}
+/** JSON with object keys sorted, like Go's encoding of maps. */
+function sortedJSON(v) {
+    return JSON.stringify(v, (_k, x) => {
+        if (x && typeof x === 'object' && !Array.isArray(x)) {
+            const o = x;
+            return Object.keys(o)
+                .sort()
+                .reduce((acc, k) => {
+                acc[k] = o[k];
+                return acc;
+            }, {});
+        }
+        return x;
+    });
+}
+function propValue(v) {
+    if (typeof v === 'string')
+        return (0, format_1.oneLine)(v, 40);
+    if (v === null || v === undefined)
+        return 'null';
+    if (typeof v === 'number' || typeof v === 'boolean')
+        return String(v);
+    try {
+        return (0, format_1.clip)(sortedJSON(v) ?? '?', 40);
+    }
+    catch {
+        return '?';
+    }
+}
+/** Event properties as "key: value" pairs, sorted by key and clipped to n characters. */
+function propsText(props, n) {
+    if (!props)
+        return '';
+    const keys = Object.keys(props).sort();
+    return (0, format_1.clip)(keys.map((k) => `${k}: ${propValue(props[k])}`).join(', '), n);
+}

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

@@ -0,0 +1,233 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const log_1 = require("../log");
+const store_1 = require("../store/store");
+const qt = __importStar(require("../testing/querytest"));
+const tmp_1 = require("../testing/tmp");
+const format_1 = require("./format");
+const network_1 = require("./network");
+const perf_1 = require("./perf");
+const reader_1 = require("./reader");
+const types_1 = require("./types");
+const t0 = qt.T0;
+afterEach(async () => {
+    await qt.closeTestStores();
+    (0, tmp_1.cleanupTempDirs)();
+});
+describe('Reader', () => {
+    it('orders lines and finds the replay start', async () => {
+        const st = qt.testStore();
+        qt.start(st, 's1', t0, 'http://app.test/', 'App');
+        // A page view that arrives before the first snapshot, and a network line
+        // that arrives out of order (the background posts it later).
+        qt.append(st, 's1', qt.pageView(t0 + 5, 'start', 'http://app.test/', 'App'), qt.rrMeta(t0 + 10, 'http://app.test/', 1280, 800), qt.rrFull(t0 + 10), qt.rrInc(t0 + 500), qt.click(t0 + 900, 'http://app.test/', { tag: 'button', selector: 'button#go', text: 'Go' }));
+        qt.append(st, 's1', qt.net(t0 + 700, { kind: 'fetch', method: 'GET', url: 'http://app.test/api', status: 500, resBody: '{"error":"x"}' }), qt.consoleRec(t0 + 950, { level: 'error', source: 'uncaught', text: 'Boom' }));
+        const v = await new reader_1.Reader(st).view('s1');
+        expect([v.replayable, v.start - t0, v.end - t0]).toEqual([true, 10, 500]);
+        expect(v.lines.map((l) => l.type).join(',')).toBe('event,rrweb,rrweb,rrweb,network,event,console');
+        expect(v.offset(t0 + 5)).toBe(0);
+        const n = v.lines[4];
+        expect(n.net?.status).toBe(500);
+        expect(n.net?.resBody).toBeUndefined(); // bodies are not indexed
+        expect((await v.fullNetwork(n)).resBody).toBe('{"error":"x"}');
+        expect([v.lines[1].rr, v.lines[2].rr]).toEqual([reader_1.RR_META, reader_1.RR_FULL_SNAPSHOT]);
+        expect(n.id.startsWith('n')).toBe(true);
+        expect(v.find(n.id)).toBe(n);
+    });
+    it('is incremental and keeps ids stable', async () => {
+        const st = qt.testStore();
+        const r = new reader_1.Reader(st);
+        qt.append(st, 's1', qt.rrMeta(t0, 'http://a/', 800, 600), qt.rrFull(t0), qt.consoleRec(t0 + 1, { level: 'log', text: 'one' }));
+        const v1 = await r.view('s1');
+        const id = v1.lines[2].id;
+        qt.append(st, 's1', qt.consoleRec(t0 + 2, { level: 'log', text: 'two' }));
+        const v2 = await r.view('s1');
+        expect(v2.lines.length).toBe(4);
+        expect(v2.lines[2].id).toBe(id);
+        expect(v2.lines[3].con?.text).toBe('two');
+    });
+    it('drops evicted segments', async () => {
+        const st = store_1.Store.open({ dir: (0, tmp_1.tempDir)(), maxBytes: 4096, segmentBytes: 1024, logger: log_1.silentLogger });
+        try {
+            const r = new reader_1.Reader(st);
+            const big = 'x'.repeat(300);
+            for (let i = 0; i < 40; i++) {
+                qt.append(st, 's1', qt.consoleRec(t0 + i, { level: 'log', text: big }));
+                await r.view('s1');
+            }
+            const v = await r.view('s1');
+            expect(v.session.truncated).toBe(true);
+            expect(v.lines.length).toBeGreaterThan(0);
+            expect(v.lines.length).toBeLessThan(40);
+            for (const l of v.lines)
+                await v.readLine(l);
+        }
+        finally {
+            await st.close();
+        }
+    });
+    it('reads compressed segments the same', async () => {
+        const st = qt.testStore({ maxBytes: 64 << 20, segmentBytes: 1 << 10, compress: 'gzip' });
+        const u = 'http://app.test/';
+        qt.start(st, 's1', t0, u, 'App');
+        qt.append(st, 's1', qt.rrMeta(t0, u, 1280, 800), qt.rrFull(t0));
+        for (let i = 0; i < 20; i++) {
+            qt.append(st, 's1', qt.net(t0 + i * 100, { kind: 'fetch', method: 'GET', url: u + 'api', status: 200, resBody: 'y'.repeat(200) + String.fromCharCode(97 + i) }));
+        }
+        const rd = new reader_1.Reader(st);
+        const before = await rd.view('s1'); // indexed while the segments are plain
+        st.end('s1', 0);
+        await (0, tmp_1.eventually)('segments to be compressed', () => st.snapshot('s1').segments.every((s) => s.path.endsWith('.gz')));
+        const after = await rd.view('s1');
+        expect(after.lines.length).toBe(before.lines.length);
+        // The old view still holds the plain paths; both read every body.
+        for (const v of [before, after]) {
+            let n = 0;
+            for (const l of v.lines) {
+                if (!l.net)
+                    continue;
+                const full = await v.fullNetwork(l);
+                expect(full.resBody?.endsWith(String.fromCharCode(97 + n))).toBe(true);
+                n++;
+            }
+            let scanned = 0;
+            await v.scan(() => {
+                scanned++;
+            });
+            expect([n, scanned]).toEqual([20, v.lines.length]);
+        }
+    });
+    it('indexes WebSocket and state records', async () => {
+        const st = qt.testStore();
+        qt.append(st, 's1', qt.rrMeta(t0, 'http://app.test/', 1280, 800), qt.rrFull(t0), qt.ws(t0 + 100, 'ws-1', 'send', '{"type":"hello"}'), qt.stateRec(t0 + 200, { store: 'cart', kind: 'action', action: 'cart/add', changes: [{ path: '/cart/items/0', value: { id: 1 }, deleted: false }] }), qt.stateRec(t0 + 300, { store: 'cart', kind: 'snapshot', reason: 'interval', state: { cart: { items: [1] } } }));
+        const v = await new reader_1.Reader(st).view('s1');
+        const [w, action, snap] = [v.lines[2], v.lines[3], v.lines[4]];
+        expect(w.ws?.conn).toBe('ws-1');
+        expect(w.ws?.data).toBeUndefined(); // data is not indexed
+        expect(w.id[0]).toBe('w');
+        expect((await v.fullWS(w)).data).toBe('{"type":"hello"}');
+        expect(action.state).toMatchObject({ store: 'cart', action: 'cart/add', changes: 1, paths: ['/cart/items/0'], full: false });
+        expect(action.id[0]).toBe('s');
+        expect(snap.state).toMatchObject({ full: true, reason: 'interval' });
+        const full = await v.fullState(action);
+        expect(JSON.stringify(full.changes?.[0].value)).toBe('{"id":1}');
+    });
+    it('skips the bulk of rrweb lines but still reads them', async () => {
+        const st = qt.testStore();
+        const big = { ts: t0 + 1, type: 'rrweb', data: { type: 3, data: { source: 0, texts: [{ id: 1, value: 'z'.repeat(1 << 20) }] } } };
+        qt.append(st, 's1', qt.rrMeta(t0, 'http://a/', 800, 600), qt.rrFull(t0), big, qt.consoleRec(t0 + 2, { level: 'log', text: 'after' }));
+        const v = await new reader_1.Reader(st).view('s1');
+        expect(v.lines.map((l) => [l.type, l.rr])).toEqual([
+            ['rrweb', 4],
+            ['rrweb', 2],
+            ['rrweb', 3],
+            ['console', -1],
+        ]);
+        expect((await v.readLine(v.lines[2])).length).toBeGreaterThan(1 << 20);
+        expect(v.lines[3].con?.text).toBe('after');
+        let sizes = 0;
+        await v.scan((_l, raw) => {
+            sizes += raw.length;
+        });
+        expect(sizes).toBe(v.lines.reduce((s, l) => s + l.len, 0));
+    });
+});
+describe('format', () => {
+    it('formats clocks', () => {
+        const cases = [
+            [0, '00:00.000'],
+            [83400, '01:23.400'],
+            [3723004, '1:02:03.004'],
+            [-5, '00:00.000'],
+        ];
+        for (const [ms, want] of cases)
+            expect((0, format_1.clock)(ms)).toBe(want);
+    });
+    it('clips by characters', () => {
+        expect((0, format_1.clip)('abc', 3)).toBe('abc');
+        expect((0, format_1.clip)('abcd', 3)).toBe('ab…');
+        expect((0, format_1.clip)('😀😀😀😀', 3)).toBe('😀😀…');
+        expect((0, format_1.oneLine)('  a \n\t b  ', 10)).toBe('a b');
+    });
+    it('formats durations and splits URLs', () => {
+        expect([(0, format_1.fmtMs)(412), (0, format_1.fmtMs)(1240), (0, format_1.fmtMs)(12340)]).toEqual(['412 ms', '1.24 s', '12.3 s']);
+        expect((0, format_1.splitURL)('https://a.test/x?y=1#z')).toEqual({ host: 'a.test', path: '/x?y=1#z' });
+        expect((0, format_1.splitURL)('/relative')).toEqual({ host: '', path: '/relative' });
+    });
+});
+describe('network texts', () => {
+    const n = (p) => ({ ...(0, types_1.decodeNetwork)({}), ...p });
+    const cases = [
+        [
+            'cors',
+            n({ error: 'net::ERR_FAILED', corsErrorStatus: { corsError: 'MissingAllowOriginHeader', failedParameter: '' } }),
+            'CORS: the response has no Access-Control-Allow-Origin header',
+        ],
+        [
+            'cors with parameter',
+            n({ corsErrorStatus: { corsError: 'AllowOriginMismatch', failedParameter: 'http://other.test' } }),
+            "CORS: Access-Control-Allow-Origin does not match this page's origin (http://other.test)",
+        ],
+        [
+            'unknown cors error',
+            n({ corsErrorStatus: { corsError: 'LocalNetworkAccessPermissionDenied', failedParameter: '' } }),
+            'CORS error: LocalNetworkAccessPermissionDenied',
+        ],
+        ['mixed content', n({ error: 'net::ERR_BLOCKED_BY_CLIENT', blockedReason: 'mixed-content' }), 'Blocked: mixed content (an http:// request from an https:// page)'],
+        ['corp', n({ blockedReason: 'corp-not-same-site' }), "Blocked by the response's Cross-Origin-Resource-Policy header"],
+        ['other block', n({ blockedReason: 'sri-message-signature-mismatch' }), 'Blocked by Chrome (sri-message-signature-mismatch)'],
+        ['plain error', n({ error: 'net::ERR_CONNECTION_REFUSED' }), 'net::ERR_CONNECTION_REFUSED'],
+        ['http error', n({ status: 500 }), ''],
+    ];
+    for (const [name, input, want] of cases) {
+        it(`explains failures: ${name}`, () => expect((0, network_1.failureReason)(input)).toBe(want));
+    }
+    it('describes cookies, timings and addresses', () => {
+        expect((0, network_1.cookieReasons)(['SameSiteNoneInsecure', 'NewReason'])).toBe('SameSite=None requires Secure [SameSiteNoneInsecure]; NewReason');
+        expect((0, network_1.timingText)({ blocked: 1.5, dns: 12, connect: 30, ssl: 18, send: -1, wait: 120, receive: 4 })).toBe('queued 2 ms · DNS 12 ms · connect 30 ms (TLS 18 ms) · wait 120 ms · download 4 ms');
+        expect((0, network_1.remoteIP)('127.0.0.1:7788')).toBe('127.0.0.1');
+        expect((0, network_1.remoteIP)('[::1]:443')).toBe('::1');
+        expect((0, network_1.remoteIP)('10.0.0.1')).toBe('10.0.0.1');
+    });
+});
+describe('perf texts', () => {
+    it('names the longest script and renders props', () => {
+        const p = { kind: 'loaf', name: '', value: 0, rating: '', id: '', url: '', duration: 600, blockingDuration: 550 };
+        expect((0, perf_1.longestScript)({ ...p, scripts: [{ url: 'http://a.test/js/slow.js?v=1', fn: 'handleClick', invoker: '', invokerType: '', duration: 1 }] })).toBe('slow.js handleClick');
+        expect((0, perf_1.longestScript)({ ...p, scripts: [{ url: '', fn: '', invoker: 'BUTTON#go.onclick', invokerType: '', duration: 1 }] })).toBe('BUTTON#go.onclick');
+        expect((0, perf_1.propsText)({ plan: 'pro', items: 3, nested: { b: 1, a: 2 }, none: null }, 120)).toBe('items: 3, nested: {"a":2,"b":1}, none: null, plan: pro');
+    });
+});