@pro-vi/designer 0.3.10 → 0.3.11

package/dist/run-state.js

@@ -0,0 +1,327 @@
+import { CdpSession } from "./cdp-trace.js";
+export const OMELETTE_TURN_SERVICE = 'anthropic.omelette.api.v1alpha.OmeletteService';
+export const TURN_RPCS = ['Chat', 'RenewTurn', 'ReleaseTurn'];
+function asRec(v) {
+    return v && typeof v === 'object' && !Array.isArray(v) ? v : {};
+}
+function num(v) {
+    return typeof v === 'number' && Number.isFinite(v) ? v : null;
+}
+function eventWallMs(params) {
+    const syntheticTraceTs = num(params.ts);
+    if (syntheticTraceTs !== null)
+        return syntheticTraceTs;
+    const wallTime = num(params.wallTime);
+    return wallTime !== null ? wallTime * 1000 : null;
+}
+function requestId(params) {
+    return typeof params.requestId === 'string' ? params.requestId : undefined;
+}
+export function turnRpcFromUrl(url) {
+    if (!url)
+        return null;
+    let path = url;
+    try {
+        path = new URL(url).pathname;
+    }
+    catch {
+    }
+    const escapedService = OMELETTE_TURN_SERVICE.replace(/\./g, '\\.');
+    const match = path.match(new RegExp(`(?:^|/)${escapedService}/(Chat|RenewTurn|ReleaseTurn)(?:$|[/?#])`));
+    if (!match?.[1])
+        return null;
+    return TURN_RPCS.includes(match[1]) ? match[1] : null;
+}
+export function observedRpcPathFromUrl(url) {
+    if (!url)
+        return null;
+    let path = url;
+    try {
+        path = new URL(url).pathname;
+    }
+    catch {
+    }
+    const serviceIdx = path.indexOf(`${OMELETTE_TURN_SERVICE}/`);
+    if (serviceIdx >= 0)
+        return path.slice(serviceIdx);
+    const idx = path.indexOf('OmeletteService/');
+    return idx >= 0 ? path.slice(idx) : null;
+}
+export function isTurnRpcUrl(url) {
+    return turnRpcFromUrl(url) !== null;
+}
+function urlFromParams(method, params) {
+    if (typeof params.requestUrl === 'string')
+        return params.requestUrl;
+    if (typeof params.url === 'string')
+        return params.url;
+    if (method === 'Network.requestWillBeSent') {
+        const req = asRec(params.request);
+        return typeof req.url === 'string' ? req.url : '';
+    }
+    if (method === 'Network.responseReceived') {
+        const resp = asRec(params.response);
+        return typeof resp.url === 'string' ? resp.url : '';
+    }
+    return '';
+}
+function isCriticalRpc(rpc) {
+    return rpc === 'Chat' || rpc === 'RenewTurn';
+}
+export function classifyEvent(method, rawParams, runStartTs) {
+    const params = asRec(rawParams);
+    const wallMs = eventWallMs(params);
+    if (wallMs !== null && wallMs < runStartTs)
+        return null;
+    const url = urlFromParams(method, params);
+    const rpc = turnRpcFromUrl(url);
+    if (method === 'Network.requestWillBeSent') {
+        if (rpc === 'Chat')
+            return { kind: 'chat-open', requestId: requestId(params) };
+        if (rpc === 'RenewTurn')
+            return { kind: 'heartbeat', requestId: requestId(params) };
+        if (rpc === 'ReleaseTurn')
+            return { kind: 'release', requestId: requestId(params) };
+        return null;
+    }
+    if (method === 'Network.dataReceived' && rpc === 'Chat') {
+        return { kind: 'chat-chunk', requestId: requestId(params) };
+    }
+    if (method === 'Network.responseReceived') {
+        const response = asRec(params.response);
+        const status = num(response.status);
+        if (status !== null && status >= 400 && isCriticalRpc(rpc)) {
+            return { kind: 'critical-error', rpc, status };
+        }
+        return null;
+    }
+    if (method === 'Network.loadingFailed' && isCriticalRpc(rpc)) {
+        return { kind: 'critical-error', rpc, status: 'failed' };
+    }
+    return null;
+}
+export class RunStateObserver extends CdpSession {
+    now;
+    currentState = 'idle';
+    runStartTs = 0;
+    lastActivity = 0;
+    priorRunSignals = 0;
+    terminalResult = null;
+    watchdog = null;
+    waiters = [];
+    requestUrls = new Map();
+    observedRpcPaths = new Set();
+    signalCounts = {
+        chatOpen: 0,
+        chatChunk: 0,
+        heartbeat: 0,
+        release: 0,
+        criticalError: 0,
+        observerLost: 0
+    };
+    closeCount = 0;
+    constructor(ws, target, opts = {}) {
+        super(ws, target, opts);
+        this.now = opts.now ?? (() => Date.now());
+    }
+    static async attach(opts = {}) {
+        if (typeof WebSocket === 'undefined')
+            return null;
+        try {
+            const { ws, target } = await RunStateObserver.connectTarget(opts);
+            const observer = new RunStateObserver(ws, target, opts);
+            await observer.start();
+            return observer;
+        }
+        catch {
+            return null;
+        }
+    }
+    async start() {
+        await this.enableDomains();
+    }
+    beginRun() {
+        if (this.terminalResult)
+            return;
+        this.runStartTs = this.now();
+        this.lastActivity = this.runStartTs;
+        this.priorRunSignals = 0;
+        this.requestUrls.clear();
+        this.observedRpcPaths.clear();
+        this.resetSignalCounts();
+        this.currentState = 'running';
+    }
+    get state() {
+        if (this.terminalResult)
+            return this.terminalResult.terminal;
+        return this.currentState;
+    }
+    awaitTerminal({ stallMs = 25_000, hardTimeoutMs = 20 * 60_000 } = {}) {
+        if (this.terminalResult)
+            return Promise.resolve(this.terminalResult);
+        this.armWatchdog(stallMs, hardTimeoutMs);
+        this.checkSilence(stallMs, hardTimeoutMs);
+        if (this.terminalResult)
+            return Promise.resolve(this.terminalResult);
+        return new Promise((resolve) => {
+            this.waiters.push(resolve);
+        });
+    }
+    close() {
+        this.clearWatchdog();
+        if (this.closeSocket())
+            this.closeCount++;
+    }
+    signalSummary() {
+        return {
+            ...this.signalCounts,
+            observedRpcPaths: [...this.observedRpcPaths].sort()
+        };
+    }
+    closeCountForTest() {
+        return this.closeCount;
+    }
+    consumeSignalForTest(signal) {
+        this.consumeSignal(signal);
+    }
+    socketGapForTest(detail = { reason: 'test' }) {
+        this.onSocketGap(detail);
+    }
+    tickForTest({ stallMs = 25_000, hardTimeoutMs = 20 * 60_000 } = {}) {
+        this.checkSilence(stallMs, hardTimeoutMs);
+    }
+    onEvent(method, rawParams, _sessionId) {
+        if (this.currentState === 'idle' && !this.terminalResult)
+            return;
+        const params = this.enrichParams(method, rawParams);
+        if (method === 'Network.responseReceived' || method === 'Network.loadingFailed') {
+            const id = requestId(params);
+            if (!id || !this.requestUrls.has(id))
+                return;
+        }
+        const signal = classifyEvent(method, params, this.runStartTs);
+        if (signal)
+            this.consumeSignal(signal);
+    }
+    onSocketGap(_detail) {
+        if (this.currentState === 'running' || this.currentState === 'stalled') {
+            this.consumeSignal({ kind: 'observer-lost' });
+        }
+    }
+    onSocketReconnectFailed() {
+        this.consumeSignal({ kind: 'observer-lost' });
+    }
+    enrichParams(method, rawParams) {
+        const params = { ...asRec(rawParams) };
+        const id = requestId(params);
+        if (method === 'Network.requestWillBeSent' && id) {
+            const wallMs = eventWallMs(params);
+            if (wallMs !== null && wallMs < this.runStartTs)
+                return params;
+            const req = asRec(params.request);
+            const url = typeof req.url === 'string' ? req.url : '';
+            if (url) {
+                this.requestUrls.set(id, url);
+                const rpcPath = observedRpcPathFromUrl(url);
+                if (rpcPath)
+                    this.observedRpcPaths.add(rpcPath);
+            }
+        }
+        else if (id && !params.requestUrl) {
+            const url = this.requestUrls.get(id);
+            if (url)
+                params.requestUrl = url;
+        }
+        return params;
+    }
+    consumeSignal(signal) {
+        if (this.terminalResult)
+            return;
+        this.countSignal(signal);
+        if (signal.kind === 'observer-lost') {
+            this.latch('observer-lost');
+            return;
+        }
+        if (this.currentState === 'idle')
+            return;
+        if (signal.kind === 'chat-open' || signal.kind === 'chat-chunk' || signal.kind === 'heartbeat') {
+            this.lastActivity = this.now();
+            this.priorRunSignals++;
+            this.currentState = 'running';
+            return;
+        }
+        if (signal.kind === 'release') {
+            if (this.priorRunSignals === 0)
+                return;
+            this.latch('finished');
+            return;
+        }
+        if (signal.kind === 'critical-error') {
+            this.latch('blocked', `${signal.rpc} ${signal.status === 'failed' ? 'failed' : `HTTP ${signal.status}`}`);
+        }
+    }
+    countSignal(signal) {
+        if (signal.kind === 'chat-open')
+            this.signalCounts.chatOpen++;
+        else if (signal.kind === 'chat-chunk')
+            this.signalCounts.chatChunk++;
+        else if (signal.kind === 'heartbeat')
+            this.signalCounts.heartbeat++;
+        else if (signal.kind === 'release')
+            this.signalCounts.release++;
+        else if (signal.kind === 'critical-error')
+            this.signalCounts.criticalError++;
+        else if (signal.kind === 'observer-lost')
+            this.signalCounts.observerLost++;
+    }
+    resetSignalCounts() {
+        this.signalCounts.chatOpen = 0;
+        this.signalCounts.chatChunk = 0;
+        this.signalCounts.heartbeat = 0;
+        this.signalCounts.release = 0;
+        this.signalCounts.criticalError = 0;
+        this.signalCounts.observerLost = 0;
+    }
+    checkSilence(stallMs, hardTimeoutMs) {
+        if (this.terminalResult || this.currentState === 'idle')
+            return;
+        const now = this.now();
+        const silence = now - this.lastActivity;
+        const elapsed = now - this.runStartTs;
+        if (silence > hardTimeoutMs) {
+            this.latch('timeout', `silent for ${silence}ms`);
+        }
+        else if (elapsed > hardTimeoutMs) {
+            this.latch('timeout', `exceeded ${hardTimeoutMs}ms wall-clock budget (elapsed ${elapsed}ms)`);
+        }
+        else if (silence > stallMs) {
+            this.currentState = 'stalled';
+        }
+    }
+    armWatchdog(stallMs, hardTimeoutMs) {
+        if (this.watchdog)
+            return;
+        const intervalMs = Math.max(250, Math.min(1000, stallMs, hardTimeoutMs));
+        this.watchdog = setInterval(() => this.checkSilence(stallMs, hardTimeoutMs), intervalMs);
+    }
+    clearWatchdog() {
+        if (!this.watchdog)
+            return;
+        clearInterval(this.watchdog);
+        this.watchdog = null;
+    }
+    latch(terminal, reason) {
+        if (this.terminalResult)
+            return;
+        this.terminalResult = {
+            terminal,
+            elapsedMs: this.runStartTs === 0 ? 0 : Math.max(0, this.now() - this.runStartTs),
+            ...(reason ? { reason } : {})
+        };
+        this.clearWatchdog();
+        this.close();
+        const waiters = this.waiters.splice(0);
+        for (const resolve of waiters)
+            resolve(this.terminalResult);
+    }
+}

package/dist/scripts/ci-health.js

@@ -217,6 +217,7 @@ async function main() {
             sessionNav = { target: probeUrl, landedOn: '', error: e.message };
             console.log(`[ci-health] canary navigation failed — ${e.message}; session anchors will fail loudly`);
         }
+        process.env.DESIGNER_TURN_RPC_CANARY ??= '1';
         sessionResults = await runHealth(browser, { phase: 'session' });
     }
     else {

package/dist/scripts/trace-analyze.js

@@ -0,0 +1,366 @@
+#!/usr/bin/env -S node --import tsx
+import fs from 'node:fs';
+import path from 'node:path';
+function asRec(v) {
+    return v && typeof v === 'object' && !Array.isArray(v) ? v : {};
+}
+function num(v) {
+    return typeof v === 'number' && Number.isFinite(v) ? v : null;
+}
+function normalizeEndpoint(url) {
+    try {
+        const u = new URL(url);
+        const p = u.pathname.replace(/[0-9a-f]{8}-[0-9a-f-]{27,}/gi, ':id').replace(/\/\d{4,}/g, '/:n');
+        return u.origin + p;
+    }
+    catch {
+        return url.slice(0, 120);
+    }
+}
+function pct(sorted, p) {
+    if (sorted.length === 0)
+        return 0;
+    const idx = Math.min(sorted.length - 1, Math.floor((p / 100) * sorted.length));
+    return sorted[idx] ?? 0;
+}
+function ms(n) {
+    return `${Math.round(n)}ms`;
+}
+function main() {
+    const argPath = process.argv[2];
+    if (!argPath) {
+        console.error('Usage: trace-analyze.ts <traceDir | trace.jsonl>');
+        process.exit(1);
+    }
+    const dir = argPath.endsWith('.jsonl') ? path.dirname(argPath) : argPath;
+    const jsonlPath = argPath.endsWith('.jsonl') ? argPath : path.join(dir, 'trace.jsonl');
+    const manifestPath = path.join(dir, 'manifest.json');
+    let manifest = {};
+    if (fs.existsSync(manifestPath)) {
+        try {
+            const parsed = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+            manifest = asRec(parsed);
+        }
+        catch {
+            manifest = {};
+        }
+    }
+    const reqs = new Map();
+    const sockets = new Map();
+    const domSamples = [];
+    const markers = [];
+    let monoToWallOffset = null;
+    let firstTs = Infinity;
+    let lastTs = 0;
+    let totalLines = 0;
+    for (const line of fs.readFileSync(jsonlPath, 'utf8').split('\n')) {
+        if (!line.trim())
+            continue;
+        totalLines++;
+        let ev;
+        try {
+            const parsed = JSON.parse(line);
+            ev = asRec(parsed);
+        }
+        catch {
+            continue;
+        }
+        const ts = num(ev.ts) ?? 0;
+        if (ts) {
+            firstTs = Math.min(firstTs, ts);
+            lastTs = Math.max(lastTs, ts);
+        }
+        if (ev.kind === 'dom-sample') {
+            domSamples.push({ ts, sample: asRec(ev.sample) });
+            continue;
+        }
+        if (ev.kind === 'recorder') {
+            const detail = asRec(ev.detail);
+            if (ev.event === 'marker')
+                markers.push({ ts, name: String(detail.name || ''), detail });
+            continue;
+        }
+        if (ev.kind !== 'cdp')
+            continue;
+        const method = String(ev.method || '');
+        const p = asRec(ev.params);
+        const requestId = typeof p.requestId === 'string' ? p.requestId : null;
+        if (method === 'Network.requestWillBeSent' && requestId) {
+            const req = asRec(p.request);
+            const mono = num(p.timestamp);
+            const wall = num(p.wallTime);
+            if (mono !== null && wall !== null && monoToWallOffset === null)
+                monoToWallOffset = wall - mono;
+            reqs.set(requestId, {
+                requestId,
+                url: String(req.url || ''),
+                method: String(req.method || 'GET'),
+                resourceType: typeof p.type === 'string' ? p.type : null,
+                mimeType: null,
+                status: null,
+                hasContentLength: false,
+                sentMono: mono,
+                sentWall: wall,
+                responseMono: null,
+                finishedMono: null,
+                failed: null,
+                fromCache: false,
+                chunks: [],
+                sseMessages: 0
+            });
+        }
+        else if (requestId && reqs.has(requestId)) {
+            const r = reqs.get(requestId);
+            if (method === 'Network.responseReceived') {
+                const resp = asRec(p.response);
+                r.mimeType = typeof resp.mimeType === 'string' ? resp.mimeType : null;
+                r.status = num(resp.status);
+                r.responseMono = num(p.timestamp);
+                const headers = asRec(resp.headers);
+                r.hasContentLength = Object.keys(headers).some((k) => k.toLowerCase() === 'content-length');
+            }
+            else if (method === 'Network.dataReceived') {
+                r.chunks.push({
+                    mono: num(p.timestamp) ?? 0,
+                    bytes: num(p.dataLength) ?? 0,
+                    encodedBytes: num(p.encodedDataLength) ?? 0
+                });
+            }
+            else if (method === 'Network.loadingFinished') {
+                r.finishedMono = num(p.timestamp);
+            }
+            else if (method === 'Network.loadingFailed') {
+                r.failed = String(p.errorText || 'failed') + (p.canceled === true ? ' (canceled)' : '');
+                r.finishedMono = num(p.timestamp);
+            }
+            else if (method === 'Network.requestServedFromCache') {
+                r.fromCache = true;
+            }
+            else if (method === 'Network.eventSourceMessageReceived') {
+                r.sseMessages++;
+            }
+        }
+        if (method === 'Network.webSocketCreated' && requestId) {
+            sockets.set(requestId, {
+                requestId,
+                url: String(p.url || ''),
+                framesSent: 0,
+                framesReceived: 0,
+                bytesReceived: 0,
+                closed: false
+            });
+        }
+        else if (requestId && sockets.has(requestId)) {
+            const s = sockets.get(requestId);
+            if (method === 'Network.webSocketFrameSent')
+                s.framesSent++;
+            if (method === 'Network.webSocketFrameReceived') {
+                s.framesReceived++;
+                const resp = asRec(p.response);
+                s.bytesReceived += typeof resp.payloadData === 'string' ? resp.payloadData.length : num(resp.payloadBytes) ?? 0;
+            }
+            if (method === 'Network.webSocketClosed')
+                s.closed = true;
+        }
+    }
+    const monoToWall = (mono) => mono !== null && monoToWallOffset !== null ? (mono + monoToWallOffset) * 1000 : null;
+    const streamKind = (r) => {
+        if (r.sseMessages > 0 || r.mimeType === 'text/event-stream')
+            return 'sse';
+        const span = r.chunks.length >= 2 ? (r.chunks[r.chunks.length - 1]?.mono ?? 0) - (r.chunks[0]?.mono ?? 0) : 0;
+        if (r.chunks.length >= 3 && span > 1 && !r.hasContentLength)
+            return 'fetch-chunked';
+        return 'plain';
+    };
+    const endpoints = new Map();
+    for (const r of reqs.values()) {
+        const key = normalizeEndpoint(r.url);
+        const e = endpoints.get(key) || { hits: 0, methods: new Set(), kinds: new Set(), bytes: 0, sentWalls: [] };
+        e.hits++;
+        e.methods.add(r.method);
+        e.kinds.add(streamKind(r));
+        e.bytes += r.chunks.reduce((a, c) => a + c.encodedBytes, 0);
+        const w = monoToWall(r.sentMono);
+        if (w !== null)
+            e.sentWalls.push(w);
+        endpoints.set(key, e);
+    }
+    const iterStart = markers.find((m) => m.name === 'iterate-start')?.ts ?? null;
+    let main_ = null;
+    let mainScore = -1;
+    for (const r of reqs.values()) {
+        if (!/^https:\/\/claude\.ai\//.test(r.url))
+            continue;
+        if (r.method !== 'POST')
+            continue;
+        const span = r.responseMono !== null && r.finishedMono !== null ? r.finishedMono - r.responseMono : 0;
+        let score = span * 1000 + r.chunks.length;
+        const w = monoToWall(r.sentMono);
+        if (iterStart !== null && w !== null && w >= iterStart - 1000 && w <= iterStart + 5000)
+            score += 100_000;
+        if (score > mainScore) {
+            mainScore = score;
+            main_ = r;
+        }
+    }
+    const lines = [];
+    const out = (s = '') => {
+        lines.push(s);
+    };
+    const m = manifest;
+    out(`# Trace summary — ${m.scenario ?? path.basename(dir)}`);
+    out();
+    out(`- file: \`${jsonlPath}\``);
+    out(`- span: ${((lastTs - firstTs) / 1000).toFixed(1)}s | lines: ${totalLines} | requests: ${reqs.size} | sockets: ${sockets.size} | dom-samples: ${domSamples.length}`);
+    if (m.iterate)
+        out(`- iterate: failureMode=${m.iterate.failureMode} elapsed=${Math.round((m.iterate.elapsedMs ?? 0) / 1000)}s`);
+    for (const mk of markers)
+        out(`- marker \`${mk.name}\` @ +${((mk.ts - firstTs) / 1000).toFixed(1)}s`);
+    out();
+    out(`## Endpoints`);
+    out();
+    out(`| endpoint | hits | methods | kind | bytes | periodicity |`);
+    out(`|---|---|---|---|---|---|`);
+    const sortedEndpoints = [...endpoints.entries()].sort((a, b) => b[1].bytes - a[1].bytes || b[1].hits - a[1].hits);
+    for (const [ep, e] of sortedEndpoints) {
+        const walls = e.sentWalls.sort((x, y) => x - y);
+        const gaps = [];
+        for (let i = 1; i < walls.length; i++)
+            gaps.push((walls[i] ?? 0) - (walls[i - 1] ?? 0));
+        gaps.sort((x, y) => x - y);
+        const period = gaps.length >= 2 ? `~${(pct(gaps, 50) / 1000).toFixed(1)}s` : '';
+        out(`| ${ep.replace(/^https:\/\//, '')} | ${e.hits} | ${[...e.methods].join(',')} | ${[...e.kinds].join(',')} | ${e.bytes} | ${period} |`);
+    }
+    out();
+    if (main_) {
+        const kind = streamKind(main_);
+        out(`## Main generation request`);
+        out();
+        out(`**Verdict: generation streams via \`${kind}\` at \`${main_.method} ${normalizeEndpoint(main_.url)}\`** (status ${main_.status}, mime ${main_.mimeType})`);
+        out();
+        const t0 = main_.sentMono ?? 0;
+        out(`- request sent: t0${iterStart !== null && monoToWall(t0) !== null ? ` (+${((monoToWall(t0) - iterStart) / 1000).toFixed(1)}s after iterate-start)` : ''}`);
+        if (main_.responseMono !== null)
+            out(`- response headers: t0+${ms((main_.responseMono - t0) * 1000)}`);
+        if (main_.finishedMono !== null)
+            out(`- loading finished: t0+${((main_.finishedMono - t0)).toFixed(1)}s${main_.failed ? ` (FAILED: ${main_.failed})` : ''}`);
+        out(`- chunks: ${main_.chunks.length} | total encoded bytes: ${main_.chunks.reduce((a, c) => a + c.encodedBytes, 0)}`);
+        out();
+        const gaps = [];
+        for (let i = 1; i < main_.chunks.length; i++) {
+            gaps.push(((main_.chunks[i]?.mono ?? 0) - (main_.chunks[i - 1]?.mono ?? 0)) * 1000);
+        }
+        if (gaps.length) {
+            const sorted = [...gaps].sort((a, b) => a - b);
+            const mean = gaps.reduce((a, b) => a + b, 0) / gaps.length;
+            out(`### Inter-chunk gaps (candidate STALLED thresholds)`);
+            out();
+            out(`max ${ms(sorted[sorted.length - 1] ?? 0)} | p95 ${ms(pct(sorted, 95))} | p50 ${ms(pct(sorted, 50))} | mean ${ms(mean)}`);
+            out();
+            out(`→ a STALLED detector needs its no-chunk timeout comfortably above max (e.g. ${Math.ceil(((sorted[sorted.length - 1] ?? 0) * 3) / 1000)}s).`);
+            out();
+        }
+        const lastChunkWall = monoToWall(main_.chunks[main_.chunks.length - 1]?.mono ?? null);
+        const finishedWall = monoToWall(main_.finishedMono);
+        out(`### Network-quiet vs DOM-stable`);
+        out();
+        if (lastChunkWall !== null)
+            out(`- last chunk of main request: +${((lastChunkWall - firstTs) / 1000).toFixed(1)}s`);
+        if (finishedWall !== null)
+            out(`- main request finished: +${((finishedWall - firstTs) / 1000).toFixed(1)}s`);
+        let lastTurnChange = null;
+        let lastIframeChange = null;
+        let prevTurns = null;
+        let prevIframe = null;
+        for (const d of domSamples) {
+            if (d.sample.chatTurnCount !== prevTurns) {
+                if (prevTurns !== null)
+                    lastTurnChange = d.ts;
+                prevTurns = d.sample.chatTurnCount;
+            }
+            if (d.sample.iframeSrc !== prevIframe) {
+                if (prevIframe !== null)
+                    lastIframeChange = d.ts;
+                prevIframe = d.sample.iframeSrc;
+            }
+        }
+        if (lastTurnChange !== null)
+            out(`- last chatTurnCount change (dom): +${((lastTurnChange - firstTs) / 1000).toFixed(1)}s`);
+        if (lastIframeChange !== null)
+            out(`- last iframeSrc change (dom): +${((lastIframeChange - firstTs) / 1000).toFixed(1)}s`);
+        const stopSeen = domSamples.filter((d) => d.sample.stopProbe).length;
+        out(`- dom-samples with a visible stop/cancel button: ${stopSeen}/${domSamples.length}`);
+        const probes = domSamples.map((d) => d.sample.stopProbe).filter(Boolean);
+        if (probes.length)
+            out(`- stop-button probe: \`${JSON.stringify(probes[0]).slice(0, 300)}\``);
+        out();
+    }
+    else {
+        out(`## Main generation request`);
+        out();
+        out(`(none identified — expected for idle/quota traces)`);
+        out();
+    }
+    const byRpc = (name) => [...reqs.values()]
+        .filter((r) => r.url.includes(`OmeletteService/${name}`))
+        .sort((a, b) => (a.sentMono ?? 0) - (b.sentMono ?? 0));
+    const renews = byRpc('RenewTurn');
+    const releases = byRpc('ReleaseTurn');
+    const chats = byRpc('Chat');
+    if (renews.length || releases.length || chats.length) {
+        out(`## Turn lifecycle (OmeletteService)`);
+        out();
+        if (chats.length) {
+            out(`Chat segments: ${chats.length}`);
+            for (const c of chats.slice(0, 40)) {
+                const w = monoToWall(c.sentMono);
+                const dur = c.responseMono !== null && c.finishedMono !== null ? c.finishedMono - c.responseMono : 0;
+                out(`- +${w !== null ? ((w - firstTs) / 1000).toFixed(1) : '?'}s dur=${dur.toFixed(1)}s chunks=${c.chunks.length} bytes=${c.chunks.reduce((a, ch) => a + ch.encodedBytes, 0)}${c.failed ? ` FAILED: ${c.failed}` : ''}`);
+            }
+            out();
+        }
+        if (renews.length >= 2) {
+            const walls = renews.map((r) => monoToWall(r.sentMono)).filter((w) => w !== null);
+            const gaps = [];
+            for (let i = 1; i < walls.length; i++)
+                gaps.push((walls[i] ?? 0) - (walls[i - 1] ?? 0));
+            gaps.sort((a, b) => a - b);
+            const firstW = walls[0] ?? 0;
+            const lastW = walls[walls.length - 1] ?? 0;
+            out(`RenewTurn: ${renews.length} calls, median gap ${(pct(gaps, 50) / 1000).toFixed(1)}s, first +${((firstW - firstTs) / 1000).toFixed(1)}s, last +${((lastW - firstTs) / 1000).toFixed(1)}s`);
+        }
+        for (const rel of releases) {
+            const w = monoToWall(rel.sentMono);
+            out(`ReleaseTurn: +${w !== null ? ((w - firstTs) / 1000).toFixed(1) : '?'}s ← discrete FINISHED candidate`);
+        }
+        const iterDone = markers.find((mk) => mk.name === 'iterate-done')?.ts ?? null;
+        if (releases.length && iterDone !== null) {
+            const w = monoToWall(releases[releases.length - 1]?.sentMono ?? null);
+            if (w !== null)
+                out(`→ ReleaseTurn led the controller's HTML-stability verdict (iterate-done) by ${((iterDone - w) / 1000).toFixed(1)}s`);
+        }
+        out();
+    }
+    if (sockets.size) {
+        out(`## WebSockets`);
+        out();
+        for (const s of sockets.values()) {
+            out(`- ${s.url.slice(0, 100)} — frames sent ${s.framesSent} / recv ${s.framesReceived}, recv bytes ${s.bytesReceived}${s.closed ? ', closed' : ''}`);
+        }
+        out();
+    }
+    const failed = [...reqs.values()].filter((r) => r.failed);
+    if (failed.length) {
+        out(`## Failed requests`);
+        out();
+        for (const r of failed)
+            out(`- ${r.method} ${normalizeEndpoint(r.url)} — ${r.failed}`);
+        out();
+    }
+    const md = lines.join('\n');
+    const outPath = path.join(dir, 'summary.md');
+    fs.writeFileSync(outPath, md);
+    console.log(md);
+    console.log(`\n(written to ${outPath})`);
+}
+main();