persistent-request-response 0.1.0

package/README.md

@@ -0,0 +1,36 @@
+This is a [Next.js](https://nextjs.org) project bootstrapped with [`create-next-app`](https://nextjs.org/docs/app/api-reference/cli/create-next-app).
+
+## Getting Started
+
+First, run the development server:
+
+```bash
+npm run dev
+# or
+yarn dev
+# or
+pnpm dev
+# or
+bun dev
+```
+
+Open [http://localhost:3000](http://localhost:3000) with your browser to see the result.
+
+You can start editing the page by modifying `app/page.tsx`. The page auto-updates as you edit the file.
+
+This project uses [`next/font`](https://nextjs.org/docs/app/building-your-application/optimizing/fonts) to automatically optimize and load [Geist](https://vercel.com/font), a new font family for Vercel.
+
+## Learn More
+
+To learn more about Next.js, take a look at the following resources:
+
+- [Next.js Documentation](https://nextjs.org/docs) - learn about Next.js features and API.
+- [Learn Next.js](https://nextjs.org/learn) - an interactive Next.js tutorial.
+
+You can check out [the Next.js GitHub repository](https://github.com/vercel/next.js) - your feedback and contributions are welcome!
+
+## Deploy on Vercel
+
+The easiest way to deploy your Next.js app is to use the [Vercel Platform](https://vercel.com/new?utm_medium=default-template&filter=next.js&utm_source=create-next-app&utm_campaign=create-next-app-readme) from the creators of Next.js.
+
+Check out our [Next.js deployment documentation](https://nextjs.org/docs/app/building-your-application/deploying) for more details.

package/dist/index.d.mts

@@ -0,0 +1,41 @@
+import { Redis } from '@upstash/redis';
+
+interface KVAdapter {
+    rpush(key: string, ...values: string[]): Promise<void>;
+    lrange(key: string, start: number, stop: number): Promise<string[]>;
+    set(key: string, value: string, ttl: number): Promise<void>;
+    get(key: string): Promise<string | null>;
+    expire(key: string, ttl: number): Promise<void>;
+}
+
+interface Options {
+    kv: KVAdapter;
+    ttl?: number;
+}
+declare function createResilientSSE(options: Options): {
+    createStream: (streamId?: string) => PersistentStream;
+    resume: (streamId: string, lastEventId?: number) => Response;
+};
+
+interface PersistentFetchOptions {
+    disconnectSignal?: AbortSignal;
+    projectId?: string;
+}
+declare function persistentFetch(url: string, init?: RequestInit, options?: PersistentFetchOptions): Promise<Response>;
+declare namespace persistentFetch {
+    var resume: (url: string, projectId: string) => Promise<Response | null>;
+}
+
+interface PersistentStream {
+    stream: ReadableStream;
+    /** accepts a pre-formatted SSE string (e.g. from formatSSE()) — id: N is prepended automatically */
+    enqueue: (sseContent: string) => Promise<void>;
+    close: () => Promise<void>;
+    streamId: string;
+}
+
+declare function upstashAdapter(redis: Redis): KVAdapter;
+
+declare const vercelKvAdapter: KVAdapter;
+
+export { type KVAdapter, type PersistentStream, createResilientSSE, persistentFetch, upstashAdapter, vercelKvAdapter };

package/dist/index.d.ts

@@ -0,0 +1,41 @@
+import { Redis } from '@upstash/redis';
+
+interface KVAdapter {
+    rpush(key: string, ...values: string[]): Promise<void>;
+    lrange(key: string, start: number, stop: number): Promise<string[]>;
+    set(key: string, value: string, ttl: number): Promise<void>;
+    get(key: string): Promise<string | null>;
+    expire(key: string, ttl: number): Promise<void>;
+}
+
+interface Options {
+    kv: KVAdapter;
+    ttl?: number;
+}
+declare function createResilientSSE(options: Options): {
+    createStream: (streamId?: string) => PersistentStream;
+    resume: (streamId: string, lastEventId?: number) => Response;
+};
+
+interface PersistentFetchOptions {
+    disconnectSignal?: AbortSignal;
+    projectId?: string;
+}
+declare function persistentFetch(url: string, init?: RequestInit, options?: PersistentFetchOptions): Promise<Response>;
+declare namespace persistentFetch {
+    var resume: (url: string, projectId: string) => Promise<Response | null>;
+}
+
+interface PersistentStream {
+    stream: ReadableStream;
+    /** accepts a pre-formatted SSE string (e.g. from formatSSE()) — id: N is prepended automatically */
+    enqueue: (sseContent: string) => Promise<void>;
+    close: () => Promise<void>;
+    streamId: string;
+}
+
+declare function upstashAdapter(redis: Redis): KVAdapter;
+
+declare const vercelKvAdapter: KVAdapter;
+
+export { type KVAdapter, type PersistentStream, createResilientSSE, persistentFetch, upstashAdapter, vercelKvAdapter };

package/dist/index.js

@@ -0,0 +1,417 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// lib/resilient-sse/index.ts
+var index_exports = {};
+__export(index_exports, {
+  createResilientSSE: () => createResilientSSE,
+  persistentFetch: () => persistentFetch,
+  upstashAdapter: () => upstashAdapter,
+  vercelKvAdapter: () => vercelKvAdapter
+});
+module.exports = __toCommonJS(index_exports);
+
+// lib/resilient-sse/server/createPersistentStream.ts
+var import_uuid = require("uuid");
+
+// lib/resilient-sse/server/fileLogger.ts
+var import_fs = __toESM(require("fs"));
+var import_path = __toESM(require("path"));
+var LOG_FILE = import_path.default.join(process.cwd(), "sse-debug.log");
+var MAX_PREVIEW = 80;
+function ts() {
+  const d = /* @__PURE__ */ new Date();
+  return d.getHours().toString().padStart(2, "0") + ":" + d.getMinutes().toString().padStart(2, "0") + ":" + d.getSeconds().toString().padStart(2, "0") + "." + d.getMilliseconds().toString().padStart(3, "0");
+}
+function short(id) {
+  return id.slice(0, 8);
+}
+function preview(s) {
+  const oneline = s.replace(/\n/g, "\u21B5");
+  return oneline.length > MAX_PREVIEW ? oneline.slice(0, MAX_PREVIEW) + "\u2026" : oneline;
+}
+function write(line) {
+  if (process.env.NODE_ENV !== "development") return;
+  import_fs.default.appendFile(LOG_FILE, line + "\n", () => {
+  });
+}
+function logCreate(streamId) {
+  write(`[${ts()}] [CREATE   ] sid=${short(streamId)}`);
+}
+function logEnqueue(streamId, eventId, sseContent) {
+  write(`[${ts()}] [ENQUEUE  ] sid=${short(streamId)} id=${String(eventId).padStart(4)} ${preview(sseContent)}`);
+}
+function logClose(streamId, totalChunks, reason) {
+  write(`[${ts()}] [CLOSE    ] sid=${short(streamId)} total=${totalChunks} reason=${reason}`);
+}
+function logResumeStart(streamId, fromEventId) {
+  write(`[${ts()}] [RESUME   ] sid=${short(streamId)} fromId=${fromEventId}`);
+}
+function logResumeBuffered(streamId, count) {
+  write(`[${ts()}] [BUFFERED ] sid=${short(streamId)} replaying=${count} buffered chunks`);
+}
+function logResumePoll(streamId, nextIndex, newCount) {
+  write(`[${ts()}] [POLL     ] sid=${short(streamId)} nextIdx=${nextIndex} newChunks=${newCount}`);
+}
+function logResumeDone(streamId, totalSent) {
+  write(`[${ts()}] [RES_DONE ] sid=${short(streamId)} totalSent=${totalSent}`);
+}
+function logResumeError(streamId, err) {
+  write(`[${ts()}] [RES_ERR  ] sid=${short(streamId)} ${String(err)}`);
+}
+function logSeparator() {
+  write("\u2500".repeat(100));
+}
+
+// lib/resilient-sse/server/createPersistentStream.ts
+function createPersistentStream(options) {
+  const { kv: kv2, ttl, streamId = (0, import_uuid.v4)() } = options;
+  const chunksKey = `stream:${streamId}:chunks`;
+  const statusKey = `stream:${streamId}:status`;
+  let controller;
+  const encoder = new TextEncoder();
+  let currentIndex = 0;
+  const BATCH_SIZE = 10;
+  const pendingBatch = [];
+  let writeQueue = Promise.resolve();
+  const flushBatch = () => {
+    if (pendingBatch.length === 0) return;
+    const batch = pendingBatch.splice(0, pendingBatch.length);
+    writeQueue = writeQueue.then(() => kv2.rpush(chunksKey, ...batch)).catch(console.error);
+  };
+  const stream = new ReadableStream({
+    start(c) {
+      controller = c;
+    }
+  });
+  kv2.set(statusKey, "streaming", ttl).catch(console.error);
+  logSeparator();
+  logCreate(streamId);
+  const enqueue = async (sseContent) => {
+    const eventId = currentIndex++;
+    const withId = `id: ${eventId}
+${sseContent}`;
+    pendingBatch.push(withId);
+    if (pendingBatch.length >= BATCH_SIZE) flushBatch();
+    if (eventId % 500 === 0 && eventId > 0) {
+      writeQueue = writeQueue.then(() => kv2.expire(chunksKey, ttl)).catch(console.error);
+    }
+    logEnqueue(streamId, eventId, sseContent);
+    try {
+      controller.enqueue(encoder.encode(withId));
+    } catch (e) {
+    }
+  };
+  const close = async () => {
+    flushBatch();
+    await writeQueue;
+    await kv2.expire(chunksKey, ttl);
+    await kv2.set(statusKey, "done", ttl);
+    logClose(streamId, currentIndex, "done");
+    try {
+      controller.close();
+    } catch (e) {
+    }
+  };
+  return { stream, enqueue, close, streamId };
+}
+
+// lib/resilient-sse/server/resume.ts
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function resume(kv2, streamId, lastEventId = -1, pollInterval = 100, ttl = 600) {
+  const chunksKey = `stream:${streamId}:chunks`;
+  const statusKey = `stream:${streamId}:status`;
+  const encoder = new TextEncoder();
+  let cancelled = false;
+  const stream = new ReadableStream({
+    cancel() {
+      cancelled = true;
+    },
+    async start(controller) {
+      const MAX_POLL_MS = 2 * 60 * 1e3;
+      try {
+        const startIndex = lastEventId + 1;
+        logResumeStart(streamId, lastEventId);
+        const buffered = await kv2.lrange(chunksKey, startIndex, -1);
+        logResumeBuffered(streamId, buffered.length);
+        for (const chunk of buffered) {
+          if (cancelled) return;
+          controller.enqueue(encoder.encode(chunk));
+        }
+        let status = await kv2.get(statusKey);
+        if (status === "done") {
+          logResumeDone(streamId, buffered.length);
+          controller.close();
+          return;
+        }
+        let nextIndex = startIndex + buffered.length;
+        let totalSent = buffered.length;
+        const deadline = Date.now() + MAX_POLL_MS;
+        while (true) {
+          await sleep(pollInterval);
+          if (cancelled) return;
+          if (Date.now() > deadline) {
+            logResumeError(streamId, "poll timeout \u2014 upstream stream never completed");
+            controller.close();
+            return;
+          }
+          status = await kv2.get(statusKey);
+          const newChunks = await kv2.lrange(chunksKey, nextIndex, -1);
+          logResumePoll(streamId, nextIndex, newChunks.length);
+          for (const chunk of newChunks) {
+            if (cancelled) return;
+            controller.enqueue(encoder.encode(chunk));
+          }
+          nextIndex += newChunks.length;
+          totalSent += newChunks.length;
+          if (status === "done" || status === null) {
+            logResumeDone(streamId, totalSent);
+            controller.close();
+            return;
+          }
+        }
+      } catch (err) {
+        console.error("[resume] error", err);
+        logResumeError(streamId, err);
+        try {
+          controller.close();
+        } catch (e) {
+        }
+      }
+    }
+  });
+  return new Response(stream, {
+    headers: {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache, no-transform",
+      "Connection": "keep-alive",
+      "X-Accel-Buffering": "no"
+    }
+  });
+}
+
+// lib/resilient-sse/createResilientSSE.ts
+function createResilientSSE(options) {
+  const { kv: kv2, ttl = 600 } = options;
+  return {
+    createStream: (streamId) => createPersistentStream({ kv: kv2, ttl, streamId }),
+    resume: (streamId, lastEventId = -1) => resume(kv2, streamId, lastEventId, 100, ttl)
+  };
+}
+
+// lib/resilient-sse/client/debugLog.ts
+var MAX_ENTRIES = 100;
+var nextId = 0;
+var entries = [];
+var listeners = /* @__PURE__ */ new Set();
+function logSSE(type, data = {}) {
+  entries.push({ id: nextId++, timestamp: Date.now(), type, data });
+  if (entries.length > MAX_ENTRIES) entries.shift();
+  listeners.forEach((fn) => fn());
+}
+
+// lib/resilient-sse/client/persistentFetch.ts
+var streamKey = (projectId) => `pf-stream-id-${projectId}`;
+var eventKey = (projectId) => `pf-last-event-id-${projectId}`;
+async function persistentFetch(url, init, options) {
+  const response = await fetch(url, init);
+  if (!response.ok || !response.body) {
+    return response;
+  }
+  const streamId = response.headers.get("X-Stream-Id");
+  const projectId = options == null ? void 0 : options.projectId;
+  if (streamId && projectId) {
+    sessionStorage.setItem(streamKey(projectId), streamId);
+    sessionStorage.setItem(eventKey(projectId), "-1");
+    logSSE("stream_start", { streamId });
+  }
+  const resilientBody = buildResilientStream(
+    response.body,
+    url,
+    init,
+    streamId,
+    projectId,
+    options == null ? void 0 : options.disconnectSignal
+  );
+  return new Response(resilientBody, {
+    status: response.status,
+    headers: response.headers
+  });
+}
+persistentFetch.resume = async (url, projectId) => {
+  const streamId = sessionStorage.getItem(streamKey(projectId));
+  if (!streamId) return null;
+  const response = await fetch(url, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ streamId, lastEventId: -1 })
+  });
+  if (!response.ok || !response.body) {
+    clearSession(projectId);
+    return null;
+  }
+  const resilientBody = buildResilientStream(response.body, url, void 0, streamId, projectId);
+  return new Response(resilientBody, {
+    status: response.status,
+    headers: response.headers
+  });
+};
+function buildResilientStream(initialBody, url, init, streamId, projectId, disconnectSignal) {
+  let cancelled = false;
+  return new ReadableStream({
+    cancel() {
+      cancelled = true;
+      if (projectId) clearSession(projectId);
+    },
+    async start(controller) {
+      var _a;
+      const initialDone = await readStream(initialBody, controller, () => cancelled, disconnectSignal, projectId);
+      if (initialDone) {
+        try {
+          controller.close();
+        } catch (e) {
+        }
+        return;
+      }
+      while (!cancelled && streamId) {
+        const lastEventId = parseInt(
+          (_a = projectId ? sessionStorage.getItem(eventKey(projectId)) : null) != null ? _a : "-1"
+        );
+        logSSE("disconnected", { streamId, lastEventId });
+        await sleep2(1e3);
+        if (cancelled) break;
+        logSSE("reconnecting", { streamId, lastEventId });
+        try {
+          const response = await fetch(url, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ streamId, lastEventId })
+          });
+          if (!response.ok || !response.body) break;
+          logSSE("resumed", { streamId, fromEventId: lastEventId });
+          const done = await readStream(response.body, controller, () => cancelled, void 0, projectId);
+          if (done) break;
+        } catch (e) {
+        }
+      }
+      try {
+        controller.close();
+      } catch (e) {
+      }
+    }
+  });
+}
+async function readStream(body, controller, isCancelled, disconnectSignal, currentProjectId) {
+  var _a;
+  const reader = body.getReader();
+  const onDisconnect = () => reader.cancel();
+  disconnectSignal == null ? void 0 : disconnectSignal.addEventListener("abort", onDisconnect);
+  const decoder = new TextDecoder();
+  let buffer = "";
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done || isCancelled()) break;
+      const text = decoder.decode(value, { stream: true });
+      buffer += text;
+      const events = buffer.split("\n\n");
+      buffer = (_a = events.pop()) != null ? _a : "";
+      for (const event of events) {
+        let id = null;
+        let isDone = false;
+        for (const line of event.split("\n")) {
+          if (line.startsWith("id: ")) id = parseInt(line.slice(4).trim());
+          if (line.startsWith("event: ") && line.slice(7).trim() === "done") isDone = true;
+          if (line.startsWith("data: ") && line.includes('"type":"done"')) isDone = true;
+        }
+        if (id !== null) {
+          if (currentProjectId) sessionStorage.setItem(eventKey(currentProjectId), String(id));
+          logSSE("chunk", { eventId: id });
+        }
+        controller.enqueue(new TextEncoder().encode(event + "\n\n"));
+        if (isDone) {
+          logSSE("done", { lastEventId: id });
+          if (currentProjectId) clearSession(currentProjectId);
+          return true;
+        }
+      }
+    }
+  } catch (e) {
+  } finally {
+    disconnectSignal == null ? void 0 : disconnectSignal.removeEventListener("abort", onDisconnect);
+    try {
+      reader.releaseLock();
+    } catch (e) {
+    }
+  }
+  return false;
+}
+function clearSession(projectId) {
+  sessionStorage.removeItem(streamKey(projectId));
+  sessionStorage.removeItem(eventKey(projectId));
+}
+function sleep2(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// lib/resilient-sse/kv/upstash.ts
+function upstashAdapter(redis) {
+  return {
+    rpush: (key, ...values) => redis.rpush(key, ...values).then(() => {
+    }),
+    lrange: (key, start, stop) => redis.lrange(key, start, stop),
+    set: (key, value, ttl) => redis.set(key, value, { ex: ttl }).then(() => {
+    }),
+    get: (key) => redis.get(key),
+    expire: (key, ttl) => redis.expire(key, ttl).then(() => {
+    })
+  };
+}
+
+// lib/resilient-sse/kv/vercelKv.ts
+var import_kv = require("@vercel/kv");
+var vercelKvAdapter = {
+  rpush: (key, ...values) => import_kv.kv.rpush(key, ...values).then(() => {
+  }),
+  lrange: (key, start, stop) => import_kv.kv.lrange(key, start, stop),
+  set: (key, value, ttl) => import_kv.kv.set(key, value, { ex: ttl }).then(() => {
+  }),
+  get: (key) => import_kv.kv.get(key),
+  expire: (key, ttl) => import_kv.kv.expire(key, ttl).then(() => {
+  })
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createResilientSSE,
+  persistentFetch,
+  upstashAdapter,
+  vercelKvAdapter
+});

package/dist/index.mjs

@@ -0,0 +1,377 @@
+// lib/resilient-sse/server/createPersistentStream.ts
+import { v4 as uuidv4 } from "uuid";
+
+// lib/resilient-sse/server/fileLogger.ts
+import fs from "fs";
+import path from "path";
+var LOG_FILE = path.join(process.cwd(), "sse-debug.log");
+var MAX_PREVIEW = 80;
+function ts() {
+  const d = /* @__PURE__ */ new Date();
+  return d.getHours().toString().padStart(2, "0") + ":" + d.getMinutes().toString().padStart(2, "0") + ":" + d.getSeconds().toString().padStart(2, "0") + "." + d.getMilliseconds().toString().padStart(3, "0");
+}
+function short(id) {
+  return id.slice(0, 8);
+}
+function preview(s) {
+  const oneline = s.replace(/\n/g, "\u21B5");
+  return oneline.length > MAX_PREVIEW ? oneline.slice(0, MAX_PREVIEW) + "\u2026" : oneline;
+}
+function write(line) {
+  if (process.env.NODE_ENV !== "development") return;
+  fs.appendFile(LOG_FILE, line + "\n", () => {
+  });
+}
+function logCreate(streamId) {
+  write(`[${ts()}] [CREATE   ] sid=${short(streamId)}`);
+}
+function logEnqueue(streamId, eventId, sseContent) {
+  write(`[${ts()}] [ENQUEUE  ] sid=${short(streamId)} id=${String(eventId).padStart(4)} ${preview(sseContent)}`);
+}
+function logClose(streamId, totalChunks, reason) {
+  write(`[${ts()}] [CLOSE    ] sid=${short(streamId)} total=${totalChunks} reason=${reason}`);
+}
+function logResumeStart(streamId, fromEventId) {
+  write(`[${ts()}] [RESUME   ] sid=${short(streamId)} fromId=${fromEventId}`);
+}
+function logResumeBuffered(streamId, count) {
+  write(`[${ts()}] [BUFFERED ] sid=${short(streamId)} replaying=${count} buffered chunks`);
+}
+function logResumePoll(streamId, nextIndex, newCount) {
+  write(`[${ts()}] [POLL     ] sid=${short(streamId)} nextIdx=${nextIndex} newChunks=${newCount}`);
+}
+function logResumeDone(streamId, totalSent) {
+  write(`[${ts()}] [RES_DONE ] sid=${short(streamId)} totalSent=${totalSent}`);
+}
+function logResumeError(streamId, err) {
+  write(`[${ts()}] [RES_ERR  ] sid=${short(streamId)} ${String(err)}`);
+}
+function logSeparator() {
+  write("\u2500".repeat(100));
+}
+
+// lib/resilient-sse/server/createPersistentStream.ts
+function createPersistentStream(options) {
+  const { kv: kv2, ttl, streamId = uuidv4() } = options;
+  const chunksKey = `stream:${streamId}:chunks`;
+  const statusKey = `stream:${streamId}:status`;
+  let controller;
+  const encoder = new TextEncoder();
+  let currentIndex = 0;
+  const BATCH_SIZE = 10;
+  const pendingBatch = [];
+  let writeQueue = Promise.resolve();
+  const flushBatch = () => {
+    if (pendingBatch.length === 0) return;
+    const batch = pendingBatch.splice(0, pendingBatch.length);
+    writeQueue = writeQueue.then(() => kv2.rpush(chunksKey, ...batch)).catch(console.error);
+  };
+  const stream = new ReadableStream({
+    start(c) {
+      controller = c;
+    }
+  });
+  kv2.set(statusKey, "streaming", ttl).catch(console.error);
+  logSeparator();
+  logCreate(streamId);
+  const enqueue = async (sseContent) => {
+    const eventId = currentIndex++;
+    const withId = `id: ${eventId}
+${sseContent}`;
+    pendingBatch.push(withId);
+    if (pendingBatch.length >= BATCH_SIZE) flushBatch();
+    if (eventId % 500 === 0 && eventId > 0) {
+      writeQueue = writeQueue.then(() => kv2.expire(chunksKey, ttl)).catch(console.error);
+    }
+    logEnqueue(streamId, eventId, sseContent);
+    try {
+      controller.enqueue(encoder.encode(withId));
+    } catch (e) {
+    }
+  };
+  const close = async () => {
+    flushBatch();
+    await writeQueue;
+    await kv2.expire(chunksKey, ttl);
+    await kv2.set(statusKey, "done", ttl);
+    logClose(streamId, currentIndex, "done");
+    try {
+      controller.close();
+    } catch (e) {
+    }
+  };
+  return { stream, enqueue, close, streamId };
+}
+
+// lib/resilient-sse/server/resume.ts
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function resume(kv2, streamId, lastEventId = -1, pollInterval = 100, ttl = 600) {
+  const chunksKey = `stream:${streamId}:chunks`;
+  const statusKey = `stream:${streamId}:status`;
+  const encoder = new TextEncoder();
+  let cancelled = false;
+  const stream = new ReadableStream({
+    cancel() {
+      cancelled = true;
+    },
+    async start(controller) {
+      const MAX_POLL_MS = 2 * 60 * 1e3;
+      try {
+        const startIndex = lastEventId + 1;
+        logResumeStart(streamId, lastEventId);
+        const buffered = await kv2.lrange(chunksKey, startIndex, -1);
+        logResumeBuffered(streamId, buffered.length);
+        for (const chunk of buffered) {
+          if (cancelled) return;
+          controller.enqueue(encoder.encode(chunk));
+        }
+        let status = await kv2.get(statusKey);
+        if (status === "done") {
+          logResumeDone(streamId, buffered.length);
+          controller.close();
+          return;
+        }
+        let nextIndex = startIndex + buffered.length;
+        let totalSent = buffered.length;
+        const deadline = Date.now() + MAX_POLL_MS;
+        while (true) {
+          await sleep(pollInterval);
+          if (cancelled) return;
+          if (Date.now() > deadline) {
+            logResumeError(streamId, "poll timeout \u2014 upstream stream never completed");
+            controller.close();
+            return;
+          }
+          status = await kv2.get(statusKey);
+          const newChunks = await kv2.lrange(chunksKey, nextIndex, -1);
+          logResumePoll(streamId, nextIndex, newChunks.length);
+          for (const chunk of newChunks) {
+            if (cancelled) return;
+            controller.enqueue(encoder.encode(chunk));
+          }
+          nextIndex += newChunks.length;
+          totalSent += newChunks.length;
+          if (status === "done" || status === null) {
+            logResumeDone(streamId, totalSent);
+            controller.close();
+            return;
+          }
+        }
+      } catch (err) {
+        console.error("[resume] error", err);
+        logResumeError(streamId, err);
+        try {
+          controller.close();
+        } catch (e) {
+        }
+      }
+    }
+  });
+  return new Response(stream, {
+    headers: {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache, no-transform",
+      "Connection": "keep-alive",
+      "X-Accel-Buffering": "no"
+    }
+  });
+}
+
+// lib/resilient-sse/createResilientSSE.ts
+function createResilientSSE(options) {
+  const { kv: kv2, ttl = 600 } = options;
+  return {
+    createStream: (streamId) => createPersistentStream({ kv: kv2, ttl, streamId }),
+    resume: (streamId, lastEventId = -1) => resume(kv2, streamId, lastEventId, 100, ttl)
+  };
+}
+
+// lib/resilient-sse/client/debugLog.ts
+var MAX_ENTRIES = 100;
+var nextId = 0;
+var entries = [];
+var listeners = /* @__PURE__ */ new Set();
+function logSSE(type, data = {}) {
+  entries.push({ id: nextId++, timestamp: Date.now(), type, data });
+  if (entries.length > MAX_ENTRIES) entries.shift();
+  listeners.forEach((fn) => fn());
+}
+
+// lib/resilient-sse/client/persistentFetch.ts
+var streamKey = (projectId) => `pf-stream-id-${projectId}`;
+var eventKey = (projectId) => `pf-last-event-id-${projectId}`;
+async function persistentFetch(url, init, options) {
+  const response = await fetch(url, init);
+  if (!response.ok || !response.body) {
+    return response;
+  }
+  const streamId = response.headers.get("X-Stream-Id");
+  const projectId = options == null ? void 0 : options.projectId;
+  if (streamId && projectId) {
+    sessionStorage.setItem(streamKey(projectId), streamId);
+    sessionStorage.setItem(eventKey(projectId), "-1");
+    logSSE("stream_start", { streamId });
+  }
+  const resilientBody = buildResilientStream(
+    response.body,
+    url,
+    init,
+    streamId,
+    projectId,
+    options == null ? void 0 : options.disconnectSignal
+  );
+  return new Response(resilientBody, {
+    status: response.status,
+    headers: response.headers
+  });
+}
+persistentFetch.resume = async (url, projectId) => {
+  const streamId = sessionStorage.getItem(streamKey(projectId));
+  if (!streamId) return null;
+  const response = await fetch(url, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ streamId, lastEventId: -1 })
+  });
+  if (!response.ok || !response.body) {
+    clearSession(projectId);
+    return null;
+  }
+  const resilientBody = buildResilientStream(response.body, url, void 0, streamId, projectId);
+  return new Response(resilientBody, {
+    status: response.status,
+    headers: response.headers
+  });
+};
+function buildResilientStream(initialBody, url, init, streamId, projectId, disconnectSignal) {
+  let cancelled = false;
+  return new ReadableStream({
+    cancel() {
+      cancelled = true;
+      if (projectId) clearSession(projectId);
+    },
+    async start(controller) {
+      var _a;
+      const initialDone = await readStream(initialBody, controller, () => cancelled, disconnectSignal, projectId);
+      if (initialDone) {
+        try {
+          controller.close();
+        } catch (e) {
+        }
+        return;
+      }
+      while (!cancelled && streamId) {
+        const lastEventId = parseInt(
+          (_a = projectId ? sessionStorage.getItem(eventKey(projectId)) : null) != null ? _a : "-1"
+        );
+        logSSE("disconnected", { streamId, lastEventId });
+        await sleep2(1e3);
+        if (cancelled) break;
+        logSSE("reconnecting", { streamId, lastEventId });
+        try {
+          const response = await fetch(url, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ streamId, lastEventId })
+          });
+          if (!response.ok || !response.body) break;
+          logSSE("resumed", { streamId, fromEventId: lastEventId });
+          const done = await readStream(response.body, controller, () => cancelled, void 0, projectId);
+          if (done) break;
+        } catch (e) {
+        }
+      }
+      try {
+        controller.close();
+      } catch (e) {
+      }
+    }
+  });
+}
+async function readStream(body, controller, isCancelled, disconnectSignal, currentProjectId) {
+  var _a;
+  const reader = body.getReader();
+  const onDisconnect = () => reader.cancel();
+  disconnectSignal == null ? void 0 : disconnectSignal.addEventListener("abort", onDisconnect);
+  const decoder = new TextDecoder();
+  let buffer = "";
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done || isCancelled()) break;
+      const text = decoder.decode(value, { stream: true });
+      buffer += text;
+      const events = buffer.split("\n\n");
+      buffer = (_a = events.pop()) != null ? _a : "";
+      for (const event of events) {
+        let id = null;
+        let isDone = false;
+        for (const line of event.split("\n")) {
+          if (line.startsWith("id: ")) id = parseInt(line.slice(4).trim());
+          if (line.startsWith("event: ") && line.slice(7).trim() === "done") isDone = true;
+          if (line.startsWith("data: ") && line.includes('"type":"done"')) isDone = true;
+        }
+        if (id !== null) {
+          if (currentProjectId) sessionStorage.setItem(eventKey(currentProjectId), String(id));
+          logSSE("chunk", { eventId: id });
+        }
+        controller.enqueue(new TextEncoder().encode(event + "\n\n"));
+        if (isDone) {
+          logSSE("done", { lastEventId: id });
+          if (currentProjectId) clearSession(currentProjectId);
+          return true;
+        }
+      }
+    }
+  } catch (e) {
+  } finally {
+    disconnectSignal == null ? void 0 : disconnectSignal.removeEventListener("abort", onDisconnect);
+    try {
+      reader.releaseLock();
+    } catch (e) {
+    }
+  }
+  return false;
+}
+function clearSession(projectId) {
+  sessionStorage.removeItem(streamKey(projectId));
+  sessionStorage.removeItem(eventKey(projectId));
+}
+function sleep2(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// lib/resilient-sse/kv/upstash.ts
+function upstashAdapter(redis) {
+  return {
+    rpush: (key, ...values) => redis.rpush(key, ...values).then(() => {
+    }),
+    lrange: (key, start, stop) => redis.lrange(key, start, stop),
+    set: (key, value, ttl) => redis.set(key, value, { ex: ttl }).then(() => {
+    }),
+    get: (key) => redis.get(key),
+    expire: (key, ttl) => redis.expire(key, ttl).then(() => {
+    })
+  };
+}
+
+// lib/resilient-sse/kv/vercelKv.ts
+import { kv } from "@vercel/kv";
+var vercelKvAdapter = {
+  rpush: (key, ...values) => kv.rpush(key, ...values).then(() => {
+  }),
+  lrange: (key, start, stop) => kv.lrange(key, start, stop),
+  set: (key, value, ttl) => kv.set(key, value, { ex: ttl }).then(() => {
+  }),
+  get: (key) => kv.get(key),
+  expire: (key, ttl) => kv.expire(key, ttl).then(() => {
+  })
+};
+export {
+  createResilientSSE,
+  persistentFetch,
+  upstashAdapter,
+  vercelKvAdapter
+};

package/package.json

@@ -0,0 +1,67 @@
+{
+  "name": "persistent-request-response",
+  "version": "0.1.0",
+  "description": "Resilient SSE streaming with automatic reconnection and Redis-backed replay",
+  "private": false,
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "dev": "next dev",
+    "build:lib": "tsup",
+    "build": "next build",
+    "start": "next start",
+    "lint": "eslint"
+  },
+  "peerDependencies": {
+    "@upstash/redis": ">=1.0.0",
+    "@vercel/kv": ">=1.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@upstash/redis": {
+      "optional": true
+    },
+    "@vercel/kv": {
+      "optional": true
+    }
+  },
+  "dependencies": {
+    "next": "16.2.2",
+    "react": "19.2.4",
+    "react-dom": "19.2.4",
+    "uuid": "^13.0.0"
+  },
+  "devDependencies": {
+    "@tailwindcss/postcss": "^4",
+    "@types/node": "^20",
+    "@types/react": "^19",
+    "@types/react-dom": "^19",
+    "@types/uuid": "^10.0.0",
+    "@upstash/redis": "^1.37.0",
+    "@vercel/kv": "^3.0.0",
+    "eslint": "^9",
+    "eslint-config-next": "16.2.2",
+    "tailwindcss": "^4",
+    "tsup": "^8.5.1",
+    "typescript": "^5"
+  },
+  "keywords": [
+    "sse",
+    "server-sent-events",
+    "resilient",
+    "streaming",
+    "redis",
+    "reconnect"
+  ],
+  "license": "MIT"
+}