patchrelay 0.35.11 → 0.35.13

package/dist/cli/watch/render-rich-text.js

@@ -0,0 +1,226 @@
+const richTextCache = new Map();
+export function lineToPlainText(line) {
+    return line.segments.map((segment) => segment.text).join("");
+}
+export function renderTextLines(text, options) {
+    const width = Math.max(8, options.width);
+    const sourceLines = text.length === 0 ? [""] : text.split("\n");
+    const lines = [];
+    for (let index = 0; index < sourceLines.length; index += 1) {
+        const sourceLine = sourceLines[index] ?? "";
+        const wrapped = wrapSegments(tokenizeSegments([{ text: sourceLine, ...(options.style ?? {}) }]), width, index === 0 ? options.firstPrefix : options.continuationPrefix ?? options.firstPrefix, options.continuationPrefix ?? options.firstPrefix, `${options.key}-${index}`);
+        lines.push(...wrapped);
+    }
+    return lines.length > 0 ? lines : [{ key: `${options.key}-0`, segments: [] }];
+}
+export function renderRichTextLines(text, options) {
+    const width = Math.max(8, options.width);
+    const cacheKey = [
+        options.key,
+        width,
+        segmentsKey(options.firstPrefix),
+        segmentsKey(options.continuationPrefix),
+        styleKey(options.style),
+        options.codeColor ?? "",
+        text,
+    ].join("\u0000");
+    const cached = richTextCache.get(cacheKey);
+    if (cached) {
+        return cached;
+    }
+    const lines = [];
+    const inputLines = text.replace(/\r\n/g, "\n").split("\n");
+    let paragraph = [];
+    let inCodeBlock = false;
+    let codeLines = [];
+    let blockIndex = 0;
+    const flushParagraph = () => {
+        if (paragraph.length === 0)
+            return;
+        const paragraphText = paragraph.join(" ").replace(/\s+/g, " ").trim();
+        if (paragraphText.length > 0) {
+            lines.push(...wrapSegments(tokenizeSegments(parseInlineMarkdown(paragraphText, options.style)), width, lines.length === 0 ? options.firstPrefix : options.continuationPrefix ?? options.firstPrefix, options.continuationPrefix ?? options.firstPrefix, `${options.key}-p-${blockIndex}`));
+            blockIndex += 1;
+        }
+        paragraph = [];
+    };
+    const flushCodeBlock = () => {
+        if (codeLines.length === 0)
+            return;
+        for (const codeLine of codeLines) {
+            lines.push(...renderTextLines(codeLine, {
+                key: `${options.key}-code-${blockIndex}`,
+                width,
+                firstPrefix: lines.length === 0 ? options.firstPrefix : options.continuationPrefix ?? options.firstPrefix,
+                continuationPrefix: options.continuationPrefix ?? options.firstPrefix,
+                style: { color: options.codeColor ?? "green" },
+            }));
+            blockIndex += 1;
+        }
+        codeLines = [];
+    };
+    const pushBlankLine = () => {
+        lines.push({ key: `${options.key}-blank-${blockIndex}`, segments: [] });
+        blockIndex += 1;
+    };
+    for (const rawLine of inputLines) {
+        const line = rawLine ?? "";
+        const trimmed = line.trim();
+        if (trimmed.startsWith("```")) {
+            flushParagraph();
+            if (inCodeBlock) {
+                flushCodeBlock();
+                inCodeBlock = false;
+            }
+            else {
+                inCodeBlock = true;
+            }
+            continue;
+        }
+        if (inCodeBlock) {
+            codeLines.push(line);
+            continue;
+        }
+        if (trimmed.length === 0) {
+            flushParagraph();
+            if (lines.length > 0) {
+                pushBlankLine();
+            }
+            continue;
+        }
+        const bulletMatch = line.match(/^\s*[-*]\s+(.*)$/);
+        if (bulletMatch?.[1]) {
+            flushParagraph();
+            lines.push(...wrapSegments(tokenizeSegments(parseInlineMarkdown(bulletMatch[1], options.style)), width, appendSegments(options.firstPrefix, [{ text: "• ", ...(options.style ?? {}) }]), appendSegments(options.continuationPrefix ?? options.firstPrefix, [{ text: "  ", ...(options.style ?? {}) }]), `${options.key}-b-${blockIndex}`));
+            blockIndex += 1;
+            continue;
+        }
+        paragraph.push(trimmed);
+    }
+    flushParagraph();
+    flushCodeBlock();
+    const result = lines.length > 0 ? lines : [{ key: `${options.key}-0`, segments: [] }];
+    richTextCache.set(cacheKey, result);
+    return result;
+}
+function parseInlineMarkdown(text, style) {
+    const pattern = /\[([^\]]+)\]\(([^)]+)\)|`([^`]+)`|\*\*([^*]+)\*\*/g;
+    const segments = [];
+    let lastIndex = 0;
+    for (const match of text.matchAll(pattern)) {
+        const index = match.index ?? 0;
+        if (index > lastIndex) {
+            segments.push({ text: text.slice(lastIndex, index), ...(style ?? {}) });
+        }
+        if (match[1] && match[2]) {
+            segments.push({ text: match[1], color: "cyan", bold: true });
+            segments.push({ text: ` (${match[2]})`, dimColor: true });
+        }
+        else if (match[3]) {
+            segments.push({ text: match[3], color: "yellow", bold: true });
+        }
+        else if (match[4]) {
+            segments.push({ text: match[4], ...(style ?? {}), bold: true });
+        }
+        lastIndex = index + match[0].length;
+    }
+    if (lastIndex < text.length) {
+        segments.push({ text: text.slice(lastIndex), ...(style ?? {}) });
+    }
+    return segments.length > 0 ? segments : [{ text, ...(style ?? {}) }];
+}
+function wrapSegments(tokens, width, firstPrefix, continuationPrefix, keyPrefix) {
+    const initialPrefix = cloneSegments(firstPrefix);
+    const nextPrefix = cloneSegments(continuationPrefix);
+    const lines = [];
+    let currentSegments = initialPrefix;
+    let currentWidth = segmentsWidth(initialPrefix);
+    let lineHasContent = false;
+    let lineIndex = 0;
+    const pushLine = () => {
+        lines.push({
+            key: `${keyPrefix}-${lineIndex}`,
+            segments: trimTrailingSpaces(currentSegments),
+        });
+        lineIndex += 1;
+        currentSegments = cloneSegments(nextPrefix);
+        currentWidth = segmentsWidth(currentSegments);
+        lineHasContent = false;
+    };
+    for (const token of tokens) {
+        let remaining = token.text.replace(/\t/g, "  ");
+        while (remaining.length > 0) {
+            const whitespace = remaining.match(/^\s+/)?.[0];
+            if (whitespace) {
+                const spaceText = lineHasContent ? whitespace : "";
+                remaining = remaining.slice(whitespace.length);
+                if (spaceText.length === 0) {
+                    continue;
+                }
+                if (currentWidth + spaceText.length > width) {
+                    pushLine();
+                    continue;
+                }
+                currentSegments.push({ ...token, text: spaceText });
+                currentWidth += spaceText.length;
+                continue;
+            }
+            const word = remaining.match(/^\S+/)?.[0] ?? remaining;
+            remaining = remaining.slice(word.length);
+            let rest = word;
+            while (rest.length > 0) {
+                const available = Math.max(1, width - currentWidth);
+                if (lineHasContent && rest.length > available) {
+                    pushLine();
+                    continue;
+                }
+                const sliceLength = Math.min(rest.length, available);
+                const chunk = rest.slice(0, sliceLength);
+                currentSegments.push({ ...token, text: chunk });
+                currentWidth += chunk.length;
+                lineHasContent = true;
+                rest = rest.slice(sliceLength);
+                if (rest.length > 0) {
+                    pushLine();
+                }
+            }
+        }
+    }
+    if (lines.length === 0 || currentSegments.length > 0 || lineHasContent) {
+        lines.push({
+            key: `${keyPrefix}-${lineIndex}`,
+            segments: trimTrailingSpaces(currentSegments),
+        });
+    }
+    return lines;
+}
+function tokenizeSegments(segments) {
+    return segments.flatMap((segment) => {
+        const parts = segment.text.length === 0 ? [""] : segment.text.match(/\s+|\S+/g) ?? [segment.text];
+        return parts.map((part) => ({ ...segment, text: part }));
+    });
+}
+function cloneSegments(segments) {
+    return (segments ?? []).map((segment) => ({ ...segment }));
+}
+function segmentsWidth(segments) {
+    return (segments ?? []).reduce((sum, segment) => sum + segment.text.length, 0);
+}
+function trimTrailingSpaces(segments) {
+    const trimmed = cloneSegments(segments);
+    while (trimmed.length > 0 && trimmed[trimmed.length - 1]?.text.trim().length === 0) {
+        trimmed.pop();
+    }
+    return trimmed;
+}
+function appendSegments(base, extra) {
+    return [...cloneSegments(base), ...cloneSegments(extra)];
+}
+function segmentsKey(segments) {
+    return (segments ?? []).map((segment) => `${segment.text}|${segment.color ?? ""}|${segment.dimColor ? "d" : ""}|${segment.bold ? "b" : ""}`).join(";");
+}
+function styleKey(style) {
+    if (!style)
+        return "";
+    return `${style.color ?? ""}|${style.dimColor ? "d" : ""}|${style.bold ? "b" : ""}`;
+}

package/dist/cli/watch/state-visualization.js

@@ -16,9 +16,6 @@ const PR_LOOP_STATES = ["changes_requested", "repairing_ci"];
 const QUEUE_LOOP_STATES = ["repairing_queue"];
 const EXIT_STATES = ["awaiting_input", "escalated", "failed"];
 const QUEUE_EVENT_STATUSES = new Set([
-    "queue_label_requested",
-    "queue_label_applied",
-    "queue_label_failed",
     "queue_repair_queued",
     "pr_merged",
 ]);
@@ -61,12 +58,6 @@ function latestQueueObservationEvent(feedEvents) {
 }
 function describeObservationEvent(event) {
     switch (event.status) {
-        case "queue_label_requested":
-            return { tone: "info", text: event.summary };
-        case "queue_label_applied":
-            return { tone: "success", text: event.summary };
-        case "queue_label_failed":
-            return { tone: "warn", text: event.summary };
         case "queue_repair_queued":
             return { tone: "warn", text: event.summary };
         case "pr_merged":
@@ -82,10 +73,10 @@ function describeObservationEvent(event) {
                 const active = event.status === "starting";
                 return {
                     tone: active ? "warn" : "info",
-                    text: active ? "PatchRelay is actively running queue repair." : event.summary,
+                    text: active ? "PatchRelay is actively running queue repair." : `Observed queue signal: ${event.summary}`,
                 };
             }
-            return { tone: "info", text: event.summary };
+            return { tone: "info", text: `Observed signal: ${event.summary}` };
     }
 }
 export function buildPatchRelayStateGraph(history, currentFactoryState) {
@@ -99,19 +90,23 @@ export function buildPatchRelayStateGraph(history, currentFactoryState) {
 }
 export function buildPatchRelayQueueObservations(issue, feedEvents) {
     const observations = [];
-    switch (issue.factoryState) {
-        case "awaiting_queue":
+    switch (issue.sessionState) {
+        case "waiting_input":
+            observations.push({
+                tone: "warn",
+                text: issue.waitingReason ?? "PatchRelay is waiting for input before continuing.",
+            });
+            break;
+        case "running":
             observations.push({
                 tone: "info",
-                text: "PatchRelay has finished branch work and is waiting for external queue progress.",
+                text: "PatchRelay is actively working this session.",
             });
             break;
-        case "repairing_queue":
+        case "idle":
             observations.push({
-                tone: issue.activeRunType === "queue_repair" ? "warn" : "info",
-                text: issue.activeRunType === "queue_repair"
-                    ? "PatchRelay is actively repairing a queue eviction."
-                    : "PatchRelay is preparing or waiting to resume queue repair.",
+                tone: "info",
+                text: "PatchRelay is idle for this issue.",
             });
             break;
         case "done":
@@ -120,12 +115,42 @@ export function buildPatchRelayQueueObservations(issue, feedEvents) {
                 text: "PatchRelay is complete because GitHub reports the PR has merged.",
             });
             break;
-        default:
+        case "failed":
             observations.push({
-                tone: "info",
-                text: "Queue hand-off has not started yet; PatchRelay still owns the issue workflow.",
+                tone: "warn",
+                text: "PatchRelay needs human help to recover this session.",
             });
             break;
+        default:
+            switch (issue.factoryState) {
+                case "awaiting_queue":
+                    observations.push({
+                        tone: "info",
+                        text: "PatchRelay has finished active work and is waiting for downstream merge flow.",
+                    });
+                    break;
+                case "repairing_queue":
+                    observations.push({
+                        tone: issue.activeRunType === "queue_repair" ? "warn" : "info",
+                        text: issue.activeRunType === "queue_repair"
+                            ? "PatchRelay is actively repairing a queue eviction."
+                            : "PatchRelay is preparing or waiting to resume queue repair.",
+                    });
+                    break;
+                case "done":
+                    observations.push({
+                        tone: "success",
+                        text: "PatchRelay is complete because GitHub reports the PR has merged.",
+                    });
+                    break;
+                default:
+                    observations.push({
+                        tone: "info",
+                        text: "PatchRelay is tracking this issue.",
+                    });
+                    break;
+            }
+            break;
     }
     const latestEvent = latestQueueObservationEvent(feedEvents);
     if (latestEvent) {
@@ -134,7 +159,7 @@ export function buildPatchRelayQueueObservations(issue, feedEvents) {
     else if (issue.factoryState === "awaiting_queue") {
         observations.push({
             tone: "info",
-            text: "No external queue signal has been observed yet.",
+            text: "No downstream queue signal has been observed yet.",
         });
     }
     if (issue.prNumber !== undefined) {

package/dist/cli/watch/timeline-builder.js

@@ -1,3 +1,4 @@
+import { getThreadTurns } from "../../codex-thread-utils.js";
 // ─── Build Timeline from Rehydration Data ─────────────────────────
 export function buildTimelineFromRehydration(runs, feedEvents, liveThread, activeRunId) {
     const entries = [];
@@ -132,7 +133,7 @@ function syntheticTimestamp(startMs, endMs, index, total) {
 // ─── Items from Live Thread ───────────────────────────────────────
 function itemsFromThread(runId, thread) {
     const entries = [];
-    for (const turn of thread.turns) {
+    for (const turn of getThreadTurns(thread)) {
         for (const item of turn.items) {
             entries.push({
                 id: `live-${item.id}`,

package/dist/cli/watch/use-detail-stream.js

@@ -14,11 +14,12 @@ export function useDetailStream(options) {
         if (bearerToken) {
             headers.authorization = `Bearer ${bearerToken}`;
         }
-        // Rehydrate from timeline endpoint
         void rehydrate(baseUrl, issueKey, headers, abortController.signal, dispatch);
-        // Stream codex notifications + feed events via filtered SSE
-        void streamEvents(baseUrl, issueKey, headers, abortController.signal, dispatch);
+        const intervalId = setInterval(() => {
+            void rehydrate(baseUrl, issueKey, headers, abortController.signal, dispatch);
+        }, 3000);
         return () => {
+            clearInterval(intervalId);
             abortController.abort();
         };
     }, [options.issueKey, options.active]);
@@ -26,117 +27,22 @@ export function useDetailStream(options) {
 // ─── Rehydration ──────────────────────────────────────────────────
 async function rehydrate(baseUrl, issueKey, headers, signal, dispatch) {
     try {
-        const url = new URL(`/api/issues/${encodeURIComponent(issueKey)}/timeline`, baseUrl);
+        const url = new URL(`/api/issues/${encodeURIComponent(issueKey)}`, baseUrl);
         const response = await fetch(url, { headers: { ...headers, accept: "application/json" }, signal });
         if (!response.ok)
             return;
         const data = await response.json();
-        const runs = (data.runs ?? []).map((r) => ({
-            id: r.id,
-            runType: r.runType,
-            status: r.status,
-            startedAt: r.startedAt,
-            endedAt: r.endedAt,
-            threadId: r.threadId,
-            ...(r.events ? { events: r.events } : {}),
-            ...(r.report ? { report: r.report } : {}),
-        }));
-        let issueContext = null;
-        if (data.issue) {
-            const i = data.issue;
-            issueContext = {
-                description: typeof i.description === "string" ? i.description : undefined,
-                currentLinearState: typeof i.currentLinearState === "string" ? i.currentLinearState : undefined,
-                issueUrl: typeof i.issueUrl === "string" ? i.issueUrl : undefined,
-                worktreePath: typeof i.worktreePath === "string" ? i.worktreePath : undefined,
-                branchName: typeof i.branchName === "string" ? i.branchName : undefined,
-                prUrl: typeof i.prUrl === "string" ? i.prUrl : undefined,
-                priority: typeof i.priority === "number" ? i.priority : undefined,
-                estimate: typeof i.estimate === "number" ? i.estimate : undefined,
-                ciRepairAttempts: typeof i.ciRepairAttempts === "number" ? i.ciRepairAttempts : 0,
-                queueRepairAttempts: typeof i.queueRepairAttempts === "number" ? i.queueRepairAttempts : 0,
-                reviewFixAttempts: typeof i.reviewFixAttempts === "number" ? i.reviewFixAttempts : 0,
-                latestFailureSource: typeof i.latestFailureSource === "string" ? i.latestFailureSource : undefined,
-                latestFailureHeadSha: typeof i.latestFailureHeadSha === "string" ? i.latestFailureHeadSha : undefined,
-                latestFailureCheckName: typeof i.latestFailureCheckName === "string" ? i.latestFailureCheckName : undefined,
-                latestFailureStepName: typeof i.latestFailureStepName === "string" ? i.latestFailureStepName : undefined,
-                latestFailureSummary: typeof i.latestFailureSummary === "string" ? i.latestFailureSummary : undefined,
-                runCount: runs.length,
-            };
-        }
         dispatch({
             type: "timeline-rehydrate",
-            runs,
-            feedEvents: data.feedEvents ?? [],
+            runs: Array.isArray(data.runs) ? data.runs : [],
+            feedEvents: [],
             liveThread: data.liveThread ?? null,
-            activeRunId: data.activeRunId ?? null,
-            issueContext,
+            activeRunId: data.activeRun?.id ?? null,
+            activeRunStartedAt: data.activeRun?.startedAt ?? null,
+            issueContext: data.issueContext ?? null,
         });
     }
     catch {
         // Rehydration is best-effort
     }
 }
-// ─── Live SSE Stream ──────────────────────────────────────────────
-async function streamEvents(baseUrl, issueKey, baseHeaders, signal, dispatch) {
-    try {
-        const url = new URL("/api/watch", baseUrl);
-        url.searchParams.set("issue", issueKey);
-        const headers = { ...baseHeaders, accept: "text/event-stream" };
-        const response = await fetch(url, { headers, signal });
-        if (!response.ok || !response.body)
-            return;
-        const reader = response.body.getReader();
-        const decoder = new TextDecoder();
-        let buffer = "";
-        let eventType = "";
-        let dataLines = [];
-        while (true) {
-            const { done, value } = await reader.read();
-            if (done)
-                break;
-            buffer += decoder.decode(value, { stream: true });
-            let newlineIndex = buffer.indexOf("\n");
-            while (newlineIndex !== -1) {
-                const rawLine = buffer.slice(0, newlineIndex);
-                buffer = buffer.slice(newlineIndex + 1);
-                const line = rawLine.endsWith("\r") ? rawLine.slice(0, -1) : rawLine;
-                if (!line) {
-                    if (dataLines.length > 0) {
-                        processEvent(dispatch, eventType, dataLines.join("\n"));
-                        dataLines = [];
-                        eventType = "";
-                    }
-                    newlineIndex = buffer.indexOf("\n");
-                    continue;
-                }
-                if (line.startsWith(":")) {
-                    newlineIndex = buffer.indexOf("\n");
-                    continue;
-                }
-                if (line.startsWith("event:")) {
-                    eventType = line.slice(6).trim();
-                }
-                else if (line.startsWith("data:")) {
-                    dataLines.push(line.slice(5).trimStart());
-                }
-                newlineIndex = buffer.indexOf("\n");
-            }
-        }
-    }
-    catch {
-        // Stream ended or aborted
-    }
-}
-function processEvent(dispatch, eventType, data) {
-    try {
-        if (eventType === "codex") {
-            const parsed = JSON.parse(data);
-            dispatch({ type: "codex-notification", method: parsed.method, params: parsed.params });
-        }
-        // Feed events are handled by the main watch stream
-    }
-    catch {
-        // Ignore parse errors
-    }
-}

package/dist/cli/watch/use-watch-stream.js

@@ -5,127 +5,36 @@ export function useWatchStream(options) {
     useEffect(() => {
         if (options.active === false)
             return;
-        let abortController = new AbortController();
-        let reconnectTimeout;
-        let attempt = 0;
+        const abortController = new AbortController();
         const fetchIssueSnapshot = async () => {
             const { baseUrl, bearerToken, dispatch } = optionsRef.current;
             const headers = { accept: "application/json" };
             if (bearerToken) {
                 headers.authorization = `Bearer ${bearerToken}`;
             }
-            const response = await fetch(new URL("/api/watch/issues", baseUrl), { headers });
+            const response = await fetch(new URL("/api/issues", baseUrl), { headers, signal: abortController.signal });
             if (!response.ok) {
                 throw new Error(`Issue snapshot failed: ${response.status}`);
             }
             const payload = await response.json();
+            dispatch({ type: "connected" });
             dispatch({ type: "issues-snapshot", issues: Array.isArray(payload.issues) ? payload.issues : [], receivedAt: Date.now() });
         };
-        const connect = () => {
-            abortController = new AbortController();
-            const { baseUrl, bearerToken, issueFilter, dispatch } = optionsRef.current;
-            const url = new URL("/api/watch", baseUrl);
-            if (issueFilter) {
-                url.searchParams.set("issue", issueFilter);
+        void fetchIssueSnapshot().catch(() => {
+            if (!abortController.signal.aborted) {
+                optionsRef.current.dispatch({ type: "disconnected" });
             }
-            const headers = { accept: "text/event-stream" };
-            if (bearerToken) {
-                headers.authorization = `Bearer ${bearerToken}`;
-            }
-            void fetch(url, { headers, signal: abortController.signal })
-                .then(async (response) => {
-                if (!response.ok || !response.body) {
-                    throw new Error(`Watch stream failed: ${response.status}`);
-                }
-                dispatch({ type: "connected" });
-                attempt = 0;
-                try {
-                    await fetchIssueSnapshot();
-                }
-                catch {
-                    // Keep the stream alive even if the snapshot endpoint temporarily fails.
-                }
-                const reader = response.body.getReader();
-                const decoder = new TextDecoder();
-                let buffer = "";
-                let eventType = "";
-                let dataLines = [];
-                while (true) {
-                    const { done, value } = await reader.read();
-                    if (done)
-                        break;
-                    buffer += decoder.decode(value, { stream: true });
-                    let newlineIndex = buffer.indexOf("\n");
-                    while (newlineIndex !== -1) {
-                        const rawLine = buffer.slice(0, newlineIndex);
-                        buffer = buffer.slice(newlineIndex + 1);
-                        const line = rawLine.endsWith("\r") ? rawLine.slice(0, -1) : rawLine;
-                        if (!line) {
-                            if (dataLines.length > 0) {
-                                processEvent(dispatch, eventType, dataLines.join("\n"));
-                                dataLines = [];
-                                eventType = "";
-                            }
-                            newlineIndex = buffer.indexOf("\n");
-                            continue;
-                        }
-                        if (line.startsWith(":")) {
-                            if (line.includes("keepalive")) {
-                                dispatch({ type: "stream-heartbeat", receivedAt: Date.now() });
-                            }
-                            newlineIndex = buffer.indexOf("\n");
-                            continue;
-                        }
-                        if (line.startsWith("event:")) {
-                            eventType = line.slice(6).trim();
-                        }
-                        else if (line.startsWith("data:")) {
-                            dataLines.push(line.slice(5).trimStart());
-                        }
-                        newlineIndex = buffer.indexOf("\n");
-                    }
+        });
+        const snapshotInterval = setInterval(() => {
+            void fetchIssueSnapshot().catch(() => {
+                if (!abortController.signal.aborted) {
+                    optionsRef.current.dispatch({ type: "disconnected" });
                 }
-            })
-                .catch((error) => {
-                if (abortController.signal.aborted)
-                    return;
-                const _msg = error instanceof Error ? error.message : String(error);
-            })
-                .finally(() => {
-                if (abortController.signal.aborted)
-                    return;
-                dispatch({ type: "disconnected" });
-                attempt = Math.min(attempt + 1, 5);
-                const delay = Math.min(2000 * Math.pow(2, attempt), 30000);
-                reconnectTimeout = setTimeout(connect, delay);
             });
-        };
-        connect();
-        void fetchIssueSnapshot().catch(() => undefined);
-        const snapshotInterval = setInterval(() => {
-            void fetchIssueSnapshot().catch(() => undefined);
         }, 5000);
         return () => {
             abortController.abort();
-            if (reconnectTimeout !== undefined) {
-                clearTimeout(reconnectTimeout);
-            }
             clearInterval(snapshotInterval);
         };
     }, [options.active]);
 }
-function processEvent(dispatch, eventType, data) {
-    try {
-        if (eventType === "issues") {
-            const issues = JSON.parse(data);
-            dispatch({ type: "issues-snapshot", issues, receivedAt: Date.now() });
-        }
-        else if (eventType === "feed") {
-            const event = JSON.parse(data);
-            dispatch({ type: "feed-event", event, receivedAt: Date.now() });
-        }
-    }
-    catch {
-        // Ignore parse errors from malformed events
-    }
-}