@noy-db/hub 0.1.0-pre.3

package/dist/store/index.cjs

@@ -0,0 +1,1069 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/store/index.ts
+var store_exports = {};
+__export(store_exports, {
+  BUNDLE_STORE_POLICY: () => BUNDLE_STORE_POLICY,
+  INDEXED_STORE_POLICY: () => INDEXED_STORE_POLICY,
+  SyncScheduler: () => SyncScheduler,
+  createBundleStore: () => createBundleStore,
+  routeStore: () => routeStore,
+  withCache: () => withCache,
+  withCircuitBreaker: () => withCircuitBreaker,
+  withHealthCheck: () => withHealthCheck,
+  withLogging: () => withLogging,
+  withMetrics: () => withMetrics,
+  withRetry: () => withRetry,
+  wrapBundleStore: () => wrapBundleStore,
+  wrapStore: () => wrapStore
+});
+module.exports = __toCommonJS(store_exports);
+
+// src/store/route-store.ts
+var BLOB_CHUNKS = "_blob_chunks";
+var BLOB_INDEX = "_blob_index";
+var BLOB_SLOTS = "_blob_slots_";
+var BLOB_VERSIONS = "_blob_versions_";
+function routeStore(opts) {
+  const primary = opts.default;
+  const blobsIsSimple = opts.blobs && "get" in opts.blobs;
+  const simpleBlobStore = blobsIsSimple ? opts.blobs : void 0;
+  const tieredBlobs = !blobsIsSimple ? opts.blobs : void 0;
+  const blobThreshold = tieredBlobs?.threshold ?? 400 * 1024;
+  const allStores = /* @__PURE__ */ new Set([primary]);
+  if (simpleBlobStore) allStores.add(simpleBlobStore);
+  if (tieredBlobs?.large) allStores.add(tieredBlobs.large);
+  if (tieredBlobs?.small) allStores.add(tieredBlobs.small);
+  if (opts.age?.cold) allStores.add(opts.age.cold);
+  if (opts.routes) for (const s of Object.values(opts.routes)) allStores.add(s);
+  if (opts.vaultRoutes) for (const s of Object.values(opts.vaultRoutes)) allStores.add(s);
+  if (opts.blobRoutes) for (const s of Object.values(opts.blobRoutes)) allStores.add(s);
+  if (opts.overflow) allStores.add(opts.overflow);
+  if (opts.blobLifecycle?.archiveStore) allStores.add(opts.blobLifecycle.archiveStore);
+  const overrides = /* @__PURE__ */ new Map();
+  const suspended = /* @__PURE__ */ new Set();
+  const writeQueues = /* @__PURE__ */ new Map();
+  const NULL_STORE = {
+    name: "suspended",
+    async get() {
+      return null;
+    },
+    async put() {
+    },
+    async delete() {
+    },
+    async list() {
+      return [];
+    },
+    async loadAll() {
+      return {};
+    },
+    async saveAll() {
+    }
+  };
+  function routeNameFor(vault, collection) {
+    if (opts.vaultRoutes) {
+      for (const prefix of Object.keys(opts.vaultRoutes)) {
+        if (vault.startsWith(prefix)) return prefix;
+      }
+    }
+    if (opts.routes && !collection.startsWith("_") && opts.routes[collection]) {
+      return collection;
+    }
+    if (isBlobChunks(collection) && (simpleBlobStore || tieredBlobs)) return "blobs";
+    if (opts.routeBlobMeta && isBlobMeta(collection) && (simpleBlobStore || tieredBlobs)) return "blobs";
+    if (opts.age && !collection.startsWith("_")) {
+    }
+    return "default";
+  }
+  const quotaExceeded = false;
+  function resolveOriginalStore(route) {
+    if (route === "blobs") return simpleBlobStore ?? tieredBlobs?.large ?? primary;
+    if (route === "cold") return opts.age?.cold ?? primary;
+    if (opts.routes?.[route]) return opts.routes[route];
+    if (opts.vaultRoutes?.[route]) return opts.vaultRoutes[route];
+    return primary;
+  }
+  function maybeQueueWrite(routeName, method, vault, collection, id, envelope, expectedVersion) {
+    if (!suspended.has(routeName)) return false;
+    const queue = writeQueues.get(routeName);
+    if (!queue) return false;
+    if (queue.writes.length >= queue.maxSize) {
+      queue.writes.shift();
+    }
+    queue.writes.push({
+      method,
+      vault,
+      collection,
+      id,
+      ...envelope !== void 0 ? { envelope } : {},
+      ...expectedVersion !== void 0 ? { expectedVersion } : {}
+    });
+    return true;
+  }
+  function isBlobChunks(collection) {
+    return collection === BLOB_CHUNKS;
+  }
+  function isBlobMeta(collection) {
+    return collection === BLOB_INDEX || collection.startsWith(BLOB_SLOTS) || collection.startsWith(BLOB_VERSIONS);
+  }
+  function isInternal(collection) {
+    return collection.startsWith("_");
+  }
+  function storeFor(vault, collection) {
+    const rName = routeNameFor(vault, collection);
+    if (suspended.has(rName)) return NULL_STORE;
+    if (overrides.has(rName)) return overrides.get(rName);
+    if (opts.vaultRoutes) {
+      for (const [prefix, store2] of Object.entries(opts.vaultRoutes)) {
+        if (vault.startsWith(prefix)) return store2;
+      }
+    }
+    if (opts.routes && !isInternal(collection) && opts.routes[collection]) {
+      return opts.routes[collection];
+    }
+    if (isBlobChunks(collection)) {
+      if (simpleBlobStore) return simpleBlobStore;
+      if (tieredBlobs) return tieredBlobs.large;
+    }
+    if (opts.routeBlobMeta && isBlobMeta(collection)) {
+      if (simpleBlobStore) return simpleBlobStore;
+      if (tieredBlobs) return tieredBlobs.large;
+    }
+    if (quotaExceeded && opts.overflow) return opts.overflow;
+    return primary;
+  }
+  function blobStoreForSize(dataSize) {
+    if (!tieredBlobs) return simpleBlobStore ?? primary;
+    if (dataSize <= blobThreshold) {
+      return tieredBlobs.small ?? primary;
+    }
+    return tieredBlobs.large;
+  }
+  function isCold(collection, envelope) {
+    if (!opts.age) return false;
+    if (isInternal(collection)) return false;
+    if (opts.age.collections && opts.age.collections.length > 0) {
+      if (!opts.age.collections.includes(collection)) return false;
+    }
+    const cutoff = Date.now() - opts.age.coldAfterDays * 24 * 60 * 60 * 1e3;
+    const ts = new Date(envelope._ts).getTime();
+    return ts < cutoff;
+  }
+  const store = {
+    name: buildName(),
+    async get(vault, collection, id) {
+      const s = storeFor(vault, collection);
+      const result = await s.get(vault, collection, id);
+      if (result === null && opts.age && !isInternal(collection)) {
+        if (!opts.age.collections?.length || opts.age.collections.includes(collection)) {
+          return opts.age.cold.get(vault, collection, id);
+        }
+      }
+      return result;
+    },
+    async put(vault, collection, id, envelope, expectedVersion) {
+      const rn = routeNameFor(vault, collection);
+      if (maybeQueueWrite(rn, "put", vault, collection, id, envelope, expectedVersion)) return;
+      if (isBlobChunks(collection) && tieredBlobs) {
+        const dataSize = envelope._data.length;
+        const s2 = blobStoreForSize(dataSize);
+        return s2.put(vault, collection, id, envelope, expectedVersion);
+      }
+      const s = storeFor(vault, collection);
+      if (opts.age && !isInternal(collection)) {
+        opts.age.cold.delete(vault, collection, id).catch(() => {
+        });
+      }
+      return s.put(vault, collection, id, envelope, expectedVersion);
+    },
+    async delete(vault, collection, id) {
+      const rn = routeNameFor(vault, collection);
+      if (maybeQueueWrite(rn, "delete", vault, collection, id)) return;
+      const s = storeFor(vault, collection);
+      await s.delete(vault, collection, id);
+      if (opts.age && !isInternal(collection)) {
+        await opts.age.cold.delete(vault, collection, id).catch(() => {
+        });
+      }
+    },
+    async list(vault, collection) {
+      const s = storeFor(vault, collection);
+      const ids = await s.list(vault, collection);
+      if (opts.age && !isInternal(collection)) {
+        if (!opts.age.collections?.length || opts.age.collections.includes(collection)) {
+          const coldIds = await opts.age.cold.list(vault, collection).catch(() => []);
+          if (coldIds.length > 0) {
+            const merged = new Set(ids);
+            for (const id of coldIds) merged.add(id);
+            return [...merged];
+          }
+        }
+      }
+      return ids;
+    },
+    async loadAll(vault) {
+      const stores = getStoresForVault(vault);
+      const snapshots = await Promise.all(
+        stores.map((s) => s.loadAll(vault).catch(() => ({})))
+      );
+      return mergeSnapshots(snapshots);
+    },
+    async saveAll(vault, data) {
+      const partitioned = /* @__PURE__ */ new Map();
+      for (const [collection, records] of Object.entries(data)) {
+        const s = storeFor(vault, collection);
+        if (!partitioned.has(s)) partitioned.set(s, {});
+        partitioned.get(s)[collection] = records;
+      }
+      await Promise.all(
+        [...partitioned.entries()].map(([s, snap]) => s.saveAll(vault, snap))
+      );
+    },
+    async compact(vault) {
+      if (!opts.age) return 0;
+      let migrated = 0;
+      const collections = opts.age.collections?.length ? opts.age.collections : await primary.list(vault, "").catch(() => []);
+      for (const collection of collections) {
+        const ids = await primary.list(vault, collection).catch(() => []);
+        for (const id of ids) {
+          const envelope = await primary.get(vault, collection, id);
+          if (!envelope) continue;
+          if (isCold(collection, envelope)) {
+            await opts.age.cold.put(vault, collection, id, envelope);
+            await primary.delete(vault, collection, id);
+            migrated++;
+          }
+        }
+      }
+      return migrated;
+    },
+    // ── Runtime override / suspend ──────────────────────
+    override(route, overrideStore, overrideOpts) {
+      if (overrideOpts?.hydrate) {
+        return (async () => {
+          overrides.set(route, overrideStore);
+        })();
+      }
+      overrides.set(route, overrideStore);
+    },
+    clearOverride(route) {
+      overrides.delete(route);
+    },
+    suspend(route, suspendOpts) {
+      suspended.add(route);
+      if (suspendOpts?.queue) {
+        writeQueues.set(route, {
+          writes: [],
+          maxSize: suspendOpts.maxQueueSize ?? 1e4
+        });
+      }
+    },
+    async resume(route) {
+      suspended.delete(route);
+      const queue = writeQueues.get(route);
+      if (!queue || queue.writes.length === 0) {
+        writeQueues.delete(route);
+        return 0;
+      }
+      let replayed = 0;
+      const target = overrides.get(route) ?? resolveOriginalStore(route);
+      for (const write of queue.writes) {
+        try {
+          if (write.method === "put" && write.envelope) {
+            await target.put(write.vault, write.collection, write.id, write.envelope, write.expectedVersion);
+          } else if (write.method === "delete") {
+            await target.delete(write.vault, write.collection, write.id);
+          }
+          replayed++;
+        } catch {
+        }
+      }
+      writeQueues.delete(route);
+      return replayed;
+    },
+    routeStatus() {
+      const ov = {};
+      for (const [k, v] of overrides) ov[k] = v.name ?? "unnamed";
+      const q = {};
+      for (const [k, v] of writeQueues) q[k] = v.writes.length;
+      return { overrides: ov, suspended: [...suspended], queued: q };
+    }
+  };
+  if (anyHas("listVaults")) {
+    store.listVaults = async () => {
+      const results = await Promise.all(
+        [...allStores].filter((s) => s.listVaults !== void 0).map((s) => s.listVaults().catch(() => []))
+      );
+      return [...new Set(results.flat())];
+    };
+  }
+  if (anyHas("ping")) {
+    store.ping = async () => {
+      const results = await Promise.all(
+        [...allStores].filter((s) => s.ping !== void 0).map((s) => s.ping().catch(() => false))
+      );
+      return results.some(Boolean);
+    };
+  }
+  return store;
+  function buildName() {
+    const names = [...allStores].map((s) => s.name ?? "?").join("+");
+    return `route(${names})`;
+  }
+  function anyHas(method) {
+    return [...allStores].some((s) => s[method]);
+  }
+  function getStoresForVault(vault) {
+    const stores = /* @__PURE__ */ new Set();
+    if (opts.vaultRoutes) {
+      for (const [prefix, s] of Object.entries(opts.vaultRoutes)) {
+        if (vault.startsWith(prefix)) {
+          stores.add(s);
+          return [...stores];
+        }
+      }
+    }
+    stores.add(primary);
+    if (simpleBlobStore) stores.add(simpleBlobStore);
+    if (tieredBlobs?.large) stores.add(tieredBlobs.large);
+    if (tieredBlobs?.small && tieredBlobs.small !== primary) stores.add(tieredBlobs.small);
+    if (opts.age?.cold) stores.add(opts.age.cold);
+    if (opts.routes) {
+      for (const s of Object.values(opts.routes)) stores.add(s);
+    }
+    return [...stores];
+  }
+}
+function mergeSnapshots(snapshots) {
+  const merged = {};
+  for (const snap of snapshots) {
+    for (const [collection, records] of Object.entries(snap)) {
+      if (!merged[collection]) {
+        merged[collection] = { ...records };
+        continue;
+      }
+      for (const [id, envelope] of Object.entries(records)) {
+        const existing = merged[collection][id];
+        if (!existing || envelope._ts >= existing._ts) {
+          merged[collection][id] = envelope;
+        }
+      }
+    }
+  }
+  return merged;
+}
+
+// src/store/store-middleware.ts
+function wrapStore(store, ...middlewares) {
+  let result = store;
+  for (let i = middlewares.length - 1; i >= 0; i--) {
+    result = middlewares[i](result);
+  }
+  return result;
+}
+function withRetry(opts = {}) {
+  const maxRetries = opts.maxRetries ?? 3;
+  const backoffMs = opts.backoffMs ?? 500;
+  const jitter = opts.jitter ?? 0.3;
+  const retryOn = opts.retryOn ? new Set(opts.retryOn) : null;
+  function shouldRetry(err) {
+    if (!retryOn) return true;
+    if (err && typeof err === "object" && "code" in err) {
+      return retryOn.has(err.code);
+    }
+    return true;
+  }
+  async function retryable(fn) {
+    let lastError;
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+      try {
+        return await fn();
+      } catch (err) {
+        lastError = err;
+        if (attempt >= maxRetries || !shouldRetry(err)) throw err;
+        const delay = backoffMs * Math.pow(2, attempt) * (1 + Math.random() * jitter);
+        await new Promise((r) => setTimeout(r, delay));
+      }
+    }
+    throw lastError;
+  }
+  return (next) => ({
+    ...next,
+    name: next.name ? `retry(${next.name})` : "retry",
+    get: (v, c, id) => retryable(() => next.get(v, c, id)),
+    put: (v, c, id, env, ev) => retryable(() => next.put(v, c, id, env, ev)),
+    delete: (v, c, id) => retryable(() => next.delete(v, c, id)),
+    list: (v, c) => retryable(() => next.list(v, c)),
+    loadAll: (v) => retryable(() => next.loadAll(v)),
+    saveAll: (v, d) => retryable(() => next.saveAll(v, d))
+  });
+}
+var LOG_LEVELS = { debug: 0, info: 1, warn: 2, error: 3 };
+function withLogging(opts = {}) {
+  const minLevel = LOG_LEVELS[opts.level ?? "info"];
+  const logger = opts.logger ?? console;
+  const logData = opts.logData ?? false;
+  function log(level, method, args, durationMs) {
+    if (LOG_LEVELS[level] < minLevel) return;
+    const parts = [`[noydb:${method}]`, ...Object.entries(args).map(([k, v]) => `${k}=${String(v)}`)];
+    if (durationMs !== void 0) parts.push(`${durationMs}ms`);
+    logger[level](parts.join(" "));
+  }
+  function timed(method, args, fn) {
+    const start = Date.now();
+    return fn().then(
+      (result) => {
+        log("debug", method, args, Date.now() - start);
+        return result;
+      },
+      (err) => {
+        log("error", method, { ...args, error: err.message }, Date.now() - start);
+        throw err;
+      }
+    );
+  }
+  return (next) => ({
+    ...next,
+    name: next.name ? `log(${next.name})` : "log",
+    get: (v, c, id) => timed("get", { vault: v, collection: c, id }, () => next.get(v, c, id)),
+    put: (v, c, id, env, ev) => timed("put", {
+      vault: v,
+      collection: c,
+      id,
+      version: env._v,
+      ...logData ? { data: env._data.slice(0, 40) + "..." } : {}
+    }, () => next.put(v, c, id, env, ev)),
+    delete: (v, c, id) => timed("delete", { vault: v, collection: c, id }, () => next.delete(v, c, id)),
+    list: (v, c) => timed("list", { vault: v, collection: c }, () => next.list(v, c)),
+    loadAll: (v) => timed("loadAll", { vault: v }, () => next.loadAll(v)),
+    saveAll: (v, d) => timed("saveAll", { vault: v }, () => next.saveAll(v, d))
+  });
+}
+function withMetrics(opts) {
+  function tracked(method, vault, fn, collection, id) {
+    const start = Date.now();
+    return fn().then(
+      (result) => {
+        opts.onOperation({
+          method,
+          vault,
+          ...collection !== void 0 ? { collection } : {},
+          ...id !== void 0 ? { id } : {},
+          durationMs: Date.now() - start,
+          success: true
+        });
+        return result;
+      },
+      (err) => {
+        opts.onOperation({
+          method,
+          vault,
+          ...collection !== void 0 ? { collection } : {},
+          ...id !== void 0 ? { id } : {},
+          durationMs: Date.now() - start,
+          success: false,
+          error: err
+        });
+        throw err;
+      }
+    );
+  }
+  return (next) => ({
+    ...next,
+    name: next.name ? `metrics(${next.name})` : "metrics",
+    get: (v, c, id) => tracked("get", v, () => next.get(v, c, id), c, id),
+    put: (v, c, id, env, ev) => tracked("put", v, () => next.put(v, c, id, env, ev), c, id),
+    delete: (v, c, id) => tracked("delete", v, () => next.delete(v, c, id), c, id),
+    list: (v, c) => tracked("list", v, () => next.list(v, c), c),
+    loadAll: (v) => tracked("loadAll", v, () => next.loadAll(v)),
+    saveAll: (v, d) => tracked("saveAll", v, () => next.saveAll(v, d))
+  });
+}
+function withCircuitBreaker(opts = {}) {
+  const threshold = opts.failureThreshold ?? 5;
+  const resetMs = opts.resetTimeoutMs ?? 3e4;
+  let state = "closed";
+  let failures = 0;
+  let lastFailureTime = 0;
+  function recordSuccess() {
+    if (state === "half-open") {
+      state = "closed";
+      failures = 0;
+      opts.onClose?.();
+    }
+    failures = 0;
+  }
+  function recordFailure() {
+    failures++;
+    lastFailureTime = Date.now();
+    if (failures >= threshold && state === "closed") {
+      state = "open";
+      opts.onOpen?.();
+    }
+  }
+  function canAttempt() {
+    if (state === "closed") return true;
+    if (state === "open") {
+      if (Date.now() - lastFailureTime >= resetMs) {
+        state = "half-open";
+        return true;
+      }
+      return false;
+    }
+    return true;
+  }
+  async function guarded(fn, fallback) {
+    if (!canAttempt()) return fallback;
+    try {
+      const result = await fn();
+      recordSuccess();
+      return result;
+    } catch (err) {
+      recordFailure();
+      throw err;
+    }
+  }
+  return (next) => ({
+    ...next,
+    name: next.name ? `cb(${next.name})` : "cb",
+    get: (v, c, id) => guarded(() => next.get(v, c, id), null),
+    put: (v, c, id, env, ev) => guarded(() => next.put(v, c, id, env, ev), void 0),
+    delete: (v, c, id) => guarded(() => next.delete(v, c, id), void 0),
+    list: (v, c) => guarded(() => next.list(v, c), []),
+    loadAll: (v) => guarded(() => next.loadAll(v), {}),
+    saveAll: (v, d) => guarded(() => next.saveAll(v, d), void 0)
+  });
+}
+function withCache(opts = {}) {
+  const maxEntries = opts.maxEntries ?? 500;
+  const ttlMs = opts.ttlMs ?? 6e4;
+  const cache = /* @__PURE__ */ new Map();
+  function cacheKey(vault, collection, id) {
+    return `${vault}\0${collection}\0${id}`;
+  }
+  function getFromCache(key) {
+    const entry = cache.get(key);
+    if (!entry) return void 0;
+    if (ttlMs > 0 && Date.now() - entry.cachedAt > ttlMs) {
+      cache.delete(key);
+      return void 0;
+    }
+    cache.delete(key);
+    cache.set(key, entry);
+    return entry.envelope;
+  }
+  function setInCache(key, envelope) {
+    if (cache.size >= maxEntries) {
+      const oldest = cache.keys().next().value;
+      if (oldest !== void 0) cache.delete(oldest);
+    }
+    cache.set(key, { envelope, cachedAt: Date.now() });
+  }
+  function invalidate(key) {
+    cache.delete(key);
+  }
+  return (next) => ({
+    ...next,
+    name: next.name ? `cache(${next.name})` : "cache",
+    async get(vault, collection, id) {
+      const key = cacheKey(vault, collection, id);
+      const cached = getFromCache(key);
+      if (cached !== void 0) return cached;
+      const result = await next.get(vault, collection, id);
+      setInCache(key, result);
+      return result;
+    },
+    async put(vault, collection, id, env, ev) {
+      invalidate(cacheKey(vault, collection, id));
+      await next.put(vault, collection, id, env, ev);
+      setInCache(cacheKey(vault, collection, id), env);
+    },
+    async delete(vault, collection, id) {
+      invalidate(cacheKey(vault, collection, id));
+      await next.delete(vault, collection, id);
+    },
+    list: (v, c) => next.list(v, c),
+    loadAll: (v) => next.loadAll(v),
+    saveAll: (v, d) => next.saveAll(v, d)
+  });
+}
+function withHealthCheck(opts = {}) {
+  const intervalMs = opts.checkIntervalMs ?? 3e4;
+  const failThreshold = opts.suspendAfterFailures ?? 3;
+  const successThreshold = opts.resumeAfterSuccess ?? 1;
+  let isSuspended = false;
+  let consecutiveFailures = 0;
+  let consecutiveSuccesses = 0;
+  return (next) => {
+    const checkFn = opts.check ?? (next.ping ? () => next.ping() : async () => {
+      await next.list("__health__", "__ping__");
+      return true;
+    });
+    async function doCheck() {
+      try {
+        const ok = await checkFn();
+        if (ok) {
+          consecutiveFailures = 0;
+          consecutiveSuccesses++;
+          if (isSuspended && consecutiveSuccesses >= successThreshold) {
+            isSuspended = false;
+            consecutiveSuccesses = 0;
+            opts.onResume?.();
+          }
+        } else {
+          throw new Error("Health check returned false");
+        }
+      } catch {
+        consecutiveSuccesses = 0;
+        consecutiveFailures++;
+        if (!isSuspended && consecutiveFailures >= failThreshold) {
+          isSuspended = true;
+          consecutiveFailures = 0;
+          opts.onSuspend?.();
+        }
+      }
+    }
+    setInterval(() => {
+      void doCheck();
+    }, intervalMs);
+    const wrapped = {
+      ...next,
+      name: next.name ? `health(${next.name})` : "health",
+      async get(v, c, id) {
+        return isSuspended ? null : next.get(v, c, id);
+      },
+      async put(v, c, id, env, ev) {
+        if (!isSuspended) await next.put(v, c, id, env, ev);
+      },
+      async delete(v, c, id) {
+        if (!isSuspended) await next.delete(v, c, id);
+      },
+      async list(v, c) {
+        return isSuspended ? [] : next.list(v, c);
+      },
+      async loadAll(v) {
+        return isSuspended ? {} : next.loadAll(v);
+      },
+      async saveAll(v, d) {
+        if (!isSuspended) await next.saveAll(v, d);
+      }
+    };
+    return wrapped;
+  };
+}
+
+// src/errors.ts
+var NoydbError = class extends Error {
+  /** Machine-readable error code. Stable across library versions. */
+  code;
+  constructor(code, message) {
+    super(message);
+    this.name = "NoydbError";
+    this.code = code;
+  }
+};
+var ConflictError = class extends NoydbError {
+  /** The actual stored version at the time of conflict. */
+  version;
+  constructor(version, message = "Version conflict") {
+    super("CONFLICT", message);
+    this.name = "ConflictError";
+    this.version = version;
+  }
+};
+var BundleVersionConflictError = class extends NoydbError {
+  /** The bundle handle of the newer remote version that rejected the push. */
+  remoteVersion;
+  constructor(remoteVersion, message = "Bundle version conflict \u2014 remote has been updated") {
+    super("BUNDLE_VERSION_CONFLICT", message);
+    this.name = "BundleVersionConflictError";
+    this.remoteVersion = remoteVersion;
+  }
+};
+
+// src/store/bundle-store.ts
+var BUNDLE_STORE_VERSION = 1;
+var MAX_CONFLICT_RETRIES = 3;
+function wrapBundleStore(bundle, options) {
+  const autoFlush = options?.autoFlush !== false;
+  const snapshots = /* @__PURE__ */ new Map();
+  const versions = /* @__PURE__ */ new Map();
+  const loaded = /* @__PURE__ */ new Set();
+  let batchDepth = 0;
+  async function load(vault) {
+    if (loaded.has(vault)) return snapshots.get(vault);
+    const result = await bundle.readBundle(vault);
+    if (result) {
+      const text = new TextDecoder().decode(result.bytes);
+      const format = JSON.parse(text);
+      snapshots.set(vault, format.data);
+      versions.set(vault, result.version);
+    } else {
+      snapshots.set(vault, {});
+      versions.set(vault, null);
+    }
+    loaded.add(vault);
+    return snapshots.get(vault);
+  }
+  async function flush(vault) {
+    const snapshot = snapshots.get(vault) ?? {};
+    const format = {
+      _noydb_bundle_store: BUNDLE_STORE_VERSION,
+      vault,
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      data: snapshot
+    };
+    const bytes = new TextEncoder().encode(JSON.stringify(format));
+    const expectedVersion = versions.get(vault) ?? null;
+    for (let attempt = 0; attempt < MAX_CONFLICT_RETRIES; attempt++) {
+      try {
+        const { version: newVersion } = await bundle.writeBundle(vault, bytes, expectedVersion);
+        versions.set(vault, newVersion);
+        return;
+      } catch (err) {
+        if (err instanceof BundleVersionConflictError && attempt < MAX_CONFLICT_RETRIES - 1) {
+          const remote = await bundle.readBundle(vault);
+          if (remote) {
+            const remoteText = new TextDecoder().decode(remote.bytes);
+            const remoteFormat = JSON.parse(remoteText);
+            const localSnap = snapshots.get(vault) ?? {};
+            const mergedSnap = mergeSnapshots2(remoteFormat.data, localSnap);
+            snapshots.set(vault, mergedSnap);
+            versions.set(vault, remote.version);
+          }
+          continue;
+        }
+        throw err;
+      }
+    }
+  }
+  async function maybeFlush(vault) {
+    if (autoFlush && batchDepth === 0) {
+      await flush(vault);
+    }
+  }
+  const store = {
+    name: bundle.name ?? "bundle",
+    async flush(vaultId) {
+      await flush(vaultId);
+    },
+    async batch(vaultId, fn) {
+      await load(vaultId);
+      batchDepth++;
+      try {
+        await fn();
+      } finally {
+        batchDepth--;
+      }
+      await flush(vaultId);
+    },
+    async get(vault, collection, id) {
+      const snap = await load(vault);
+      return snap[collection]?.[id] ?? null;
+    },
+    async put(vault, collection, id, envelope, expectedVersion) {
+      const snap = await load(vault);
+      if (expectedVersion !== void 0) {
+        const current = snap[collection]?.[id];
+        const currentVersion = current?._v ?? 0;
+        if (currentVersion !== expectedVersion) {
+          throw new ConflictError(
+            currentVersion,
+            `Expected version ${expectedVersion} but found ${currentVersion} on ${collection}/${id}`
+          );
+        }
+      }
+      snap[collection] ??= {};
+      snap[collection][id] = envelope;
+      await maybeFlush(vault);
+    },
+    async delete(vault, collection, id) {
+      const snap = await load(vault);
+      if (snap[collection]) {
+        delete snap[collection][id];
+        await maybeFlush(vault);
+      }
+    },
+    async list(vault, collection) {
+      const snap = await load(vault);
+      return Object.keys(snap[collection] ?? {});
+    },
+    async loadAll(vault) {
+      return await load(vault);
+    },
+    async saveAll(vault, data) {
+      snapshots.set(vault, data);
+      loaded.add(vault);
+      await flush(vault);
+    }
+  };
+  return store;
+}
+function mergeSnapshots2(remote, local) {
+  const merged = {};
+  for (const [coll, records] of Object.entries(remote)) {
+    merged[coll] = { ...records };
+  }
+  for (const [coll, records] of Object.entries(local)) {
+    if (!merged[coll]) {
+      merged[coll] = { ...records };
+      continue;
+    }
+    for (const [id, envelope] of Object.entries(records)) {
+      const existing = merged[coll][id];
+      if (!existing || envelope._ts >= existing._ts) {
+        merged[coll][id] = envelope;
+      }
+    }
+  }
+  return merged;
+}
+function createBundleStore(factory) {
+  return factory;
+}
+
+// src/store/sync-policy.ts
+var INDEXED_STORE_POLICY = {
+  push: { mode: "on-change", minIntervalMs: 0, onUnload: true },
+  pull: { mode: "manual" }
+};
+var BUNDLE_STORE_POLICY = {
+  push: { mode: "debounce", debounceMs: 3e4, minIntervalMs: 12e4, onUnload: true },
+  pull: { mode: "interval", intervalMs: 6e4 }
+};
+var SyncScheduler = class {
+  policy;
+  callbacks;
+  _state = "idle";
+  _lastPushAt = null;
+  _lastPullAt = null;
+  _lastError = null;
+  _lastPushTime = 0;
+  // monotonic ms for minIntervalMs enforcement
+  // Timers
+  debounceTimer = null;
+  pushIntervalTimer = null;
+  pullIntervalTimer = null;
+  // Bound handlers for cleanup
+  boundOnVisibilityChange = null;
+  boundOnBeforeExit = null;
+  boundOnPageHide = null;
+  started = false;
+  constructor(policy, callbacks) {
+    this.policy = policy;
+    this.callbacks = callbacks;
+    if (this.shouldRegisterUnload()) {
+      this.boundOnVisibilityChange = this.handleVisibilityChange.bind(this);
+      this.boundOnPageHide = this.handlePageHide.bind(this);
+      this.boundOnBeforeExit = this.handleBeforeExit.bind(this);
+    }
+  }
+  /** Current scheduler status snapshot. */
+  get status() {
+    return {
+      state: this._state,
+      lastPushAt: this._lastPushAt,
+      lastPullAt: this._lastPullAt,
+      lastError: this._lastError,
+      pendingWrites: this.callbacks.getDirtyCount()
+    };
+  }
+  /** Start the scheduler — registers timers, event listeners. */
+  start() {
+    if (this.started) return;
+    this.started = true;
+    if (this.policy.push.mode === "interval" && this.policy.push.intervalMs) {
+      this.pushIntervalTimer = setInterval(() => {
+        void this.executePush();
+      }, this.policy.push.intervalMs);
+    }
+    if (this.policy.pull.mode === "interval" && this.policy.pull.intervalMs) {
+      this.pullIntervalTimer = setInterval(() => {
+        void this.executePull();
+      }, this.policy.pull.intervalMs);
+    }
+    if (this.policy.pull.mode === "on-focus" && typeof document !== "undefined") {
+      document.addEventListener("visibilitychange", this.handleFocusPull);
+    }
+    if (this.shouldRegisterUnload()) {
+      if (typeof document !== "undefined" && this.boundOnVisibilityChange) {
+        document.addEventListener("visibilitychange", this.boundOnVisibilityChange);
+      }
+      if (typeof globalThis.addEventListener === "function" && this.boundOnPageHide) {
+        globalThis.addEventListener("pagehide", this.boundOnPageHide);
+      }
+      if (typeof process !== "undefined" && this.boundOnBeforeExit) {
+        process.on("beforeExit", this.boundOnBeforeExit);
+      }
+    }
+  }
+  /** Stop the scheduler — clears timers, removes event listeners. */
+  stop() {
+    if (!this.started) return;
+    this.started = false;
+    if (this.debounceTimer) {
+      clearTimeout(this.debounceTimer);
+      this.debounceTimer = null;
+    }
+    if (this.pushIntervalTimer) {
+      clearInterval(this.pushIntervalTimer);
+      this.pushIntervalTimer = null;
+    }
+    if (this.pullIntervalTimer) {
+      clearInterval(this.pullIntervalTimer);
+      this.pullIntervalTimer = null;
+    }
+    if (this.policy.pull.mode === "on-focus" && typeof document !== "undefined") {
+      document.removeEventListener("visibilitychange", this.handleFocusPull);
+    }
+    if (typeof document !== "undefined" && this.boundOnVisibilityChange) {
+      document.removeEventListener("visibilitychange", this.boundOnVisibilityChange);
+    }
+    if (typeof globalThis.removeEventListener === "function" && this.boundOnPageHide) {
+      globalThis.removeEventListener("pagehide", this.boundOnPageHide);
+    }
+    if (typeof process !== "undefined" && this.boundOnBeforeExit) {
+      process.removeListener("beforeExit", this.boundOnBeforeExit);
+    }
+  }
+  /**
+   * Notify the scheduler that a local write occurred.
+   * For `on-change` mode: triggers immediate push (respecting minIntervalMs).
+   * For `debounce` mode: resets the debounce timer.
+   * For `manual` / `interval`: no-op.
+   */
+  notifyChange() {
+    if (!this.started) return;
+    if (this.policy.push.mode === "on-change") {
+      void this.executePush();
+    } else if (this.policy.push.mode === "debounce") {
+      this.resetDebounce();
+    }
+  }
+  /** Force an immediate push, bypassing the scheduler. */
+  async forcePush() {
+    await this.executePush();
+  }
+  /** Force an immediate pull, bypassing the scheduler. */
+  async forcePull() {
+    await this.executePull();
+  }
+  // ─── Internal ─────────────────────────────────────────────────────
+  async executePush() {
+    if (this._state === "pushing") return;
+    const minInterval = this.policy.push.minIntervalMs ?? 0;
+    if (minInterval > 0) {
+      const elapsed = Date.now() - this._lastPushTime;
+      if (elapsed < minInterval) {
+        if (this.policy.push.mode === "debounce") {
+          this.scheduleDebounce(minInterval - elapsed);
+        }
+        return;
+      }
+    }
+    if (this.callbacks.getDirtyCount() === 0) {
+      this._state = "idle";
+      return;
+    }
+    this._state = "pushing";
+    try {
+      await this.callbacks.push();
+      this._lastPushAt = (/* @__PURE__ */ new Date()).toISOString();
+      this._lastPushTime = Date.now();
+      this._lastError = null;
+      this._state = this.callbacks.getDirtyCount() > 0 ? "pending" : "idle";
+    } catch (err) {
+      this._lastError = err instanceof Error ? err : new Error(String(err));
+      this._state = "error";
+    }
+  }
+  async executePull() {
+    if (this._state === "pulling") return;
+    const previousState = this._state;
+    this._state = "pulling";
+    try {
+      await this.callbacks.pull();
+      this._lastPullAt = (/* @__PURE__ */ new Date()).toISOString();
+      this._lastError = null;
+      this._state = previousState === "pending" ? "pending" : "idle";
+    } catch (err) {
+      this._lastError = err instanceof Error ? err : new Error(String(err));
+      this._state = "error";
+    }
+  }
+  resetDebounce() {
+    if (this.debounceTimer) clearTimeout(this.debounceTimer);
+    const ms = this.policy.push.debounceMs ?? 3e4;
+    this._state = "pending";
+    this.scheduleDebounce(ms);
+  }
+  scheduleDebounce(ms) {
+    if (this.debounceTimer) clearTimeout(this.debounceTimer);
+    this.debounceTimer = setTimeout(() => {
+      this.debounceTimer = null;
+      void this.executePush();
+    }, ms);
+  }
+  shouldRegisterUnload() {
+    const onUnload = this.policy.push.onUnload;
+    if (onUnload !== void 0) return onUnload;
+    return this.policy.push.mode !== "manual";
+  }
+  // ─── Event handlers ───────────────────────────────────────────────
+  handleVisibilityChange() {
+    if (typeof document !== "undefined" && document.visibilityState === "hidden") {
+      this.fireUnloadPush();
+    }
+  }
+  handlePageHide() {
+    this.fireUnloadPush();
+  }
+  handleBeforeExit() {
+    this.fireUnloadPush();
+  }
+  handleFocusPull = () => {
+    if (typeof document !== "undefined" && document.visibilityState === "visible") {
+      void this.executePull();
+    }
+  };
+  fireUnloadPush() {
+    if (this.callbacks.getDirtyCount() === 0) return;
+    void this.callbacks.push().catch(() => {
+    });
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BUNDLE_STORE_POLICY,
+  INDEXED_STORE_POLICY,
+  SyncScheduler,
+  createBundleStore,
+  routeStore,
+  withCache,
+  withCircuitBreaker,
+  withHealthCheck,
+  withLogging,
+  withMetrics,
+  withRetry,
+  wrapBundleStore,
+  wrapStore
+});
+//# sourceMappingURL=index.cjs.map