@boy-offi9-inc/reqkit 0.2.0 → 0.5.0

package/src/createRateLimiter.js

@@ -0,0 +1,111 @@
+const { abortableSleep } = require("./_sleep");
+const { getRateLimitInfo } = require("./_http");
+
+function abortable(promise, signal) {
+  if (!signal) return promise;
+  return new Promise((resolve, reject) => {
+    if (signal.aborted) {
+      reject(signal.reason);
+      return;
+    }
+    const onAbort = () => reject(signal.reason);
+    signal.addEventListener("abort", onAbort, { once: true });
+    promise.then(
+      (v) => (signal.removeEventListener("abort", onAbort), resolve(v)),
+      (e) => (signal.removeEventListener("abort", onAbort), reject(e))
+    );
+  });
+}
+
+/**
+ * A *proactive* rate limiter: slows you down before the server has to say
+ * 429. Two things feed it:
+ *  1. your own budget — `requests` per `perMs` (sliding window), and
+ *  2. what the server tells you — `update(response)` reads X-RateLimit-* /
+ *     RateLimit-* / Retry-After and pauses everything once `remaining` hits 0
+ *     (or the server sent Retry-After), until the reset time.
+ *
+ * Callers are served FIFO.
+ *
+ * ```js
+ * const rl = createRateLimiter({ requests: 10, perMs: 1000 });
+ * const res = await rl.run(() => fetch(url)); // acquire → call → learn from headers
+ * ```
+ *
+ * @param {object} [opts]
+ * @param {number} [opts.requests=Infinity] - max requests per window
+ * @param {number} [opts.perMs=1000] - window length
+ */
+function createRateLimiter(opts = {}) {
+  const { requests = Infinity, perMs = 1000 } = opts;
+  if (requests !== Infinity && !(Number.isInteger(requests) && requests >= 1)) {
+    throw new TypeError("createRateLimiter: `requests` must be an integer >= 1 (or Infinity)");
+  }
+  if (!(typeof perMs === "number" && perMs > 0 && Number.isFinite(perMs))) {
+    throw new TypeError("createRateLimiter: `perMs` must be a positive number");
+  }
+
+  const stamps = [];
+  let blockedUntil = 0;
+  let tail = Promise.resolve();
+
+  async function take(signal) {
+    for (;;) {
+      signal?.throwIfAborted?.();
+      const now = Date.now();
+      while (stamps.length > 0 && stamps[0] <= now - perMs) stamps.shift();
+
+      let waitMs = 0;
+      if (blockedUntil > now) waitMs = blockedUntil - now;
+      else if (stamps.length >= requests) waitMs = stamps[0] + perMs - now;
+
+      if (waitMs <= 0) {
+        stamps.push(now);
+        return;
+      }
+      await abortableSleep(waitMs, signal);
+    }
+  }
+
+  /** Resolves when it's your turn. Rejects with the signal's reason if aborted while waiting. */
+  function acquire({ signal } = {}) {
+    const turn = tail.then(() => take(signal));
+    tail = turn.catch(() => {});
+    return abortable(turn, signal);
+  }
+
+  /** Feed a response (anything with `.headers`/`.status`) so the limiter learns the server's limits. */
+  function update(response) {
+    if (!response || !response.headers) return;
+    const { remaining, resetMs, retryAfterMs } = getRateLimitInfo(response.headers);
+    let blockMs = null;
+    if (retryAfterMs !== null && (response.status === 429 || response.status === 503)) blockMs = retryAfterMs;
+    else if (remaining === 0 && resetMs !== null) blockMs = resetMs;
+    if (blockMs !== null) blockedUntil = Math.max(blockedUntil, Date.now() + blockMs);
+  }
+
+  /** acquire → fn() → update(result). Errors thrown by fn propagate (the slot stays spent). */
+  async function run(fn, { signal } = {}) {
+    await acquire({ signal });
+    const result = await fn();
+    update(result);
+    return result;
+  }
+
+  return {
+    acquire,
+    update,
+    run,
+    /** Ms until the server-imposed pause ends (0 if none). */
+    get blockedForMs() {
+      return Math.max(0, blockedUntil - Date.now());
+    },
+    /** Forget all history and server hints. */
+    reset() {
+      stamps.length = 0;
+      blockedUntil = 0;
+    },
+  };
+}
+
+module.exports = { createRateLimiter };

package/src/downloadResumable.js

@@ -0,0 +1,193 @@
+const { HTTPError } = require("./HTTPError");
+const { BodyTooLargeError } = require("./withProgress");
+const { normalizeError } = require("./normalizeError");
+const { getWaitMsFromHeaders } = require("./_http");
+const { abortableSleep } = require("./_sleep");
+
+const RETRYABLE_STATUS = new Set([408, 425, 429, 500, 502, 503, 504]);
+
+function parseContentRange(header) {
+  // "bytes 100-199/1000" (total may be "*")
+  const m = /^bytes\s+(\d+)-(\d+)\/(\d+|\*)$/i.exec(String(header || "").trim());
+  if (!m) return null;
+  return { start: Number(m[1]), end: Number(m[2]), total: m[3] === "*" ? null : Number(m[3]) };
+}
+
+function isRetryable(err) {
+  if (err instanceof BodyTooLargeError) return false;
+  if (err instanceof HTTPError) return RETRYABLE_STATUS.has(err.status);
+  const n = normalizeError(err);
+  if (n.isAborted) return false;
+  return n.isNetworkError || n.isTimeout;
+}
+
+/**
+ * Downloads a URL into memory and, if the connection drops mid-body, resumes
+ * from where it stopped with an HTTP `Range` request instead of starting
+ * over. Uses `If-Range` with the first response's strong ETag (or
+ * Last-Modified) so a file that changed on the server is restarted rather
+ * than stitched together wrongly. If the server ignores Range, it simply
+ * restarts from zero.
+ *
+ * `retries` counts consecutive attempts *without progress* — a flaky link
+ * that keeps making headway keeps going. Honors Retry-After on 429/503.
+ *
+ * ```js
+ * const bytes = await downloadResumable(url, {
+ *   onProgress: ({ percent }) => console.log(percent),
+ *   maxBytes: 200 * 1024 * 1024,
+ * });
+ * ```
+ *
+ * @param {string} url
+ * @param {object} [opts]
+ * @param {typeof fetch} [opts.fetch=globalThis.fetch] - e.g. `createFetch(...)` or a mock
+ * @param {HeadersInit} [opts.headers]
+ * @param {number} [opts.retries=5]
+ * @param {number} [opts.baseDelayMs=500]
+ * @param {number} [opts.maxDelayMs=10000]
+ * @param {(p: {loaded: number, total: number | null, percent: number | null}) => void} [opts.onProgress]
+ * @param {number} [opts.maxBytes] - throws BodyTooLargeError past this
+ * @param {AbortSignal} [opts.signal]
+ * @param {(err: any, attempt: number, delayMs: number, info: {resumeFrom: number}) => void} [opts.onRetry]
+ * @returns {Promise<Uint8Array>}
+ */
+async function downloadResumable(url, opts = {}) {
+  const {
+    fetch: fetchFn = globalThis.fetch,
+    headers,
+    retries = 5,
+    baseDelayMs = 500,
+    maxDelayMs = 10000,
+    onProgress,
+    maxBytes,
+    signal,
+    onRetry,
+  } = opts;
+
+  const chunks = [];
+  let loaded = 0;
+  let total = null;
+  let validator = null;
+  let attempt = 0; // consecutive attempts without progress
+
+  const report = () => {
+    if (onProgress) {
+      onProgress({ loaded, total, percent: total ? Math.min(100, Math.round((loaded / total) * 100)) : null });
+    }
+  };
+
+  for (;;) {
+    signal?.throwIfAborted?.();
+    const loadedBefore = loaded;
+
+    try {
+      const reqHeaders = new Headers(headers || undefined);
+      // Range offsets count encoded bytes, so ask for an uncompressed body.
+      if (!reqHeaders.has("accept-encoding")) reqHeaders.set("accept-encoding", "identity");
+      if (loaded > 0) {
+        reqHeaders.set("range", `bytes=${loaded}-`);
+        if (validator) reqHeaders.set("if-range", validator);
+      }
+
+      const res = await fetchFn(url, { headers: reqHeaders, signal });
+
+      if (res.status === 416 && loaded > 0) {
+        // Our offset no longer fits the file — start over, without burning a retry.
+        await res.body?.cancel?.().catch(() => {});
+        chunks.length = 0;
+        loaded = 0;
+        continue;
+      }
+      if (!res.ok) {
+        await res.body?.cancel?.().catch(() => {});
+        throw new HTTPError(res, { method: "GET", url });
+      }
+
+      const encoding = res.headers.get("content-encoding");
+      const encoded = Boolean(encoding) && encoding.trim().toLowerCase() !== "identity";
+
+      if (loaded > 0) {
+        const range = res.status === 206 ? parseContentRange(res.headers.get("content-range")) : null;
+        if (!range || range.start !== loaded || encoded) {
+          // Server ignored Range, the file changed (If-Range failed), or the
+          // bytes don't line up: discard and restart from the beginning.
+          chunks.length = 0;
+          loaded = 0;
+        }
+      }
+
+      if (loaded === 0) {
+        const range = res.status === 206 ? parseContentRange(res.headers.get("content-range")) : null;
+        const length = Number(res.headers.get("content-length"));
+        total = encoded ? null : range ? range.total : Number.isFinite(length) && res.headers.has("content-length") ? length : null;
+        const etag = res.headers.get("etag");
+        validator = etag && !etag.startsWith("W/") ? etag : res.headers.get("last-modified");
+      }
+
+      if (maxBytes !== undefined && total !== null && total > maxBytes) {
+        await res.body?.cancel?.().catch(() => {});
+        throw new BodyTooLargeError(maxBytes);
+      }
+
+      if (!res.body || typeof res.body.getReader !== "function") {
+        const buf = new Uint8Array(await res.arrayBuffer());
+        if (maxBytes !== undefined && buf.byteLength > maxBytes) throw new BodyTooLargeError(maxBytes);
+        chunks.push(buf);
+        loaded += buf.byteLength;
+        total = total ?? loaded;
+        report();
+      } else {
+        const reader = res.body.getReader();
+        const onAbort = () => reader.cancel(signal.reason).catch(() => {});
+        signal?.addEventListener("abort", onAbort, { once: true });
+        let finished = false;
+        try {
+          for (;;) {
+            const { done, value } = await reader.read();
+            signal?.throwIfAborted?.();
+            if (done) break;
+            chunks.push(value);
+            loaded += value.byteLength;
+            if (maxBytes !== undefined && loaded > maxBytes) throw new BodyTooLargeError(maxBytes);
+            report();
+          }
+          finished = true;
+        } finally {
+          signal?.removeEventListener("abort", onAbort);
+          if (!finished) reader.cancel().catch(() => {});
+        }
+      }
+
+      if (total !== null && loaded < total) {
+        // Stream ended early without an error (some servers just close the socket).
+        throw Object.assign(new Error(`Incomplete download: got ${loaded} of ${total} bytes`), { code: "ECONNRESET" });
+      }
+
+      const out = new Uint8Array(loaded);
+      let offset = 0;
+      for (const chunk of chunks) {
+        out.set(chunk, offset);
+        offset += chunk.byteLength;
+      }
+      return out;
+    } catch (err) {
+      if (signal?.aborted) throw signal.reason ?? err;
+      if (!isRetryable(err)) throw err;
+
+      if (loaded > loadedBefore) attempt = 0; // it made progress — doesn't count against the budget
+      if (attempt >= retries) throw err;
+
+      let delayMs = Math.min(baseDelayMs * 2 ** attempt, maxDelayMs);
+      if (err instanceof HTTPError) {
+        const headerMs = getWaitMsFromHeaders(err.response && err.response.headers);
+        if (headerMs !== null) delayMs = Math.min(headerMs, 60000);
+      }
+      attempt++;
+      if (onRetry) onRetry(err, attempt, delayMs, { resumeFrom: loaded });
+      await abortableSleep(delayMs, signal);
+    }
+  }
+}
+
+module.exports = { downloadResumable };

package/src/index.js

@@ -1,4 +1,4 @@
-const { withRetry, RetryAbortedError } = require("./withRetry");
+const { withRetry, RetryAbortedError, StopRetry } = require("./withRetry");
 const { withTimeout, TimeoutError } = require("./withTimeout");
 const { normalizeError } = require("./normalizeError");
 const { parseJsonSafe } = require("./parseJsonSafe");
@@ -6,10 +6,19 @@ const { buildQuery } = require("./buildQuery");
 const { retryAfterAware, parseRetryAfter, getWaitMsFromHeaders } = require("./retryAfterAware");
 const { withProgress, BodyTooLargeError } = require("./withProgress");
 const { withDedupe } = require("./withDedupe");
+const { createLimiter } = require("./createLimiter");
+const { createFetch, HTTPError } = require("./createFetch");
+const { createRateLimiter } = require("./createRateLimiter");
+const { createCircuitBreaker, CircuitOpenError } = require("./createCircuitBreaker");
+const { createMemoryCache } = require("./createMemoryCache");
+const { createMockFetch } = require("./createMockFetch");
+const { downloadResumable } = require("./downloadResumable");
+const { readLines, readNDJSON, readSSE } = require("./streams");
 
 module.exports = {
   withRetry,
   RetryAbortedError,
+  StopRetry,
   withTimeout,
   TimeoutError,
   normalizeError,
@@ -21,4 +30,16 @@ module.exports = {
   withProgress,
   BodyTooLargeError,
   withDedupe,
+  createLimiter,
+  createFetch,
+  HTTPError,
+  createRateLimiter,
+  createCircuitBreaker,
+  CircuitOpenError,
+  createMemoryCache,
+  createMockFetch,
+  downloadResumable,
+  readLines,
+  readNDJSON,
+  readSSE,
 };

package/src/index.mjs

@@ -3,6 +3,7 @@ import reqkit from "./index.js";
 export const {
   withRetry,
   RetryAbortedError,
+  StopRetry,
   withTimeout,
   TimeoutError,
   normalizeError,
@@ -14,6 +15,18 @@ export const {
   withProgress,
   BodyTooLargeError,
   withDedupe,
+  createLimiter,
+  createFetch,
+  HTTPError,
+  createRateLimiter,
+  createCircuitBreaker,
+  CircuitOpenError,
+  createMemoryCache,
+  createMockFetch,
+  downloadResumable,
+  readLines,
+  readNDJSON,
+  readSSE,
 } = reqkit;
 
 export default reqkit;

package/src/retryAfterAware.js

@@ -1,75 +1,23 @@
-const { RetryAbortedError, sleep } = require("./_sleep");
+const { withRetry } = require("./withRetry");
 const { normalizeError } = require("./normalizeError");
-
-/**
- * Parses a Retry-After header value into milliseconds. Per HTTP spec it's
- * either an integer number of seconds, or an HTTP-date.
- */
-function parseRetryAfter(headerValue) {
-  if (headerValue === null || headerValue === undefined) return null;
-  const value = String(headerValue).trim();
-  if (!value) return null;
-
-  // delta-seconds (spec says integer; tolerate "1.5" from sloppy servers)
-  if (/^\d+(\.\d+)?$/.test(value)) {
-    return Number(value) * 1000;
-  }
-
-  const dateMs = Date.parse(value);
-  if (!Number.isNaN(dateMs)) {
-    return Math.max(0, dateMs - Date.now());
-  }
-
-  return null;
-}
-
-/**
- * Reads a wait time from common rate-limit headers, trying Retry-After first,
- * then falling back to X-RateLimit-Reset (epoch seconds or ms) if present.
- */
-function getWaitMsFromHeaders(headers) {
-  if (!headers || typeof headers.get !== "function") return null;
-
-  const retryAfter = parseRetryAfter(headers.get("retry-after"));
-  if (retryAfter !== null) return retryAfter;
-
-  const resetHeader = headers.get("x-ratelimit-reset") || headers.get("x-rate-limit-reset");
-  if (resetHeader) {
-    const resetValue = Number(resetHeader);
-    if (!Number.isNaN(resetValue)) {
-      // Could be epoch seconds or epoch ms — treat values below a
-      // year-2100-in-seconds threshold as seconds.
-      const resetMs = resetValue > 4102444800 ? resetValue : resetValue * 1000;
-      return Math.max(0, resetMs - Date.now());
-    }
-  }
-
-  return null;
-}
+const { parseRetryAfter, getWaitMsFromHeaders } = require("./_http");
 
 function defaultShouldRetryError(err) {
   const normalized = normalizeError(err);
   return normalized.isNetworkError || normalized.isTimeout;
 }
 
-async function discardBody(response) {
-  // An unread body keeps the underlying connection busy; cancel it before
-  // we sit through a backoff and fire the next request.
-  try {
-    if (response.body && typeof response.body.cancel === "function" && !response.bodyUsed) {
-      await response.body.cancel();
-    }
-  } catch {
-    // locked / already consumed / not a web stream — safe to ignore
-  }
-}
-
 /**
  * Retries a fetch-like call, honoring Retry-After / X-RateLimit-Reset
  * headers on 429/503 responses instead of blind exponential backoff — most
  * generic retry libraries treat rate-limit responses like any other failure
  * and ignore the header the server is explicitly giving you.
  *
+ * This is a thin preset over `withRetry` (retryStatusCodes + Retry-After,
+ * no jitter, network errors/timeouts only for thrown errors). Reach for
+ * `withRetry` directly when you need jitter, `maxRetryTime`, `StopRetry`,
+ * `calculateDelay`, ...
+ *
  * Also retries thrown network errors / timeouts (see `shouldRetryError`),
  * and the whole loop — including any backoff wait — can be cancelled with
  * `signal`. The body of each response that gets retried is cancelled so the
@@ -92,7 +40,7 @@ async function discardBody(response) {
  * @param {AbortSignal} [opts.signal] - cancels the retry loop, throwing
  *   RetryAbortedError
  */
-async function retryAfterAware(fn, opts = {}) {
+function retryAfterAware(fn, opts = {}) {
   const {
     retries = 3,
     retryStatusCodes = [429, 503],
@@ -104,34 +52,24 @@ async function retryAfterAware(fn, opts = {}) {
     signal,
   } = opts;
 
-  let lastErr;
-  for (let attempt = 0; attempt <= retries; attempt++) {
-    if (signal?.aborted) throw new RetryAbortedError(lastErr);
-
-    let response;
-    try {
-      response = await fn(attempt);
-    } catch (err) {
-      lastErr = err;
-      if (attempt === retries || !shouldRetryError(err, attempt)) throw err;
-
-      const waitMs = Math.min(fallbackDelayMs * 2 ** attempt, maxDelayMs);
-      if (onRetryError) onRetryError(err, waitMs, attempt);
-      await sleep(waitMs, signal, err);
-      continue;
-    }
-
-    if (!retryStatusCodes.includes(response.status) || attempt === retries) {
-      return response;
-    }
-
-    const headerWaitMs = getWaitMsFromHeaders(response.headers);
-    const waitMs = Math.min(headerWaitMs ?? fallbackDelayMs * 2 ** attempt, maxDelayMs);
-
-    await discardBody(response);
-    if (onRetry) onRetry(response.status, waitMs, attempt);
-    await sleep(waitMs, signal);
-  }
+  return withRetry(fn, {
+    retries,
+    retryStatusCodes,
+    baseDelayMs: fallbackDelayMs,
+    maxDelayMs,
+    maxRetryAfterMs: maxDelayMs,
+    factor: 2,
+    jitter: 0,
+    shouldRetry: shouldRetryError,
+    onRetry: (err, attempt, waitMs, ctx) => {
+      if (ctx.reason === "result") {
+        if (onRetry) onRetry(ctx.status, waitMs, attempt);
+      } else if (onRetryError) {
+        onRetryError(err, waitMs, attempt);
+      }
+    },
+    signal,
+  });
 }
 
 module.exports = { retryAfterAware, parseRetryAfter, getWaitMsFromHeaders };

package/src/streams.js

@@ -0,0 +1,149 @@
+const encoder = new TextEncoder();
+
+// Yields Uint8Array chunks from a fetch Response, a web ReadableStream, or any
+// async iterable (e.g. a Node Readable). Cancels the underlying stream when
+// the consumer stops early or the signal aborts, so the connection is freed.
+async function* chunks(source, signal) {
+  let body = source;
+  if (body && typeof body.getReader !== "function" && "body" in body) body = body.body; // a Response
+  if (body === null || body === undefined) return;
+  signal?.throwIfAborted?.();
+
+  if (typeof body.getReader === "function") {
+    const reader = body.getReader();
+    const onAbort = () => reader.cancel(signal.reason).catch(() => {});
+    signal?.addEventListener("abort", onAbort, { once: true });
+    try {
+      for (;;) {
+        const { done, value } = await reader.read();
+        signal?.throwIfAborted?.(); // cancel() makes read() resolve as done — don't mistake that for the end
+        if (done) return;
+        yield value;
+      }
+    } finally {
+      signal?.removeEventListener("abort", onAbort);
+      reader.cancel().catch(() => {});
+    }
+  } else if (typeof body[Symbol.asyncIterator] === "function") {
+    for await (const chunk of body) {
+      signal?.throwIfAborted?.();
+      yield typeof chunk === "string" ? encoder.encode(chunk) : chunk;
+    }
+  } else {
+    throw new TypeError("reqkit streams: expected a Response, a ReadableStream or an async iterable");
+  }
+}
+
+/**
+ * Async-iterates the text lines of a streamed body. Handles \n, \r\n and \r,
+ * multi-byte characters split across chunks, and a leading BOM.
+ *
+ * ```js
+ * for await (const line of readLines(response)) console.log(line);
+ * ```
+ *
+ * @param {Response | ReadableStream | AsyncIterable<Uint8Array>} source
+ * @param {{ signal?: AbortSignal }} [opts]
+ * @returns {AsyncGenerator<string>}
+ */
+async function* readLines(source, opts = {}) {
+  const decoder = new TextDecoder("utf-8");
+  let buffer = "";
+  let first = true;
+
+  for await (const chunk of chunks(source, opts.signal)) {
+    buffer += decoder.decode(chunk, { stream: true });
+    if (first && buffer.length > 0) {
+      buffer = buffer.replace(/^\uFEFF/, "");
+      first = false;
+    }
+
+    let pos = 0;
+    for (;;) {
+      const rest = buffer.slice(pos);
+      const i = rest.search(/\r\n|\n|\r/);
+      if (i === -1) break;
+      // A trailing "\r" might be the first half of "\r\n" — wait for more data.
+      if (rest[i] === "\r" && i === rest.length - 1) break;
+      yield rest.slice(0, i);
+      pos += i + (rest.startsWith("\r\n", i) ? 2 : 1);
+    }
+    buffer = buffer.slice(pos);
+  }
+
+  buffer += decoder.decode();
+  if (buffer.endsWith("\r")) buffer = buffer.slice(0, -1);
+  if (buffer.length > 0) yield buffer;
+}
+
+/**
+ * Async-iterates parsed JSON values from a newline-delimited JSON stream
+ * (NDJSON / JSON Lines). Blank lines are skipped. A malformed line throws a
+ * SyntaxError naming the line, unless `skipInvalid` is true.
+ *
+ * @param {Response | ReadableStream | AsyncIterable<Uint8Array>} source
+ * @param {{ signal?: AbortSignal, skipInvalid?: boolean }} [opts]
+ */
+async function* readNDJSON(source, opts = {}) {
+  let lineNo = 0;
+  for await (const line of readLines(source, opts)) {
+    lineNo++;
+    if (line.trim() === "") continue;
+    try {
+      yield JSON.parse(line);
+    } catch (err) {
+      if (opts.skipInvalid) continue;
+      throw new SyntaxError(`readNDJSON: invalid JSON on line ${lineNo}: ${err.message}`);
+    }
+  }
+}
+
+/**
+ * Async-iterates Server-Sent Events (text/event-stream) as
+ * `{ event, data, id, retry }`, following the spec: multi-line `data:` is
+ * joined with "\n", comments (`:`) are ignored, `event` defaults to
+ * "message", `id` carries over between events, and an event cut off by the end
+ * of the stream is discarded. Great for LLM token streams.
+ *
+ * ```js
+ * for await (const { data } of readSSE(response)) {
+ *   if (data === "[DONE]") break;
+ *   console.log(JSON.parse(data));
+ * }
+ * ```
+ *
+ * @param {Response | ReadableStream | AsyncIterable<Uint8Array>} source
+ * @param {{ signal?: AbortSignal }} [opts]
+ */
+async function* readSSE(source, opts = {}) {
+  let event = "";
+  let data = [];
+  let retry;
+  let lastId = "";
+
+  for await (const line of readLines(source, opts)) {
+    if (line === "") {
+      if (data.length > 0) yield { event: event || "message", data: data.join("\n"), id: lastId, retry };
+      event = "";
+      data = [];
+      retry = undefined;
+      continue;
+    }
+    if (line.startsWith(":")) continue;
+
+    const idx = line.indexOf(":");
+    const field = idx === -1 ? line : line.slice(0, idx);
+    let value = idx === -1 ? "" : line.slice(idx + 1);
+    if (value.startsWith(" ")) value = value.slice(1);
+
+    if (field === "event") event = value;
+    else if (field === "data") data.push(value);
+    else if (field === "id") {
+      if (!value.includes("\0")) lastId = value;
+    } else if (field === "retry") {
+      if (/^\d+$/.test(value)) retry = Number(value);
+    }
+  }
+}
+
+module.exports = { readLines, readNDJSON, readSSE };