@guidelytech/react-native 0.9.0 → 0.10.0

package/dist/index.js

@@ -554,51 +554,108 @@ function isArticleListed(collections, article, member) {
 }
 var CAPTURE_SCREENSHOT_MAX_BYTES = 8 * 1024 * 1024;
 
-// ../sdk-core/dist/chunk-CYAG6ZYX.js
-function readJson(store, key, fallback) {
-  const raw = store.get(key);
-  if (raw == null) return fallback;
-  try {
-    return JSON.parse(raw);
-  } catch {
-    return fallback;
-  }
-}
-function writeJson(store, key, value) {
-  try {
-    store.set(key, JSON.stringify(value));
-  } catch {
-  }
-}
-var KEYS = {
-  anon: "guidely:anon",
-  seen: "guidely:seen",
-  config: (key) => `guidely:config:${key}`,
-  etag: (key) => `guidely:etag:${key}`,
-  state: (key) => `guidely:state:${key}`,
-  user: (key) => `guidely:user:${key}`,
-  queue: (key) => `guidely:queue:${key}`,
-  session: "guidely:session",
-  active: "guidely:active",
-  authoring: "guidely:authoring",
-  /** How-to capture session marker ({ token, … }) and its not-yet-uploaded steps. */
-  capture: "guidely:capture",
-  capturePending: "guidely:capture:pending",
-  /** Messenger conversations this browser can read: [{ id, token }]. */
-  conversations: (key) => `guidely:conversations:${key}`,
-  /** Announcement ids opened in the messenger's News tab. */
-  newsSeen: (key) => `guidely:news:${key}`
-};
-
-// ../sdk-core/dist/chunk-AKNE7D5M.js
+// ../sdk-core/dist/chunk-C4WWSF67.js
 var __defProp2 = Object.defineProperty;
 var __defNormalProp2 = (obj, key, value) => key in obj ? __defProp2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __publicField2 = (obj, key, value) => __defNormalProp2(obj, typeof key !== "symbol" ? key + "" : key, value);
+var MAX_RETRY_AFTER_MS = 60 * 60 * 1e3;
+var OFFLINE_WAIT_MS = 3e4;
+var ServerHealth = class {
+  constructor(opts = {}) {
+    __publicField2(this, "failures", 0);
+    __publicField2(this, "openUntil", 0);
+    __publicField2(this, "lastOkAt", 0);
+    __publicField2(this, "listeners", /* @__PURE__ */ new Set());
+    __publicField2(this, "threshold");
+    __publicField2(this, "baseMs");
+    __publicField2(this, "maxMs");
+    __publicField2(this, "now");
+    __publicField2(this, "random");
+    this.threshold = opts.threshold ?? 3;
+    this.baseMs = opts.baseMs ?? 5e3;
+    this.maxMs = opts.maxMs ?? 5 * 60 * 1e3;
+    this.now = opts.now ?? Date.now;
+    this.random = opts.random ?? Math.random;
+  }
+  /** The server answered (2xx, 3xx, or a 4xx other than 429): it is up. */
+  success() {
+    const wasDown = this.failures > 0 || this.openUntil > 0;
+    this.failures = 0;
+    this.openUntil = 0;
+    this.lastOkAt = this.now();
+    if (wasDown) this.notify();
+  }
+  /** The request failed or the server is overloaded. `retryAfterMs` comes from a `Retry-After` header. */
+  failure(retryAfterMs) {
+    this.failures += 1;
+    const now = this.now();
+    if (retryAfterMs != null && retryAfterMs > 0) {
+      this.openUntil = Math.max(this.openUntil, now + Math.min(retryAfterMs, MAX_RETRY_AFTER_MS));
+      return;
+    }
+    if (this.failures < this.threshold) return;
+    const cooldown = Math.min(this.maxMs, this.baseMs * 2 ** (this.failures - this.threshold));
+    this.openUntil = Math.max(this.openUntil, now + cooldown * (0.8 + this.random() * 0.4));
+  }
+  /** Milliseconds background traffic should wait before trying again (0: send now). */
+  waitMs() {
+    if (typeof navigator !== "undefined" && navigator.onLine === false) return OFFLINE_WAIT_MS;
+    return Math.max(0, this.openUntil - this.now());
+  }
+  canSend() {
+    return this.waitMs() === 0;
+  }
+  /**
+   * The last request got an answer. Unload beacons can't report back, so what they carry is only
+   * forgotten while this holds; otherwise it stays queued and is sent again (the server drops duplicates).
+   */
+  get reachable() {
+    return this.failures === 0 && this.lastOkAt > 0;
+  }
+  /** The browser came back online: end the cooldown and let queued traffic try straight away. */
+  online() {
+    this.openUntil = 0;
+    this.notify();
+  }
+  /** Called when the server answers again after failures, or the browser comes back online. */
+  onRecover(cb) {
+    this.listeners.add(cb);
+    return () => this.listeners.delete(cb);
+  }
+  notify() {
+    for (const cb of Array.from(this.listeners)) {
+      try {
+        cb();
+      } catch {
+      }
+    }
+  }
+};
+function parseRetryAfter(value, now = Date.now()) {
+  if (!value) return null;
+  const trimmed = value.trim();
+  if (/^\d+$/.test(trimmed)) return Number(trimmed) * 1e3;
+  const at = Date.parse(trimmed);
+  return Number.isNaN(at) ? null : Math.max(0, at - now);
+}
+function isServerFailure(status) {
+  return status === 429 || status >= 500;
+}
+var STREAM_RESPONSE_TIMEOUT_MS = 3e4;
+var STREAM_IDLE_TIMEOUT_MS = 6e4;
 var Api = class {
-  constructor(baseUrl, key, fetchImpl) {
+  constructor(baseUrl, key, fetchImpl, health) {
     __publicField2(this, "baseUrl", baseUrl);
     __publicField2(this, "key", key);
     __publicField2(this, "fetchImpl", fetchImpl);
+    __publicField2(this, "health");
+    this.health = health ?? new ServerHealth();
+  }
+  /** Feeds an answer (or a failed request, `null`) into {@link health}. */
+  observe(res) {
+    if (!res) this.health.failure();
+    else if (isServerFailure(res.status)) this.health.failure(parseRetryAfter(res.headers?.get?.("retry-after")));
+    else this.health.success();
   }
   url(path, params = {}) {
     const query = Object.entries({ key: this.key, ...params }).filter((e) => e[1] != null).map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(v)}`).join("&");
@@ -618,15 +675,22 @@ var Api = class {
     const ac = typeof AbortController !== "undefined" ? new AbortController() : null;
     const timer = ac ? setTimeout(() => ac.abort(), options.timeoutMs ?? 1e4) : null;
     try {
-      const res = await f(this.url(path, options.params), {
-        method,
-        headers,
-        body: options.body === void 0 ? void 0 : form ? options.body : JSON.stringify(options.body),
-        keepalive: options.keepalive,
-        signal: ac?.signal,
-        credentials: "omit",
-        mode: "cors"
-      });
+      let res;
+      try {
+        res = await f(this.url(path, options.params), {
+          method,
+          headers,
+          body: options.body === void 0 ? void 0 : form ? options.body : JSON.stringify(options.body),
+          keepalive: options.keepalive,
+          signal: ac?.signal,
+          credentials: "omit",
+          mode: "cors"
+        });
+      } catch (err) {
+        this.observe(null);
+        throw err;
+      }
+      this.observe(res);
       let data = null;
       if (res.status !== 304 && res.status !== 204) {
         try {
@@ -652,30 +716,53 @@ var Api = class {
   }
   /**
    * POST that may answer with server-sent events. Each event is passed to `onEvent`; a JSON answer is
-   * returned instead. No timeout: Scout replies can take a while and the server keeps the stream alive.
+   * returned instead. Scout replies can take a while, so there is no overall timeout: the response
+   * must start within 30 s and then never go quiet for more than 60 s (the server sends keepalives),
+   * otherwise the request is aborted and rejects.
    */
   async stream(path, body, onEvent, headers = {}) {
     const f = this.fetcher;
     if (!f) throw new Error("fetch is not available");
-    const res = await f(this.url(path), {
-      method: "POST",
-      headers: { ...headers, "X-Guidely-Key": this.key, Accept: "text/event-stream, application/json", "Content-Type": "application/json" },
-      body: JSON.stringify(body),
-      credentials: "omit",
-      mode: "cors"
-    });
-    const type = res.headers?.get?.("content-type") ?? "";
-    if (!type.includes("text/event-stream") || !res.body) {
-      let data = null;
+    const ac = typeof AbortController !== "undefined" ? new AbortController() : null;
+    let timer = null;
+    const arm = (ms) => {
+      if (!ac) return;
+      if (timer) clearTimeout(timer);
+      timer = setTimeout(() => ac.abort(), ms);
+    };
+    arm(STREAM_RESPONSE_TIMEOUT_MS);
+    try {
+      let res;
       try {
-        data = await res.json();
-      } catch {
-        data = null;
+        res = await f(this.url(path), {
+          method: "POST",
+          headers: { ...headers, "X-Guidely-Key": this.key, Accept: "text/event-stream, application/json", "Content-Type": "application/json" },
+          body: JSON.stringify(body),
+          signal: ac?.signal,
+          credentials: "omit",
+          mode: "cors"
+        });
+      } catch (err) {
+        this.observe(null);
+        throw err;
       }
-      return { status: res.status, ok: res.ok, data, etag: null };
+      this.observe(res);
+      const type = res.headers?.get?.("content-type") ?? "";
+      if (!type.includes("text/event-stream") || !res.body) {
+        let data = null;
+        try {
+          data = await res.json();
+        } catch {
+          data = null;
+        }
+        return { status: res.status, ok: res.ok, data, etag: null };
+      }
+      arm(STREAM_IDLE_TIMEOUT_MS);
+      await readEventStream(res.body, onEvent, () => arm(STREAM_IDLE_TIMEOUT_MS));
+      return { status: res.status, ok: res.ok, data: null, etag: null };
+    } finally {
+      if (timer) clearTimeout(timer);
     }
-    await readEventStream(res.body, onEvent);
-    return { status: res.status, ok: res.ok, data: null, etag: null };
   }
   /** `navigator.sendBeacon` when available (page unload); returns false when it could not be queued. */
   beacon(path, body) {
@@ -706,7 +793,7 @@ async function withRetry(send, attempts = 3, baseMs = 500) {
 function postWithRetry(api, path, body, attempts = 3, baseMs = 500) {
   return withRetry(() => api.post(path, body), attempts, baseMs);
 }
-async function readEventStream(body, onEvent) {
+async function readEventStream(body, onEvent, onChunk) {
   const reader = body.getReader();
   const decoder = new TextDecoder();
   let buffer = "";
@@ -729,6 +816,7 @@ async function readEventStream(body, onEvent) {
   };
   for (; ; ) {
     const { done, value } = await reader.read();
+    if (value) onChunk?.();
     if (value) buffer += decoder.decode(value, { stream: true }).replace(/\r\n?/g, "\n");
     let sep;
     while ((sep = buffer.indexOf("\n\n")) >= 0) {
@@ -739,8 +827,44 @@ async function readEventStream(body, onEvent) {
   }
   if (buffer.trim()) dispatch(buffer);
 }
+function readJson(store, key, fallback) {
+  const raw = store.get(key);
+  if (raw == null) return fallback;
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return fallback;
+  }
+}
+function writeJson(store, key, value) {
+  try {
+    store.set(key, JSON.stringify(value));
+  } catch {
+  }
+}
+var KEYS = {
+  anon: "guidely:anon",
+  seen: "guidely:seen",
+  config: (key) => `guidely:config:${key}`,
+  etag: (key) => `guidely:etag:${key}`,
+  state: (key) => `guidely:state:${key}`,
+  user: (key) => `guidely:user:${key}`,
+  queue: (key) => `guidely:queue:${key}`,
+  /** Survey answers and guide/checklist progress not yet accepted by the server. */
+  outbox: (key) => `guidely:outbox:${key}`,
+  session: "guidely:session",
+  active: "guidely:active",
+  authoring: "guidely:authoring",
+  /** How-to capture session marker ({ token, … }) and its not-yet-uploaded steps. */
+  capture: "guidely:capture",
+  capturePending: "guidely:capture:pending",
+  /** Messenger conversations this browser can read: [{ id, token }]. */
+  conversations: (key) => `guidely:conversations:${key}`,
+  /** Announcement ids opened in the messenger's News tab. */
+  newsSeen: (key) => `guidely:news:${key}`
+};
 
-// ../sdk-core/dist/chunk-544KSOC3.js
+// ../sdk-core/dist/chunk-GDJB466J.js
 var EventQueue = class {
   constructor(opts) {
     __publicField2(this, "opts", opts);
@@ -751,17 +875,34 @@ var EventQueue = class {
     __publicField2(this, "inflightIds", /* @__PURE__ */ new Set());
     __publicField2(this, "attempt", 0);
     __publicField2(this, "destroyed", false);
+    __publicField2(this, "offRecover", null);
     __publicField2(this, "flushIntervalMs");
     __publicField2(this, "maxQueue");
     __publicField2(this, "batchSize");
     __publicField2(this, "maxAttempts");
     this.flushIntervalMs = opts.flushIntervalMs ?? 2e3;
-    this.maxQueue = opts.maxQueue ?? 200;
+    this.maxQueue = opts.maxQueue ?? 500;
     this.batchSize = opts.batchSize ?? 50;
     this.maxAttempts = opts.maxAttempts ?? 5;
     const persisted = readJson(opts.store, opts.storageKey, []);
     if (Array.isArray(persisted)) this.events = persisted.filter((e) => e && typeof e.eventId === "string").slice(-this.maxQueue);
     if (this.events.length) this.schedule();
+    this.offRecover = opts.health?.onRecover(() => this.retryNow()) ?? null;
+  }
+  /** The API is back: drop any pending backoff and send what is queued. */
+  retryNow() {
+    if (this.destroyed) return;
+    if (this.retryTimer) clearTimeout(this.retryTimer);
+    this.retryTimer = null;
+    this.attempt = 0;
+    void this.flush();
+  }
+  retryIn(ms) {
+    if (this.retryTimer || this.destroyed) return;
+    this.retryTimer = setTimeout(() => {
+      this.retryTimer = null;
+      void this.flush();
+    }, ms);
   }
   get size() {
     return this.events.length;
@@ -795,6 +936,8 @@ var EventQueue = class {
       clearTimeout(this.timer);
       this.timer = null;
     }
+    const wait = this.opts.health?.waitMs() ?? 0;
+    if (wait > 0) return this.retryIn(wait);
     this.inflight = true;
     const batch = this.events.slice(0, this.batchSize);
     this.inflightIds = new Set(batch.map((e) => e.eventId));
@@ -818,26 +961,20 @@ var EventQueue = class {
       if (this.events.length) this.schedule();
       return;
     }
-    this.attempt += 1;
-    if (this.attempt >= this.maxAttempts) {
-      this.attempt = 0;
-      return;
-    }
-    this.retryTimer = setTimeout(() => {
-      this.retryTimer = null;
-      void this.flush();
-    }, backoffMs(this.attempt - 1));
+    this.attempt = Math.min(this.attempt + 1, this.maxAttempts);
+    const delay = this.attempt >= this.maxAttempts ? 6e4 : backoffMs(this.attempt - 1);
+    this.retryIn(Math.max(delay, this.opts.health?.waitMs() ?? 0));
   }
   /** Best-effort synchronous flush on unload using `sendBeacon`. */
   flushSync() {
     if (this.destroyed || !this.opts.enabled() || !this.opts.beacon) return;
     const batch = this.events.filter((e) => !this.inflightIds.has(e.eventId)).slice(0, this.batchSize);
     if (!batch.length) return;
-    if (this.opts.beacon(batch)) {
+    if (this.opts.beacon(batch) && (this.opts.health?.reachable ?? true)) {
       const ids = new Set(batch.map((e) => e.eventId));
       this.events = this.events.filter((e) => !ids.has(e.eventId));
-      this.persist();
     }
+    this.persist();
   }
   clear() {
     this.events = [];
@@ -845,6 +982,7 @@ var EventQueue = class {
   }
   destroy() {
     this.destroyed = true;
+    this.offRecover?.();
     if (this.timer) clearTimeout(this.timer);
     if (this.retryTimer) clearTimeout(this.retryTimer);
     this.timer = null;
@@ -852,6 +990,88 @@ var EventQueue = class {
     this.persist();
   }
 };
+var Outbox = class {
+  constructor(opts) {
+    __publicField2(this, "opts", opts);
+    __publicField2(this, "items");
+    __publicField2(this, "sending", false);
+    __publicField2(this, "attempt", 0);
+    __publicField2(this, "timer", null);
+    __publicField2(this, "destroyed", false);
+    __publicField2(this, "offRecover");
+    __publicField2(this, "maxItems");
+    __publicField2(this, "maxAgeMs");
+    this.maxItems = opts.maxItems ?? 50;
+    this.maxAgeMs = opts.maxAgeMs ?? 7 * 24 * 60 * 60 * 1e3;
+    const stored = readJson(opts.store, opts.storageKey, []);
+    const cutoff = Date.now() - this.maxAgeMs;
+    this.items = Array.isArray(stored) ? stored.filter((i) => i && typeof i.path === "string" && typeof i.key === "string" && i.createdAt > cutoff).slice(-this.maxItems) : [];
+    this.offRecover = opts.health?.onRecover(() => {
+      this.attempt = 0;
+      this.retryIn(0);
+    }) ?? null;
+    if (this.items.length) this.retryIn(0);
+  }
+  get size() {
+    return this.items.length;
+  }
+  /** Queues `POST path` and sends it now (or as soon as the API is reachable). */
+  add(key, path, body) {
+    if (this.destroyed) return;
+    this.items = this.items.filter((i) => i.key !== key);
+    this.items.push({ key, path, body, createdAt: Date.now() });
+    if (this.items.length > this.maxItems) this.items.splice(0, this.items.length - this.maxItems);
+    this.persist();
+    void this.flush();
+  }
+  persist() {
+    writeJson(this.opts.store, this.opts.storageKey, this.items);
+  }
+  retryIn(ms) {
+    if (this.destroyed) return;
+    if (this.timer) clearTimeout(this.timer);
+    this.timer = setTimeout(() => {
+      this.timer = null;
+      void this.flush();
+    }, ms);
+  }
+  /** Sends queued requests in order, one at a time. */
+  async flush() {
+    if (this.destroyed || this.sending || !this.items.length) return;
+    const wait = this.opts.health?.waitMs() ?? 0;
+    if (wait > 0) return this.retryIn(wait);
+    this.sending = true;
+    try {
+      while (this.items.length && !this.destroyed) {
+        const item = this.items[0];
+        let retry = false;
+        try {
+          const res = await this.opts.api.post(item.path, item.body);
+          retry = !res.ok && (res.status === 429 || res.status >= 500);
+        } catch (err) {
+          retry = true;
+          this.opts.onError?.(err);
+        }
+        if (retry) {
+          this.attempt += 1;
+          this.retryIn(Math.max(backoffMs(this.attempt - 1, 1e3, 6e4), this.opts.health?.waitMs() ?? 0));
+          return;
+        }
+        this.attempt = 0;
+        this.items = this.items.filter((i) => i !== item);
+        this.persist();
+      }
+    } finally {
+      this.sending = false;
+    }
+  }
+  destroy() {
+    this.destroyed = true;
+    this.offRecover?.();
+    if (this.timer) clearTimeout(this.timer);
+    this.timer = null;
+  }
+};
 var Emitter = class {
   constructor(onError) {
     __publicField2(this, "onError", onError);
@@ -1407,12 +1627,29 @@ function createSseParser(onEvent) {
     }
   };
 }
+var STREAM_RESPONSE_TIMEOUT_MS2 = 3e4;
+var STREAM_IDLE_TIMEOUT_MS2 = 6e4;
 function xhrStreamPost() {
   if (typeof XMLHttpRequest === "undefined") return null;
   return (url, headers, body, onChunk) => new Promise((resolve, reject) => {
     const xhr = new XMLHttpRequest();
     let seen = 0;
     let streamed = false;
+    let timer = null;
+    let settled = false;
+    const settle = (fn) => {
+      if (settled) return;
+      settled = true;
+      if (timer) clearTimeout(timer);
+      fn();
+    };
+    const arm = (ms, what) => {
+      if (timer) clearTimeout(timer);
+      timer = setTimeout(() => {
+        settle(() => reject(new Error(`Scout ${what} timed out`)));
+        xhr.abort();
+      }, ms);
+    };
     const pump = () => {
       const type = xhr.getResponseHeader("content-type") || "";
       if (!type.includes("text/event-stream")) return;
@@ -1425,8 +1662,15 @@ function xhrStreamPost() {
     };
     xhr.open("POST", url);
     for (const [k, v] of Object.entries(headers)) xhr.setRequestHeader(k, v);
-    xhr.onprogress = pump;
-    xhr.onload = () => {
+    xhr.onreadystatechange = () => {
+      if (!settled && xhr.readyState >= 2 && xhr.readyState < 4) arm(STREAM_IDLE_TIMEOUT_MS2, "reply");
+    };
+    xhr.onprogress = () => {
+      if (settled) return;
+      arm(STREAM_IDLE_TIMEOUT_MS2, "reply");
+      pump();
+    };
+    xhr.onload = () => settle(() => {
       pump();
       let json = null;
       if (!streamed) {
@@ -1437,27 +1681,74 @@ function xhrStreamPost() {
         }
       }
       resolve({ status: xhr.status, json, streamed });
-    };
-    xhr.onerror = () => reject(new Error("Network request failed"));
+    });
+    xhr.onerror = () => settle(() => reject(new Error("Network request failed")));
+    arm(STREAM_RESPONSE_TIMEOUT_MS2, "request");
     xhr.send(JSON.stringify(body));
   });
 }
+function bodyReader(res) {
+  const body = res.body;
+  const Decoder = globalThis.TextDecoder;
+  return body && typeof body.getReader === "function" && Decoder ? { reader: body.getReader(), decoder: new Decoder() } : null;
+}
 function fetchStreamPost(fetchImpl) {
   return async (url, headers, body, onChunk) => {
-    const res = await fetchImpl(url, { method: "POST", headers, body: JSON.stringify(body) });
-    const type = res.headers.get("content-type") || "";
-    const text = await res.text();
-    if (type.includes("text/event-stream")) {
-      onChunk(text);
-      return { status: res.status, json: null, streamed: true };
-    }
-    let json = null;
+    const ac = typeof AbortController !== "undefined" ? new AbortController() : null;
+    let timer = null;
+    let timedOut = "";
+    let fail = () => {
+    };
+    const expired = new Promise((_, reject) => fail = reject);
+    expired.catch(() => {
+    });
+    const arm = (ms, what) => {
+      if (timer) clearTimeout(timer);
+      timer = setTimeout(() => {
+        timedOut = what;
+        ac?.abort();
+        fail(new Error(`Scout ${what} timed out`));
+      }, ms);
+    };
+    const race = (p) => Promise.race([p, expired]);
+    arm(STREAM_RESPONSE_TIMEOUT_MS2, "request");
     try {
-      json = JSON.parse(text || "null");
-    } catch {
-      json = null;
+      const res = await race(fetchImpl(url, { method: "POST", headers, body: JSON.stringify(body), signal: ac?.signal }));
+      arm(STREAM_IDLE_TIMEOUT_MS2, "reply");
+      const type = res.headers.get("content-type") || "";
+      const sse = type.includes("text/event-stream");
+      const streaming = sse ? bodyReader(res) : null;
+      if (streaming) {
+        const { reader, decoder } = streaming;
+        for (; ; ) {
+          const { done, value } = await race(reader.read());
+          if (value) {
+            arm(STREAM_IDLE_TIMEOUT_MS2, "reply");
+            onChunk(decoder.decode(value, { stream: true }));
+          }
+          if (done) break;
+        }
+        const rest = decoder.decode();
+        if (rest) onChunk(rest);
+        return { status: res.status, json: null, streamed: true };
+      }
+      const text = await race(res.text());
+      if (sse) {
+        onChunk(text);
+        return { status: res.status, json: null, streamed: true };
+      }
+      let json = null;
+      try {
+        json = JSON.parse(text || "null");
+      } catch {
+        json = null;
+      }
+      return { status: res.status, json, streamed: false };
+    } catch (err) {
+      throw timedOut ? new Error(`Scout ${timedOut} timed out`) : err;
+    } finally {
+      if (timer) clearTimeout(timer);
     }
-    return { status: res.status, json, streamed: false };
   };
 }
 var byNewest = (a, b) => Date.parse(b.lastMessageAt) - Date.parse(a.lastMessageAt);
@@ -1642,7 +1933,15 @@ var Messenger = class {
       }
     });
     try {
-      const res = await this.deps.streamPost(this.url(path), headers, payload, (chunk) => parser.feed(chunk));
+      let res;
+      try {
+        res = await this.deps.streamPost(this.url(path), headers, payload, (chunk) => parser.feed(chunk));
+      } catch (err) {
+        this.deps.health?.failure();
+        throw err;
+      }
+      if (isServerFailure(res.status)) this.deps.health?.failure();
+      else this.deps.health?.success();
       parser.end();
       if (res.status < 200 || res.status >= 300) throw new Error(`Request failed (${res.status})`);
       if (!res.streamed && res.json) {
@@ -1829,9 +2128,20 @@ var PersistentStore = class {
 
 // src/core/client.ts
 var SDK_NAME = "@guidelytech/react-native";
-var SDK_VERSION = "0.9.0";
+var SDK_VERSION = "0.10.0";
 var DEFAULT_API_URL = "https://guidelytech.com";
 var PAGE_SCOPED = /* @__PURE__ */ new Set(["page_load", "url_match", "element_click", "element_visible", "delay"]);
+var CACHED_START_MS = 1500;
+function settlesWithin(promise, ms) {
+  return new Promise((resolve) => {
+    const timer = setTimeout(() => resolve(false), ms);
+    const done = () => {
+      clearTimeout(timer);
+      resolve(true);
+    };
+    promise.then(done, done);
+  });
+}
 var nowIso = () => (/* @__PURE__ */ new Date()).toISOString();
 var emptyState = () => ({ guides: {}, checklists: {}, surveysSubmitted: [], audienceIds: [] });
 var newSession = () => ({ id: `s_${randomId(16)}`, startedAt: nowIso(), lastActiveAt: nowIso(), shownGuides: [], events: [] });
@@ -1844,6 +2154,8 @@ var GuidelyClient = class {
     __publicField(this, "store");
     __publicField(this, "emitter");
     __publicField(this, "queue", null);
+    /** Survey answers, guide completions/dismissals and checklist progress, kept until the server has them. */
+    __publicField(this, "outbox", null);
     __publicField(this, "config", null);
     __publicField(this, "configFetchedAt", 0);
     __publicField(this, "etag", null);
@@ -1906,7 +2218,7 @@ var GuidelyClient = class {
     this.emitter = new Emitter((err) => this.reportError(err));
     this.api = new Api(this.options.apiUrl, this.options.projectId, options.fetch);
     this.store = new PersistentStore(options.storage ?? null, (err) => this.log("storage error", err));
-    if (!options.storage) this.log("no `storage` passed: identity and guide history last only for this app session. Pass AsyncStorage to persist them.");
+    if (!options.storage) this.log("no `storage` passed: identity, guide history, queued events and survey answers last only for this app session, so whatever could not be sent during a Guidely outage is lost when the app restarts. Pass AsyncStorage to persist them.");
     this.cleanups.push(this.targets.onTap((id) => this.handleTap(id)));
     if (options.user) this.user = { ...options.user };
     this.flags = this.createFlags(options.flags);
@@ -1957,7 +2269,7 @@ var GuidelyClient = class {
   async bootstrap() {
     const key = this.options.projectId;
     try {
-      await this.store.hydrate([KEYS.anon, KEYS.seen, KEYS.session, KEYS.config(key), KEYS.etag(key), KEYS.state(key), KEYS.user(key), KEYS.queue(key), KEYS.conversations(key)]);
+      await this.store.hydrate([KEYS.anon, KEYS.seen, KEYS.session, KEYS.config(key), KEYS.etag(key), KEYS.state(key), KEYS.user(key), KEYS.queue(key), KEYS.outbox(key), KEYS.conversations(key)]);
       if (this.destroyed) return;
       this.anonymousId = this.store.get(KEYS.anon) || "";
       if (!this.anonymousId) {
@@ -1977,22 +2289,27 @@ var GuidelyClient = class {
         store: this.store,
         storageKey: KEYS.queue(key),
         enabled: () => this.analyticsEnabled(),
+        health: this.api.health,
         send: async (events) => {
           const res = await this.api.post("/events", { events, sentAt: nowIso(), sdk: { name: SDK_NAME, version: SDK_VERSION } });
           return { ok: res.ok, retry: !(res.status >= 400 && res.status < 500 && res.status !== 429) };
         },
         onError: (err) => this.reportError(err)
       });
+      this.outbox = new Outbox({ api: this.api, store: this.store, storageKey: KEYS.outbox(key), health: this.api.health });
       this.hydrated = true;
       const cached = readJson(this.store, KEYS.config(key), null);
       this.etag = this.store.get(KEYS.etag(key));
       if (cached && Array.isArray(cached.guides)) this.config = forPlatform(cached, this.bridge.device.platform);
       this.syncMessenger();
       this.pending.splice(0).forEach((fn) => fn());
-      await this.fetchConfig();
+      const before = this.config?.configVersion;
+      const fresh = this.fetchConfig();
+      if (!this.config) await fresh;
+      else if (!await settlesWithin(fresh, CACHED_START_MS)) void fresh.then(() => this.applyConfigChange(before));
       if (this.destroyed) return;
       this.wireTimers();
-      if (this.user?.id) await this.identify(this.user.id, this.user.traits, this.user.account);
+      if (this.user?.id) await settlesWithin(this.identify(this.user.id, this.user.traits, this.user.account), CACHED_START_MS);
       if (this.destroyed) return;
       this.isReady = true;
       if (this.config) this.emitter.emit("ready", this.config);
@@ -2032,7 +2349,9 @@ var GuidelyClient = class {
     }
   }
   wireTimers() {
-    const refresh = setInterval(() => void this.refresh(), this.options.configRefreshMs);
+    const refresh = setInterval(() => {
+      if (this.api.health.canSend()) void this.refresh();
+    }, this.options.configRefreshMs);
     this.cleanups.push(() => clearInterval(refresh));
     const poll = setInterval(() => {
       if (!this.isReady || !this.config || this.backgroundedAt !== null) return;
@@ -2048,6 +2367,11 @@ var GuidelyClient = class {
     if (this.destroyed) return;
     const before = this.config?.configVersion;
     await this.fetchConfig();
+    this.applyConfigChange(before);
+  }
+  /** Re-renders after a config change (refresh, or a config that arrived after start). */
+  applyConfigChange(before) {
+    if (this.destroyed || !this.isReady) return;
     if (this.config && this.config.configVersion !== before) {
       this.notify();
       this.evaluate("ready");
@@ -2061,6 +2385,7 @@ var GuidelyClient = class {
       this.session.lastActiveAt = nowIso();
       this.persistSession();
       void this.queue?.flush();
+      void this.outbox?.flush();
       void this.store.flush();
       void this.flags.flush();
       this.messenger?.setForeground(false);
@@ -2074,7 +2399,7 @@ var GuidelyClient = class {
         this.firedDelays.clear();
       }
       void this.flags.refresh();
-      if (Date.now() - this.configFetchedAt > this.options.configRefreshMs) void this.refresh();
+      if (Date.now() - this.configFetchedAt > this.options.configRefreshMs && this.api.health.canSend()) void this.refresh();
       else if (this.isReady) this.evaluate("ready");
     }
   }
@@ -2100,6 +2425,7 @@ var GuidelyClient = class {
     this.cleanups.splice(0).forEach((fn) => fn());
     void this.queue?.flush();
     this.queue?.destroy();
+    this.outbox?.destroy();
     this.flags.destroy();
     this.emitter.clear();
     this.uiListeners.clear();
@@ -2513,7 +2839,13 @@ var GuidelyClient = class {
     if (reason === "completed") this.completeChecklistTasksBy("guide_completed", guide);
   }
   syncGuideState(guideId, update) {
-    void postWithRetry(this.api, "/guide-state", { anonymousId: this.anonymousId, userId: this.user?.id || null, updates: [{ guideId, ...update }] });
+    const body = { anonymousId: this.anonymousId, userId: this.user?.id || null, updates: [{ guideId, ...update }] };
+    if (update.impression) void postWithRetry(this.api, "/guide-state", body);
+    else this.sendDurably(`guide:${guideId}:${update.completed ? "completed" : "dismissed"}:${this.anonymousId}`, "/guide-state", body);
+  }
+  /** Queues a write in the persisted outbox (sent now, or once the API is reachable again). */
+  sendDurably(key, path, body) {
+    this.whenHydrated(() => this.outbox?.add(key, path, body));
   }
   show(guide, manual, stepId) {
     try {
@@ -2721,7 +3053,7 @@ var GuidelyClient = class {
     progress.dismissedAt = nowIso();
     this.persistState();
     this.enqueue("checklist_dismissed", { guideId: guide.id, guideVersion: guide.version });
-    void postWithRetry(this.api, `/checklists/${encodeURIComponent(guide.id)}/progress`, { anonymousId: this.anonymousId, userId: this.user?.id || null, guideVersion: guide.version, completedTaskIds: progress.completedTaskIds, dismissed: true });
+    this.sendDurably(`checklist:${guide.id}:dismissed:${this.anonymousId}`, `/checklists/${encodeURIComponent(guide.id)}/progress`, { anonymousId: this.anonymousId, userId: this.user?.id || null, guideVersion: guide.version, completedTaskIds: progress.completedTaskIds, dismissed: true });
     this.checklists.delete(guide.id);
     this.notify();
   }
@@ -2734,7 +3066,7 @@ var GuidelyClient = class {
     this.persistState();
     this.recordEnd(guide, "completed");
     this.enqueue("survey_submitted", { guideId: guide.id, guideVersion: guide.version, properties: { responseId } });
-    void postWithRetry(this.api, `/surveys/${encodeURIComponent(guide.id)}/responses`, { anonymousId: this.anonymousId, userId: this.user?.id || null, accountId: this.user?.account?.id || null, guideVersion: guide.version, answers, responseId });
+    this.sendDurably(`survey:${responseId}`, `/surveys/${encodeURIComponent(guide.id)}/responses`, { anonymousId: this.anonymousId, userId: this.user?.id || null, accountId: this.user?.account?.id || null, guideVersion: guide.version, answers, responseId });
     this.emitter.emit("survey:submit", { guide, answers, responseId });
     this.emitter.emit("guide:complete", guide);
     this.surveyView = { ...this.surveyView, submitted: true };
@@ -2791,7 +3123,7 @@ var GuidelyClient = class {
       this.enqueue("checklist_completed", { guideId: guide.id, guideVersion: guide.version });
     }
     this.persistState();
-    void postWithRetry(this.api, `/checklists/${encodeURIComponent(guide.id)}/progress`, { anonymousId: this.anonymousId, userId: this.user?.id || null, guideVersion: guide.version, completedTaskIds: progress.completedTaskIds, completed: !!progress.completedAt });
+    this.sendDurably(`checklist:${guide.id}:progress:${this.anonymousId}`, `/checklists/${encodeURIComponent(guide.id)}/progress`, { anonymousId: this.anonymousId, userId: this.user?.id || null, guideVersion: guide.version, completedTaskIds: progress.completedTaskIds, completed: !!progress.completedAt });
     this.emitter.emit("checklist:task", { guide, task, progress: this.getChecklistProgress(guide.id) });
     if (complete) {
       this.emitter.emit("checklist:complete", guide);
@@ -2928,7 +3260,8 @@ var GuidelyClient = class {
           },
           onMessage: (message, conversation) => this.emitter.emit("conversation:message", { message, conversation }),
           onStartGuide: (key) => this.setTimer(() => this.startGuide(key), 0),
-          onError: (err) => this.log("messenger", err instanceof Error ? err.message : err)
+          onError: (err) => this.log("messenger", err instanceof Error ? err.message : err),
+          health: this.api.health
         });
         this.resourceCenterOpen = false;
       }
@@ -3033,6 +3366,7 @@ var GuidelyClient = class {
       audienceIds: this.state.audienceIds,
       session: this.session,
       pendingEvents: this.queue?.size ?? 0,
+      pendingWrites: this.outbox?.size ?? 0,
       targets: this.targets.ids(),
       flagsReady: this.flags.isReady()
     };