@noy-db/hub 0.2.0-pre.9 → 0.3.0-pre.10

package/dist/chunk-QEILDE6R.js

@@ -1,793 +0,0 @@
-import {
-  BundleVersionConflictError,
-  ConflictError
-} from "./chunk-B6PB7JLN.js";
-
-// 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 = mergeSnapshots(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 mergeSnapshots(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/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 mergeSnapshots2(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 mergeSnapshots2(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;
-  };
-}
-
-export {
-  wrapBundleStore,
-  createBundleStore,
-  routeStore,
-  wrapStore,
-  withRetry,
-  withLogging,
-  withMetrics,
-  withCircuitBreaker,
-  withCache,
-  withHealthCheck
-};
-//# sourceMappingURL=chunk-QEILDE6R.js.map