@newtalaria/browser 0.1.0 → 0.1.4

package/dist/index.js

@@ -38,8 +38,18 @@ var ServerpodTransport = class {
     });
     if (!response.ok) {
       const text = await response.text().catch(() => "");
+      let detail = text.slice(0, 400);
+      try {
+        const parsed = JSON.parse(text);
+        const className = parsed.className ?? parsed.exception;
+        const message = parsed.message;
+        if (className || message) {
+          detail = [className, message].filter(Boolean).join(": ");
+        }
+      } catch {
+      }
       throw new Error(
-        `Talaria ${endpoint}/${method} failed: HTTP ${response.status}${text ? ` \u2014 ${text.slice(0, 200)}` : ""}`
+        `Talaria ${endpoint}/${method} failed: HTTP ${response.status}${detail ? ` \u2014 ${detail}` : ""}`
       );
     }
     const contentType = response.headers.get("content-type") ?? "";
@@ -101,56 +111,6 @@ function toServerpodByteData(bytes) {
   return `decode('${b64}', 'base64')`;
 }
 
-// src/transport/replays.ts
-async function startReplay(transport, params) {
-  const input2 = {
-    __className__: "StartReplayInput",
-    replayId: params.replayId,
-    environment: params.environment
-  };
-  if (params.sessionId) input2.sessionId = params.sessionId;
-  if (params.url) input2.url = params.url;
-  if (params.userId) input2.userId = params.userId;
-  return transport.call(
-    "replays",
-    "start",
-    { input: input2 },
-    { keepalive: params.keepalive }
-  );
-}
-async function ingestReplaySegment(transport, params) {
-  const json = JSON.stringify(params.events);
-  const compressed = await gzipBytes(new TextEncoder().encode(json));
-  const input2 = {
-    __className__: "IngestReplaySegmentInput",
-    replayId: params.replayId,
-    segmentIndex: params.segmentIndex,
-    gzipBytes: toServerpodByteData(compressed),
-    eventCount: params.events.length,
-    startedAt: params.startedAt.toISOString(),
-    endedAt: params.endedAt.toISOString()
-  };
-  return transport.call(
-    "replays",
-    "ingestSegment",
-    { input: input2 },
-    { keepalive: params.keepalive }
-  );
-}
-async function finishReplay(transport, params) {
-  const input2 = {
-    __className__: "FinishReplayInput",
-    replayId: params.replayId
-  };
-  if (params.reason) input2.reason = params.reason;
-  return transport.call(
-    "replays",
-    "finish",
-    { input: input2 },
-    { keepalive: params.keepalive }
-  );
-}
-
 // src/utils/estimate.ts
 function estimateJsonBytes(value) {
   try {
@@ -161,9 +121,20 @@ function estimateJsonBytes(value) {
 }
 
 // src/replay/segment_buffer.ts
-var SEGMENT_SIZE_BYTES = 1e5;
+var SEGMENT_SIZE_BYTES = 4e5;
+var MAX_COMPRESSED_SEGMENT_BYTES = 512 * 1024;
+var TARGET_COMPRESSED_SEGMENT_BYTES = MAX_COMPRESSED_SEGMENT_BYTES - 32 * 1024;
+var MAX_SEGMENTS_PER_REPLAY = 200;
+var MAX_SEGMENTS_ERROR_CLIP = 12;
+var MAX_ERROR_CLIP_COMPRESSED_BYTES = 2 * 1024 * 1024;
+var ERROR_CLIP_FLUSH_SLACK_MS = 5e3;
 var SEGMENT_FLUSH_MS = 5e3;
 var RING_BUFFER_MS = 6e4;
+var RING_BUFFER_MAX_BYTES = 15e5;
+var ERROR_REPLAY_AFTER_MS = 15e3;
+var MAX_REPLAY_DURATION_MS = 5 * 60 * 1e3;
+var RRWEB_FULL_SNAPSHOT = 2;
+var RRWEB_META = 4;
 var SegmentBuffer = class {
   constructor() {
     this.events = [];
@@ -179,8 +150,31 @@ var SegmentBuffer = class {
     this.events.push(event);
     this.pendingBytes += estimateJsonBytes(event);
   }
-  /** Drop events older than the ring window (buffer-only mode). */
-  trimRing(now = Date.now()) {
+  hasFullSnapshot() {
+    return this.events.some((e) => e.type === RRWEB_FULL_SNAPSHOT);
+  }
+  /**
+   * Drop leading events until Meta+FullSnapshot (or FullSnapshot alone).
+   * Returns false if no FullSnapshot is present (replay would paint blank).
+   */
+  trimToFullSnapshot() {
+    const fullIdx = this.events.findIndex((e) => e.type === RRWEB_FULL_SNAPSHOT);
+    if (fullIdx < 0) return false;
+    let start = fullIdx;
+    if (fullIdx > 0 && this.events[fullIdx - 1].type === RRWEB_META) {
+      start = fullIdx - 1;
+    }
+    if (start > 0) {
+      this.events.splice(0, start);
+      this.recomputeBytes();
+    }
+    return true;
+  }
+  /**
+   * Drop events older than the ring window and/or over the byte cap
+   * (buffer-only mode). Prefer keeping the newest events.
+   */
+  trimRing(now = Date.now(), maxBytes = RING_BUFFER_MAX_BYTES) {
     const cutoff = now - RING_BUFFER_MS;
     let remove = 0;
     while (remove < this.events.length && this.events[remove].timestamp < cutoff) {
@@ -190,22 +184,55 @@ var SegmentBuffer = class {
       this.events.splice(0, remove);
       this.recomputeBytes();
     }
+    while (this.events.length > 1 && this.pendingBytes > maxBytes) {
+      this.events.shift();
+      this.recomputeBytes();
+    }
   }
   shouldFlushBySize() {
     return this.pendingBytes >= SEGMENT_SIZE_BYTES;
   }
+  /**
+   * Take a prefix of events whose estimated JSON size is ~maxBytes.
+   * Always returns at least one event when the buffer is non-empty (caller
+   * must handle a single oversized event).
+   */
+  takeByEstimatedBytes(maxBytes) {
+    if (this.events.length === 0) return [];
+    const batch = [];
+    let batchBytes = 0;
+    while (this.events.length > 0) {
+      const next = this.events[0];
+      const nextBytes = estimateJsonBytes(next);
+      if (batch.length > 0 && batchBytes + nextBytes > maxBytes) {
+        break;
+      }
+      this.events.shift();
+      batch.push(next);
+      batchBytes += nextBytes;
+      if (batch.length === 1 && nextBytes >= maxBytes) {
+        break;
+      }
+    }
+    this.recomputeBytes();
+    return batch;
+  }
   takeAll() {
     const batch = this.events;
     this.events = [];
     this.pendingBytes = 0;
     return batch;
   }
-  /** Re-queue events at the front (failed upload retry). */
+  /** Re-queue events at the front (failed upload retry / bisect remainder). */
   prepend(events) {
     if (events.length === 0) return;
     this.events = events.concat(this.events);
     this.recomputeBytes();
   }
+  clear() {
+    this.events = [];
+    this.pendingBytes = 0;
+  }
   peekTimes() {
     if (this.events.length === 0) return null;
     const first = this.events[0];
@@ -220,6 +247,114 @@ var SegmentBuffer = class {
   }
 };
 
+// src/transport/replays.ts
+async function compressReplayEvents(events) {
+  const json = JSON.stringify(events);
+  return gzipBytes(new TextEncoder().encode(json));
+}
+async function startReplay(transport, params) {
+  const input2 = {
+    __className__: "StartReplayInput",
+    replayId: params.replayId,
+    environment: params.environment
+  };
+  if (params.sessionId) input2.sessionId = params.sessionId;
+  if (params.url) input2.url = params.url;
+  if (params.userId) input2.userId = params.userId;
+  return transport.call(
+    "replays",
+    "start",
+    { input: input2 },
+    { keepalive: params.keepalive }
+  );
+}
+async function ingestReplaySegment(transport, params) {
+  const compressed = params.gzip ?? await compressReplayEvents(params.events);
+  if (compressed.length > MAX_COMPRESSED_SEGMENT_BYTES) {
+    throw new Error(
+      `Talaria replays/ingestSegment failed: HTTP 400 \u2014 segment exceeds max compressed size (${compressed.length} > ${MAX_COMPRESSED_SEGMENT_BYTES})`
+    );
+  }
+  const input2 = {
+    __className__: "IngestReplaySegmentInput",
+    replayId: params.replayId,
+    segmentIndex: params.segmentIndex,
+    gzipBytes: toServerpodByteData(compressed),
+    eventCount: params.events.length,
+    startedAt: params.startedAt.toISOString(),
+    endedAt: params.endedAt.toISOString()
+  };
+  return transport.call(
+    "replays",
+    "ingestSegment",
+    { input: input2 },
+    { keepalive: params.keepalive }
+  );
+}
+async function finishReplay(transport, params) {
+  const input2 = {
+    __className__: "FinishReplayInput",
+    replayId: params.replayId
+  };
+  if (params.reason) input2.reason = params.reason;
+  return transport.call(
+    "replays",
+    "finish",
+    { input: input2 },
+    { keepalive: params.keepalive }
+  );
+}
+
+// src/replay/fit_segment.ts
+function computeErrorClipDeadlineMs(uploadStartedAtMs, afterMs, slackMs = ERROR_CLIP_FLUSH_SLACK_MS) {
+  return uploadStartedAtMs + afterMs + slackMs;
+}
+function isErrorClipBudgetExhausted(opts) {
+  const maxSegments = opts.maxSegments ?? MAX_SEGMENTS_ERROR_CLIP;
+  const maxBytes = opts.maxBytes ?? MAX_ERROR_CLIP_COMPRESSED_BYTES;
+  return opts.segmentIndex >= maxSegments || opts.uploadedCompressedBytes >= maxBytes;
+}
+function planOversizedRetry(events) {
+  if (events.length <= 1) {
+    return { action: "drop" };
+  }
+  const mid = Math.ceil(events.length / 2);
+  return {
+    action: "bisect",
+    left: events.slice(0, mid),
+    right: events.slice(mid)
+  };
+}
+async function fitCompressedPrefix(events, compress, targetBytes = TARGET_COMPRESSED_SEGMENT_BYTES, hardCap = MAX_COMPRESSED_SEGMENT_BYTES) {
+  if (events.length === 0) return null;
+  let remaining = events;
+  while (remaining.length > 0) {
+    let lo = 1;
+    let hi = remaining.length;
+    let best = null;
+    while (lo <= hi) {
+      const mid = Math.floor((lo + hi) / 2);
+      const prefix = remaining.slice(0, mid);
+      const gzip = await compress(prefix);
+      if (gzip.length <= targetBytes && gzip.length <= hardCap) {
+        best = { events: prefix, gzip };
+        lo = mid + 1;
+      } else {
+        hi = mid - 1;
+      }
+    }
+    if (best) {
+      return {
+        events: best.events,
+        gzip: best.gzip,
+        remainder: remaining.slice(best.events.length)
+      };
+    }
+    remaining = remaining.slice(1);
+  }
+  return null;
+}
+
 // ../../node_modules/rrweb/dist/rrweb.js
 var __defProp = Object.defineProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
@@ -12975,13 +13110,27 @@ function redactUrl(raw) {
   }
 }
 function defaultBlockSelector(extra) {
-  const parts = ["[data-talaria-mask]", ".talaria-block"];
+  const parts = [
+    "[data-talaria-mask]",
+    ".talaria-block",
+    // Heavy docs surfaces (syntax-highlighted code) blow up FullSnapshots.
+    "pre",
+    "code"
+  ];
   if (extra?.trim()) parts.push(extra.trim());
   return parts.join(", ");
 }
 
 // src/replay/recorder.ts
 function startRecorder(options) {
+  if (typeof document === "undefined") {
+    return {
+      stop: () => {
+      },
+      takeFullSnapshot: () => {
+      }
+    };
+  }
   const stopFn = record({
     emit(event) {
       options.onEvent(event);
@@ -12992,11 +13141,25 @@ function startRecorder(options) {
     },
     blockSelector: defaultBlockSelector(options.blockSelector),
     recordCanvas: false,
-    collectFonts: false
+    collectFonts: false,
+    inlineStylesheet: false,
+    // Shrink DOM snapshots on heavy sites (docs / marketing).
+    slimDOMOptions: "all",
+    sampling: {
+      mousemove: 150,
+      scroll: 200,
+      input: "last"
+    }
   });
   return {
     stop: () => {
       stopFn?.();
+    },
+    takeFullSnapshot: () => {
+      try {
+        record.takeFullSnapshot(true);
+      } catch {
+      }
     }
   };
 }
@@ -13129,6 +13292,7 @@ function resolveOptions(options) {
     release: options.release,
     replaysSessionSampleRate: clamp01(options.replaysSessionSampleRate ?? 0),
     replaysOnErrorSampleRate: clamp01(options.replaysOnErrorSampleRate ?? 1),
+    replaysErrorAfterMs: normalizeErrorAfterMs(options.replaysErrorAfterMs),
     maskAllInputs: options.maskAllInputs ?? true,
     blockSelector: options.blockSelector ?? "",
     userId: options.userId,
@@ -13139,12 +13303,26 @@ function clamp01(n2) {
   if (Number.isNaN(n2)) return 0;
   return Math.min(1, Math.max(0, n2));
 }
+function normalizeErrorAfterMs(n2) {
+  if (n2 === void 0 || Number.isNaN(n2) || n2 < 0) {
+    return ERROR_REPLAY_AFTER_MS;
+  }
+  return Math.floor(n2);
+}
 function levelToEventType(level) {
   if (level === "fatal" || level === "error") return "error";
   if (level === "warning") return "warning";
   if (level === "debug") return "debug";
   return "info";
 }
+function isTerminalReplayLimitError(error) {
+  const msg = error instanceof Error ? error.message : String(error);
+  return msg.includes("replay exceeds max segment count") || msg.includes("replay exceeds max total size") || msg.includes("replay exceeds max duration") || msg.includes("Replay has expired");
+}
+function isOversizedSegmentError(error) {
+  const msg = error instanceof Error ? error.message : String(error);
+  return msg.includes("segment exceeds max compressed size") || msg.includes("segment exceeds max uncompressed size") || msg.includes("HTTP 400") && msg.includes("ApiValidationException");
+}
 var TalariaClient = class {
   constructor() {
     this.options = null;
@@ -13153,14 +13331,28 @@ var TalariaClient = class {
     this.sessionId = null;
     this.recorder = null;
     this.buffer = new SegmentBuffer();
+    /** Continuous upload for the whole page session (session sample hit). */
+    this.sessionSampled = false;
     this.uploadEnabled = false;
     this.startedOnServer = false;
     this.finishedOnServer = false;
     this.segmentIndex = 0;
+    this.uploadedCompressedBytes = 0;
+    /** Wall clock when continuous upload began (session or error promote). */
+    this.uploadStartedAtMs = null;
+    /** Absolute deadline for error-clip mode (not extended by later errors). */
+    this.errorClipDeadlineMs = null;
     this.flushTimer = null;
+    this.errorClipTimer = null;
+    this.maxDurationTimer = null;
     this.uploadChain = Promise.resolve();
     this.closed = false;
     this.teardowns = [];
+    /**
+     * Replay id that just finished with segments — kept briefly so capture can
+     * attach it to the error event after budget/timer finish resets buffer mode.
+     */
+    this.linkableReplayId = null;
   }
   init(options) {
     if (this.options) {
@@ -13178,9 +13370,14 @@ var TalariaClient = class {
     this.finishedOnServer = false;
     this.startedOnServer = false;
     this.segmentIndex = 0;
+    this.uploadedCompressedBytes = 0;
+    this.uploadStartedAtMs = null;
+    this.errorClipDeadlineMs = null;
+    this.linkableReplayId = null;
     this.buffer = new SegmentBuffer();
-    const sessionSampled = Math.random() < this.options.replaysSessionSampleRate;
-    this.uploadEnabled = sessionSampled;
+    this.uploadChain = Promise.resolve();
+    this.sessionSampled = Math.random() < this.options.replaysSessionSampleRate;
+    this.uploadEnabled = this.sessionSampled;
     this.recorder = startRecorder({
       maskAllInputs: this.options.maskAllInputs,
       blockSelector: this.options.blockSelector,
@@ -13205,13 +13402,15 @@ var TalariaClient = class {
       });
     }
     if (this.uploadEnabled) {
+      this.markUploadStarted();
       void this.enqueueUpload(async () => {
         await this.ensureStarted({ keepalive: false });
       });
     }
   }
   getReplayId() {
-    return this.uploadEnabled ? this.replayId : null;
+    if (this.uploadEnabled && this.replayId) return this.replayId;
+    return this.linkableReplayId;
   }
   async captureException(error, context) {
     const err = error instanceof Error ? error : new Error(typeof error === "string" ? error : "Unknown error");
@@ -13239,16 +13438,39 @@ var TalariaClient = class {
       return;
     }
     await this.enqueueUpload(async () => {
+      if (!this.uploadEnabled || this.closed) return;
+      if (this.isPastErrorClipDeadline() && !opts?.finish) {
+        await this.runEndErrorClip({ reason: "error_clip_deadline" });
+        return;
+      }
+      if (this.isPastMaxDuration() && !opts?.finish) {
+        await this.runStopForMaxDuration({ keepalive });
+        return;
+      }
       await this.ensureStarted({ keepalive });
       await this.uploadPendingSegments({ keepalive });
-      if (opts?.finish) {
-        await this.finishOnServer({ keepalive, reason: opts.reason ?? "pagehide" });
+      if (opts?.finish && this.uploadEnabled) {
+        await this.finishOnServer({
+          keepalive,
+          reason: opts.reason ?? "pagehide"
+        });
+        if (!this.sessionSampled) {
+          this.resetToBufferMode();
+        } else {
+          this.uploadEnabled = false;
+          this.clearMaxDurationTimer();
+        }
       }
     });
   }
+  /**
+   * Stop recording, flush while still open, then fully reset so `init()` can
+   * run again (React Strict Mode remount).
+   */
   async close() {
-    if (this.closed) return;
-    this.closed = true;
+    if (this.closed && !this.options) return;
+    this.clearErrorClipTimer();
+    this.clearMaxDurationTimer();
     if (this.flushTimer) {
       clearInterval(this.flushTimer);
       this.flushTimer = null;
@@ -13261,17 +13483,45 @@ var TalariaClient = class {
       } catch {
       }
     }
-    if (this.uploadEnabled) {
-      await this.flush({ reason: "close", finish: true });
+    if (this.uploadEnabled && this.options && this.transport) {
+      try {
+        await this.flush({ reason: "close", finish: true });
+      } catch (error) {
+        console.warn("@newtalaria/browser: close flush failed", error);
+      }
     }
+    this.options = null;
+    this.transport = null;
+    this.replayId = null;
+    this.sessionId = null;
+    this.sessionSampled = false;
+    this.uploadEnabled = false;
+    this.startedOnServer = false;
+    this.finishedOnServer = false;
+    this.segmentIndex = 0;
+    this.uploadedCompressedBytes = 0;
+    this.uploadStartedAtMs = null;
+    this.errorClipDeadlineMs = null;
+    this.buffer.clear();
+    this.uploadChain = Promise.resolve();
+    this.closed = false;
+    this.linkableReplayId = null;
   }
   onRrwebEvent(event) {
-    if (this.closed) return;
+    if (this.closed || !this.options) return;
     this.buffer.push(event);
     if (!this.uploadEnabled) {
       this.buffer.trimRing();
       return;
     }
+    if (this.isPastErrorClipDeadline()) {
+      void this.flush({ reason: "error_clip_deadline" });
+      return;
+    }
+    if (this.isPastMaxDuration()) {
+      void this.flush({ reason: "max_duration" });
+      return;
+    }
     if (this.buffer.shouldFlushBySize()) {
       void this.flush({ reason: "size" });
     }
@@ -13281,13 +13531,19 @@ var TalariaClient = class {
       throw new Error("@newtalaria/browser: call Talaria.init() first");
     }
     const isErrorLike = args.level === "error" || args.level === "fatal";
-    if (isErrorLike && !this.uploadEnabled) {
-      if (Math.random() < this.options.replaysOnErrorSampleRate) {
-        this.uploadEnabled = true;
+    if (isErrorLike && !this.sessionSampled) {
+      if (!this.uploadEnabled) {
+        if (Math.random() < this.options.replaysOnErrorSampleRate) {
+          this.uploadEnabled = true;
+          this.checkoutFullSnapshot();
+          this.markUploadStarted();
+          this.scheduleErrorClipEnd();
+        }
+      } else {
+        this.scheduleErrorClipEnd();
       }
     }
-    const attachReplay = this.uploadEnabled;
-    if (attachReplay) {
+    if (this.uploadEnabled) {
       try {
         await this.flush({ reason: "capture", keepalive: args.keepalive });
       } catch (error) {
@@ -13297,7 +13553,7 @@ var TalariaClient = class {
     }
     const tags = { ...args.context?.tags ?? {} };
     const extra = args.context?.extra;
-    const replayId = attachReplay ? this.replayId : null;
+    const replayId = this.uploadEnabled && this.segmentIndex > 0 ? this.replayId : this.linkableReplayId;
     try {
       await ingestEvent(this.transport, {
         message: args.message,
@@ -13316,11 +13572,169 @@ var TalariaClient = class {
         timestamp: (/* @__PURE__ */ new Date()).toISOString(),
         keepalive: args.keepalive
       });
+      if (replayId && replayId === this.linkableReplayId) {
+        this.linkableReplayId = null;
+      }
     } catch (error) {
       console.warn("@newtalaria/browser: event ingest failed", error);
       throw error;
     }
   }
+  markUploadStarted() {
+    if (this.uploadStartedAtMs == null) {
+      this.uploadStartedAtMs = Date.now();
+    }
+    if (!this.sessionSampled && this.options && this.options.replaysErrorAfterMs > 0 && this.errorClipDeadlineMs == null) {
+      this.errorClipDeadlineMs = computeErrorClipDeadlineMs(
+        this.uploadStartedAtMs,
+        this.options.replaysErrorAfterMs
+      );
+    }
+    this.scheduleMaxDurationStop();
+  }
+  isPastMaxDuration() {
+    if (this.uploadStartedAtMs == null) return false;
+    return Date.now() - this.uploadStartedAtMs >= MAX_REPLAY_DURATION_MS;
+  }
+  isPastErrorClipDeadline() {
+    if (this.sessionSampled || this.errorClipDeadlineMs == null) return false;
+    return Date.now() >= this.errorClipDeadlineMs;
+  }
+  isErrorClipMode() {
+    return !this.sessionSampled && !!this.options && this.options.replaysErrorAfterMs > 0;
+  }
+  scheduleMaxDurationStop() {
+    if (this.closed || this.uploadStartedAtMs == null) return;
+    this.clearMaxDurationTimer();
+    const remaining = Math.max(
+      0,
+      MAX_REPLAY_DURATION_MS - (Date.now() - this.uploadStartedAtMs)
+    );
+    this.maxDurationTimer = setTimeout(() => {
+      this.maxDurationTimer = null;
+      if (!this.uploadEnabled || this.closed) return;
+      void this.enqueueUpload(async () => {
+        if (!this.uploadEnabled || this.closed) return;
+        await this.runStopForMaxDuration({ keepalive: false });
+      });
+    }, remaining);
+  }
+  clearMaxDurationTimer() {
+    if (this.maxDurationTimer) {
+      clearTimeout(this.maxDurationTimer);
+      this.maxDurationTimer = null;
+    }
+  }
+  async runStopForMaxDuration(opts) {
+    if (!this.uploadEnabled) return;
+    await this.ensureStarted({ keepalive: opts.keepalive });
+    await this.uploadPendingSegments({ keepalive: opts.keepalive });
+    await this.finishOnServer({
+      keepalive: opts.keepalive,
+      reason: "max_duration"
+    });
+    if (this.sessionSampled) {
+      this.uploadEnabled = false;
+      this.clearMaxDurationTimer();
+      if (this.flushTimer) {
+        clearInterval(this.flushTimer);
+        this.flushTimer = null;
+      }
+    } else {
+      this.resetToBufferMode();
+    }
+  }
+  /**
+   * Schedule end of the cheap error clip against a fixed absolute deadline.
+   * Subsequent errors re-arm the timer but never push the wall later.
+   */
+  scheduleErrorClipEnd() {
+    if (this.sessionSampled || this.closed || !this.options) return;
+    const afterMs = this.options.replaysErrorAfterMs;
+    if (afterMs <= 0) return;
+    if (this.errorClipDeadlineMs == null) {
+      const started = this.uploadStartedAtMs ?? Date.now();
+      this.errorClipDeadlineMs = computeErrorClipDeadlineMs(started, afterMs);
+    }
+    const remaining = Math.max(0, this.errorClipDeadlineMs - Date.now());
+    this.clearErrorClipTimer();
+    this.errorClipTimer = setTimeout(() => {
+      this.errorClipTimer = null;
+      void this.endErrorClip({ reason: "error_clip" });
+    }, remaining);
+  }
+  clearErrorClipTimer() {
+    if (this.errorClipTimer) {
+      clearTimeout(this.errorClipTimer);
+      this.errorClipTimer = null;
+    }
+  }
+  /** Flush trailing post-error window, finish replay, return to ring buffer. */
+  async endErrorClip(opts) {
+    if (this.closed || this.sessionSampled || !this.uploadEnabled || !this.options || !this.transport) {
+      return;
+    }
+    await this.enqueueUpload(async () => {
+      await this.runEndErrorClip(opts);
+    });
+  }
+  async runEndErrorClip(opts) {
+    if (!this.uploadEnabled || this.sessionSampled) return;
+    await this.ensureStarted({ keepalive: false });
+    await this.uploadPendingSegments({ keepalive: false });
+    await this.finishOnServer({
+      keepalive: false,
+      reason: opts?.reason ?? "error_clip"
+    });
+    this.resetToBufferMode();
+  }
+  /** After an error clip (or terminal limit), buffer locally until the next error. */
+  resetToBufferMode() {
+    this.clearErrorClipTimer();
+    this.clearMaxDurationTimer();
+    this.uploadEnabled = false;
+    this.startedOnServer = false;
+    this.finishedOnServer = false;
+    this.segmentIndex = 0;
+    this.uploadedCompressedBytes = 0;
+    this.uploadStartedAtMs = null;
+    this.errorClipDeadlineMs = null;
+    this.replayId = createId();
+    this.buffer.clear();
+    this.checkoutFullSnapshot();
+  }
+  /** Emit a checkout FullSnapshot into the ring buffer (sync via rrweb emit). */
+  checkoutFullSnapshot() {
+    this.recorder?.takeFullSnapshot();
+  }
+  /**
+   * Ensure segment 0 begins at Meta+FullSnapshot. Orphan increments alone
+   * produce a blank rrweb player.
+   */
+  prepareBufferForNewReplay() {
+    if (this.segmentIndex !== 0) return;
+    if (!this.buffer.hasFullSnapshot()) {
+      this.checkoutFullSnapshot();
+    }
+    if (!this.buffer.trimToFullSnapshot()) {
+      console.warn(
+        "@newtalaria/browser: replay has no FullSnapshot; player may show a blank screen"
+      );
+    }
+  }
+  stopUploadingAfterLimit() {
+    this.clearErrorClipTimer();
+    this.clearMaxDurationTimer();
+    this.uploadEnabled = false;
+    if (this.sessionSampled) {
+      if (this.flushTimer) {
+        clearInterval(this.flushTimer);
+        this.flushTimer = null;
+      }
+    } else {
+      this.resetToBufferMode();
+    }
+  }
   installGlobalHandlers() {
     if (typeof window === "undefined") return;
     const onError = (event) => {
@@ -13361,13 +13775,61 @@ var TalariaClient = class {
       keepalive: opts.keepalive
     });
     this.startedOnServer = true;
+    this.markUploadStarted();
   }
   async uploadPendingSegments(opts) {
     if (!this.options || !this.transport || !this.replayId) return;
     if (!this.startedOnServer || this.finishedOnServer) return;
+    this.prepareBufferForNewReplay();
     while (this.buffer.length > 0) {
-      const events = this.buffer.takeAll();
-      if (events.length === 0) break;
+      if (this.isPastMaxDuration()) {
+        break;
+      }
+      if (this.isPastErrorClipDeadline()) {
+        break;
+      }
+      if (this.segmentIndex >= this.maxSegmentsAllowed()) {
+        console.warn(
+          "@newtalaria/browser: replay upload stopped (max segments)",
+          { segmentIndex: this.segmentIndex }
+        );
+        await this.finishOnServer({
+          keepalive: opts.keepalive,
+          reason: "max_segments"
+        });
+        this.stopUploadingAfterLimit();
+        break;
+      }
+      if (this.isErrorClipMode() && isErrorClipBudgetExhausted({
+        segmentIndex: this.segmentIndex,
+        uploadedCompressedBytes: this.uploadedCompressedBytes
+      })) {
+        console.warn(
+          "@newtalaria/browser: replay upload stopped (error clip budget)",
+          {
+            segmentIndex: this.segmentIndex,
+            uploadedCompressedBytes: this.uploadedCompressedBytes
+          }
+        );
+        await this.finishOnServer({
+          keepalive: opts.keepalive,
+          reason: "error_clip_budget"
+        });
+        this.stopUploadingAfterLimit();
+        break;
+      }
+      const fitted = await this.takeFittedSegment();
+      if (!fitted) break;
+      const { events, gzip } = fitted;
+      if (this.isErrorClipMode() && this.uploadedCompressedBytes + gzip.length > MAX_ERROR_CLIP_COMPRESSED_BYTES && this.segmentIndex > 0) {
+        this.buffer.clear();
+        await this.finishOnServer({
+          keepalive: opts.keepalive,
+          reason: "error_clip_budget"
+        });
+        this.stopUploadingAfterLimit();
+        break;
+      }
       const startedAt = new Date(events[0].timestamp);
       const endedAt = new Date(events[events.length - 1].timestamp);
       const index2 = this.segmentIndex;
@@ -13378,10 +13840,37 @@ var TalariaClient = class {
           events,
           startedAt,
           endedAt,
+          gzip,
           keepalive: opts.keepalive
         });
         this.segmentIndex = index2 + 1;
+        this.uploadedCompressedBytes += gzip.length;
       } catch (error) {
+        if (isTerminalReplayLimitError(error)) {
+          console.warn(
+            "@newtalaria/browser: replay upload stopped (server limit)",
+            error
+          );
+          await this.finishOnServer({
+            keepalive: opts.keepalive,
+            reason: "limit"
+          });
+          this.stopUploadingAfterLimit();
+          break;
+        }
+        if (isOversizedSegmentError(error)) {
+          const plan = planOversizedRetry(events);
+          if (plan.action === "drop") {
+            console.warn(
+              "@newtalaria/browser: dropping rrweb event rejected as oversized",
+              { type: events[0]?.type }
+            );
+            continue;
+          }
+          this.buffer.prepend(plan.right);
+          this.buffer.prepend(plan.left);
+          continue;
+        }
         this.buffer.prepend(events);
         console.warn("@newtalaria/browser: replays/ingestSegment failed", error);
         break;
@@ -13389,9 +13878,44 @@ var TalariaClient = class {
       if (opts.keepalive) break;
     }
   }
+  maxSegmentsAllowed() {
+    if (this.sessionSampled) return MAX_SEGMENTS_PER_REPLAY;
+    if (this.options && this.options.replaysErrorAfterMs <= 0) {
+      return MAX_SEGMENTS_PER_REPLAY;
+    }
+    return MAX_SEGMENTS_ERROR_CLIP;
+  }
+  /**
+   * Pull the largest event prefix that gzips under the target compressed size.
+   * Drops a single event that can never fit.
+   */
+  async takeFittedSegment() {
+    const chunk = this.buffer.takeByEstimatedBytes(SEGMENT_SIZE_BYTES);
+    if (chunk.length === 0) return null;
+    const fitted = await fitCompressedPrefix(
+      chunk,
+      compressReplayEvents,
+      TARGET_COMPRESSED_SEGMENT_BYTES,
+      MAX_COMPRESSED_SEGMENT_BYTES
+    );
+    if (!fitted) {
+      console.warn(
+        "@newtalaria/browser: dropping rrweb event that exceeds max segment size",
+        { type: chunk[0]?.type }
+      );
+      return this.takeFittedSegment();
+    }
+    if (fitted.remainder.length > 0) {
+      this.buffer.prepend(fitted.remainder);
+    }
+    return { events: fitted.events, gzip: fitted.gzip };
+  }
   async finishOnServer(opts) {
     if (!this.transport || !this.replayId) return;
     if (!this.startedOnServer || this.finishedOnServer) return;
+    if (this.segmentIndex > 0) {
+      this.linkableReplayId = this.replayId;
+    }
     try {
       await finishReplay(this.transport, {
         replayId: this.replayId,
@@ -13429,9 +13953,17 @@ var Talaria = {
 };
 var index_default = Talaria;
 export {
+  MAX_COMPRESSED_SEGMENT_BYTES,
+  MAX_ERROR_CLIP_COMPRESSED_BYTES,
+  MAX_SEGMENTS_ERROR_CLIP,
+  TARGET_COMPRESSED_SEGMENT_BYTES,
   Talaria,
   TalariaClient,
-  index_default as default
+  computeErrorClipDeadlineMs,
+  index_default as default,
+  fitCompressedPrefix,
+  isErrorClipBudgetExhausted,
+  planOversizedRetry
 };
 /*! Bundled license information: