@noy-db/hub 0.2.0-pre.30 → 0.2.0-pre.31

package/dist/store/index.cjs

@@ -1,1091 +0,0 @@
-"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,
-  StoreCapabilityError: () => StoreCapabilityError,
-  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 };
-    },
-    resolveBackend(vaultId) {
-      if (opts.vaultRoutes) {
-        for (const [prefix, s] of Object.entries(opts.vaultRoutes)) {
-          if (vaultId.startsWith(prefix)) return s;
-        }
-      }
-      return primary;
-    }
-  };
-  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 StoreCapabilityError = class extends NoydbError {
-  /** The store method/capability that was missing. */
-  capability;
-  constructor(capability, callerApi, storeName) {
-    super(
-      "STORE_CAPABILITY",
-      `${callerApi} requires the optional store capability "${capability}" but the active store${storeName ? ` (${storeName})` : ""} does not implement it. Use a store that supports "${capability}" (store-memory, store-file) or pass an explicit vault list to bypass enumeration.`
-    );
-    this.name = "StoreCapabilityError";
-    this.capability = capability;
-  }
-};
-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,
-  StoreCapabilityError,
-  SyncScheduler,
-  createBundleStore,
-  routeStore,
-  withCache,
-  withCircuitBreaker,
-  withHealthCheck,
-  withLogging,
-  withMetrics,
-  withRetry,
-  wrapBundleStore,
-  wrapStore
-});
-//# sourceMappingURL=index.cjs.map