@anyreplay/browser 0.1.4 → 0.2.0

package/dist/index.js

@@ -3637,6 +3637,323 @@ record.takeFullSnapshot = (isCheckout) => {
 };
 record.mirror = mirror;
 
+// src/assets.ts
+var ASSET_TAG = "anyreplay.asset";
+var ASSET_LIMITS = {
+  maxImageBytes: 3 * 1024 * 1024,
+  maxFontBytes: 160 * 1024,
+  maxSvgBytes: 48 * 1024,
+  inlineBudgetBytes: 1024 * 1024,
+  maxUrls: 300
+};
+function defaultAssetMode(loc = currentLocation()) {
+  if (!loc) return "reference";
+  const protocol = loc.protocol.toLowerCase();
+  return protocol === "http:" || protocol === "https:" ? "reference" : "inline";
+}
+function localAssetPrefix(loc = currentLocation()) {
+  if (!loc) return null;
+  const protocol = loc.protocol.toLowerCase();
+  if (protocol === "file:") {
+    const folder = loc.pathname.slice(0, loc.pathname.lastIndexOf("/") + 1);
+    return folder ? `file://${folder}` : null;
+  }
+  if (!loc.host) return null;
+  return `${protocol}//${loc.host}/`;
+}
+function currentLocation() {
+  try {
+    return typeof location !== "undefined" ? location : void 0;
+  } catch (e) {
+    return void 0;
+  }
+}
+function classify(url) {
+  const path = url.split(/[?#]/, 1)[0].toLowerCase();
+  const ext = path.slice(path.lastIndexOf(".") + 1);
+  switch (ext) {
+    case "png":
+    case "jpg":
+    case "jpeg":
+    case "gif":
+    case "webp":
+      return { kind: "image" };
+    case "svg":
+      return { kind: "inline", mime: "image/svg+xml", cap: "maxSvgBytes" };
+    case "woff2":
+      return { kind: "inline", mime: "font/woff2", cap: "maxFontBytes" };
+    case "woff":
+      return { kind: "inline", mime: "font/woff", cap: "maxFontBytes" };
+    case "ttf":
+      return { kind: "inline", mime: "font/ttf", cap: "maxFontBytes" };
+    case "otf":
+      return { kind: "inline", mime: "font/otf", cap: "maxFontBytes" };
+    default:
+      return null;
+  }
+}
+var DEVICE_FILE_PATH = /^(_capacitor_|__cdvfile_)/;
+var EVENT_FULL_SNAPSHOT = 2;
+var EVENT_INCREMENTAL = 3;
+var SOURCES_WITH_URLS = /* @__PURE__ */ new Set([
+  0,
+  // Mutation: added nodes, changed attributes (`src`, `style`, `srcset`)
+  8,
+  // StyleSheetRule: a rule inserted with insertRule
+  13,
+  // StyleDeclaration: a property set through CSSOM
+  15
+  // AdoptedStyleSheet: constructed stylesheets (Ionic's web components)
+]);
+var escapeRegExp = (text) => text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+var AssetCollector = class {
+  constructor(deps) {
+    this.deps = deps;
+    __publicField(this, "limits");
+    __publicField(this, "pattern");
+    __publicField(this, "seen", /* @__PURE__ */ new Set());
+    __publicField(this, "queue", []);
+    /** Hashes ingest confirmed this page, so two URLs with the same bytes ask once. */
+    __publicField(this, "confirmed", /* @__PURE__ */ new Set());
+    __publicField(this, "inlineSpent", 0);
+    __publicField(this, "running", false);
+    __publicField(this, "stopped", false);
+    this.limits = { ...ASSET_LIMITS, ...deps.limits };
+    this.pattern = new RegExp(`${escapeRegExp(deps.prefix)}[^\\s"'()<>,\\\\]+`, "g");
+  }
+  /** Notes every URL of the app's files in one event. Cheap when there are none. */
+  scan(event) {
+    var _a;
+    if (this.stopped) return;
+    if (event.type === EVENT_FULL_SNAPSHOT) {
+      this.walk(event.data, 0);
+    } else if (event.type === EVENT_INCREMENTAL) {
+      const source = (_a = event.data) == null ? void 0 : _a.source;
+      if (source !== void 0 && SOURCES_WITH_URLS.has(source)) this.walk(event.data, 0);
+    }
+  }
+  stop() {
+    this.stopped = true;
+    this.queue.length = 0;
+  }
+  /** Resolves once everything queued so far has been handled. For tests. */
+  async idle() {
+    while (this.running || this.queue.length > 0) await new Promise((resolve) => setTimeout(resolve, 1));
+  }
+  walk(value, depth) {
+    if (depth > 400 || value === null) return;
+    if (typeof value === "string") {
+      if (value.length >= this.deps.prefix.length && value.includes(this.deps.prefix)) this.match(value);
+      return;
+    }
+    if (typeof value !== "object") return;
+    if (Array.isArray(value)) {
+      for (const item of value) this.walk(item, depth + 1);
+      return;
+    }
+    for (const key in value) this.walk(value[key], depth + 1);
+  }
+  match(text) {
+    var _a;
+    this.pattern.lastIndex = 0;
+    for (const found of (_a = text.match(this.pattern)) != null ? _a : []) {
+      if (this.seen.has(found)) continue;
+      if (this.seen.size >= this.limits.maxUrls) return;
+      this.seen.add(found);
+      if (DEVICE_FILE_PATH.test(found.slice(this.deps.prefix.length))) continue;
+      if (!classify(found)) continue;
+      this.queue.push(found);
+    }
+    if (this.queue.length > 0) void this.drain();
+  }
+  async drain() {
+    if (this.running) return;
+    this.running = true;
+    try {
+      while (this.queue.length > 0 && !this.stopped) {
+        const url = this.queue.shift();
+        try {
+          const payload = await this.resolve(url);
+          if (payload && !this.stopped) this.deps.emit(payload);
+        } catch (error) {
+          if (this.deps.debug) console.warn("[anyreplay] could not include", url, error);
+        }
+      }
+    } finally {
+      this.running = false;
+    }
+  }
+  async resolve(url) {
+    const kind = classify(url);
+    if (!kind) return null;
+    const response = await this.deps.fetch(url);
+    if (!response.ok) return null;
+    const bytes = new Uint8Array(await response.arrayBuffer());
+    if (bytes.length === 0) return null;
+    if (kind.kind === "inline") {
+      if (bytes.length > this.limits[kind.cap]) return this.skip(url, "over its size cap");
+      if (this.inlineSpent + bytes.length > this.limits.inlineBudgetBytes) return this.skip(url, "over the page budget");
+      this.inlineSpent += bytes.length;
+      return { url, data: `data:${kind.mime};base64,${toBase64(bytes)}` };
+    }
+    if (bytes.length > this.limits.maxImageBytes) return this.skip(url, "larger than 3 MB");
+    const sha256 = await sha256Hex(bytes);
+    if (this.confirmed.has(sha256) || await this.upload(sha256, bytes)) {
+      this.confirmed.add(sha256);
+      return { url, sha256 };
+    }
+    return null;
+  }
+  /** Contract §9: ask first, upload only what the project does not hold. */
+  async upload(sha256, bytes) {
+    const { ingestUrl, projectKey, appId } = this.deps;
+    const app = appId ? { appId } : {};
+    const post = (path, body) => this.deps.fetch(`${ingestUrl}${path}`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      credentials: "omit",
+      body: JSON.stringify(body)
+    });
+    const known = await post("/v1/ingest/assets/known", { projectKey, hashes: [sha256], ...app });
+    if (known.ok) {
+      const body = await known.json();
+      if (Array.isArray(body.known) && body.known.includes(sha256)) return true;
+    }
+    const upload = await post("/v1/ingest/assets", { projectKey, sha256, data: toBase64(bytes), ...app });
+    return upload.ok;
+  }
+  skip(url, why) {
+    if (this.deps.debug) console.warn(`[anyreplay] not included in the replay (${why}): ${url}`);
+    return null;
+  }
+};
+function toBase64(bytes) {
+  let binary = "";
+  for (let i = 0; i < bytes.length; i += 32768) {
+    binary += String.fromCharCode.apply(null, bytes.subarray(i, i + 32768));
+  }
+  return btoa(binary);
+}
+async function sha256Hex(bytes) {
+  try {
+    const subtle = typeof crypto !== "undefined" ? crypto.subtle : void 0;
+    if (subtle) {
+      const digest = new Uint8Array(await subtle.digest("SHA-256", bytes));
+      return Array.from(digest, (b) => b.toString(16).padStart(2, "0")).join("");
+    }
+  } catch (e) {
+  }
+  return sha256HexSync(bytes);
+}
+var K = [
+  1116352408,
+  1899447441,
+  3049323471,
+  3921009573,
+  961987163,
+  1508970993,
+  2453635748,
+  2870763221,
+  3624381080,
+  310598401,
+  607225278,
+  1426881987,
+  1925078388,
+  2162078206,
+  2614888103,
+  3248222580,
+  3835390401,
+  4022224774,
+  264347078,
+  604807628,
+  770255983,
+  1249150122,
+  1555081692,
+  1996064986,
+  2554220882,
+  2821834349,
+  2952996808,
+  3210313671,
+  3336571891,
+  3584528711,
+  113926993,
+  338241895,
+  666307205,
+  773529912,
+  1294757372,
+  1396182291,
+  1695183700,
+  1986661051,
+  2177026350,
+  2456956037,
+  2730485921,
+  2820302411,
+  3259730800,
+  3345764771,
+  3516065817,
+  3600352804,
+  4094571909,
+  275423344,
+  430227734,
+  506948616,
+  659060556,
+  883997877,
+  958139571,
+  1322822218,
+  1537002063,
+  1747873779,
+  1955562222,
+  2024104815,
+  2227730452,
+  2361852424,
+  2428436474,
+  2756734187,
+  3204031479,
+  3329325298
+];
+function sha256HexSync(bytes) {
+  const length = bytes.length;
+  const padded = new Uint8Array(length + 9 + 63 >>> 6 << 6);
+  padded.set(bytes);
+  padded[length] = 128;
+  const view = new DataView(padded.buffer);
+  view.setUint32(padded.length - 8, Math.floor(length / 536870912));
+  view.setUint32(padded.length - 4, length << 3 >>> 0);
+  const h = [1779033703, 3144134277, 1013904242, 2773480762, 1359893119, 2600822924, 528734635, 1541459225];
+  const w = new Array(64);
+  const rotr = (x, n) => x >>> n | x << 32 - n;
+  for (let offset = 0; offset < padded.length; offset += 64) {
+    for (let i = 0; i < 16; i += 1) w[i] = view.getUint32(offset + i * 4);
+    for (let i = 16; i < 64; i += 1) {
+      const a2 = w[i - 15];
+      const b2 = w[i - 2];
+      w[i] = w[i - 16] + (rotr(a2, 7) ^ rotr(a2, 18) ^ a2 >>> 3) + w[i - 7] + (rotr(b2, 17) ^ rotr(b2, 19) ^ b2 >>> 10) | 0;
+    }
+    let [a, b, c, d, e, f, g, hh] = h;
+    for (let i = 0; i < 64; i += 1) {
+      const t1 = hh + (rotr(e, 6) ^ rotr(e, 11) ^ rotr(e, 25)) + (e & f ^ ~e & g) + K[i] + w[i] | 0;
+      const t2 = (rotr(a, 2) ^ rotr(a, 13) ^ rotr(a, 22)) + (a & b ^ a & c ^ b & c) | 0;
+      hh = g;
+      g = f;
+      f = e;
+      e = d + t1 | 0;
+      d = c;
+      c = b;
+      b = a;
+      a = t1 + t2 | 0;
+    }
+    h[0] = h[0] + a | 0;
+    h[1] = h[1] + b | 0;
+    h[2] = h[2] + c | 0;
+    h[3] = h[3] + d | 0;
+    h[4] = h[4] + e | 0;
+    h[5] = h[5] + f | 0;
+    h[6] = h[6] + g | 0;
+    h[7] = h[7] + hh | 0;
+  }
+  return h.map((x) => (x >>> 0).toString(16).padStart(8, "0")).join("");
+}
+
 // src/config.ts
 var DEFAULTS = {
   ingestUrl: "https://in.anyreplay.com",
@@ -3652,15 +3969,23 @@ var DEFAULTS = {
   requireConsent: false,
   maxEventsPerChunk: 200,
   flushIntervalMs: 5e3,
-  maxConsecutiveFailures: 5,
+  // Never: an outage is what the buffer is for. Set a number to give up instead.
+  maxConsecutiveFailures: 0,
+  // The three diagnostic streams. On, because "why did it break" is the
+  // question a replay is opened to answer; each is a documented switch, and
+  // what they can and cannot contain is in diagnostics.ts.
+  recordErrors: true,
+  recordConsole: true,
+  recordNetwork: true,
   debug: false
 };
 var ConfigError = class extends Error {
 };
 var KEY_PATTERN = /^ar_pk_(live|test)_[0-9a-f]{24}$/;
 var MAX_SESSION_CAP = 1e6;
+var APP_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]{1,254}$/;
 function resolveOptions(input) {
-  var _a, _b, _c;
+  var _a, _b, _c, _d;
   if (!input || typeof input !== "object") throw new ConfigError("anyreplay: options object required");
   if (!KEY_PATTERN.test((_a = input.projectKey) != null ? _a : "")) {
     throw new ConfigError("anyreplay: projectKey looks wrong \u2014 copy it from the dashboard");
@@ -3673,53 +3998,42 @@ function resolveOptions(input) {
   if (cap !== void 0 && !(Number.isInteger(cap) && cap >= 1 && cap <= MAX_SESSION_CAP)) {
     throw new ConfigError(`anyreplay: maxSessionsPerMonth must be a whole number between 1 and ${MAX_SESSION_CAP}`);
   }
+  const appId = (_c = input.appId) == null ? void 0 : _c.trim();
+  if (input.appId !== void 0 && !(appId && APP_ID_PATTERN.test(appId))) {
+    throw new ConfigError("anyreplay: appId should be an app identifier such as com.example.app");
+  }
+  let assets = input.assets;
+  if (assets !== void 0 && assets !== "reference" && assets !== "inline") {
+    if (typeof console !== "undefined") {
+      console.warn(`[anyreplay] assets ignored: expected 'reference' or 'inline', got ${JSON.stringify(assets)}.`);
+    }
+    assets = void 0;
+  }
   return {
     ...DEFAULTS,
     ...input,
+    ...appId ? { appId } : {},
+    assets: assets != null ? assets : defaultAssetMode(),
     projectKey: input.projectKey,
     sampleRate,
-    ingestUrl: ((_c = input.ingestUrl) != null ? _c : DEFAULTS.ingestUrl).replace(/\/+$/, ""),
+    ingestUrl: ((_d = input.ingestUrl) != null ? _d : DEFAULTS.ingestUrl).replace(/\/+$/, ""),
     maskAllInputs: readSwitch(input, "maskAllInputs"),
-    maskAllTyping: readSwitch(input, "maskAllTyping")
+    maskAllTyping: readSwitch(input, "maskAllTyping"),
+    recordErrors: readSwitch(input, "recordErrors"),
+    recordConsole: readSwitch(input, "recordConsole"),
+    recordNetwork: readSwitch(input, "recordNetwork")
   };
 }
 function readSwitch(input, name) {
   const value = input[name];
   if (typeof value === "boolean") return value;
   if (value !== void 0 && typeof console !== "undefined") {
-    console.warn(`[anyreplay] ${name} ignored: expected true or false, got ${typeof value}. Nothing is masked by this option.`);
+    const consequence = name.startsWith("mask") ? "Nothing is masked by this option." : `${name.slice("record".length)} are recorded, as by default.`;
+    console.warn(`[anyreplay] ${name} ignored: expected true or false, got ${typeof value}. ${consequence}`);
   }
   return DEFAULTS[name];
 }
 
-// src/events.ts
-var TRACK_TAG = "anyreplay.track";
-var NAVIGATE_TAG = "anyreplay.navigate";
-var EVENT_NAME_PATTERN = /^[A-Za-z0-9_.:-]{1,64}$/;
-var MAX_PROPERTIES_BYTES = 4 * 1024;
-function validateTrack(name, properties) {
-  if (typeof name !== "string" || !EVENT_NAME_PATTERN.test(name)) {
-    return `event name must be 1-64 characters of [A-Za-z0-9_.:-], got ${JSON.stringify(name)}`;
-  }
-  if (properties === void 0 || properties === null) return { name, properties: {} };
-  if (typeof properties !== "object" || Array.isArray(properties)) {
-    return `properties for "${name}" must be a plain object`;
-  }
-  let serialised;
-  try {
-    serialised = JSON.stringify(properties);
-  } catch (e) {
-    return `properties for "${name}" are not JSON-serialisable`;
-  }
-  if (serialised === void 0 || byteLength(serialised) > MAX_PROPERTIES_BYTES) {
-    return `properties for "${name}" exceed ${MAX_PROPERTIES_BYTES} bytes once serialised`;
-  }
-  return { name, properties: JSON.parse(serialised) };
-}
-function byteLength(text) {
-  return typeof TextEncoder === "function" ? new TextEncoder().encode(text).length : text.length * 3;
-}
-
 // src/masking.ts
 var maskValue = (text) => "*".repeat(text.length);
 var MASK_EVERY_FIELD = {
@@ -3884,6 +4198,296 @@ function scrubEvent(event, getNode, policy) {
   }
 }
 
+// src/diagnostics.ts
+var ERROR_TAG = "anyreplay.error";
+var CONSOLE_TAG = "anyreplay.console";
+var NETWORK_TAG = "anyreplay.network";
+var LIMITS = { error: 100, console: 200, network: 500 };
+var MAX_MESSAGE = 1e3;
+var MAX_STACK = 4e3;
+var MAX_URL = 500;
+var SECRET_KEY = /^(?:.*[_-])?(?:token|secret|password|passwd|pwd|key|apikey|api_key|auth|authorization|session|sid|jwt|code|otp|signature|sig|credential|access|refresh)(?:[_-].*)?$/i;
+var EMAIL = /[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}/g;
+var OPAQUE = /\b(?=[A-Za-z0-9_-]*\d)[A-Za-z0-9_-]{24,}\b/g;
+var DIGITS = /\b[0-9][0-9 -]{11,22}[0-9]\b/g;
+var REDACTED = "[redacted]";
+function redactText(text) {
+  return text.replace(EMAIL, REDACTED).replace(DIGITS, (match) => looksLikeCardNumber(match.trim()) ? REDACTED : match).replace(OPAQUE, REDACTED);
+}
+function redactUrl(raw) {
+  const text = raw.length > MAX_URL ? raw.slice(0, MAX_URL) : raw;
+  let parsed;
+  try {
+    parsed = new URL(text, typeof location !== "undefined" ? location.href : "http://localhost");
+  } catch (e) {
+    return redactText(text);
+  }
+  for (const key of [...parsed.searchParams.keys()]) {
+    if (SECRET_KEY.test(key)) parsed.searchParams.set(key, REDACTED);
+  }
+  parsed.hash = "";
+  return redactText(`${parsed.origin}${parsed.pathname}${parsed.search}`);
+}
+var clip = (text, max) => text.length > max ? `${text.slice(0, max)}\u2026` : text;
+function describe(value) {
+  if (typeof value === "string") return value;
+  if (value === null) return "null";
+  if (value === void 0) return "undefined";
+  if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") return String(value);
+  if (value instanceof Error) return `${value.name}: ${value.message}`;
+  try {
+    const json = JSON.stringify(value);
+    return json === void 0 ? Object.prototype.toString.call(value) : json;
+  } catch (e) {
+    return Object.prototype.toString.call(value);
+  }
+}
+function errorPayload(kind, value, where) {
+  const error = value instanceof Error ? value : null;
+  const message = error ? `${error.name}: ${error.message}` : describe(value);
+  const payload = { message: clip(redactText(message) || "error", MAX_MESSAGE), kind };
+  if (error) {
+    payload.name = error.name;
+    if (typeof error.stack === "string" && error.stack.length > 0) {
+      payload.stack = clip(redactText(error.stack), MAX_STACK);
+    }
+  }
+  if (typeof (where == null ? void 0 : where.source) === "string" && where.source.length > 0) payload.source = redactUrl(where.source);
+  if (typeof (where == null ? void 0 : where.line) === "number" && Number.isFinite(where.line)) payload.line = where.line;
+  if (typeof (where == null ? void 0 : where.column) === "number" && Number.isFinite(where.column)) payload.column = where.column;
+  return payload;
+}
+function consolePayload(level, args) {
+  const joined = args.map(describe).join(" ");
+  return { level, message: clip(redactText(joined), MAX_MESSAGE) };
+}
+function methodOf(value) {
+  const text = typeof value === "string" ? value.toUpperCase() : "GET";
+  return /^[A-Z]{3,10}$/.test(text) ? text : "GET";
+}
+function startDiagnostics(options) {
+  const undo = [];
+  const counts = { error: 0, console: 0, network: 0 };
+  let flagged = false;
+  const budget = (stream) => {
+    if (counts[stream] >= LIMITS[stream]) return false;
+    counts[stream] += 1;
+    return true;
+  };
+  const flag = () => {
+    if (flagged) return;
+    flagged = true;
+    try {
+      options.onError();
+    } catch (e) {
+    }
+  };
+  const send = (tag, payload) => {
+    try {
+      options.emit(tag, payload);
+    } catch (e) {
+    }
+  };
+  let ingestOrigin = null;
+  try {
+    ingestOrigin = new URL(options.ingestUrl).origin;
+  } catch (e) {
+  }
+  const ours = (url) => ingestOrigin !== null && url.startsWith(ingestOrigin);
+  if (options.errors && typeof window !== "undefined") {
+    const onError = (event) => {
+      var _a;
+      flag();
+      if (!budget("error")) return;
+      send(ERROR_TAG, errorPayload("error", (_a = event.error) != null ? _a : event.message, {
+        source: event.filename,
+        line: event.lineno,
+        column: event.colno
+      }));
+    };
+    const onRejection = (event) => {
+      flag();
+      if (!budget("error")) return;
+      send(ERROR_TAG, errorPayload("rejection", event.reason));
+    };
+    window.addEventListener("error", onError, { capture: true });
+    window.addEventListener("unhandledrejection", onRejection, { capture: true });
+    undo.push(() => {
+      window.removeEventListener("error", onError, { capture: true });
+      window.removeEventListener("unhandledrejection", onRejection, { capture: true });
+    });
+  }
+  if (options.console && typeof console !== "undefined") {
+    for (const level of ["error", "warn"]) {
+      const original = console[level];
+      if (typeof original !== "function") continue;
+      const patched = function patchedConsole(...args) {
+        try {
+          const first = args[0];
+          const own = typeof first === "string" && first.startsWith("[anyreplay]");
+          if (!own && budget("console")) send(CONSOLE_TAG, consolePayload(level, args));
+        } catch (e) {
+        }
+        original.apply(this, args);
+      };
+      console[level] = patched;
+      undo.push(() => {
+        console[level] = original;
+      });
+    }
+  }
+  if (options.network && typeof window !== "undefined") {
+    const originalFetch = window.fetch;
+    if (typeof originalFetch === "function") {
+      const patchedFetch = function patchedFetch2(input, init) {
+        var _a, _b;
+        let url = "";
+        let method = "GET";
+        try {
+          url = typeof input === "string" ? input : input instanceof URL ? input.href : (_a = input.url) != null ? _a : "";
+          method = methodOf((_b = init == null ? void 0 : init.method) != null ? _b : input == null ? void 0 : input.method);
+        } catch (e) {
+        }
+        const started = Date.now();
+        const result = originalFetch.call(window, input, init);
+        if (!url || ours(url)) return result;
+        return result.then(
+          (response) => {
+            try {
+              if (budget("network")) {
+                if (response.status >= 400) flag();
+                send(NETWORK_TAG, {
+                  url: redactUrl(url),
+                  method,
+                  status: response.status,
+                  durationMs: Date.now() - started,
+                  initiator: "fetch"
+                });
+              }
+            } catch (e) {
+            }
+            return response;
+          },
+          (reason) => {
+            try {
+              flag();
+              if (budget("network")) {
+                send(NETWORK_TAG, {
+                  url: redactUrl(url),
+                  method,
+                  status: 0,
+                  durationMs: Date.now() - started,
+                  initiator: "fetch",
+                  failed: true
+                });
+              }
+            } catch (e) {
+            }
+            throw reason;
+          }
+        );
+      };
+      window.fetch = patchedFetch;
+      undo.push(() => {
+        window.fetch = originalFetch;
+      });
+    }
+    const Xhr = window.XMLHttpRequest;
+    if (typeof Xhr === "function") {
+      const open = Xhr.prototype.open;
+      const sendMethod = Xhr.prototype.send;
+      const seen = /* @__PURE__ */ new WeakMap();
+      Xhr.prototype.open = function patchedOpen(method, url, ...rest) {
+        try {
+          const href = typeof url === "string" ? url : url.href;
+          if (href && !ours(href)) seen.set(this, { url: href, method: methodOf(method), started: 0 });
+        } catch (e) {
+        }
+        return open.call(this, method, url, ...rest);
+      };
+      Xhr.prototype.send = function patchedSend(...args) {
+        try {
+          const request = seen.get(this);
+          if (request) {
+            request.started = Date.now();
+            const done = (failed) => {
+              try {
+                if (failed || this.status >= 400) flag();
+                if (!budget("network")) return;
+                send(NETWORK_TAG, {
+                  url: redactUrl(request.url),
+                  method: request.method,
+                  status: this.status || 0,
+                  durationMs: Date.now() - request.started,
+                  initiator: "xhr",
+                  ...failed ? { failed: true } : {}
+                });
+              } catch (e) {
+              }
+            };
+            this.addEventListener("load", () => done(false));
+            this.addEventListener("error", () => done(true));
+            this.addEventListener("timeout", () => done(true));
+            this.addEventListener("abort", () => done(true));
+          }
+        } catch (e) {
+        }
+        return sendMethod.call(this, ...args);
+      };
+      undo.push(() => {
+        Xhr.prototype.open = open;
+        Xhr.prototype.send = sendMethod;
+      });
+    }
+  }
+  let stopped = false;
+  return {
+    error: (value) => {
+      if (stopped) return;
+      flag();
+      if (budget("error")) send(ERROR_TAG, errorPayload("error", value));
+    },
+    stop: () => {
+      if (stopped) return;
+      stopped = true;
+      for (let i = undo.length - 1; i >= 0; i -= 1) {
+        try {
+          undo[i]();
+        } catch (e) {
+        }
+      }
+    }
+  };
+}
+
+// src/events.ts
+var TRACK_TAG = "anyreplay.track";
+var NAVIGATE_TAG = "anyreplay.navigate";
+var EVENT_NAME_PATTERN = /^[A-Za-z0-9_.:-]{1,64}$/;
+var MAX_PROPERTIES_BYTES = 4 * 1024;
+function validateTrack(name, properties) {
+  if (typeof name !== "string" || !EVENT_NAME_PATTERN.test(name)) {
+    return `event name must be 1-64 characters of [A-Za-z0-9_.:-], got ${JSON.stringify(name)}`;
+  }
+  if (properties === void 0 || properties === null) return { name, properties: {} };
+  if (typeof properties !== "object" || Array.isArray(properties)) {
+    return `properties for "${name}" must be a plain object`;
+  }
+  let serialised;
+  try {
+    serialised = JSON.stringify(properties);
+  } catch (e) {
+    return `properties for "${name}" are not JSON-serialisable`;
+  }
+  if (serialised === void 0 || byteLength(serialised) > MAX_PROPERTIES_BYTES) {
+    return `properties for "${name}" exceed ${MAX_PROPERTIES_BYTES} bytes once serialised`;
+  }
+  return { name, properties: JSON.parse(serialised) };
+}
+function byteLength(text) {
+  return typeof TextEncoder === "function" ? new TextEncoder().encode(text).length : text.length * 3;
+}
+
 // src/sampling.ts
 function hashToUnitInterval(input) {
   let hash = 2166136261;
@@ -3901,6 +4505,17 @@ function isSampledIn(visitorId, sampleRate) {
 
 // src/transport.ts
 var MAX_STALE_RECOVERIES = 3;
+var EVENT_FULL_SNAPSHOT2 = 2;
+var EVENT_INCREMENTAL2 = 3;
+var MAX_BODY_BYTES = 512 * 1024;
+var TARGET_CHUNK_BYTES = 256 * 1024;
+var MIN_BODY_BYTES = 8 * 1024;
+var ENVELOPE_SLACK_BYTES = 1024;
+var MAX_CHUNKS_PER_FLUSH = 20;
+var BACKOFF_BASE_MS = 2e3;
+var BACKOFF_MAX_MS = 6e4;
+var MAX_RETRY_AFTER_MS = 10 * 6e4;
+var MAX_CONSECUTIVE_REFUSALS = 3;
 async function staleSeqHint(response, sent) {
   try {
     if (typeof response.json !== "function") return void 0;
@@ -3912,10 +4527,40 @@ async function staleSeqHint(response, sent) {
     return void 0;
   }
 }
+function retryAfterMs(response, now = Date.now()) {
+  var _a, _b;
+  let raw;
+  try {
+    raw = (_b = (_a = response.headers) == null ? void 0 : _a.get) == null ? void 0 : _b.call(_a, "Retry-After");
+  } catch (e) {
+    return void 0;
+  }
+  if (!raw) return void 0;
+  const text = raw.trim();
+  if (/^\d+(\.\d+)?$/.test(text)) return Math.min(MAX_RETRY_AFTER_MS, Number(text) * 1e3);
+  const date = Date.parse(text);
+  if (Number.isNaN(date)) return void 0;
+  return Math.min(MAX_RETRY_AFTER_MS, Math.max(0, date - now));
+}
+function utf8Length(text) {
+  let bytes = 0;
+  for (let i = 0; i < text.length; i += 1) {
+    const code = text.charCodeAt(i);
+    if (code < 128) bytes += 1;
+    else if (code < 2048) bytes += 2;
+    else if (code >= 55296 && code <= 56319 && i + 1 < text.length) {
+      const next = text.charCodeAt(i + 1);
+      if (next >= 56320 && next <= 57343) {
+        bytes += 4;
+        i += 1;
+      } else bytes += 3;
+    } else bytes += 3;
+  }
+  return bytes;
+}
 var KEEPALIVE_BODY_LIMIT_BYTES = 56 * 1024;
 function withinKeepaliveLimit(payload) {
-  const bytes = typeof TextEncoder === "function" ? new TextEncoder().encode(payload).length : payload.length * 3;
-  return bytes <= KEEPALIVE_BODY_LIMIT_BYTES;
+  return utf8Length(payload) <= KEEPALIVE_BODY_LIMIT_BYTES;
 }
 var Transport = class {
   constructor(options, context, hooks = {}) {
@@ -3923,27 +4568,52 @@ var Transport = class {
     this.context = context;
     this.hooks = hooks;
     __publicField(this, "buffer", []);
+    /** The chunk being delivered: built, numbered, maybe already attempted. */
+    __publicField(this, "pending");
+    /** The next unused chunk number. */
     __publicField(this, "seq", 0);
     __publicField(this, "consecutiveFailures", 0);
+    __publicField(this, "consecutiveRefusals", 0);
     __publicField(this, "state", "open");
     __publicField(this, "timer");
+    __publicField(this, "retryTimer");
     __publicField(this, "pendingMeta");
     __publicField(this, "flags", {});
     __publicField(this, "inFlight", false);
-    /** The chunk number of the last request that left, to tell a retry from a first attempt. */
-    __publicField(this, "lastAttemptedSeq", -1);
     __publicField(this, "staleRecoveries", 0);
+    /** Our own backoff after a failure. Cleared when the network comes back. */
+    __publicField(this, "backoffUntil", 0);
+    /** What the server asked for in `Retry-After`. Not cleared by anything but time. */
+    __publicField(this, "serverWaitUntil", 0);
+    /** Largest body this transport will build; lowered by a `413`. */
+    __publicField(this, "bodyLimit", MAX_BODY_BYTES);
+    __publicField(this, "targetBytes", TARGET_CHUNK_BYTES);
+    /**
+     * Set when events were dropped and a full snapshot has been asked for:
+     * DOM changes are not kept until it arrives.
+     */
+    __publicField(this, "awaitingSnapshot", false);
+    /** Serialised events, so a retry or a re-split does not stringify a snapshot twice. */
+    __publicField(this, "serialised", /* @__PURE__ */ new WeakMap());
     var _a;
     this.seq = (_a = context.initialSeq) != null ? _a : 0;
   }
   get isStopped() {
     return this.state === "stopped";
   }
+  /** Events not yet delivered, including a chunk waiting to be retried. */
   get bufferedCount() {
-    return this.buffer.length;
+    var _a, _b;
+    return this.buffer.length + ((_b = (_a = this.pending) == null ? void 0 : _a.events.length) != null ? _b : 0);
   }
+  /** The number the next undelivered chunk will carry — the count of chunks delivered, for a fresh session. */
   get sentChunks() {
-    return this.seq;
+    var _a, _b;
+    return (_b = (_a = this.pending) == null ? void 0 : _a.seq) != null ? _b : this.seq;
+  }
+  /** The most events kept while deliveries fail. Older ones are dropped first. */
+  get bufferLimit() {
+    return this.options.maxEventsPerChunk * 10;
   }
   /** Attaches metadata to the next chunk. Sent once, with the session's first chunk. */
   setMeta(meta) {
@@ -3962,22 +4632,131 @@ var Transport = class {
     var _a, _b;
     this.state = "stopped";
     if (this.timer) clearInterval(this.timer);
+    if (this.retryTimer) clearTimeout(this.retryTimer);
     this.timer = void 0;
+    this.retryTimer = void 0;
     this.buffer = [];
+    this.pending = void 0;
     (_b = (_a = this.hooks).onStopped) == null ? void 0 : _b.call(_a, reason);
   }
   push(event) {
     if (this.state === "stopped") return;
+    if (this.awaitingSnapshot) {
+      if (event.type === EVENT_INCREMENTAL2) return;
+      if (event.type === EVENT_FULL_SNAPSHOT2) this.awaitingSnapshot = false;
+    }
     this.buffer.push(event);
+    if (this.bufferedCount > this.bufferLimit) this.dropOldest(this.bufferedCount - this.bufferLimit);
     if (this.buffer.length >= this.options.maxEventsPerChunk) void this.flush();
   }
-  body(events) {
+  /**
+   * The network is back (`online`), or the page is visible again: try now
+   * rather than at the end of the backoff. A server's `Retry-After` still
+   * holds — it was not about our connection.
+   */
+  resume() {
+    if (this.state === "stopped") return;
+    this.backoffUntil = 0;
+    void this.flush();
+  }
+  /**
+   * Sends whatever is buffered, as as many chunks as it takes. Safe to call
+   * when there is nothing to send, and while waiting out a failure, when it
+   * does nothing. `force` skips our own backoff (an explicit `flush()` from
+   * the page) but never the server's `Retry-After`.
+   */
+  async flush(force = false) {
+    var _a;
+    if (this.state === "stopped" || this.inFlight) return;
+    const now = Date.now();
+    if (now < this.serverWaitUntil) return;
+    if (!force && now < this.backoffUntil) return;
+    if (!this.pending && this.buffer.length === 0) return;
+    this.inFlight = true;
+    try {
+      for (let sent = 0, tries = 0; sent < MAX_CHUNKS_PER_FLUSH && tries < MAX_CHUNKS_PER_FLUSH * 3 && this.state === "open"; tries += 1) {
+        const chunk = (_a = this.pending) != null ? _a : this.nextChunk(this.bodyLimit, this.targetBytes);
+        if (!chunk) break;
+        this.pending = chunk;
+        const outcome = await this.send(chunk);
+        if (outcome === "sent") sent += 1;
+        else if (outcome !== "again") break;
+      }
+    } finally {
+      this.inFlight = false;
+    }
+  }
+  /**
+   * Builds the next chunk from the front of the buffer: at most
+   * `maxEventsPerChunk` events and `target` bytes, or one event alone up to
+   * `limit`. An event too large for any chunk is dropped here — it would be
+   * refused, and refused again, and hold up everything behind it. For a
+   * beacon (`forBeacon`) it is left where it is instead: an ordinary request
+   * can still carry what a beacon cannot.
+   */
+  nextChunk(limit, target, forBeacon = false) {
+    const envelope = utf8Length(this.envelope(this.seq)) + ENVELOPE_SLACK_BYTES;
+    const events = [];
+    const parts = [];
+    let bytes = envelope;
+    while (this.buffer.length > 0 && events.length < this.options.maxEventsPerChunk) {
+      const event = this.buffer[0];
+      const part = this.serialise(event);
+      const size = utf8Length(part) + 1;
+      if (events.length === 0 && bytes + size > limit) {
+        if (forBeacon) return void 0;
+        this.buffer.shift();
+        if (!this.dropOversized(event, size)) return void 0;
+        continue;
+      }
+      if (events.length > 0 && bytes + size > target) break;
+      events.push(event);
+      parts.push(part);
+      bytes += size;
+      this.buffer.shift();
+    }
+    if (events.length === 0) return void 0;
+    const chunk = { seq: this.seq, events, parts, attempts: 0 };
+    this.seq += 1;
+    return chunk;
+  }
+  /**
+   * An event that no chunk can carry. A DOM change or a custom event is
+   * dropped, and the DOM is re-sent whole if the dropped one described it.
+   * A full snapshot that alone exceeds the limit is a page this transport
+   * cannot record — re-taking it would only be refused again — so recording
+   * stops instead of uploading a snapshot every few seconds forever.
+   */
+  dropOversized(event, bytes) {
+    var _a, _b, _c, _d;
+    const kb = Math.ceil(bytes / 1024);
+    if (event.type === EVENT_FULL_SNAPSHOT2) {
+      (_b = (_a = this.hooks).onWarning) == null ? void 0 : _b.call(_a, `page snapshot is ${kb} KB, over the ${Math.floor(this.bodyLimit / 1024)} KB ingest accepts`);
+      this.stop("snapshot_too_large");
+      return false;
+    }
+    (_d = (_c = this.hooks).onWarning) == null ? void 0 : _d.call(_c, `dropped one event of ${kb} KB: larger than ingest accepts`);
+    if (event.type === EVENT_INCREMENTAL2) this.afterGap();
+    return true;
+  }
+  serialise(event) {
+    let part = this.serialised.get(event);
+    if (part === void 0) {
+      part = JSON.stringify(event);
+      this.serialised.set(event, part);
+    }
+    return part;
+  }
+  /** Everything in a chunk's body except its events, as a JSON object. */
+  envelope(seq) {
     return JSON.stringify({
       projectKey: this.context.projectKey,
       sessionId: this.context.sessionId,
       visitorId: this.context.visitorId,
-      seq: this.seq,
-      events,
+      seq,
+      // The app this page runs inside, on every request: ingest reads it only
+      // when the request has no real web origin. See `appId` in config.ts.
+      ...this.options.appId ? { appId: this.options.appId } : {},
       ...this.pendingMeta ? { meta: this.pendingMeta } : {},
       ...Object.keys(this.flags).length > 0 ? { flags: this.flags } : {},
       // This device's clock as the request leaves, on the same clock as the
@@ -3989,20 +4768,24 @@ var Transport = class {
       sentAt: Date.now()
     });
   }
-  /** Sends whatever is buffered. Safe to call when there is nothing to send. */
-  async flush() {
-    var _a, _b, _c, _d;
-    if (this.state === "stopped" || this.inFlight || this.buffer.length === 0) return;
-    this.inFlight = true;
-    const events = this.buffer;
-    this.buffer = [];
-    let resend = false;
+  /**
+   * The body, assembled from the events' cached JSON rather than by
+   * stringifying them again: a retry resends exactly the bytes the first
+   * attempt sent, which is also what lets ingest read it as a retry.
+   */
+  body(chunk) {
+    return `{"events":[${chunk.parts.join(",")}],${this.envelope(chunk.seq).slice(1)}`;
+  }
+  /** One request, and what to do next. */
+  async send(chunk) {
+    var _a, _b, _c, _d, _e, _f;
+    const retry = chunk.attempts > 0;
+    chunk.attempts += 1;
+    (_b = (_a = this.hooks).onSeqReserved) == null ? void 0 : _b.call(_a, chunk.seq + 1);
+    const payload = this.body(chunk);
+    let response;
     try {
-      const retry = this.lastAttemptedSeq === this.seq;
-      this.lastAttemptedSeq = this.seq;
-      (_b = (_a = this.hooks).onSeqReserved) == null ? void 0 : _b.call(_a, this.seq + 1);
-      const payload = this.body(events);
-      const response = await fetch(`${this.options.ingestUrl}/v1/ingest/events`, {
+      response = await fetch(`${this.options.ingestUrl}/v1/ingest/events`, {
         method: "POST",
         headers: { "Content-Type": "application/json" },
         body: payload,
@@ -4011,84 +4794,215 @@ var Transport = class {
         credentials: "omit",
         keepalive: withinKeepaliveLimit(payload)
       });
-      if (response.ok) {
-        const nextSeq = retry ? void 0 : await staleSeqHint(response, this.seq);
-        if (nextSeq !== void 0 && this.staleRecoveries < MAX_STALE_RECOVERIES) {
-          this.staleRecoveries += 1;
-          this.seq = nextSeq;
-          this.requeue(events);
-          resend = true;
-          return;
-        }
-        this.staleRecoveries = 0;
-        this.seq += 1;
-        this.pendingMeta = void 0;
-        this.consecutiveFailures = 0;
-        (_d = (_c = this.hooks).onSent) == null ? void 0 : _d.call(_c, this.seq - 1, events.length);
-        return;
+    } catch (e) {
+      return this.registerFailure(void 0);
+    }
+    if (this.state === "stopped" || this.pending !== chunk) return "stopped";
+    if (response.ok) {
+      const nextSeq = retry ? void 0 : await staleSeqHint(response, chunk.seq);
+      if (nextSeq !== void 0 && this.staleRecoveries < MAX_STALE_RECOVERIES) {
+        this.staleRecoveries += 1;
+        chunk.seq = nextSeq;
+        chunk.attempts = 0;
+        this.seq = Math.max(this.seq, nextSeq + 1);
+        return "again";
       }
-      if (response.status >= 400 && response.status < 500 && response.status !== 429) {
-        this.stop(`rejected_${response.status}`);
-        return;
+      this.pending = void 0;
+      this.staleRecoveries = 0;
+      this.pendingMeta = void 0;
+      this.consecutiveFailures = 0;
+      this.consecutiveRefusals = 0;
+      this.backoffUntil = 0;
+      (_d = (_c = this.hooks).onSent) == null ? void 0 : _d.call(_c, chunk.seq, chunk.events.length);
+      return "sent";
+    }
+    const status = response.status;
+    if (status === 413) return this.shrink(chunk, utf8Length(payload));
+    if (status === 400 || status === 422) {
+      this.pending = void 0;
+      this.consecutiveRefusals += 1;
+      if (this.consecutiveRefusals >= MAX_CONSECUTIVE_REFUSALS) {
+        this.stop(`rejected_${status}`);
+        return "stopped";
       }
-      this.requeue(events);
-      this.registerFailure();
-    } catch (e) {
-      this.requeue(events);
-      this.registerFailure();
-    } finally {
-      this.inFlight = false;
-      if (resend) void this.flush();
+      (_f = (_e = this.hooks).onWarning) == null ? void 0 : _f.call(_e, `ingest refused a chunk (${status}); its ${chunk.events.length} events are dropped`);
+      this.afterGap();
+      return "again";
     }
+    if (status === 408 || status === 429 || status >= 500) {
+      return this.registerFailure(retryAfterMs(response));
+    }
+    this.stop(`rejected_${status}`);
+    return "stopped";
   }
   /**
-   * Puts a failed batch back at the front of the queue.
-   *
-   * Bounded on purpose: a long offline period must not grow the buffer until
-   * the tab runs out of memory. Older events are dropped first — a replay
-   * missing its beginning is still useful; a crashed page is not.
+   * `413`: this ingest takes less than we thought. The chunk was not stored,
+   * so its events go back to the front of the queue and are re-cut under a
+   * lower limit; its number is not reused, so no number ever carries two
+   * different sets of events. A chunk of one event that is still too large is
+   * dropped by `nextChunk` on the way back out.
    */
-  requeue(events) {
-    const limit = this.options.maxEventsPerChunk * 10;
-    this.buffer = [...events, ...this.buffer].slice(-limit);
+  shrink(chunk, bytes) {
+    var _a, _b;
+    this.pending = void 0;
+    if (this.bodyLimit <= MIN_BODY_BYTES) {
+      this.stop("rejected_413");
+      return "stopped";
+    }
+    this.buffer = [...chunk.events, ...this.buffer];
+    this.bodyLimit = Math.max(MIN_BODY_BYTES, Math.min(this.bodyLimit, Math.floor(bytes / 2)));
+    this.targetBytes = Math.min(this.targetBytes, this.bodyLimit);
+    (_b = (_a = this.hooks).onWarning) == null ? void 0 : _b.call(_a, `ingest refused ${Math.ceil(bytes / 1024)} KB as too large; sending at most ${Math.floor(this.bodyLimit / 1024)} KB per chunk`);
+    return "again";
   }
-  registerFailure() {
+  /**
+   * Counts a failed delivery and schedules the next attempt: 2 s, 4 s, 8 s …
+   * up to a minute, each with jitter so a thousand tabs that lost the same
+   * Wi-Fi do not all come back in the same second. The chunk stays pending,
+   * to be resent under the same number.
+   *
+   * Recording does not stop over this unless the page asked for it with
+   * `maxConsecutiveFailures`: the buffer exists for exactly this, and a
+   * phone in a tunnel for half a minute must not end the visit's recording.
+   */
+  registerFailure(serverWaitMs) {
     this.consecutiveFailures += 1;
-    if (this.consecutiveFailures >= this.options.maxConsecutiveFailures) {
+    const limit = this.options.maxConsecutiveFailures;
+    if (limit > 0 && this.consecutiveFailures >= limit) {
       this.stop("too_many_failures");
+      return "stopped";
+    }
+    const now = Date.now();
+    const ceiling = Math.min(BACKOFF_MAX_MS, BACKOFF_BASE_MS * 2 ** Math.min(this.consecutiveFailures - 1, 16));
+    const delay = ceiling / 2 + Math.random() * (ceiling / 2);
+    this.backoffUntil = now + delay;
+    if (serverWaitMs !== void 0) this.serverWaitUntil = now + serverWaitMs;
+    this.scheduleRetry(Math.max(this.backoffUntil, this.serverWaitUntil) - now);
+    return "wait";
+  }
+  /**
+   * The attempt at the end of a backoff. It skips the backoff check itself:
+   * a timer may fire a fraction of a millisecond "early" against `Date.now`,
+   * and refusing then would leave nothing scheduled until the next tick.
+   */
+  scheduleRetry(delayMs) {
+    var _a, _b;
+    if (this.retryTimer) clearTimeout(this.retryTimer);
+    this.retryTimer = setTimeout(() => {
+      this.retryTimer = void 0;
+      void this.flush(true);
+    }, Math.max(0, Math.ceil(delayMs)));
+    (_b = (_a = this.retryTimer).unref) == null ? void 0 : _b.call(_a);
+  }
+  /**
+   * Keeps the buffer bounded during a long outage. Older events go first — a
+   * replay missing a stretch is still useful; a crashed page is not. A chunk
+   * waiting to be retried is the oldest of all, and goes whole: sending part
+   * of it under its number could clash with an attempt that did arrive.
+   */
+  dropOldest(count) {
+    var _a, _b;
+    let remaining = count;
+    if (this.pending && !this.inFlight) {
+      remaining -= this.pending.events.length;
+      this.pending = void 0;
+    }
+    if (remaining > 0) this.buffer.splice(0, remaining);
+    (_b = (_a = this.hooks).onWarning) == null ? void 0 : _b.call(_a, `dropped ${count} buffered events while ingest could not be reached`);
+    this.afterGap();
+  }
+  /**
+   * After events were dropped: DOM changes left before the next full snapshot
+   * may describe nodes whose creation was dropped, and a replay applying them
+   * breaks. They go, and when the buffer holds no snapshot to start again
+   * from, the recorder is asked for one. Custom events, errors and the like
+   * do not depend on the DOM and stay.
+   */
+  afterGap() {
+    const snapshot2 = this.buffer.findIndex((e) => e.type === EVENT_FULL_SNAPSHOT2);
+    const end = snapshot2 === -1 ? this.buffer.length : snapshot2;
+    this.buffer = [
+      ...this.buffer.slice(0, end).filter((e) => e.type !== EVENT_INCREMENTAL2),
+      ...this.buffer.slice(end)
+    ];
+    if (snapshot2 === -1 && !this.awaitingSnapshot && this.hooks.onResyncNeeded) {
+      this.awaitingSnapshot = true;
+      this.hooks.onResyncNeeded();
     }
   }
   /**
-   * Last-gasp send when the page is going away.
+   * Last-gasp send when the page is going away or hidden.
    *
    * `fetch` is cancelled once the document unloads, so the tail of every
    * session would be lost. `sendBeacon` hands the payload to the browser, which
-   * delivers it after the page is gone.
+   * delivers it after the page is gone — but only up to 64 KB in flight, so
+   * the tail goes as a run of small chunks, oldest first, until the browser
+   * says it has no room. What it refuses stays buffered for the page's next
+   * flush, should there be one (a hidden tab that comes back, a page restored
+   * from the back/forward cache).
+   *
+   * For a tab that is only hidden, and so likely to come back, nothing goes
+   * while deliveries are failing or the server asked us to wait: a beacon
+   * "queued" while offline is usually a beacon lost, where the buffer and the
+   * backoff would have delivered it. On `pagehide` (`final`), the last
+   * chance there is, it goes regardless.
    */
-  flushWithBeacon() {
-    var _a, _b;
-    if (this.state === "stopped" || this.buffer.length === 0) return false;
-    const events = this.buffer;
-    const payload = this.body(events);
-    this.buffer = [];
+  flushWithBeacon(final = false) {
+    if (this.state === "stopped" || !this.pending && this.buffer.length === 0) return false;
+    if (!final && (this.consecutiveFailures > 0 || Date.now() < this.serverWaitUntil)) return false;
+    if (typeof navigator === "undefined" || typeof navigator.sendBeacon !== "function") return false;
+    const url = `${this.options.ingestUrl}/v1/ingest/events`;
+    let queuedAny = false;
+    let tooLarge = false;
     try {
-      if (typeof navigator !== "undefined" && typeof navigator.sendBeacon === "function") {
-        (_b = (_a = this.hooks).onSeqReserved) == null ? void 0 : _b.call(_a, this.seq + 1);
-        const blob = new Blob([payload], { type: "text/plain;charset=UTF-8" });
-        const queued = navigator.sendBeacon(`${this.options.ingestUrl}/v1/ingest/events`, blob);
-        if (queued) {
-          this.seq += 1;
-          this.pendingMeta = void 0;
-          return true;
+      const pending = this.pending;
+      if (pending) {
+        const payload = this.body(pending);
+        if (!withinKeepaliveLimit(payload)) {
+          tooLarge = true;
+        } else {
+          if (!this.beacon(url, pending, payload)) return queuedAny;
+          queuedAny = true;
+          if (!this.inFlight) {
+            this.pending = void 0;
+            this.pendingMeta = void 0;
+          }
+        }
+      }
+      while (!tooLarge && this.buffer.length > 0) {
+        const chunk = this.nextChunk(KEEPALIVE_BODY_LIMIT_BYTES, KEEPALIVE_BODY_LIMIT_BYTES, true);
+        if (!chunk) {
+          tooLarge = true;
+          break;
+        }
+        const payload = this.body(chunk);
+        if (!this.beacon(url, chunk, payload)) {
+          this.buffer = [...chunk.events, ...this.buffer];
+          this.seq = chunk.seq;
+          break;
         }
+        queuedAny = true;
+        this.pendingMeta = void 0;
       }
     } catch (e) {
     }
-    this.buffer = events;
-    return false;
+    if (tooLarge) void this.flush(true);
+    return queuedAny;
+  }
+  /** Hands one chunk to the browser. False when its beacon queue is full. */
+  beacon(url, chunk, payload) {
+    var _a, _b;
+    (_b = (_a = this.hooks).onSeqReserved) == null ? void 0 : _b.call(_a, chunk.seq + 1);
+    const blob = new Blob([payload], { type: "text/plain;charset=UTF-8" });
+    return navigator.sendBeacon(url, blob);
   }
 };
 
+// src/version.ts
+var SDK_NAME = "@anyreplay/browser";
+var SDK_VERSION = true ? "0.2.0" : "0.0.0-dev";
+var PLATFORM = "web";
+
 // src/visitor.ts
 var VISITOR_KEY = "anyreplay.vid";
 var SESSION_KEY = "anyreplay.sid";
@@ -4198,7 +5112,7 @@ var RAGE_CLICK_WINDOW_MS = 1e3;
 var RAGE_CLICK_RADIUS_PX = 30;
 var MAX_PENDING_EVENTS = 32;
 var EDITABLE_SELECTOR = '[contenteditable]:not([contenteditable="false"])';
-function createRecorder(rawOptions) {
+function createRecorder(rawOptions, shell) {
   const options = resolveOptions(rawOptions);
   const local = safeStorage(() => globalThis.localStorage);
   const session = safeStorage(() => globalThis.sessionStorage);
@@ -4206,6 +5120,8 @@ function createRecorder(rawOptions) {
   let identity;
   let transport;
   let stopRecording;
+  let diagnostics;
+  let assets;
   let pageCount = 0;
   let pendingTraits;
   const sendIdentity = (who, traits) => {
@@ -4213,22 +5129,34 @@ function createRecorder(rawOptions) {
       method: "POST",
       headers: { "Content-Type": "application/json" },
       credentials: "omit",
-      body: JSON.stringify({ projectKey: options.projectKey, sessionId: who.sessionId, ...traits })
+      body: JSON.stringify({
+        projectKey: options.projectKey,
+        sessionId: who.sessionId,
+        ...traits,
+        ...options.appId ? { appId: options.appId } : {}
+      })
     }).catch(() => {
     });
   };
-  const collectMeta = (who) => ({
-    startedAt: Date.now(),
-    url: safeLocation(),
-    lang: typeof navigator !== "undefined" ? navigator.language : void 0,
-    userAgent: typeof navigator !== "undefined" ? navigator.userAgent : void 0,
-    screenWidth: typeof window !== "undefined" ? window.innerWidth : void 0,
-    screenHeight: typeof window !== "undefined" ? window.innerHeight : void 0,
-    referrer: typeof document !== "undefined" ? document.referrer || void 0 : void 0,
-    // The cap is a decision about starting a session, so it goes only where
-    // ingest makes that decision: chunk 0. A resumed page starts later.
-    ...options.maxSessionsPerMonth !== void 0 && who.nextSeq === 0 ? { sessionCap: options.maxSessionsPerMonth } : {}
-  });
+  const collectMeta = (who) => {
+    var _a, _b;
+    return {
+      startedAt: Date.now(),
+      url: safeLocation(),
+      lang: typeof navigator !== "undefined" ? navigator.language : void 0,
+      userAgent: typeof navigator !== "undefined" ? navigator.userAgent : void 0,
+      screenWidth: typeof window !== "undefined" ? window.innerWidth : void 0,
+      screenHeight: typeof window !== "undefined" ? window.innerHeight : void 0,
+      referrer: typeof document !== "undefined" ? document.referrer || void 0 : void 0,
+      platform: (_a = shell == null ? void 0 : shell.platform) != null ? _a : PLATFORM,
+      sdk: (_b = shell == null ? void 0 : shell.sdk) != null ? _b : { name: SDK_NAME, version: SDK_VERSION },
+      ...(shell == null ? void 0 : shell.appVersion) ? { appVersion: shell.appVersion.slice(0, 40) } : {},
+      ...(shell == null ? void 0 : shell.deviceModel) ? { deviceModel: shell.deviceModel.slice(0, 64) } : {},
+      // The cap is a decision about starting a session, so it goes only where
+      // ingest makes that decision: chunk 0. A resumed page starts later.
+      ...options.maxSessionsPerMonth !== void 0 && who.nextSeq === 0 ? { sessionCap: options.maxSessionsPerMonth } : {}
+    };
+  };
   const recentClicks = [];
   const noteInteraction = (event, channel) => {
     var _a;
@@ -4256,6 +5184,7 @@ function createRecorder(rawOptions) {
         const next = pending[0];
         record.addCustomEvent(next.tag, next.payload);
         pending.shift();
+        if (next.tag === ERROR_TAG) transport == null ? void 0 : transport.mergeFlags({ hasError: true });
       }
     } catch (e) {
       if (!drainScheduled && status === "recording") {
@@ -4322,17 +5251,52 @@ function createRecorder(rawOptions) {
           status = "stopped";
           stopRecording == null ? void 0 : stopRecording();
           stopRecording = void 0;
+          diagnostics == null ? void 0 : diagnostics.stop();
+          diagnostics = void 0;
+          assets == null ? void 0 : assets.stop();
+          assets = void 0;
           if (reason === "rejected_402") startCooldown(session);
           if (options.debug) console.warn(`[anyreplay] recording stopped: ${reason}`);
-        }
+        },
+        onWarning: (message) => {
+          if (options.debug) console.warn(`[anyreplay] ${message}`);
+        },
+        // Events were dropped (a long outage, or one too large to send), so
+        // the DOM changes after the gap describe nodes ingest never got. A
+        // fresh full snapshot starts the page over. Taken on the next turn,
+        // not here: this can be called from inside rrweb's own emit, in the
+        // middle of handing over a batch of mutations.
+        onResyncNeeded: () => setTimeout(() => takeSnapshot(2), 0)
       }
     );
     transport = channel;
     status = "recording";
+    const takeSnapshot = (triesLeft) => {
+      if (status !== "recording" || !stopRecording) return;
+      try {
+        record.takeFullSnapshot(true);
+      } catch (e) {
+        if (triesLeft > 0) setTimeout(() => takeSnapshot(triesLeft - 1), 1e3);
+      }
+    };
     lastUrl = safeLocation();
     channel.setMeta(collectMeta(who));
     channel.mergeFlags({ pageCount });
     channel.start();
+    const prefix = options.assets === "inline" ? localAssetPrefix() : null;
+    if (prefix && typeof fetch === "function") {
+      assets = new AssetCollector({
+        prefix,
+        ingestUrl: options.ingestUrl,
+        projectKey: options.projectKey,
+        appId: options.appId,
+        // Bound now, before the network diagnostics wrap `fetch`: reading the
+        // app's own files is the recorder's business, not the app's traffic.
+        fetch: fetch.bind(globalThis),
+        emit: (payload) => emitCustom(ASSET_TAG, payload),
+        debug: options.debug
+      });
+    }
     const policy = {
       maskEveryField: options.maskAllInputs || options.maskAllTyping,
       maskClass: options.maskClass
@@ -4341,6 +5305,7 @@ function createRecorder(rawOptions) {
       emit: (event) => {
         const typed = event;
         scrubEvent(typed, (id) => record.mirror.getNode(id), policy);
+        assets == null ? void 0 : assets.scan(typed);
         noteInteraction(typed, channel);
         touchSession(session, typed.timestamp);
         channel.push(typed);
@@ -4350,6 +5315,9 @@ function createRecorder(rawOptions) {
       maskTextClass: options.maskClass,
       maskTextSelector: options.maskAllTyping ? EDITABLE_SELECTOR : void 0,
       blockClass: options.blockClass,
+      // Readable stylesheets go into the snapshot as text, in both asset
+      // modes. rrweb's default, written out because 'inline' depends on it.
+      inlineStylesheet: true,
       // Canvas capture is expensive and off unless a customer opts in later.
       recordCanvas: false,
       collectFonts: false
@@ -4364,13 +5332,21 @@ function createRecorder(rawOptions) {
   const attachLifecycleHooks = (channel) => {
     if (typeof window === "undefined") return;
     window.addEventListener("pagehide", () => {
-      channel.flushWithBeacon();
+      channel.flushWithBeacon(true);
     }, { capture: true });
     document.addEventListener("visibilitychange", () => {
       if (document.visibilityState === "hidden") channel.flushWithBeacon();
+      else channel.resume();
+    });
+    window.addEventListener("online", () => channel.resume());
+    diagnostics = startDiagnostics({
+      errors: options.recordErrors,
+      console: options.recordConsole,
+      network: options.recordNetwork,
+      ingestUrl: options.ingestUrl,
+      emit: emitCustom,
+      onError: () => channel.mergeFlags({ hasError: true })
     });
-    window.addEventListener("error", () => channel.mergeFlags({ hasError: true }));
-    window.addEventListener("unhandledrejection", () => channel.mergeFlags({ hasError: true }));
     const patch2 = (method) => {
       const original = history[method].bind(history);
       history[method] = function patched(...args) {
@@ -4400,8 +5376,12 @@ function createRecorder(rawOptions) {
         return;
       }
       transport == null ? void 0 : transport.stop("consent_withdrawn");
-      if (status === "idle" || status === "awaiting-consent") status = "stopped";
+      if (status === "idle" || status === "awaiting-consent" || status === "sampled-out") {
+        status = "awaiting-consent";
+        identity = void 0;
+      }
       pendingTraits = void 0;
+      pending.length = 0;
       forgetVisitor(local, session);
     },
     identify: (traits) => {
@@ -4421,14 +5401,24 @@ function createRecorder(rawOptions) {
       }
       emitCustom(TRACK_TAG, payload);
     },
+    trackError: (error) => {
+      if (!options.recordErrors) return;
+      if (diagnostics) {
+        diagnostics.error(error);
+        return;
+      }
+      emitCustom(ERROR_TAG, errorPayload("error", error));
+      if (status === "recording") transport == null ? void 0 : transport.mergeFlags({ hasError: true });
+    },
     stop: () => {
       transport == null ? void 0 : transport.stop("stopped_by_page");
       if (status === "idle" || status === "awaiting-consent") status = "stopped";
       pendingTraits = void 0;
     },
+    // Asked for by the page, so it skips our own backoff (never a server's Retry-After).
     flush: () => {
       var _a;
-      return (_a = transport == null ? void 0 : transport.flush()) != null ? _a : Promise.resolve();
+      return (_a = transport == null ? void 0 : transport.flush(true)) != null ? _a : Promise.resolve();
     }
   };
 }
@@ -4440,20 +5430,36 @@ function safeLocation() {
   }
 }
 export {
+  ASSET_LIMITS,
+  ASSET_TAG,
+  CONSOLE_TAG,
   ConfigError,
   DEFAULTS,
+  ERROR_TAG,
   EVENT_NAME_PATTERN,
+  LIMITS,
   MAX_PROPERTIES_BYTES,
   NAVIGATE_TAG,
+  NETWORK_TAG,
+  REDACTED,
+  SDK_NAME,
+  SDK_VERSION,
   TRACK_TAG,
   Transport,
+  consolePayload,
   createRecorder,
+  defaultAssetMode,
+  errorPayload,
   forgetVisitor,
   hashToUnitInterval,
   isSampledIn,
+  localAssetPrefix,
+  redactText,
+  redactUrl,
   resolveIdentity,
   resolveOptions,
   safeStorage,
+  startDiagnostics,
   uuidv4,
   validateTrack
 };