@farm.js/core 0.1.17 → 0.1.19

package/dist/chunk-H6G5INWM.cjs

@@ -0,0 +1,1094 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } async function _asyncNullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return await rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+
+
+
+var _chunkZEG3OPIBcjs = require('./chunk-ZEG3OPIB.cjs');
+
+
+var _chunkLIUGYUX3cjs = require('./chunk-LIUGYUX3.cjs');
+
+
+var _chunkE3UK5IIBcjs = require('./chunk-E3UK5IIB.cjs');
+
+
+var _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
+
+// src/cache-invalidation-stream.ts
+var DEFAULT_HEARTBEAT_INTERVAL_MS = 15e3;
+var DEFAULT_RETRY_MS = 3e3;
+var MAX_BUFFERED_BYTES = 64 * 1024;
+var MAX_PENDING_KEYS = 1024;
+var textEncoder = new TextEncoder();
+function positiveDuration(value, fallback) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0 ? Math.floor(value) : fallback;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, positiveDuration, "positiveDuration");
+function createFarmCacheInvalidationStream(options = {}) {
+  const heartbeatIntervalMs = options.heartbeatIntervalMs === false ? false : positiveDuration(options.heartbeatIntervalMs, DEFAULT_HEARTBEAT_INTERVAL_MS);
+  const retryMs = positiveDuration(options.retryMs, DEFAULT_RETRY_MS);
+  let unsubscribe;
+  let heartbeat;
+  let controller;
+  let closed = false;
+  let flushScheduled = false;
+  const pending = /* @__PURE__ */ new Set();
+  let pendingBytes = 0;
+  const enqueue = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, (value) => {
+    if (closed || !controller) return;
+    const chunk = textEncoder.encode(value);
+    if (chunk.byteLength > (_nullishCoalesce(controller.desiredSize, () => ( 0)))) {
+      overflow();
+      return;
+    }
+    controller.enqueue(chunk);
+  }, "enqueue");
+  const cleanup = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, () => {
+    _optionalChain([unsubscribe, 'optionalCall', _ => _()]);
+    unsubscribe = void 0;
+    if (heartbeat !== void 0) clearInterval(heartbeat);
+    heartbeat = void 0;
+    _optionalChain([options, 'access', _2 => _2.signal, 'optionalAccess', _3 => _3.removeEventListener, 'call', _4 => _4("abort", abort)]);
+    pending.clear();
+    pendingBytes = 0;
+  }, "cleanup");
+  const stop = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, (closeController) => {
+    if (closed) return;
+    closed = true;
+    cleanup();
+    if (closeController) _optionalChain([controller, 'optionalAccess', _5 => _5.close, 'call', _6 => _6()]);
+  }, "stop");
+  const abort = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, () => stop(true), "abort");
+  const overflow = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, () => {
+    if (closed) return;
+    stop(false);
+    _optionalChain([controller, 'optionalAccess', _7 => _7.error, 'call', _8 => _8(new Error("Farm cache invalidation stream exceeded its buffer limit."))]);
+  }, "overflow");
+  const flush = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, () => {
+    flushScheduled = false;
+    if (closed || pending.size === 0) return;
+    const encoded = _chunkZEG3OPIBcjs.encodeFarmCacheInvalidations.call(void 0, [...pending]);
+    pending.clear();
+    pendingBytes = 0;
+    if (encoded !== null) enqueue(`data: ${encoded}
+
+`);
+  }, "flush");
+  const stream = new ReadableStream(
+    {
+      start(nextController) {
+        controller = nextController;
+        if (_optionalChain([options, 'access', _9 => _9.signal, 'optionalAccess', _10 => _10.aborted])) {
+          stop(true);
+          return;
+        }
+        enqueue(`: connected
+retry: ${retryMs}
+
+`);
+        unsubscribe = _chunkZEG3OPIBcjs.subscribeFarmCacheInvalidation.call(void 0, (key) => {
+          if (closed || _optionalChain([options, 'access', _11 => _11.filter, 'optionalCall', _12 => _12(key)]) === false) return;
+          if (closed || pending.has(key)) return;
+          if (pending.size >= MAX_PENDING_KEYS || pendingBytes + key.length * 2 > MAX_BUFFERED_BYTES) {
+            overflow();
+            return;
+          }
+          pending.add(key);
+          pendingBytes += key.length * 2;
+          if (!flushScheduled) {
+            flushScheduled = true;
+            queueMicrotask(flush);
+          }
+        });
+        _optionalChain([options, 'access', _13 => _13.signal, 'optionalAccess', _14 => _14.addEventListener, 'call', _15 => _15("abort", abort, { once: true })]);
+        if (heartbeatIntervalMs !== false) {
+          heartbeat = setInterval(() => {
+            if (_optionalChain([controller, 'optionalAccess', _16 => _16.desiredSize]) === MAX_BUFFERED_BYTES) enqueue(": heartbeat\n\n");
+          }, heartbeatIntervalMs);
+        }
+      },
+      cancel() {
+        stop(false);
+      }
+    },
+    { highWaterMark: MAX_BUFFERED_BYTES, size: /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, (chunk) => chunk.byteLength, "size") }
+  );
+  return new Response(stream, {
+    headers: {
+      "Cache-Control": "no-cache, no-transform",
+      "Content-Type": "text/event-stream; charset=utf-8"
+    }
+  });
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, createFarmCacheInvalidationStream, "createFarmCacheInvalidationStream");
+
+// src/cache.ts
+function defineCacheKey() {
+  return (factory) => {
+    if (typeof factory !== "function") {
+      throw new TypeError("defineCacheKey expects a key factory function.");
+    }
+    return ((...args) => {
+      const key = factory(...args);
+      if (typeof key !== "string" && !Array.isArray(key)) {
+        throw new TypeError(
+          "A defined cache key factory must return a string or structured array."
+        );
+      }
+      return key;
+    });
+  };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, defineCacheKey, "defineCacheKey");
+function storageCacheAdapter(storage, options = {}) {
+  if (!storage || typeof storage.getItem !== "function" || typeof storage.setItem !== "function") {
+    throw new TypeError("storageCacheAdapter expects a compatible storage client.");
+  }
+  const base = normalizeCacheNamespace(options.base || "farm-cache");
+  const entryKey = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, (key) => `${base}:entry:${key}`, "entryKey");
+  const tagKey = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, (tag) => `${base}:tag:${tag}`, "tagKey");
+  return {
+    name: "storage",
+    get: /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, (key) => storage.getItem(entryKey(key)), "get"),
+    set: /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, async (key, entry) => {
+      await storage.setItem(entryKey(key), entry);
+    }, "set"),
+    delete: /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, async (key) => {
+      await storage.removeItem(entryKey(key));
+    }, "delete"),
+    clear: storage.clear ? async () => {
+      await storage.clear(base);
+    } : void 0,
+    getTagVersions: /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, async (tags) => {
+      const versions = await Promise.all(
+        tags.map(async (tag) => {
+          const value = await storage.getItem(tagKey(tag));
+          return [tag, normalizeAdapterVersion(value)];
+        })
+      );
+      return Object.fromEntries(versions);
+    }, "getTagVersions"),
+    invalidateTags: /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, async (tags) => {
+      await Promise.all(
+        tags.map(async (tag) => {
+          const key = tagKey(tag);
+          const current = normalizeAdapterVersion(await storage.getItem(key));
+          await storage.setItem(key, Math.max(Date.now(), current + 1));
+        })
+      );
+    }, "invalidateTags")
+  };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, storageCacheAdapter, "storageCacheAdapter");
+var _FarmDataCache = class _FarmDataCache {
+  constructor(config = {}) {
+    this.entries = /* @__PURE__ */ new Map();
+    this.inflight = /* @__PURE__ */ new Map();
+    /** Local entries by tag, so tag counts and pruning never scan unrelated entries. */
+    this.entriesByTag = /* @__PURE__ */ new Map();
+    this.invalidatedTagVersions = /* @__PURE__ */ new Map();
+    this.activeGenerations = /* @__PURE__ */ new Set();
+    this.version = 0;
+    this.generation = 0;
+    this.namespace = "farm";
+    this.local = true;
+    this.maxEntries = 1024;
+    this.lease = {
+      enabled: true,
+      ttlMs: 1e4,
+      waitTimeoutMs: 1e4,
+      pollIntervalMs: 25
+    };
+    this.configure(config);
+  }
+  configure(config = {}) {
+    this.generation++;
+    this.entries.clear();
+    this.entriesByTag.clear();
+    this.inflight.clear();
+    this.invalidatedTagVersions.clear();
+    this.activeGenerations.clear();
+    this.version = 0;
+    this.adapter = config.adapter;
+    this.namespace = normalizeCacheNamespace(config.namespace || "farm");
+    this.local = !config.adapter;
+    this.maxEntries = normalizePositiveInteger(config.maxEntries, 1024, "cache.maxEntries");
+    this.lease = config.lease === false ? { ...this.lease, enabled: false } : {
+      enabled: true,
+      ttlMs: normalizePositiveDuration(_optionalChain([config, 'access', _17 => _17.lease, 'optionalAccess', _18 => _18.ttlMs]), 1e4, "cache.lease.ttlMs"),
+      waitTimeoutMs: normalizePositiveDuration(
+        _optionalChain([config, 'access', _19 => _19.lease, 'optionalAccess', _20 => _20.waitTimeoutMs]),
+        1e4,
+        "cache.lease.waitTimeoutMs"
+      ),
+      pollIntervalMs: normalizePositiveDuration(
+        _optionalChain([config, 'access', _21 => _21.lease, 'optionalAccess', _22 => _22.pollIntervalMs]),
+        25,
+        "cache.lease.pollIntervalMs"
+      )
+    };
+  }
+  get adapterName() {
+    return _optionalChain([this, 'access', _23 => _23.adapter, 'optionalAccess', _24 => _24.name]) || (this.adapter ? "custom" : "memory");
+  }
+  get hasAdapter() {
+    return this.adapter !== void 0;
+  }
+  get size() {
+    return this.entries.size;
+  }
+  get(key, options = {}) {
+    return _optionalChain([this, 'access', _25 => _25.getEntry, 'call', _26 => _26(key, options), 'optionalAccess', _27 => _27.value]);
+  }
+  getEntry(key, options = {}) {
+    const entry = this.entries.get(key);
+    if (!entry) {
+      _chunkE3UK5IIBcjs.emitFarmEvent.call(void 0, { type: "cache.miss", key });
+      return void 0;
+    }
+    const stale = this.isStale(entry, options.now);
+    if (stale) {
+      _chunkE3UK5IIBcjs.emitFarmEvent.call(void 0, {
+        type: "cache.stale",
+        key,
+        tags: Array.from(entry.tags),
+        revalidate: entry.revalidate
+      });
+    }
+    if (!options.allowStale && stale) {
+      _chunkE3UK5IIBcjs.emitFarmEvent.call(void 0, { type: "cache.miss", key, reason: "stale" });
+      return void 0;
+    }
+    this.touchEntry(key, entry);
+    _chunkE3UK5IIBcjs.emitFarmEvent.call(void 0, {
+      type: "cache.hit",
+      key,
+      tags: Array.from(entry.tags),
+      revalidate: entry.revalidate,
+      stale
+    });
+    return this.toPublicEntry(entry);
+  }
+  async getEntryAsync(key, options = {}) {
+    if (this.local) {
+      const localEntry = this.getEntry(key, options);
+      if (localEntry) return localEntry;
+    }
+    if (!this.adapter) {
+      return this.local ? void 0 : this.getEntry(key, options);
+    }
+    const generation = this.generation;
+    const adapter = this.adapter;
+    const namespace = this.namespace;
+    const entry = await adapter.get(`${namespace}:entry:${key}`);
+    if (generation !== this.generation) return void 0;
+    if (!entry) {
+      _chunkE3UK5IIBcjs.emitFarmEvent.call(void 0, { type: "cache.miss", key });
+      return void 0;
+    }
+    assertFarmCacheEntry(entry, key);
+    const stale = await this.isAdapterEntryStale(entry, options.now, adapter, namespace);
+    if (generation !== this.generation) return void 0;
+    if (stale) {
+      _chunkE3UK5IIBcjs.emitFarmEvent.call(void 0, {
+        type: "cache.stale",
+        key,
+        tags: [...entry.tags],
+        revalidate: entry.revalidate
+      });
+      if (!options.allowStale) {
+        _chunkE3UK5IIBcjs.emitFarmEvent.call(void 0, { type: "cache.miss", key, reason: "stale" });
+        return void 0;
+      }
+    }
+    _chunkE3UK5IIBcjs.emitFarmEvent.call(void 0, {
+      type: "cache.hit",
+      key,
+      tags: [...entry.tags],
+      revalidate: entry.revalidate,
+      stale
+    });
+    if (this.local && !stale) {
+      this.hydrateLocalEntry(entry);
+    }
+    return { ...entry, key };
+  }
+  set(key, value, options = {}) {
+    const revalidate = normalizeRevalidate(options.revalidate);
+    const tags = /* @__PURE__ */ new Set();
+    for (const tag of _nullishCoalesce(options.tags, () => ( []))) {
+      tags.add(normalizeCacheTag(tag));
+    }
+    for (const routePath of _nullishCoalesce(options.paths, () => ( []))) {
+      tags.add(createPathCacheTag(routePath));
+    }
+    const entry = {
+      key,
+      value,
+      tags,
+      tagVersions: void 0,
+      createdAt: _nullishCoalesce(options.createdAt, () => ( Date.now())),
+      createdVersion: ++this.version,
+      revalidate
+    };
+    this.storeLocalEntry(entry);
+    _chunkE3UK5IIBcjs.emitFarmEvent.call(void 0, {
+      type: "cache.set",
+      key,
+      tags: Array.from(tags),
+      revalidate: entry.revalidate
+    });
+    return this.toPublicEntry(entry);
+  }
+  async setAsync(key, value, options = {}, tagVersions) {
+    return this.writeAsync(key, value, options, tagVersions);
+  }
+  async writeAsync(key, value, options, tagVersions, createdVersion) {
+    const revalidate = normalizeRevalidate(options.revalidate);
+    const tags = normalizeCacheOptionsTags(options);
+    const capturedVersions = await _asyncNullishCoalesce(tagVersions, async () => ( await this.getAdapterTagVersions(Array.from(tags.values()))));
+    const entry = {
+      key,
+      value,
+      tags: Array.from(tags),
+      tagVersions: capturedVersions,
+      createdAt: _nullishCoalesce(options.createdAt, () => ( Date.now())),
+      createdVersion: _nullishCoalesce(createdVersion, () => ( ++this.version)),
+      revalidate
+    };
+    if (this.local) {
+      this.hydrateLocalEntry(entry);
+    }
+    if (this.adapter) {
+      await this.adapter.set(this.createAdapterKey(key), entry);
+    }
+    _chunkE3UK5IIBcjs.emitFarmEvent.call(void 0, {
+      type: "cache.set",
+      key,
+      tags: [...entry.tags],
+      revalidate: entry.revalidate
+    });
+    return entry;
+  }
+  delete(key) {
+    const deleted = this.deleteLocalEntry(key);
+    _chunkE3UK5IIBcjs.emitFarmEvent.call(void 0, { type: "cache.delete", key, deleted });
+    return deleted;
+  }
+  async deleteAsync(key) {
+    const deleted = this.deleteLocalEntry(key);
+    if (this.adapter) {
+      await this.adapter.delete(this.createAdapterKey(key));
+    }
+    _chunkE3UK5IIBcjs.emitFarmEvent.call(void 0, { type: "cache.delete", key, deleted: this.adapter ? true : deleted });
+    return this.adapter ? true : deleted;
+  }
+  clear() {
+    const count = this.entries.size;
+    this.generation++;
+    this.entries.clear();
+    this.entriesByTag.clear();
+    this.inflight.clear();
+    this.invalidatedTagVersions.clear();
+    this.activeGenerations.clear();
+    this.version = 0;
+    _chunkE3UK5IIBcjs.emitFarmEvent.call(void 0, { type: "cache.clear", count });
+  }
+  async clearAsync() {
+    this.clear();
+    await _optionalChain([this, 'access', _28 => _28.adapter, 'optionalAccess', _29 => _29.clear, 'optionalCall', _30 => _30()]);
+  }
+  isStale(entry, now = Date.now()) {
+    if (typeof entry.revalidate === "number" && entry.revalidate >= 0 && now - entry.createdAt >= entry.revalidate * 1e3) {
+      return true;
+    }
+    for (const tag of entry.tags) {
+      const invalidatedVersion = this.invalidatedTagVersions.get(normalizeCacheTag(tag));
+      if (typeof invalidatedVersion === "number" && typeof entry.createdVersion === "number" && invalidatedVersion > entry.createdVersion) {
+        return true;
+      }
+    }
+    return false;
+  }
+  async isStaleAsync(entry, now = Date.now()) {
+    if (this.adapter) {
+      return this.isAdapterEntryStale(entry, now);
+    }
+    return this.isStale(entry, now);
+  }
+  revalidateTag(tag, options = {}) {
+    const normalized = normalizeCacheTag(tag);
+    const count = this.invalidateTag(normalized);
+    _chunkE3UK5IIBcjs.emitFarmEvent.call(void 0, 
+      options.source === "updateTag" ? { type: "cache.updateTag", tag: normalized, count } : { type: "cache.revalidateTag", tag: normalized, profile: options.profile, count }
+    );
+    return count;
+  }
+  async revalidateTagAsync(tag, options = {}) {
+    const normalized = normalizeCacheTag(tag);
+    const count = this.invalidateTag(normalized);
+    await _optionalChain([this, 'access', _31 => _31.adapter, 'optionalAccess', _32 => _32.invalidateTags, 'optionalCall', _33 => _33([this.createAdapterTag(normalized)])]);
+    _chunkE3UK5IIBcjs.emitFarmEvent.call(void 0, 
+      options.source === "updateTag" ? { type: "cache.updateTag", tag: normalized, count } : { type: "cache.revalidateTag", tag: normalized, profile: options.profile, count }
+    );
+    return count;
+  }
+  revalidatePath(routePath) {
+    const normalizedPath = normalizeRevalidatePath(routePath);
+    const pathTag = createPathCacheTag(normalizedPath);
+    const pprCount = this.countEntriesForTags([pathTag, "ppr"]);
+    const count = this.invalidateTag(pathTag);
+    _chunkE3UK5IIBcjs.emitFarmEvent.call(void 0, { type: "cache.revalidatePath", path: normalizedPath, count });
+    if (pprCount > 0) {
+      _chunkE3UK5IIBcjs.emitFarmEvent.call(void 0, {
+        type: "ppr.shell.invalidated",
+        route: normalizedPath,
+        reason: "revalidatePath",
+        count: pprCount
+      });
+    }
+    return count;
+  }
+  async revalidatePathAsync(routePath) {
+    const normalizedPath = normalizeRevalidatePath(routePath);
+    const pathTag = createPathCacheTag(normalizedPath);
+    const pprCount = this.countEntriesForTags([pathTag, "ppr"]);
+    const count = this.invalidateTag(pathTag);
+    await _optionalChain([this, 'access', _34 => _34.adapter, 'optionalAccess', _35 => _35.invalidateTags, 'optionalCall', _36 => _36([this.createAdapterTag(pathTag)])]);
+    _chunkE3UK5IIBcjs.emitFarmEvent.call(void 0, { type: "cache.revalidatePath", path: normalizedPath, count });
+    if (pprCount > 0) {
+      _chunkE3UK5IIBcjs.emitFarmEvent.call(void 0, {
+        type: "ppr.shell.invalidated",
+        route: normalizedPath,
+        reason: "revalidatePath",
+        count: pprCount
+      });
+    }
+    return count;
+  }
+  async getOrSet(key, producer, options = {}) {
+    normalizeRevalidate(options.revalidate);
+    const cached = await this.getEntryAsync(key);
+    if (cached) {
+      return cached.value;
+    }
+    const inflight = this.inflight.get(key);
+    if (inflight && !this.wasInvalidatedSince(inflight.tags, inflight.startVersion)) {
+      _chunkE3UK5IIBcjs.emitFarmEvent.call(void 0, { type: "cache.dedupe", key });
+      return inflight.promise;
+    }
+    const tags = Array.from(normalizeCacheOptionsTags(options));
+    const generation = this.generation;
+    const startVersion = this.version;
+    const promise = this.fillCacheEntry(key, producer, options, tags, generation).catch((error) => {
+      _chunkE3UK5IIBcjs.emitFarmEvent.call(void 0, { type: "cache.error", key, operation: "set", error });
+      throw error;
+    }).finally(() => {
+      if (_optionalChain([this, 'access', _37 => _37.inflight, 'access', _38 => _38.get, 'call', _39 => _39(key), 'optionalAccess', _40 => _40.promise]) === promise) {
+        this.inflight.delete(key);
+      }
+    });
+    this.inflight.set(key, { promise, tags, startVersion });
+    return promise;
+  }
+  /** A fill that started before one of its tags was invalidated cannot satisfy later readers. */
+  wasInvalidatedSince(tags, version) {
+    for (const tag of tags) {
+      const invalidatedVersion = this.invalidatedTagVersions.get(tag);
+      if (invalidatedVersion !== void 0 && invalidatedVersion > version) return true;
+    }
+    return false;
+  }
+  async fillCacheEntry(key, producer, options, tags, generation) {
+    const adapter = this.adapter;
+    const namespace = this.namespace;
+    const lease = { ...this.lease };
+    const leaseKey = `${namespace}:lease:${key}`;
+    let leaseToken;
+    if (_optionalChain([adapter, 'optionalAccess', _41 => _41.acquireLease]) && adapter.releaseLease && lease.enabled) {
+      leaseToken = await adapter.acquireLease(leaseKey, lease.ttlMs);
+      if (!leaseToken) {
+        const shared = await this.waitForAdapterEntry(
+          key,
+          adapter,
+          namespace,
+          lease,
+          generation
+        );
+        if (shared) {
+          _chunkE3UK5IIBcjs.emitFarmEvent.call(void 0, { type: "cache.dedupe", key });
+          return shared.value;
+        }
+        if (generation === this.generation) {
+          leaseToken = await adapter.acquireLease(leaseKey, lease.ttlMs);
+        }
+      }
+    }
+    const initialCreatedVersion = this.version;
+    const activeGeneration = {
+      tags: new Set(tags),
+      createdVersion: initialCreatedVersion
+    };
+    this.activeGenerations.add(activeGeneration);
+    try {
+      const initialTagVersions = await this.getAdapterTagVersions(tags, adapter, namespace);
+      const value = await producer();
+      if (generation === this.generation) {
+        await this.writeAsync(key, value, options, initialTagVersions, initialCreatedVersion);
+      }
+      return value;
+    } finally {
+      this.activeGenerations.delete(activeGeneration);
+      this.pruneInvalidatedTagVersions(activeGeneration.tags);
+      if (leaseToken && _optionalChain([adapter, 'optionalAccess', _42 => _42.releaseLease])) {
+        try {
+          await adapter.releaseLease(leaseKey, leaseToken);
+        } catch (error) {
+          _chunkE3UK5IIBcjs.emitFarmEvent.call(void 0, { type: "cache.error", key, operation: "set", error });
+        }
+      }
+    }
+  }
+  async waitForAdapterEntry(key, adapter, namespace, lease, generation) {
+    const deadline = Date.now() + lease.waitTimeoutMs;
+    while (Date.now() < deadline) {
+      await delay(lease.pollIntervalMs);
+      if (generation !== this.generation) return void 0;
+      const entry = await adapter.get(`${namespace}:entry:${key}`);
+      if (generation !== this.generation) return void 0;
+      if (!entry) {
+        _chunkE3UK5IIBcjs.emitFarmEvent.call(void 0, { type: "cache.miss", key });
+        continue;
+      }
+      assertFarmCacheEntry(entry, key);
+      const stale = await this.isAdapterEntryStale(entry, Date.now(), adapter, namespace);
+      if (generation !== this.generation) return void 0;
+      if (stale) {
+        _chunkE3UK5IIBcjs.emitFarmEvent.call(void 0, {
+          type: "cache.stale",
+          key,
+          tags: [...entry.tags],
+          revalidate: entry.revalidate
+        });
+        _chunkE3UK5IIBcjs.emitFarmEvent.call(void 0, { type: "cache.miss", key, reason: "stale" });
+      } else {
+        _chunkE3UK5IIBcjs.emitFarmEvent.call(void 0, {
+          type: "cache.hit",
+          key,
+          tags: [...entry.tags],
+          revalidate: entry.revalidate,
+          stale: false
+        });
+        return { ...entry, key };
+      }
+    }
+    return void 0;
+  }
+  countEntriesForTags(tags) {
+    let count = 0;
+    for (const entry of _nullishCoalesce(this.entriesByTag.get(tags[0]), () => ( []))) {
+      if (tags.every((tag) => entry.tags.has(tag))) {
+        count++;
+      }
+    }
+    return count;
+  }
+  invalidateTag(normalizedTag) {
+    const count = _nullishCoalesce(_optionalChain([this, 'access', _43 => _43.entriesByTag, 'access', _44 => _44.get, 'call', _45 => _45(normalizedTag), 'optionalAccess', _46 => _46.size]), () => ( 0));
+    this.invalidatedTagVersions.delete(normalizedTag);
+    this.invalidatedTagVersions.set(normalizedTag, ++this.version);
+    this.pruneInvalidatedTagVersions([normalizedTag]);
+    return count;
+  }
+  toPublicEntry(entry) {
+    return {
+      key: entry.key,
+      value: entry.value,
+      tags: Array.from(entry.tags),
+      tagVersions: entry.tagVersions,
+      createdAt: entry.createdAt,
+      createdVersion: entry.createdVersion,
+      revalidate: entry.revalidate
+    };
+  }
+  hydrateLocalEntry(entry) {
+    this.storeLocalEntry({
+      key: entry.key,
+      value: entry.value,
+      tags: new Set(entry.tags.map(normalizeCacheTag)),
+      tagVersions: entry.tagVersions,
+      createdAt: entry.createdAt,
+      createdVersion: _nullishCoalesce(entry.createdVersion, () => ( ++this.version)),
+      revalidate: normalizeRevalidate(entry.revalidate)
+    });
+  }
+  touchEntry(key, entry) {
+    this.entries.delete(key);
+    this.entries.set(key, entry);
+  }
+  storeLocalEntry(entry) {
+    const removed = [];
+    const replaced = this.detachLocalEntry(entry.key);
+    if (replaced) removed.push(replaced);
+    this.entries.set(entry.key, entry);
+    for (const tag of entry.tags) {
+      let tagged = this.entriesByTag.get(tag);
+      if (!tagged) this.entriesByTag.set(tag, tagged = /* @__PURE__ */ new Set());
+      tagged.add(entry);
+    }
+    while (this.entries.size > this.maxEntries) {
+      const oldestKey = this.entries.keys().next().value;
+      if (oldestKey === void 0) break;
+      removed.push(this.detachLocalEntry(oldestKey));
+    }
+    for (const removedEntry of removed) this.pruneInvalidatedTagVersions(removedEntry.tags);
+  }
+  deleteLocalEntry(key) {
+    const entry = this.detachLocalEntry(key);
+    if (!entry) return false;
+    this.pruneInvalidatedTagVersions(entry.tags);
+    return true;
+  }
+  detachLocalEntry(key) {
+    const entry = this.entries.get(key);
+    if (!entry) return void 0;
+    this.entries.delete(key);
+    for (const tag of entry.tags) {
+      const tagged = this.entriesByTag.get(tag);
+      if (!tagged) continue;
+      tagged.delete(entry);
+      if (tagged.size === 0) this.entriesByTag.delete(tag);
+    }
+    return entry;
+  }
+  /**
+   * Drop invalidation versions that no local entry or active fill can be stale against.
+   * Callers pass only the tags whose dependents just changed, so the cost is bounded by
+   * the entries sharing those tags rather than by the whole cache.
+   */
+  pruneInvalidatedTagVersions(tags) {
+    tags: for (const tag of tags) {
+      const invalidatedVersion = this.invalidatedTagVersions.get(tag);
+      if (invalidatedVersion === void 0) continue;
+      for (const entry of _nullishCoalesce(this.entriesByTag.get(tag), () => ( []))) {
+        if (entry.createdVersion < invalidatedVersion) continue tags;
+      }
+      for (const generation of this.activeGenerations) {
+        if (generation.tags.has(tag) && generation.createdVersion < invalidatedVersion)
+          continue tags;
+      }
+      this.invalidatedTagVersions.delete(tag);
+    }
+  }
+  createAdapterKey(key) {
+    return `${this.namespace}:entry:${key}`;
+  }
+  createAdapterTag(tag) {
+    return `${this.namespace}:tag:${tag}`;
+  }
+  async getAdapterTagVersions(tags, adapter = this.adapter, namespace = this.namespace) {
+    if (!_optionalChain([adapter, 'optionalAccess', _47 => _47.getTagVersions]) || tags.length === 0) return {};
+    const normalized = tags.map(normalizeCacheTag);
+    const physicalTags = normalized.map((tag) => `${namespace}:tag:${tag}`);
+    const versions = await adapter.getTagVersions(physicalTags);
+    return Object.fromEntries(
+      normalized.map((tag, index) => [
+        tag,
+        normalizeAdapterVersion(versions[physicalTags[index]])
+      ])
+    );
+  }
+  async isAdapterEntryStale(entry, now = Date.now(), adapter = this.adapter, namespace = this.namespace) {
+    if (typeof entry.revalidate === "number" && entry.revalidate >= 0 && now - entry.createdAt >= entry.revalidate * 1e3) {
+      return true;
+    }
+    const currentVersions = await this.getAdapterTagVersions(entry.tags, adapter, namespace);
+    for (const tag of entry.tags) {
+      if (normalizeAdapterVersion(currentVersions[tag]) > normalizeAdapterVersion(_optionalChain([entry, 'access', _48 => _48.tagVersions, 'optionalAccess', _49 => _49[tag]]))) {
+        return true;
+      }
+    }
+    return false;
+  }
+};
+_chunkS3JO3N4Hcjs.__name.call(void 0, _FarmDataCache, "FarmDataCache");
+var FarmDataCache = _FarmDataCache;
+var FARM_DATA_CACHE_SYMBOL = /* @__PURE__ */ Symbol.for("farm.dataCache");
+var farmDataCacheGlobal = globalThis;
+var sharedFarmDataCache = _nullishCoalesce(farmDataCacheGlobal[FARM_DATA_CACHE_SYMBOL], () => ( (farmDataCacheGlobal[FARM_DATA_CACHE_SYMBOL] = new FarmDataCache())));
+function getFarmDataCache() {
+  return sharedFarmDataCache;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, getFarmDataCache, "getFarmDataCache");
+function configureFarmCache(config) {
+  sharedFarmDataCache.configure(config);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, configureFarmCache, "configureFarmCache");
+function unstable_cache(fn, keyParts = [], options = {}) {
+  return async (...args) => {
+    const locale = _optionalChain([_chunkLIUGYUX3cjs.getActiveFarmI18nSnapshot.call(void 0, ), 'optionalAccess', _50 => _50.locale]);
+    const key = createFarmCacheKey([
+      "unstable_cache",
+      getFunctionCacheIdentity(fn),
+      locale ? ["locale", locale] : null,
+      keyParts,
+      args
+    ]);
+    return getFarmDataCache().getOrSet(key, () => fn(...args), options);
+  };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, unstable_cache, "unstable_cache");
+function revalidateTag(_tag, _profile) {
+  const cache = getFarmDataCache();
+  if (cache.hasAdapter) {
+    const task = cache.revalidateTagAsync(_tag, {
+      source: "revalidateTag",
+      profile: _profile
+    }).then(() => void 0);
+    _chunkZEG3OPIBcjs.notifyFarmCacheTask.call(void 0, task);
+    return task;
+  }
+  cache.revalidateTag(_tag, {
+    source: "revalidateTag",
+    profile: _profile
+  });
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, revalidateTag, "revalidateTag");
+function updateTag(tag) {
+  const cache = getFarmDataCache();
+  if (cache.hasAdapter) {
+    const task = cache.revalidateTagAsync(tag, { source: "updateTag" }).then(() => void 0);
+    _chunkZEG3OPIBcjs.notifyFarmCacheTask.call(void 0, task);
+    return task;
+  }
+  cache.revalidateTag(tag, { source: "updateTag" });
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, updateTag, "updateTag");
+function revalidatePath(routePath) {
+  const cache = getFarmDataCache();
+  if (cache.hasAdapter) {
+    const task = cache.revalidatePathAsync(routePath).then(() => void 0);
+    _chunkZEG3OPIBcjs.notifyFarmCacheTask.call(void 0, task);
+    return task;
+  }
+  cache.revalidatePath(routePath);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, revalidatePath, "revalidatePath");
+function invalidate(key) {
+  const clientKey = createRouteDataCacheKey(key);
+  const task = updateTag(createRouteDataCacheTag(key));
+  _chunkZEG3OPIBcjs.notifyFarmCacheInvalidation.call(void 0, clientKey);
+  return task;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, invalidate, "invalidate");
+function invalidateRouteData(key) {
+  return invalidate(key);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, invalidateRouteData, "invalidateRouteData");
+async function applyFarmCacheInvalidationTargets(targets) {
+  if (!Array.isArray(targets)) {
+    throw new TypeError("Cache invalidations must resolve to an array of targets.");
+  }
+  const clientKeys = [];
+  for (const target of targets) {
+    assertFarmCacheInvalidationTarget(target);
+    if ("key" in target) {
+      await invalidate(target.key);
+      clientKeys.push(createRouteDataCacheKey(target.key));
+    } else if ("path" in target) {
+      await revalidatePath(target.path);
+    } else {
+      await updateTag(target.tag);
+    }
+  }
+  return Array.from(new Set(clientKeys));
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, applyFarmCacheInvalidationTargets, "applyFarmCacheInvalidationTargets");
+function createPathCacheTag(routePath) {
+  return `path:${normalizeRevalidatePath(routePath)}`;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, createPathCacheTag, "createPathCacheTag");
+function createRouteDataCacheTag(key) {
+  return `route-data:${createRouteDataCacheKey(key)}`;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, createRouteDataCacheTag, "createRouteDataCacheTag");
+function createRouteDataCacheKey(key) {
+  return createFarmCacheKey(Array.isArray(key) ? key : [key]);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, createRouteDataCacheKey, "createRouteDataCacheKey");
+function normalizeRevalidatePath(routePath) {
+  if (typeof routePath !== "string") {
+    throw new TypeError("revalidatePath expects a path string.");
+  }
+  let normalized = routePath.trim();
+  if (!normalized) {
+    throw new Error("revalidatePath expects a non-empty path.");
+  }
+  try {
+    if (/^https?:\/\//i.test(normalized)) {
+      normalized = new URL(normalized).pathname;
+    }
+  } catch (e) {
+  }
+  normalized = _nullishCoalesce(normalized.split(/[?#]/, 1)[0], () => ( normalized));
+  normalized = normalized.startsWith("/") ? normalized : `/${normalized}`;
+  normalized = normalized.replace(/\/{2,}/g, "/");
+  normalized = new URL(normalized, "http://farm.invalid").pathname;
+  if (normalized.length > 1) {
+    normalized = normalized.replace(/\/+$/, "");
+  }
+  return normalized || "/";
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, normalizeRevalidatePath, "normalizeRevalidatePath");
+function createFarmCacheKey(parts) {
+  return stableSerialize(parts);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, createFarmCacheKey, "createFarmCacheKey");
+function normalizeRevalidate(revalidate) {
+  if (revalidate === false || revalidate === void 0) {
+    return revalidate;
+  }
+  if (!Number.isFinite(revalidate) || revalidate < 0) {
+    throw new TypeError("Cache revalidate must be false or a finite, non-negative number.");
+  }
+  return revalidate;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, normalizeRevalidate, "normalizeRevalidate");
+function normalizeCacheTag(tag) {
+  if (typeof tag !== "string") {
+    throw new TypeError("Cache tags must be strings.");
+  }
+  const normalized = tag.trim();
+  if (!normalized) {
+    throw new Error("Cache tags cannot be empty.");
+  }
+  return normalized;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, normalizeCacheTag, "normalizeCacheTag");
+function normalizeCacheNamespace(namespace) {
+  if (typeof namespace !== "string") {
+    throw new TypeError("Cache namespace must be a string.");
+  }
+  const normalized = namespace.trim().replace(/:+$/g, "");
+  if (!normalized) {
+    throw new Error("Cache namespace cannot be empty.");
+  }
+  return normalized;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, normalizeCacheNamespace, "normalizeCacheNamespace");
+function normalizeAdapterVersion(value) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : 0;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, normalizeAdapterVersion, "normalizeAdapterVersion");
+function normalizePositiveDuration(value, fallback, name) {
+  if (value === void 0) return fallback;
+  if (!Number.isFinite(value) || value <= 0) {
+    throw new TypeError(`${name} must be a positive number of milliseconds.`);
+  }
+  return Math.floor(value);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, normalizePositiveDuration, "normalizePositiveDuration");
+function normalizePositiveInteger(value, fallback, name) {
+  if (value === void 0) return fallback;
+  if (!Number.isSafeInteger(value) || value <= 0) {
+    throw new TypeError(`${name} must be a positive integer.`);
+  }
+  return value;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, normalizePositiveInteger, "normalizePositiveInteger");
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, delay, "delay");
+function normalizeCacheOptionsTags(options) {
+  const tags = /* @__PURE__ */ new Set();
+  for (const tag of _nullishCoalesce(options.tags, () => ( []))) {
+    tags.add(normalizeCacheTag(tag));
+  }
+  for (const routePath of _nullishCoalesce(options.paths, () => ( []))) {
+    tags.add(createPathCacheTag(routePath));
+  }
+  return tags;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, normalizeCacheOptionsTags, "normalizeCacheOptionsTags");
+function assertFarmCacheEntry(entry, expectedKey) {
+  if (!entry || typeof entry !== "object" || entry.key !== expectedKey || !Array.isArray(entry.tags) || typeof entry.createdAt !== "number") {
+    throw new TypeError(
+      `Cache adapter returned an invalid entry for ${JSON.stringify(expectedKey)}.`
+    );
+  }
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, assertFarmCacheEntry, "assertFarmCacheEntry");
+function assertFarmCacheInvalidationTarget(target) {
+  if (!target || typeof target !== "object") {
+    throw new TypeError("Cache invalidation targets must be { key }, { path }, or { tag }.");
+  }
+  if ("key" in target) {
+    const key = target.key;
+    if (typeof key === "string" || Array.isArray(key)) return;
+  } else if ("path" in target && typeof target.path === "string") {
+    return;
+  } else if ("tag" in target && typeof target.tag === "string") {
+    return;
+  }
+  throw new TypeError("Cache invalidation targets must contain a string/array key, path, or tag.");
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, assertFarmCacheInvalidationTarget, "assertFarmCacheInvalidationTarget");
+function getFunctionCacheIdentity(fn) {
+  const name = fn.name || "anonymous";
+  return `${name}:${hashFunctionSource(String(fn))}`;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, getFunctionCacheIdentity, "getFunctionCacheIdentity");
+function hashFunctionSource(source) {
+  let hash = 2166136261;
+  for (let index = 0; index < source.length; index++) {
+    hash ^= source.charCodeAt(index);
+    hash = Math.imul(hash, 16777619);
+  }
+  return (hash >>> 0).toString(36);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, hashFunctionSource, "hashFunctionSource");
+function compareCodepoint(a, b) {
+  return a < b ? -1 : a > b ? 1 : 0;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, compareCodepoint, "compareCodepoint");
+function serializeBinaryBytes(bytes) {
+  return Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, serializeBinaryBytes, "serializeBinaryBytes");
+function serializeCanonicalStringEntries(entries, seen) {
+  const valuesByKey = /* @__PURE__ */ new Map();
+  for (const [key, item] of entries) {
+    const values = valuesByKey.get(key);
+    if (values) values.push(item);
+    else valuesByKey.set(key, [item]);
+  }
+  return Array.from(valuesByKey.keys()).sort(compareCodepoint).flatMap(
+    (key) => valuesByKey.get(key).map((item) => `[${stableSerialize(key, seen)},${stableSerialize(item, seen)}]`)
+  ).join(",");
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, serializeCanonicalStringEntries, "serializeCanonicalStringEntries");
+function isPlainCacheKeyObject(value) {
+  const prototype = Object.getPrototypeOf(value);
+  if (prototype === null) return true;
+  const constructor = _optionalChain([Object, 'access', _51 => _51.getOwnPropertyDescriptor, 'call', _52 => _52(prototype, "constructor"), 'optionalAccess', _53 => _53.value]);
+  return Object.getPrototypeOf(prototype) === null && typeof constructor === "function" && constructor.name === "Object";
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, isPlainCacheKeyObject, "isPlainCacheKeyObject");
+function getCacheKeyValueType(value) {
+  const prototype = Object.getPrototypeOf(value);
+  const constructor = prototype ? _optionalChain([Object, 'access', _54 => _54.getOwnPropertyDescriptor, 'call', _55 => _55(prototype, "constructor"), 'optionalAccess', _56 => _56.value]) : void 0;
+  if (typeof constructor === "function" && constructor.name) {
+    return constructor.name;
+  }
+  return Object.prototype.toString.call(value).slice(8, -1) || "object";
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, getCacheKeyValueType, "getCacheKeyValueType");
+function stableSerialize(value, seen = /* @__PURE__ */ new WeakSet()) {
+  if (value === null) return "null";
+  if (value === void 0) return "undefined";
+  const valueType = typeof value;
+  if (valueType === "string") return JSON.stringify(value);
+  if (valueType === "number" || valueType === "boolean" || valueType === "bigint") {
+    return `${valueType}:${String(value)}`;
+  }
+  if (valueType === "symbol") {
+    return `symbol:${String(value)}`;
+  }
+  if (valueType === "function") {
+    return `function:${getFunctionCacheIdentity(value)}`;
+  }
+  if (value instanceof Date) {
+    return Number.isNaN(value.getTime()) ? "date:invalid" : `date:${value.toISOString()}`;
+  }
+  if (value instanceof URL) {
+    return `url:${value.toString()}`;
+  }
+  if (value instanceof RegExp) {
+    return `regexp:${value.toString()}`;
+  }
+  if (value instanceof ArrayBuffer) {
+    return `arraybuffer:${serializeBinaryBytes(new Uint8Array(value))}`;
+  }
+  if (typeof SharedArrayBuffer !== "undefined" && value instanceof SharedArrayBuffer) {
+    return `sharedarraybuffer:${serializeBinaryBytes(new Uint8Array(value))}`;
+  }
+  if (ArrayBuffer.isView(value)) {
+    const viewType = Object.prototype.toString.call(value).slice(8, -1);
+    const bytes = new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+    return `binary:${viewType}:${serializeBinaryBytes(bytes)}`;
+  }
+  if (value && typeof value === "object") {
+    if (seen.has(value)) {
+      return "[Circular]";
+    }
+    seen.add(value);
+    if (Array.isArray(value)) {
+      const items = [];
+      for (let index = 0; index < value.length; index++) {
+        items.push(
+          Object.prototype.hasOwnProperty.call(value, index) ? stableSerialize(value[index], seen) : "[Hole]"
+        );
+      }
+      seen.delete(value);
+      return `[${items.join(",")}]`;
+    }
+    if (value instanceof Set) {
+      const items = Array.from(value, (item) => stableSerialize(item, seen)).sort(compareCodepoint);
+      seen.delete(value);
+      return `set:[${items.join(",")}]`;
+    }
+    if (value instanceof Map) {
+      const items = Array.from(
+        value,
+        ([key, item]) => `[${stableSerialize(key, seen)},${stableSerialize(item, seen)}]`
+      ).sort(compareCodepoint);
+      seen.delete(value);
+      return `map:[${items.join(",")}]`;
+    }
+    if (value instanceof URLSearchParams) {
+      const serialized2 = serializeCanonicalStringEntries(value, seen);
+      seen.delete(value);
+      return `urlsearchparams:[${serialized2}]`;
+    }
+    if (value instanceof Headers) {
+      const serialized2 = serializeCanonicalStringEntries(value, seen);
+      seen.delete(value);
+      return `headers:[${serialized2}]`;
+    }
+    if (!isPlainCacheKeyObject(value)) {
+      throw new TypeError(
+        `Cache keys do not support ${getCacheKeyValueType(value)} values. Convert the value to an explicit stable string or structured key before caching.`
+      );
+    }
+    const entries = Object.entries(value).sort(
+      ([a], [b]) => compareCodepoint(a, b)
+    );
+    const serialized = entries.map(([key, item]) => `${JSON.stringify(key)}:${stableSerialize(item, seen)}`).join(",");
+    seen.delete(value);
+    return `{${serialized}}`;
+  }
+  return String(value);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, stableSerialize, "stableSerialize");
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.createFarmCacheInvalidationStream = createFarmCacheInvalidationStream; exports.defineCacheKey = defineCacheKey; exports.storageCacheAdapter = storageCacheAdapter; exports.FarmDataCache = FarmDataCache; exports.getFarmDataCache = getFarmDataCache; exports.configureFarmCache = configureFarmCache; exports.unstable_cache = unstable_cache; exports.revalidateTag = revalidateTag; exports.updateTag = updateTag; exports.revalidatePath = revalidatePath; exports.invalidate = invalidate; exports.invalidateRouteData = invalidateRouteData; exports.applyFarmCacheInvalidationTargets = applyFarmCacheInvalidationTargets; exports.createPathCacheTag = createPathCacheTag; exports.createRouteDataCacheTag = createRouteDataCacheTag; exports.createRouteDataCacheKey = createRouteDataCacheKey; exports.normalizeRevalidatePath = normalizeRevalidatePath; exports.createFarmCacheKey = createFarmCacheKey;