repoburg 1.3.255 → 1.3.256

package/daemon/dist/tabtape/mcp/definitions.js

@@ -0,0 +1,362 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArgumentsError = exports.TOOL_LIST = void 0;
+exports.decodeArguments = decodeArguments;
+exports.hasTool = hasTool;
+exports.callTool = callTool;
+const errors_1 = require("../errors");
+const types_1 = require("../query/types");
+const gofmt_1 = require("./gofmt");
+// ---------- schema building ----------
+const STR = { type: 'string' };
+const INT = { type: 'integer' };
+const NUM = { type: 'number' };
+const BOOL = { type: 'boolean' };
+const NULL_NUM = { type: ['null', 'number'] };
+/** A Go map[string]string: never null (jsonschema-go does not make maps nullable). */
+const STR_MAP = { type: 'object', additionalProperties: STR };
+/** A Go struct: no other properties; fields without omitempty are required ("required" is left out when none are). */
+function obj(properties, required, nullable = false) {
+    return {
+        type: nullable ? ['null', 'object'] : 'object',
+        properties,
+        ...(required.length > 0 ? { required } : {}),
+        additionalProperties: false,
+    };
+}
+/** A Go slice: null when nil. */
+const list = (items) => ({ type: ['null', 'array'], items });
+const sessionOut = obj({
+    id: STR,
+    startedAt: STR,
+    durationMs: INT,
+    title: STR,
+    url: STR,
+    browser: STR,
+    pages: INT,
+    clicks: INT,
+    errors: INT,
+    failedRequests: INT,
+    trimmed: BOOL,
+    live: BOOL,
+    source: STR,
+    user: STR,
+    perf: STR,
+    replay: STR,
+}, ['id', 'startedAt', 'durationMs', 'pages', 'clicks', 'errors', 'failedRequests', 'replay']);
+const itemOut = obj({ id: STR, at: STR, offsetMs: INT, kind: STR, text: STR, replay: STR }, ['id', 'at', 'offsetMs', 'kind', 'text', 'replay']);
+const frameCounts = obj({ sent: INT, received: INT, sentBytes: NUM, receivedBytes: NUM, dropped: INT, dataOmitted: INT }, ['sent', 'received', 'sentBytes', 'receivedBytes'], true);
+const requestSummaryProps = {
+    id: STR,
+    at: STR,
+    offsetMs: INT,
+    kind: STR,
+    method: STR,
+    url: STR,
+    status: INT,
+    error: STR,
+    durationMs: NULL_NUM,
+    size: NUM,
+    frames: frameCounts,
+    reqBody: STR,
+    resBody: STR,
+    replay: STR,
+};
+const requestSummaryRequired = ['id', 'at', 'offsetMs', 'kind', 'method', 'url', 'replay'];
+const blockedCookie = obj({ name: STR, reasons: list(STR), domain: STR, path: STR }, ['name', 'reasons']);
+const frameOut = obj({
+    id: STR,
+    at: STR,
+    offsetMs: INT,
+    dir: STR,
+    opcode: INT,
+    size: NUM,
+    data: STR,
+    truncated: BOOL,
+    dataOmitted: BOOL,
+    dropped: INT,
+    error: STR,
+}, ['id', 'at', 'offsetMs', 'dir', 'opcode', 'size']);
+const timing = obj({ blocked: NULL_NUM, dns: NULL_NUM, connect: NULL_NUM, ssl: NULL_NUM, send: NULL_NUM, wait: NULL_NUM, receive: NULL_NUM }, [], true);
+const consoleItem = obj({ id: STR, at: STR, offsetMs: INT, level: STR, source: STR, text: STR, stack: STR, location: STR, replay: STR }, ['id', 'at', 'offsetMs', 'level', 'source', 'text', 'replay']);
+const stateActionOut = obj({ id: STR, at: STR, offsetMs: INT, store: STR, action: STR, changes: list(STR), replay: STR }, ['id', 'at', 'offsetMs', 'store', 'action', 'replay']);
+const OUTPUT = {
+    list: obj({ sessions: list(sessionOut), matched: INT }, ['sessions', 'matched']),
+    summary: obj({ session: sessionOut, items: list(itemOut), total: INT, next_cursor: STR }, ['session', 'items', 'total']),
+    network: obj({ requests: list(obj(requestSummaryProps, requestSummaryRequired)), matched: INT, next_cursor: STR }, ['requests', 'matched']),
+    request: obj({
+        ...requestSummaryProps,
+        statusText: STR,
+        ttfbMs: NULL_NUM,
+        mime: STR,
+        initiator: STR,
+        reqHeaders: STR_MAP,
+        resHeaders: STR_MAP,
+        reqBodyNote: STR,
+        resBodyNote: STR,
+        reqBodyLength: INT,
+        resBodyLength: INT,
+        next_body_offset: INT,
+        recorded: STR,
+        protocol: STR,
+        remoteAddress: STR,
+        cache: STR,
+        worker: obj({ type: STR, url: STR }, ['type', 'url'], true),
+        timing,
+        failureReason: STR,
+        blockedCookies: list(blockedCookie),
+        blockedSetCookies: list(blockedCookie),
+        messages: list(frameOut),
+        messagesTotal: INT,
+        next_frames_offset: INT,
+    }, requestSummaryRequired),
+    console: obj({ messages: list(consoleItem), matched: INT, next_cursor: STR }, ['messages', 'matched']),
+    context: obj({ at: STR, offsetMs: INT, items: list(itemOut), stateActions: list(stateActionOut) }, ['at', 'offsetMs', 'items']),
+    repro: obj({ markdown: STR, steps: INT, replay: STR }, ['markdown', 'steps', 'replay']),
+    recordLink: obj({ start: STR, stop: STR }, ['start', 'stop']),
+};
+// ---------- the tools ----------
+const SESSION_LATEST = 'session id, or latest';
+const CURSOR = 'continue a cut result: pass next_cursor from the previous call';
+const FROM = 'start of the time window: mm:ss(.mmm), a duration like 90s, or milliseconds';
+const TO = 'end of the time window, same format as from';
+function def(name, description, params, output, run) {
+    return { name, description, params, output, run: run };
+}
+const TOOLS = [
+    def('list_sessions', 'List tabtape recordings, newest first, with page, click, error and failed-request counts, the identified user and a replay link. Filter by text, user, time and errors.', [
+        { name: 'query', type: 'string', description: 'only sessions whose title, URL, id or user id contains this text (case-insensitive)' },
+        {
+            name: 'user',
+            type: 'string',
+            description: 'only sessions of this user: the id the page passed to tabtape.identify() contains this text (case-insensitive)',
+        },
+        { name: 'since', type: 'string', description: 'only sessions started within this long (e.g. 2h, 30m, 3d) or after this RFC 3339 time' },
+        { name: 'has_errors', type: 'boolean', description: 'only sessions with console errors or failed requests' },
+        { name: 'limit', type: 'integer', description: 'maximum number of sessions (default 20)' },
+    ], OUTPUT.list, (t, input) => t.listSessions(input)),
+    def('get_session_summary', "What happened in a recording, in order: page views, clicks, form changes, submits, the app's own events (tabtape.track), console errors, failed requests, poor Web Vitals and long freezes, each with its time and replay link. Also the identified user (tabtape.identify).", [
+        { name: 'session_id', type: 'string', description: 'session id, or latest for the most recent recording', required: true },
+        { name: 'cursor', type: 'string', description: CURSOR },
+    ], OUTPUT.summary, (t, input) => t.getSessionSummary(input)),
+    def('get_network', 'Network requests of a recording: time, method, URL, status, duration, size and request id. Filter by status, URL, method, kind (websocket for WebSocket connections) and time window.', [
+        { name: 'session_id', type: 'string', description: SESSION_LATEST, required: true },
+        { name: 'status', type: 'string', description: 'status filter: 500, 5xx, >=400, failed (>=400 or network error), error (network errors only)' },
+        { name: 'url_contains', type: 'string', description: 'only URLs containing this text (case-insensitive)' },
+        { name: 'method', type: 'string', description: 'HTTP method, e.g. POST' },
+        {
+            name: 'kind',
+            type: 'string',
+            description: 'fetch, xhr, beacon, api (fetch+xhr+beacon), document, resource (scripts, images, CSS), or websocket (deep mode recordings)',
+        },
+        { name: 'from', type: 'string', description: FROM },
+        { name: 'to', type: 'string', description: TO },
+        {
+            name: 'include_bodies',
+            type: 'boolean',
+            description: 'also return request and response bodies, cut to 2000 characters (use get_request for the full body)',
+        },
+        { name: 'limit', type: 'integer', description: 'maximum number of requests (default 50)' },
+        { name: 'cursor', type: 'string', description: CURSOR },
+    ], OUTPUT.network, (t, input) => t.getNetwork(input)),
+    def('get_request', 'One request in full: headers (sensitive ones redacted), request and response bodies in pages of 20000 characters, and timing. Deep mode recordings add the timing split, cookies Chrome blocked and why a request failed (CORS, ...). For a WebSocket connection it returns its messages in order, 100 per call.', [
+        { name: 'session_id', type: 'string', description: SESSION_LATEST, required: true },
+        { name: 'request_id', type: 'string', description: 'request id from get_network or get_session_summary, e.g. n12-345', required: true },
+        { name: 'body_offset', type: 'integer', description: 'character offset into the bodies, for bodies longer than 20000 characters' },
+        { name: 'frames_offset', type: 'integer', description: 'WebSocket connections: index of the first message to return (100 per call)' },
+    ], OUTPUT.request, (t, input) => t.getRequest(input)),
+    def('get_console', 'Console output of a recording: level, source, message and a short stack. Uncaught errors and unhandled rejections are level error.', [
+        { name: 'session_id', type: 'string', description: SESSION_LATEST, required: true },
+        { name: 'level', type: 'string', description: 'error, warn, info, log, debug or trace; warn+ means warnings and errors' },
+        { name: 'text_contains', type: 'string', description: 'only messages containing this text (case-insensitive)' },
+        { name: 'from', type: 'string', description: FROM },
+        { name: 'to', type: 'string', description: TO },
+        { name: 'limit', type: 'integer', description: 'maximum number of messages (default 100)' },
+        { name: 'cursor', type: 'string', description: CURSOR },
+    ], OUTPUT.console, (t, input) => t.getConsole(input)),
+    def('get_context_at', 'Everything around one moment, in order: user actions, requests and console messages from 10 seconds before to 2 seconds after (adjustable), then the last 10 Redux / Zustand store actions before the moment with the state paths they changed. Use it to see what led to an error.', [
+        { name: 'session_id', type: 'string', description: SESSION_LATEST, required: true },
+        {
+            name: 'at',
+            type: 'string',
+            description: 'the moment: mm:ss(.mmm) like 01:23.4, or the id of a request, console message or event',
+            required: true,
+        },
+        { name: 'before', type: 'string', description: 'how far to look back: seconds or a duration like 1500ms (default 10s)' },
+        { name: 'after', type: 'string', description: 'how far to look ahead (default 2s)' },
+    ], OUTPUT.context, (t, input) => t.getContextAt(input)),
+    def('get_repro_steps', 'Markdown reproduction steps for a bug report: environment, numbered user actions with failed requests and console errors under the step that caused them, and a replay link.', [
+        { name: 'session_id', type: 'string', description: SESSION_LATEST, required: true },
+        { name: 'from', type: 'string', description: 'start of the range: mm:ss(.mmm), a duration like 90s, or milliseconds' },
+        { name: 'to', type: 'string', description: 'end of the range, same format as from' },
+        { name: 'lang', type: 'string', description: 'en (default) or tr' },
+    ], OUTPUT.repro, (t, input) => t.getReproSteps(input)),
+    def('get_record_link', 'Links that start and stop a tabtape recording in the browser that opens them, e.g. one driven by Playwright MCP: open the start link before checking a page and the stop link after it. The stop page names the session to look at with the other tools. The browser needs the tabtape extension.', [
+        {
+            name: 'name',
+            type: 'string',
+            description: "what is about to be recorded, e.g. the check you are going to run; it becomes the recording's title",
+        },
+        {
+            name: 'url',
+            type: 'string',
+            description: 'page the tab opens once the recording runs (http, https or file URL); recorded from its first request',
+        },
+    ], OUTPUT.recordLink, (t, input) => t.getRecordLink(input)),
+].sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0)); // the Go SDK lists tools by name
+const BY_NAME = new Map(TOOLS.map((t) => [t.name, t]));
+function inputSchema(params) {
+    const properties = {};
+    for (const p of params)
+        properties[p.name] = { type: p.type, description: p.description };
+    const required = params.filter((p) => p.required).map((p) => p.name);
+    return { type: 'object', properties, ...(required.length > 0 ? { required } : {}), additionalProperties: false };
+}
+/** The tools as tools/list returns them. */
+exports.TOOL_LIST = TOOLS.map((t) => ({
+    name: t.name,
+    description: t.description,
+    inputSchema: inputSchema(t.params),
+    outputSchema: t.output,
+    // The Go SDK always sends idempotentHint and readOnlyHint.
+    annotations: { idempotentHint: false, openWorldHint: false, readOnlyHint: true },
+}));
+// ---------- arguments ----------
+/** Arguments that do not match a tool's input schema. */
+class ArgumentsError extends Error {
+    constructor(detail) {
+        super(`validating "arguments": ${detail}`);
+        this.name = 'ArgumentsError';
+    }
+}
+exports.ArgumentsError = ArgumentsError;
+/** jsonschema-go's JSON type of a decoded value; whole numbers are integers. */
+function jsonType(v) {
+    if (v === null)
+        return 'null';
+    if (Array.isArray(v))
+        return 'array';
+    if (typeof v === 'number')
+        return Number.isInteger(v) ? 'integer' : 'number';
+    return typeof v;
+}
+/** fmt's %v of a float64: shortest digits, exponent form below 1e-4 and from 1e6. */
+function goFloat(n) {
+    if (Number.isNaN(n))
+        return 'NaN';
+    if (!Number.isFinite(n))
+        return n > 0 ? '+Inf' : '-Inf';
+    if (n === 0)
+        return Object.is(n, -0) ? '-0' : '0';
+    const [mant, e] = n.toExponential().split('e');
+    const exp = Number(e);
+    if (exp < -4 || exp >= 6)
+        return `${mant}e${exp < 0 ? '-' : '+'}${String(Math.abs(exp)).padStart(2, '0')}`;
+    return String(n);
+}
+/** fmt's %v of a value decoded by encoding/json (a JSON null is an invalid reflect.Value there). */
+function goValue(v) {
+    if (v === null || v === undefined)
+        return '<invalid reflect.Value>';
+    if (typeof v === 'number')
+        return goFloat(v);
+    if (Array.isArray(v))
+        return '[' + v.map(goValue).join(' ') + ']';
+    if ((0, types_1.isObj)(v)) {
+        return ('map[' +
+            Object.keys(v)
+                .sort()
+                .map((k) => k + ':' + goValue(v[k]))
+                .join(' ') +
+            ']');
+    }
+    return String(v);
+}
+/** fmt's %q of a []string. */
+const goQuoteList = (list) => '[' + list.map(gofmt_1.goQuote).join(' ') + ']';
+const has = (o, k) => Object.prototype.hasOwnProperty.call(o, k);
+function fits(v, type) {
+    switch (type) {
+        case 'string':
+            return typeof v === 'string';
+        case 'integer':
+            return typeof v === 'number' && Number.isInteger(v);
+        case 'boolean':
+            return typeof v === 'boolean';
+    }
+}
+/**
+ * Validates arguments against a tool's parameters like the Go SDK does
+ * (property types, then unknown properties, then required ones) and fills in
+ * Go's zero values for the missing ones. Strings get Go's JSON decoding of
+ * lone surrogates (U+FFFD).
+ */
+function decodeArguments(params, raw) {
+    const args = raw === undefined || raw === null ? {} : raw;
+    if (!(0, types_1.isObj)(args)) {
+        throw new ArgumentsError(`validating root: type: ${goValue(args)} has type ${(0, gofmt_1.goQuote)(jsonType(args))}, want "object"`);
+    }
+    for (const p of params) {
+        if (!has(args, p.name))
+            continue;
+        const v = args[p.name];
+        if (!fits(v, p.type)) {
+            throw new ArgumentsError(`validating root: validating /properties/${p.name}: type: ${goValue(v)} has type ${(0, gofmt_1.goQuote)(jsonType(v))}, want ${(0, gofmt_1.goQuote)(p.type)}`);
+        }
+    }
+    const known = new Set(params.map((p) => p.name));
+    const extra = Object.keys(args).filter((k) => !known.has(k));
+    if (extra.length > 0)
+        throw new ArgumentsError(`validating root: unexpected additional properties ${goQuoteList(extra.sort())}`);
+    const missing = params.filter((p) => p.required && !has(args, p.name)).map((p) => p.name);
+    if (missing.length > 0)
+        throw new ArgumentsError(`validating root: required: missing properties: ${goQuoteList(missing)}`);
+    const out = {};
+    for (const p of params) {
+        const v = args[p.name];
+        if (v === undefined)
+            out[p.name] = p.type === 'string' ? '' : p.type === 'integer' ? 0 : false;
+        else
+            out[p.name] = typeof v === 'string' ? (0, gofmt_1.wellFormed)(v) : v;
+    }
+    return out;
+}
+/** Whether a tool exists. */
+function hasTool(name) {
+    return BY_NAME.has(name);
+}
+/**
+ * A copy of a JSON value with object keys sorted and undefined fields left
+ * out. The Go SDK validated structured output as a map[string]any and sent
+ * that re-encoded, which sorts keys at every level.
+ */
+function sortKeys(v) {
+    if (Array.isArray(v))
+        return v.map(sortKeys);
+    if (!(0, types_1.isObj)(v))
+        return v;
+    const out = {};
+    for (const k of Object.keys(v).sort()) {
+        if (v[k] !== undefined)
+            out[k] = sortKeys(v[k]);
+    }
+    return out;
+}
+/**
+ * Runs a tool. Invalid arguments and tool failures come back as error
+ * results (isError), which the model sees and can correct; an unknown tool
+ * name throws.
+ */
+async function callTool(tools, name, args) {
+    const def = BY_NAME.get(name);
+    if (!def)
+        throw new Error(`unknown tool ${(0, gofmt_1.goQuote)(name)}`);
+    try {
+        const input = decodeArguments(def.params, args);
+        const { text, out } = await def.run(tools, input);
+        return { content: [{ type: 'text', text }], structuredContent: sortKeys(out) };
+    }
+    catch (err) {
+        return { content: [{ type: 'text', text: (0, errors_1.errorMessage)(err) }], isError: true };
+    }
+}

package/daemon/dist/tabtape/mcp/gofmt.js

@@ -0,0 +1,227 @@
+"use strict";
+/**
+ * Text helpers that reproduce what the Go server printed: strconv.Quote
+ * (fmt's %q), %-Ns padding, UTF-8 byte lengths (Go strings are bytes), Go's
+ * strings.TrimSpace and strings.ToLower, and time formatting in a zone.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TextBuf = void 0;
+exports.goQuote = goQuote;
+exports.runeCount = runeCount;
+exports.padRight = padRight;
+exports.byteLen = byteLen;
+exports.goTrimSpace = goTrimSpace;
+exports.goToLower = goToLower;
+exports.wellFormed = wellFormed;
+exports.formatRFC3339 = formatRFC3339;
+exports.formatStamp = formatStamp;
+exports.rfc3339DateTime = rfc3339DateTime;
+const PRINTABLE = /^[\p{L}\p{M}\p{N}\p{P}\p{S}]$/u;
+const HEX = '0123456789abcdef';
+function hex(cp, digits) {
+    let s = '';
+    for (let shift = (digits - 1) * 4; shift >= 0; shift -= 4)
+        s += HEX[(cp >> shift) & 0xf];
+    return s;
+}
+/** Go's unicode.IsPrint: letters, marks, numbers, punctuation, symbols and the ASCII space. */
+function isPrint(cp) {
+    return cp === 0x20 || PRINTABLE.test(String.fromCodePoint(cp));
+}
+/** Go's strconv.Quote, which fmt's %q uses for strings. */
+function goQuote(s) {
+    let out = '"';
+    for (const ch of s) {
+        let cp = ch.codePointAt(0);
+        if (cp >= 0xd800 && cp <= 0xdfff)
+            cp = 0xfffd; // a lone surrogate: Go decoded it as U+FFFD
+        if (cp === 0x22 || cp === 0x5c) {
+            out += '\\' + String.fromCodePoint(cp);
+            continue;
+        }
+        if (isPrint(cp)) {
+            out += String.fromCodePoint(cp);
+            continue;
+        }
+        switch (cp) {
+            case 0x07:
+                out += '\\a';
+                continue;
+            case 0x08:
+                out += '\\b';
+                continue;
+            case 0x0c:
+                out += '\\f';
+                continue;
+            case 0x0a:
+                out += '\\n';
+                continue;
+            case 0x0d:
+                out += '\\r';
+                continue;
+            case 0x09:
+                out += '\\t';
+                continue;
+            case 0x0b:
+                out += '\\v';
+                continue;
+        }
+        if (cp < 0x20 || cp === 0x7f)
+            out += '\\x' + hex(cp, 2);
+        else if (cp < 0x10000)
+            out += '\\u' + hex(cp, 4);
+        else
+            out += '\\U' + hex(cp, 8);
+    }
+    return out + '"';
+}
+/** Number of code points (Go's runes). */
+function runeCount(s) {
+    let n = 0;
+    for (let i = 0; i < s.length; i++) {
+        const c = s.charCodeAt(i);
+        if (c >= 0xd800 && c <= 0xdbff) {
+            const d = s.charCodeAt(i + 1);
+            if (d >= 0xdc00 && d <= 0xdfff)
+                i++;
+        }
+        n++;
+    }
+    return n;
+}
+/** fmt's %-Ns: pads s with spaces to width runes. */
+function padRight(s, width) {
+    const n = runeCount(s);
+    return n < width ? s + ' '.repeat(width - n) : s;
+}
+/** UTF-8 length, which is what len() of a Go string counts. */
+function byteLen(s) {
+    return Buffer.byteLength(s, 'utf8');
+}
+/** A strings.Builder that knows its length in UTF-8 bytes. */
+class TextBuf {
+    constructor() {
+        this.parts = [];
+        /** Bytes written so far. */
+        this.len = 0;
+    }
+    write(s) {
+        this.parts.push(s);
+        this.len += byteLen(s);
+    }
+    toString() {
+        return this.parts.join('');
+    }
+}
+exports.TextBuf = TextBuf;
+/** Go's unicode.IsSpace. */
+function isGoSpace(c) {
+    return ((c >= 0x09 && c <= 0x0d) ||
+        c === 0x20 ||
+        c === 0x85 ||
+        c === 0xa0 ||
+        c === 0x1680 ||
+        (c >= 0x2000 && c <= 0x200a) ||
+        c === 0x2028 ||
+        c === 0x2029 ||
+        c === 0x202f ||
+        c === 0x205f ||
+        c === 0x3000);
+}
+/** Go's strings.TrimSpace: Unicode white space at both ends. */
+function goTrimSpace(s) {
+    let i = 0;
+    let j = s.length;
+    while (i < j && isGoSpace(s.charCodeAt(i)))
+        i++;
+    while (j > i && isGoSpace(s.charCodeAt(j - 1)))
+        j--;
+    return s.slice(i, j);
+}
+const CAPITAL_I_WITH_DOT = String.fromCharCode(0x130);
+const CAPITAL_SIGMA = String.fromCharCode(0x3a3);
+const SMALL_SIGMA = String.fromCharCode(0x3c3);
+/**
+ * Go's strings.ToLower, which maps rune by rune. JavaScript's toLowerCase
+ * differs in two places: it turns "İ" into "i" plus a combining dot and a
+ * word-final "Σ" into "ς".
+ */
+function goToLower(s) {
+    let ascii = true;
+    for (let i = 0; i < s.length && ascii; i++)
+        ascii = s.charCodeAt(i) < 0x80;
+    if (ascii)
+        return s.toLowerCase();
+    return s.split(CAPITAL_I_WITH_DOT).join('i').split(CAPITAL_SIGMA).join(SMALL_SIGMA).toLowerCase();
+}
+/** Replaces lone surrogates with U+FFFD, as Go's JSON decoder does. */
+function wellFormed(s) {
+    let out = '';
+    let last = 0;
+    for (let i = 0; i < s.length; i++) {
+        const c = s.charCodeAt(i);
+        if (c < 0xd800 || c > 0xdfff)
+            continue;
+        if (c <= 0xdbff) {
+            const d = s.charCodeAt(i + 1);
+            if (d >= 0xdc00 && d <= 0xdfff) {
+                i++;
+                continue;
+            }
+        }
+        out += s.slice(last, i) + String.fromCharCode(0xfffd);
+        last = i + 1;
+    }
+    return last === 0 ? s : out + s.slice(last);
+}
+const formatters = new Map();
+function formatter(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',
+            second: '2-digit',
+            hourCycle: 'h23',
+        });
+        formatters.set(key, f);
+    }
+    return f;
+}
+/** The date and time of epoch ms in a time zone (undefined: the machine's). */
+function wallClock(ms, timeZone) {
+    const parts = formatter(timeZone).formatToParts(new Date(ms));
+    const get = (type) => Number(parts.find((p) => p.type === type)?.value ?? '0');
+    const w = { year: get('year'), month: get('month'), day: get('day'), hour: get('hour'), minute: get('minute'), second: get('second'), offset: 0 };
+    const asUTC = new Date(0);
+    asUTC.setUTCFullYear(w.year, w.month - 1, w.day);
+    asUTC.setUTCHours(w.hour, w.minute, w.second, 0);
+    w.offset = Math.round((asUTC.getTime() - Math.floor(ms / 1000) * 1000) / 1000);
+    return w;
+}
+const pad = (n, width) => String(n).padStart(width, '0');
+/** Go's time.RFC3339 layout, e.g. "2025-10-05T07:47:12Z" or "2025-10-05T09:47:12+02:00". */
+function formatRFC3339(ms, timeZone) {
+    const w = wallClock(ms, timeZone);
+    let zone = 'Z';
+    if (w.offset !== 0) {
+        const minutes = Math.trunc(Math.abs(w.offset) / 60);
+        zone = (w.offset < 0 ? '-' : '+') + pad(Math.floor(minutes / 60), 2) + ':' + pad(minutes % 60, 2);
+    }
+    return `${pad(w.year, 4)}-${pad(w.month, 2)}-${pad(w.day, 2)}T${pad(w.hour, 2)}:${pad(w.minute, 2)}:${pad(w.second, 2)}${zone}`;
+}
+const MONTHS = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
+/** Go's "Jan 2 15:04" layout, e.g. "Oct 5 07:47". */
+function formatStamp(ms, timeZone) {
+    const w = wallClock(ms, timeZone);
+    return `${MONTHS[w.month - 1]} ${w.day} ${pad(w.hour, 2)}:${pad(w.minute, 2)}`;
+}
+/** An RFC 3339 time of formatRFC3339 in Go's "2006-01-02 15:04:05" layout, in its own zone. */
+function rfc3339DateTime(t) {
+    return t.slice(0, 10) + ' ' + t.slice(11, 19);
+}