lowdata 0.1.0

package/dist/forms.cjs

@@ -0,0 +1,1090 @@
+'use strict';
+
+// src/core/events.ts
+var Emitter = class {
+  constructor() {
+    this.listeners = /* @__PURE__ */ new Set();
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  emit(value) {
+    for (const listener of this.listeners) {
+      listener(value);
+    }
+  }
+  clear() {
+    this.listeners.clear();
+  }
+  get size() {
+    return this.listeners.size;
+  }
+};
+
+// src/core/id.ts
+function createId() {
+  const g = globalThis;
+  if (g.crypto && typeof g.crypto.randomUUID === "function") {
+    return g.crypto.randomUUID();
+  }
+  return `ld_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 10)}`;
+}
+
+// src/core/connection.ts
+var DEFAULT_SLOW_RTT_MS = 600;
+var DEFAULT_SLOW_DOWNLINK_MBPS = 0.5;
+var DEFAULT_PING_TIMEOUT_MS = 5e3;
+function hasNavigator() {
+  return typeof navigator !== "undefined";
+}
+var ConnectionMonitor = class {
+  constructor(options = {}) {
+    this.emitter = new Emitter();
+    this.disposed = false;
+    var _a, _b, _c;
+    this.options = {
+      pingUrl: options.pingUrl,
+      slowRttThresholdMs: (_a = options.slowRttThresholdMs) != null ? _a : DEFAULT_SLOW_RTT_MS,
+      slowDownlinkMbps: (_b = options.slowDownlinkMbps) != null ? _b : DEFAULT_SLOW_DOWNLINK_MBPS,
+      pingTimeoutMs: (_c = options.pingTimeoutMs) != null ? _c : DEFAULT_PING_TIMEOUT_MS
+    };
+    this.current = this.computeInfo();
+    if (hasNavigator() && typeof window !== "undefined") {
+      this.onlineHandler = () => {
+        this.refresh();
+        void this.probeNow();
+      };
+      this.offlineHandler = () => this.refresh();
+      window.addEventListener("online", this.onlineHandler);
+      window.addEventListener("offline", this.offlineHandler);
+      const conn = navigator.connection;
+      if (conn == null ? void 0 : conn.addEventListener) {
+        this.connectionChangeHandler = () => this.refresh();
+        conn.addEventListener("change", this.connectionChangeHandler);
+      }
+    }
+    if (this.options.pingUrl) {
+      void this.probeNow();
+    }
+  }
+  getStatus() {
+    return this.current;
+  }
+  subscribe(listener) {
+    return this.emitter.subscribe(listener);
+  }
+  /** Manually re-run the opt-in ping probe (no-op if no `pingUrl` was configured). */
+  async probeNow() {
+    if (!this.options.pingUrl || !hasNavigator() || navigator.onLine === false) {
+      return this.current;
+    }
+    const start = Date.now();
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), this.options.pingTimeoutMs);
+    try {
+      await fetch(this.options.pingUrl, {
+        method: "HEAD",
+        cache: "no-store",
+        signal: controller.signal
+      });
+      this.probedRttMs = Date.now() - start;
+    } catch {
+    } finally {
+      clearTimeout(timer);
+    }
+    return this.refresh();
+  }
+  destroy() {
+    var _a;
+    if (this.disposed) return;
+    this.disposed = true;
+    if (typeof window !== "undefined") {
+      if (this.onlineHandler) window.removeEventListener("online", this.onlineHandler);
+      if (this.offlineHandler) window.removeEventListener("offline", this.offlineHandler);
+    }
+    if (hasNavigator() && this.connectionChangeHandler) {
+      const conn = navigator.connection;
+      (_a = conn == null ? void 0 : conn.removeEventListener) == null ? void 0 : _a.call(conn, "change", this.connectionChangeHandler);
+    }
+    this.emitter.clear();
+  }
+  refresh() {
+    this.current = this.computeInfo();
+    this.emitter.emit(this.current);
+    return this.current;
+  }
+  computeInfo() {
+    if (!hasNavigator()) {
+      return { quality: "online", online: true };
+    }
+    const online = navigator.onLine !== false;
+    if (!online) {
+      return { quality: "offline", online: false };
+    }
+    const conn = navigator.connection;
+    if (conn) {
+      const info = {
+        quality: "online",
+        online: true,
+        effectiveType: conn.effectiveType,
+        downlinkMbps: conn.downlink,
+        rttMs: conn.rtt,
+        saveData: conn.saveData
+      };
+      const isSlow = conn.saveData === true || conn.effectiveType === "2g" || conn.effectiveType === "slow-2g" || typeof conn.downlink === "number" && conn.downlink < this.options.slowDownlinkMbps || typeof conn.rtt === "number" && conn.rtt > this.options.slowRttThresholdMs;
+      return { ...info, quality: isSlow ? "slow" : "online" };
+    }
+    const quality = typeof this.probedRttMs === "number" && this.probedRttMs > this.options.slowRttThresholdMs ? "slow" : "online";
+    return {
+      quality,
+      online: true,
+      rttMs: this.probedRttMs
+    };
+  }
+};
+
+// src/core/idb.ts
+function isIndexedDbAvailable() {
+  try {
+    return typeof indexedDB !== "undefined" && indexedDB !== null;
+  } catch {
+    return false;
+  }
+}
+function openDatabase(name, version, stores) {
+  if (!isIndexedDbAvailable()) {
+    return Promise.reject(new Error("lowdata: IndexedDB is not available in this environment"));
+  }
+  return new Promise((resolve, reject) => {
+    const request = indexedDB.open(name, version);
+    request.onupgradeneeded = () => {
+      var _a, _b;
+      const db = request.result;
+      for (const store of stores) {
+        if (db.objectStoreNames.contains(store.name)) continue;
+        const objectStore = db.createObjectStore(store.name, { keyPath: store.keyPath });
+        for (const index of (_a = store.indexes) != null ? _a : []) {
+          objectStore.createIndex(index.name, index.keyPath, { unique: (_b = index.unique) != null ? _b : false });
+        }
+      }
+    };
+    request.onsuccess = () => resolve(request.result);
+    request.onerror = () => {
+      var _a;
+      return reject((_a = request.error) != null ? _a : new Error("lowdata: failed to open IndexedDB database"));
+    };
+    request.onblocked = () => reject(new Error("lowdata: IndexedDB open blocked by another connection"));
+  });
+}
+function wrapRequest(request) {
+  return new Promise((resolve, reject) => {
+    request.onsuccess = () => resolve(request.result);
+    request.onerror = () => {
+      var _a;
+      return reject((_a = request.error) != null ? _a : new Error("lowdata: IndexedDB request failed"));
+    };
+  });
+}
+function wrapTransaction(tx) {
+  return new Promise((resolve, reject) => {
+    tx.oncomplete = () => resolve();
+    tx.onerror = () => {
+      var _a;
+      return reject((_a = tx.error) != null ? _a : new Error("lowdata: IndexedDB transaction failed"));
+    };
+    tx.onabort = () => {
+      var _a;
+      return reject((_a = tx.error) != null ? _a : new Error("lowdata: IndexedDB transaction aborted"));
+    };
+  });
+}
+async function idbPut(db, storeName, value) {
+  const tx = db.transaction(storeName, "readwrite");
+  tx.objectStore(storeName).put(value);
+  await wrapTransaction(tx);
+}
+async function idbGet(db, storeName, key) {
+  const tx = db.transaction(storeName, "readonly");
+  return wrapRequest(tx.objectStore(storeName).get(key));
+}
+async function idbDelete(db, storeName, key) {
+  const tx = db.transaction(storeName, "readwrite");
+  tx.objectStore(storeName).delete(key);
+  await wrapTransaction(tx);
+}
+async function idbGetAll(db, storeName, options) {
+  const tx = db.transaction(storeName, "readonly");
+  const source = (options == null ? void 0 : options.indexName) ? tx.objectStore(storeName).index(options.indexName) : tx.objectStore(storeName);
+  return wrapRequest(source.getAll(options == null ? void 0 : options.query));
+}
+async function idbClear(db, storeName) {
+  const tx = db.transaction(storeName, "readwrite");
+  tx.objectStore(storeName).clear();
+  await wrapTransaction(tx);
+}
+var LOWDATA_DB_NAME = "lowdata";
+var LOWDATA_DB_VERSION = 1;
+var LOWDATA_STORES = [
+  {
+    name: "queue",
+    keyPath: "id",
+    indexes: [
+      { name: "status", keyPath: "status" },
+      { name: "priority", keyPath: "priority" },
+      { name: "nextAttemptAt", keyPath: "nextAttemptAt" }
+    ]
+  },
+  { name: "meta", keyPath: "key" },
+  {
+    name: "formDrafts",
+    keyPath: "submissionId",
+    indexes: [{ name: "formId", keyPath: "formId" }]
+  }
+];
+var sharedDbPromise;
+function getSharedDb() {
+  if (!sharedDbPromise) {
+    sharedDbPromise = openDatabase(LOWDATA_DB_NAME, LOWDATA_DB_VERSION, LOWDATA_STORES).catch(
+      (err) => {
+        sharedDbPromise = void 0;
+        throw err;
+      }
+    );
+  }
+  return sharedDbPromise;
+}
+function createDbFallbackAccessor(getDb) {
+  let dbAvailable = true;
+  return {
+    async run(fn, fallback) {
+      if (!dbAvailable) return fallback();
+      try {
+        const db = await getDb();
+        return await fn(db);
+      } catch {
+        dbAvailable = false;
+        return fallback();
+      }
+    },
+    isPersistent: () => dbAvailable
+  };
+}
+
+// src/network/errors.ts
+var LowdataRequestError = class extends Error {
+  constructor(message, init) {
+    var _a, _b;
+    super(message, init.cause !== void 0 ? { cause: init.cause } : void 0);
+    this.name = "LowdataRequestError";
+    this.status = init.status;
+    this.isNetworkError = (_a = init.isNetworkError) != null ? _a : false;
+    this.isTimeout = (_b = init.isTimeout) != null ? _b : false;
+    this.attempt = init.attempt;
+    this.retryAfterMs = init.retryAfterMs;
+  }
+};
+
+// src/network/queue.ts
+var STORE = "queue";
+var PRIORITY_ORDER = { high: 0, normal: 1, low: 2 };
+var RequestQueue = class {
+  constructor(getDb) {
+    this.memory = /* @__PURE__ */ new Map();
+    this.accessor = createDbFallbackAccessor(getDb);
+  }
+  isPersistent() {
+    return this.accessor.isPersistent();
+  }
+  async add(item) {
+    return this.accessor.run(
+      async (db) => {
+        await idbPut(db, STORE, item);
+        return item;
+      },
+      () => {
+        this.memory.set(item.id, item);
+        return item;
+      }
+    );
+  }
+  async update(item) {
+    await this.accessor.run(
+      async (db) => {
+        await idbPut(db, STORE, item);
+      },
+      () => {
+        this.memory.set(item.id, item);
+      }
+    );
+  }
+  async get(id) {
+    return this.accessor.run(
+      (db) => idbGet(db, STORE, id),
+      () => this.memory.get(id)
+    );
+  }
+  async remove(id) {
+    await this.accessor.run(
+      (db) => idbDelete(db, STORE, id),
+      () => {
+        this.memory.delete(id);
+      }
+    );
+  }
+  /** Filtering by status queries the `status` index rather than scanning the whole store. */
+  async list(filter) {
+    if (filter == null ? void 0 : filter.status) {
+      const status = filter.status;
+      return this.accessor.run(
+        (db) => idbGetAll(db, STORE, { indexName: "status", query: status }),
+        () => Array.from(this.memory.values()).filter((item) => item.status === status)
+      );
+    }
+    return this.accessor.run(
+      (db) => idbGetAll(db, STORE),
+      () => Array.from(this.memory.values())
+    );
+  }
+  async clear() {
+    await this.accessor.run(
+      (db) => idbClear(db, STORE),
+      () => {
+        this.memory.clear();
+      }
+    );
+  }
+  /** Items ready to send now: `pending` and due, sorted by priority then insertion order. */
+  async selectEligible(now) {
+    const pending = await this.list({ status: "pending" });
+    return pending.filter((item) => item.nextAttemptAt <= now).sort((a, b) => {
+      const byPriority = PRIORITY_ORDER[a.priority] - PRIORITY_ORDER[b.priority];
+      return byPriority !== 0 ? byPriority : a.createdAt - b.createdAt;
+    });
+  }
+  /** Revive items stuck in `sending` longer than `staleAfterMs` (recovers from a crash mid-send). */
+  async sweepStale(staleAfterMs, now) {
+    const sending = await this.list({ status: "sending" });
+    const revived = [];
+    for (const item of sending) {
+      if (now - item.updatedAt > staleAfterMs) {
+        const next = { ...item, status: "pending", updatedAt: now };
+        await this.update(next);
+        revived.push(next);
+      }
+    }
+    return revived;
+  }
+};
+
+// src/core/backoff.ts
+function computeBackoffDelay(attempt, config) {
+  const safeAttempt = Math.max(0, attempt);
+  const exp = Math.min(config.maxDelayMs, config.baseDelayMs * 2 ** safeAttempt);
+  switch (config.jitter) {
+    case "none":
+      return exp;
+    case "equal":
+      return exp / 2 + Math.random() * (exp / 2);
+    case "full":
+    default:
+      return Math.random() * exp;
+  }
+}
+
+// src/core/abortAny.ts
+function combineSignals(signals) {
+  const controller = new AbortController();
+  const active = signals.filter((s) => Boolean(s));
+  const onAbort = (source) => () => {
+    if (!controller.signal.aborted) {
+      controller.abort(source.reason);
+    }
+  };
+  const cleanups = [];
+  for (const s of active) {
+    if (s.aborted) {
+      controller.abort(s.reason);
+      break;
+    }
+    const handler = onAbort(s);
+    s.addEventListener("abort", handler, { once: true });
+    cleanups.push(() => s.removeEventListener("abort", handler));
+  }
+  return {
+    signal: controller.signal,
+    dispose: () => {
+      for (const cleanup of cleanups) cleanup();
+    }
+  };
+}
+
+// src/core/types.ts
+var DEFAULT_RETRY_CONFIG = {
+  maxRetries: 8,
+  baseDelayMs: 500,
+  maxDelayMs: 3e4,
+  jitter: "full"
+};
+
+// src/network/retry.ts
+var RETRYABLE_STATUS = /* @__PURE__ */ new Set([429, 502, 503, 504]);
+function isRetryableStatus(status) {
+  return RETRYABLE_STATUS.has(status);
+}
+function defaultRetryOn(error) {
+  if (error.isNetworkError || error.isTimeout) return true;
+  return typeof error.status === "number" && RETRYABLE_STATUS.has(error.status);
+}
+function parseRetryAfterMs(response) {
+  const header = response.headers.get("Retry-After");
+  if (!header) return void 0;
+  const seconds = Number(header);
+  if (!Number.isNaN(seconds)) return seconds * 1e3;
+  const dateMs = Date.parse(header);
+  if (!Number.isNaN(dateMs)) return Math.max(0, dateMs - Date.now());
+  return void 0;
+}
+function sleep(ms, signal) {
+  return new Promise((resolve, reject) => {
+    var _a;
+    if (signal == null ? void 0 : signal.aborted) {
+      reject((_a = signal.reason) != null ? _a : new Error("lowdata: aborted"));
+      return;
+    }
+    const timer = setTimeout(resolve, ms);
+    signal == null ? void 0 : signal.addEventListener(
+      "abort",
+      () => {
+        var _a2;
+        clearTimeout(timer);
+        reject((_a2 = signal.reason) != null ? _a2 : new Error("lowdata: aborted"));
+      },
+      { once: true }
+    );
+  });
+}
+var DEFAULT_TIMEOUT_MS = 15e3;
+async function attemptWithRetry(options) {
+  var _a, _b, _c, _d;
+  const config = { ...DEFAULT_RETRY_CONFIG, ...options.retryConfig };
+  const retryOn = (_a = config.retryOn) != null ? _a : defaultRetryOn;
+  const timeoutMs = (_b = options.timeoutMs) != null ? _b : DEFAULT_TIMEOUT_MS;
+  let lastError;
+  for (let attempt = 0; attempt <= config.maxRetries; attempt++) {
+    const timeoutController = new AbortController();
+    const timer = setTimeout(() => timeoutController.abort(), timeoutMs);
+    const combined = combineSignals([options.signal, timeoutController.signal]);
+    try {
+      const response = await fetch(options.url, { ...options.init, signal: combined.signal });
+      clearTimeout(timer);
+      combined.dispose();
+      if (response.ok || !RETRYABLE_STATUS.has(response.status)) {
+        return response;
+      }
+      lastError = new LowdataRequestError(`Request failed with status ${response.status}`, {
+        status: response.status,
+        attempt,
+        retryAfterMs: parseRetryAfterMs(response)
+      });
+    } catch (cause) {
+      clearTimeout(timer);
+      combined.dispose();
+      if ((_c = options.signal) == null ? void 0 : _c.aborted) {
+        throw cause;
+      }
+      const isTimeout = timeoutController.signal.aborted;
+      lastError = new LowdataRequestError(
+        isTimeout ? "Request timed out" : "Network request failed",
+        { isNetworkError: !isTimeout, isTimeout, attempt, cause }
+      );
+    }
+    const isLastAttempt = attempt === config.maxRetries;
+    const continueRetrying = options.shouldContinue ? options.shouldContinue() : true;
+    if (isLastAttempt || !continueRetrying || !retryOn(lastError, attempt)) {
+      throw lastError;
+    }
+    const delay = (_d = lastError.retryAfterMs) != null ? _d : computeBackoffDelay(attempt, config);
+    await sleep(Math.min(delay, config.maxDelayMs), options.signal);
+  }
+  throw lastError != null ? lastError : new LowdataRequestError("Request failed", { attempt: config.maxRetries });
+}
+
+// src/core/lock.ts
+var LOCK_STALE_AFTER_MS = 15e3;
+function getLockManager() {
+  if (typeof navigator === "undefined") return void 0;
+  return navigator.locks;
+}
+function acquireWebLock(locks, name) {
+  return new Promise((resolveOuter) => {
+    locks.request(name, { ifAvailable: true }, (lock) => {
+      if (!lock) {
+        resolveOuter(void 0);
+        return;
+      }
+      return new Promise((resolveInner) => {
+        resolveOuter({
+          release: async () => resolveInner(),
+          renew: async () => {
+          }
+        });
+      });
+    }).catch(() => resolveOuter(void 0));
+  });
+}
+async function acquireIdbLock(db, name, ownerId) {
+  const key = `syncLock:${name}`;
+  const now = Date.now();
+  const existing = await idbGet(db, "meta", key);
+  if (existing && existing.expiresAt > now && existing.ownerId !== ownerId) {
+    return void 0;
+  }
+  await idbPut(db, "meta", { key, ownerId, expiresAt: now + LOCK_STALE_AFTER_MS });
+  return {
+    release: async () => {
+      const current = await idbGet(db, "meta", key);
+      if ((current == null ? void 0 : current.ownerId) === ownerId) {
+        await idbDelete(db, "meta", key);
+      }
+    },
+    renew: async () => {
+      await idbPut(db, "meta", {
+        key,
+        ownerId,
+        expiresAt: Date.now() + LOCK_STALE_AFTER_MS
+      });
+    }
+  };
+}
+async function acquireSyncLock(db, name, ownerId) {
+  const locks = getLockManager();
+  if (locks) {
+    return acquireWebLock(locks, name);
+  }
+  if (!db) return void 0;
+  return acquireIdbLock(db, name, ownerId);
+}
+
+// src/network/sync.ts
+var STALE_SENDING_MS = 6e4;
+var SAFETY_POLL_MS = 3e4;
+var SYNC_LOCK_NAME = "lowdata-sync";
+var CANCELLED = /* @__PURE__ */ Symbol("lowdata-cancelled");
+var SyncManager = class {
+  constructor(opts) {
+    this.opts = opts;
+    this.ownerId = createId();
+    this.inFlight = /* @__PURE__ */ new Map();
+    this.draining = false;
+    this.disposed = false;
+    var _a;
+    this.retryConfig = { ...DEFAULT_RETRY_CONFIG, ...opts.retryConfig };
+    this.syncConcurrency = Math.max(1, (_a = opts.syncConcurrency) != null ? _a : 1);
+    this.unsubscribeConnection = this.opts.connection.subscribe((info) => {
+      if (info.quality !== "offline") void this.drain();
+    });
+    if (typeof document !== "undefined" && typeof setInterval !== "undefined") {
+      this.safetyTimer = setInterval(() => {
+        if (document.visibilityState === "visible") void this.drain();
+      }, SAFETY_POLL_MS);
+    }
+  }
+  /** Call after enqueueing a new item so a high-priority item is picked up without waiting for the next trigger. */
+  notifyEnqueued() {
+    if (this.opts.connection.getStatus().quality !== "offline") void this.drain();
+  }
+  cancel(id) {
+    var _a;
+    (_a = this.inFlight.get(id)) == null ? void 0 : _a.abort(CANCELLED);
+    this.inFlight.delete(id);
+  }
+  /**
+   * Never throws/rejects — `drain()` is always invoked fire-and-forget (`void this.drain()`) from
+   * event listeners, so any failure here (e.g. the shared IndexedDB connection was closed
+   * mid-drain) is swallowed rather than surfacing as an unhandled rejection; the next reconnect
+   * or safety poll simply tries again.
+   */
+  async drain() {
+    var _a, _b, _c, _d;
+    if (this.draining || this.disposed) return;
+    if (this.opts.connection.getStatus().quality === "offline") return;
+    this.draining = true;
+    try {
+      const db = await this.opts.getDb().catch(() => void 0);
+      const lock = await acquireSyncLock(db, SYNC_LOCK_NAME, this.ownerId);
+      if (!lock) return;
+      let succeeded = 0;
+      let failed = 0;
+      try {
+        await this.opts.queue.sweepStale(STALE_SENDING_MS, Date.now());
+        const initialEligible = await this.opts.queue.selectEligible(Date.now());
+        if (initialEligible.length === 0) return;
+        (_b = (_a = this.opts).onEvent) == null ? void 0 : _b.call(_a, { type: "sync-start", pending: initialEligible.length });
+        while (!this.disposed && this.opts.connection.getStatus().quality !== "offline") {
+          const eligible = await this.opts.queue.selectEligible(Date.now());
+          if (eligible.length === 0) break;
+          const batch = eligible.slice(0, this.syncConcurrency);
+          const results = await Promise.all(batch.map((item) => this.sendItem(item)));
+          succeeded += results.filter(Boolean).length;
+          failed += results.filter((ok) => !ok).length;
+        }
+        (_d = (_c = this.opts).onEvent) == null ? void 0 : _d.call(_c, { type: "sync-complete", succeeded, failed });
+      } finally {
+        await lock.release().catch(() => {
+        });
+      }
+    } catch {
+    } finally {
+      this.draining = false;
+    }
+  }
+  destroy() {
+    this.disposed = true;
+    this.unsubscribeConnection();
+    if (this.safetyTimer) clearInterval(this.safetyTimer);
+    for (const controller of this.inFlight.values()) controller.abort(CANCELLED);
+    this.inFlight.clear();
+  }
+  async sendItem(item) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l;
+    const controller = new AbortController();
+    this.inFlight.set(item.id, controller);
+    const timeoutMs = (_a = item.timeoutMs) != null ? _a : DEFAULT_TIMEOUT_MS;
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    const sendingItem = { ...item, status: "sending", updatedAt: Date.now() };
+    await this.opts.queue.update(sendingItem);
+    (_c = (_b = this.opts).onEvent) == null ? void 0 : _c.call(_b, { type: "item-start", item: sendingItem });
+    const retryConfig = { ...this.retryConfig, ...item.retry };
+    const retryOn = (_d = retryConfig.retryOn) != null ? _d : defaultRetryOn;
+    let requestError;
+    try {
+      const response = await fetch(item.url, {
+        method: item.method,
+        headers: item.headers,
+        body: (_e = item.body) != null ? _e : void 0,
+        signal: controller.signal
+      });
+      if (response.ok || !isRetryableStatus(response.status)) {
+        const doneItem = { ...sendingItem, status: "done", updatedAt: Date.now() };
+        await this.opts.queue.remove(doneItem.id);
+        (_g = (_f = this.opts).onEvent) == null ? void 0 : _g.call(_f, { type: "item-success", item: doneItem });
+        return true;
+      }
+      requestError = new LowdataRequestError(`Request failed with status ${response.status}`, {
+        status: response.status,
+        attempt: item.attempts,
+        retryAfterMs: parseRetryAfterMs(response)
+      });
+    } catch (cause) {
+      if (controller.signal.reason === CANCELLED) {
+        const cancelledItem = {
+          ...sendingItem,
+          status: "cancelled",
+          updatedAt: Date.now()
+        };
+        await this.opts.queue.update(cancelledItem);
+        (_i = (_h = this.opts).onEvent) == null ? void 0 : _i.call(_h, { type: "item-failed", item: cancelledItem, willRetry: false });
+        return false;
+      }
+      const isTimeout = controller.signal.aborted && controller.signal.reason !== CANCELLED;
+      requestError = new LowdataRequestError(
+        isTimeout ? "Request timed out" : "Network request failed",
+        { isNetworkError: !isTimeout, isTimeout, attempt: item.attempts, cause }
+      );
+    } finally {
+      clearTimeout(timer);
+      this.inFlight.delete(item.id);
+    }
+    const attempts = item.attempts + 1;
+    const willRetry = attempts <= retryConfig.maxRetries && retryOn(requestError, item.attempts);
+    const rawDelay = (_j = requestError.retryAfterMs) != null ? _j : computeBackoffDelay(item.attempts, retryConfig);
+    const nextAttemptAt = willRetry ? Date.now() + Math.min(rawDelay, retryConfig.maxDelayMs) : sendingItem.nextAttemptAt;
+    const resultItem = {
+      ...sendingItem,
+      attempts,
+      status: willRetry ? "pending" : "failed",
+      nextAttemptAt,
+      lastError: requestError.message,
+      updatedAt: Date.now()
+    };
+    await this.opts.queue.update(resultItem);
+    (_l = (_k = this.opts).onEvent) == null ? void 0 : _l.call(_k, { type: "item-failed", item: resultItem, willRetry });
+    return false;
+  }
+};
+
+// src/network/client.ts
+var DEFAULT_MAX_QUEUE_ITEM_BYTES = 5 * 1024 * 1024;
+var MUTATING_METHODS = /* @__PURE__ */ new Set(["POST", "PUT", "PATCH", "DELETE"]);
+function defaultShouldQueueOffline({ method }) {
+  return MUTATING_METHODS.has(method);
+}
+function normalizeHeaders(headers) {
+  if (!headers) return void 0;
+  if (headers instanceof Headers) {
+    const out = {};
+    headers.forEach((value, key) => {
+      out[key] = value;
+    });
+    return out;
+  }
+  if (Array.isArray(headers)) return Object.fromEntries(headers);
+  return { ...headers };
+}
+function normalizeQueueableBody(body) {
+  if (body == null) return null;
+  if (typeof body === "string" || body instanceof Blob) return body;
+  throw new TypeError(
+    "lowdata: only string or Blob request bodies can be queued for offline delivery. Serialize your payload (e.g. JSON.stringify) or pass a Blob/File before queuing."
+  );
+}
+function bodySizeBytes(body) {
+  if (body === null) return 0;
+  return typeof body === "string" ? new Blob([body]).size : body.size;
+}
+var LowdataClient = class {
+  constructor(config = {}) {
+    this.config = config;
+    this.syncEmitter = new Emitter();
+    this.destroyed = false;
+    this.monitor = new ConnectionMonitor(config.connection);
+    this.requestQueue = new RequestQueue(() => getSharedDb());
+    this.syncManager = new SyncManager({
+      queue: this.requestQueue,
+      connection: this.monitor,
+      getDb: () => getSharedDb(),
+      retryConfig: config.retry,
+      syncConcurrency: config.syncConcurrency,
+      onEvent: (event) => this.syncEmitter.emit(event)
+    });
+    this.connection = {
+      getStatus: () => this.monitor.getStatus(),
+      subscribe: (listener) => this.monitor.subscribe(listener)
+    };
+    this.queue = {
+      add: (item) => this.enqueue(item),
+      cancel: (id) => this.cancelQueued(id),
+      list: (filter) => this.requestQueue.list(filter),
+      clear: () => this.requestQueue.clear()
+    };
+  }
+  onSync(listener) {
+    return this.syncEmitter.subscribe(listener);
+  }
+  /**
+   * Drop-in `fetch()` wrapper: retries transient failures with backoff, and — for mutating
+   * requests that still can't get through — falls back to the persistent offline queue instead
+   * of losing the request. Returns a `QueuedResult` (check with `isQueued()`) when queued.
+   */
+  async fetch(url, init = {}) {
+    var _a, _b, _c, _d;
+    if (this.destroyed) throw new Error("lowdata: this client has been destroyed");
+    const fullUrl = this.resolveUrl(url);
+    const method = ((_a = init.method) != null ? _a : "GET").toUpperCase();
+    const shouldQueueOffline = (_b = this.config.shouldQueueOffline) != null ? _b : defaultShouldQueueOffline;
+    const canQueue = shouldQueueOffline({ url: fullUrl, method });
+    const isOffline = this.monitor.getStatus().quality === "offline";
+    if ((init.forceQueue || isOffline) && canQueue) {
+      return this.enqueueFromInit(fullUrl, method, init);
+    }
+    if (init.forceQueue || isOffline) {
+      throw new LowdataRequestError("Offline and this request is not configured to be queued", {
+        isNetworkError: true,
+        attempt: 0
+      });
+    }
+    try {
+      return await attemptWithRetry({
+        url: fullUrl,
+        init: {
+          ...init,
+          headers: { ...this.config.defaultHeaders, ...normalizeHeaders(init.headers) }
+        },
+        retryConfig: { ...this.config.retry, ...init.retry },
+        timeoutMs: init.timeoutMs,
+        signal: (_c = init.signal) != null ? _c : void 0,
+        shouldContinue: () => this.monitor.getStatus().quality !== "offline"
+      });
+    } catch (err) {
+      if ((_d = init.signal) == null ? void 0 : _d.aborted) throw err;
+      if (canQueue) {
+        return this.enqueueFromInit(fullUrl, method, init);
+      }
+      throw err;
+    }
+  }
+  destroy() {
+    if (this.destroyed) return;
+    this.destroyed = true;
+    this.syncManager.destroy();
+    this.monitor.destroy();
+    this.syncEmitter.clear();
+  }
+  resolveUrl(url) {
+    if (!this.config.baseUrl || /^[a-z][a-z0-9+.-]*:\/\//i.test(url)) return url;
+    return `${this.config.baseUrl.replace(/\/$/, "")}/${url.replace(/^\//, "")}`;
+  }
+  maxQueueItemBytes() {
+    var _a;
+    return (_a = this.config.maxQueueItemSizeBytes) != null ? _a : DEFAULT_MAX_QUEUE_ITEM_BYTES;
+  }
+  assertWithinSizeBudget(body) {
+    const size = bodySizeBytes(body);
+    const max = this.maxQueueItemBytes();
+    if (size > max) {
+      throw new RangeError(
+        `lowdata: request body (${size} bytes) exceeds maxQueueItemSizeBytes (${max} bytes).`
+      );
+    }
+  }
+  /**
+   * Shared by `enqueueFromInit` (the `fetch()` fallback path) and `enqueue` (the direct
+   * `queue.add()` path) — the only difference between the two call sites is where the fields come
+   * from, not how a queue item gets constructed, persisted, and announced to the sync manager.
+   */
+  async persistNewQueueItem(fields) {
+    const body = normalizeQueueableBody(fields.body);
+    this.assertWithinSizeBudget(body);
+    const now = Date.now();
+    const item = {
+      ...fields,
+      body,
+      id: createId(),
+      createdAt: now,
+      updatedAt: now,
+      attempts: 0,
+      status: "pending",
+      nextAttemptAt: now
+    };
+    const saved = await this.requestQueue.add(item);
+    this.syncManager.notifyEnqueued();
+    return saved;
+  }
+  async enqueueFromInit(url, method, init) {
+    var _a;
+    const saved = await this.persistNewQueueItem({
+      url,
+      method,
+      headers: { ...this.config.defaultHeaders, ...normalizeHeaders(init.headers) },
+      body: init.body,
+      priority: (_a = init.priority) != null ? _a : "normal",
+      meta: init.meta,
+      timeoutMs: init.timeoutMs,
+      retry: init.retry,
+      idempotencyKey: init.idempotencyKey
+    });
+    return { queued: true, id: saved.id, item: saved };
+  }
+  async enqueue(partial) {
+    return this.persistNewQueueItem(partial);
+  }
+  async cancelQueued(id) {
+    this.syncManager.cancel(id);
+    const item = await this.requestQueue.get(id);
+    if (item && item.status !== "done" && item.status !== "cancelled") {
+      await this.requestQueue.update({ ...item, status: "cancelled", updatedAt: Date.now() });
+    }
+  }
+};
+function createLowdataClient(config) {
+  return new LowdataClient(config);
+}
+
+// src/network/types.ts
+function isQueued(result) {
+  return typeof result === "object" && result !== null && result.queued === true;
+}
+
+// src/forms/storage.ts
+var STORE2 = "formDrafts";
+function draftKey(formId) {
+  return `draft:${formId}`;
+}
+var memory = /* @__PURE__ */ new Map();
+var accessor = createDbFallbackAccessor(getSharedDb);
+async function saveDraft(formId, values) {
+  var _a;
+  const key = draftKey(formId);
+  const now = Date.now();
+  const existing = await getSubmission(key);
+  const record = {
+    submissionId: key,
+    formId,
+    kind: "draft",
+    values,
+    status: "saved",
+    createdAt: (_a = existing == null ? void 0 : existing.createdAt) != null ? _a : now,
+    updatedAt: now
+  };
+  await saveSubmission(record);
+  return record;
+}
+async function loadDraft(formId) {
+  return getSubmission(draftKey(formId));
+}
+async function discardDraft(formId) {
+  const key = draftKey(formId);
+  await accessor.run(
+    (db) => idbDelete(db, STORE2, key),
+    () => {
+      memory.delete(key);
+    }
+  );
+}
+async function saveSubmission(record) {
+  await accessor.run(
+    (db) => idbPut(db, STORE2, record),
+    () => {
+      memory.set(record.submissionId, record);
+    }
+  );
+}
+async function getSubmission(submissionId) {
+  return accessor.run(
+    (db) => idbGet(db, STORE2, submissionId),
+    () => memory.get(submissionId)
+  );
+}
+
+// src/forms/offlineForm.ts
+var defaultClient;
+function getDefaultClient() {
+  if (!defaultClient) defaultClient = createLowdataClient();
+  return defaultClient;
+}
+function createOfflineForm(config) {
+  var _a;
+  const client = (_a = config.client) != null ? _a : getDefaultClient();
+  const emitter = new Emitter();
+  let status = "idle";
+  let lastValues;
+  let activeSubmissionId;
+  let unsubscribeSync;
+  void loadDraft(config.id).then((draft) => {
+    if (draft && status === "idle") {
+      lastValues = draft.values;
+      setStatus("saved");
+    }
+  });
+  function setStatus(next, detail) {
+    var _a2;
+    status = next;
+    (_a2 = config.onStatusChange) == null ? void 0 : _a2.call(config, next, detail);
+    emitter.emit({ status: next, detail });
+  }
+  async function patchSubmission(submissionId, patch) {
+    const existing = await getSubmission(submissionId);
+    if (!existing) return;
+    await saveSubmission({ ...existing, ...patch, updatedAt: Date.now() });
+  }
+  async function onSubmissionSettled(submissionId, next, error) {
+    await patchSubmission(submissionId, { status: next, lastError: error });
+    const isActive = submissionId === activeSubmissionId;
+    if (next === "success" && isActive) {
+      await discardDraft(config.id);
+    }
+    if (isActive) {
+      setStatus(next, { submissionId, error });
+    }
+  }
+  function ensureSyncSubscription() {
+    if (unsubscribeSync) return;
+    unsubscribeSync = client.onSync((event) => {
+      var _a2;
+      if (event.type === "sync-start" || event.type === "sync-complete") return;
+      const submissionId = (_a2 = event.item.meta) == null ? void 0 : _a2["submissionId"];
+      if (typeof submissionId !== "string" || submissionId !== activeSubmissionId) return;
+      if (event.type === "item-start") {
+        void patchSubmission(submissionId, { status: "syncing" });
+        setStatus("syncing", { submissionId });
+      } else if (event.type === "item-success") {
+        void onSubmissionSettled(submissionId, "success");
+      } else if (event.type === "item-failed") {
+        if (event.willRetry) {
+          void patchSubmission(submissionId, {
+            status: "pending",
+            lastError: event.item.lastError
+          });
+          setStatus("pending", { submissionId, error: event.item.lastError });
+        } else {
+          void onSubmissionSettled(submissionId, "failed", event.item.lastError);
+        }
+      }
+    });
+  }
+  async function save(values) {
+    lastValues = values;
+    await saveDraft(config.id, values);
+    setStatus("saved");
+  }
+  async function submit(values) {
+    var _a2;
+    await save(values);
+    const submissionId = createId();
+    activeSubmissionId = submissionId;
+    const payload = config.transform ? config.transform(values) : JSON.stringify(values);
+    const body = typeof payload === "string" ? payload : JSON.stringify(payload);
+    await saveSubmission({
+      submissionId,
+      formId: config.id,
+      kind: "submission",
+      values,
+      status: "pending",
+      createdAt: Date.now(),
+      updatedAt: Date.now()
+    });
+    setStatus("pending", { submissionId });
+    ensureSyncSubscription();
+    const result = await client.fetch(config.endpoint, {
+      method: (_a2 = config.method) != null ? _a2 : "POST",
+      headers: { "Content-Type": "application/json" },
+      body,
+      meta: { formId: config.id, submissionId },
+      idempotencyKey: submissionId
+    });
+    if (isQueued(result)) {
+      await patchSubmission(submissionId, { status: "pending", queueId: result.id });
+      setStatus("pending", { submissionId });
+    } else if (result.ok) {
+      await onSubmissionSettled(submissionId, "success");
+    } else {
+      await onSubmissionSettled(
+        submissionId,
+        "failed",
+        `Request failed with status ${result.status}`
+      );
+    }
+    return { status };
+  }
+  async function retry() {
+    if (!lastValues) return;
+    await submit(lastValues);
+  }
+  function destroy() {
+    unsubscribeSync == null ? void 0 : unsubscribeSync();
+    unsubscribeSync = void 0;
+  }
+  async function discard() {
+    await discardDraft(config.id);
+    lastValues = void 0;
+    activeSubmissionId = void 0;
+    destroy();
+    setStatus("idle");
+  }
+  return {
+    save,
+    submit,
+    retry,
+    getStatus: () => status,
+    subscribe: (callback) => emitter.subscribe(({ status: s, detail }) => callback(s, detail)),
+    discard,
+    destroy
+  };
+}
+
+exports.createOfflineForm = createOfflineForm;
+//# sourceMappingURL=forms.cjs.map
+//# sourceMappingURL=forms.cjs.map