@farm.js/core 0.1.46 → 0.1.48

package/dist/chunk-DMAP4RND.cjs

@@ -0,0 +1,998 @@
+"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 _chunkEVIWKPJVcjs = require('./chunk-EVIWKPJV.cjs');
+
+
+var _chunkAOKXITZ6cjs = require('./chunk-AOKXITZ6.cjs');
+
+
+
+
+var _chunkDXUXQP2Tcjs = require('./chunk-DXUXQP2T.cjs');
+
+
+
+
+
+var _chunkUZCMMJJTcjs = require('./chunk-UZCMMJJT.cjs');
+
+
+var _chunk3BIASUGRcjs = require('./chunk-3BIASUGR.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;
+}
+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 = (value) => {
+    if (closed || !controller) return;
+    const chunk = textEncoder.encode(value);
+    if (chunk.byteLength > (_nullishCoalesce(controller.desiredSize, () => ( 0)))) {
+      overflow();
+      return;
+    }
+    controller.enqueue(chunk);
+  };
+  const cleanup = () => {
+    _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;
+  };
+  const stop = (closeController) => {
+    if (closed) return;
+    closed = true;
+    cleanup();
+    if (closeController) _optionalChain([controller, 'optionalAccess', _5 => _5.close, 'call', _6 => _6()]);
+  };
+  const abort = () => stop(true);
+  const overflow = () => {
+    if (closed) return;
+    stop(false);
+    _optionalChain([controller, 'optionalAccess', _7 => _7.error, 'call', _8 => _8(new Error("Farm cache invalidation stream exceeded its buffer limit."))]);
+  };
+  const flush = () => {
+    flushScheduled = false;
+    if (closed || pending.size === 0) return;
+    const encoded = _chunkUZCMMJJTcjs.encodeFarmCacheInvalidations.call(void 0, [...pending]);
+    pending.clear();
+    pendingBytes = 0;
+    if (encoded !== null) enqueue(`data: ${encoded}
+
+`);
+  };
+  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 = _chunkUZCMMJJTcjs.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: (chunk) => chunk.byteLength }
+  );
+  return new Response(stream, {
+    headers: {
+      "Cache-Control": "no-cache, no-transform",
+      "Content-Type": "text/event-stream; charset=utf-8"
+    }
+  });
+}
+
+// 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;
+    });
+  };
+}
+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 = async (key) => `${base}:entry:${await encodeStorageKeySegment(key)}`;
+  const tagKey = async (tag) => `${base}:tag:${await encodeStorageKeySegment(tag)}`;
+  return {
+    name: "storage",
+    get: async (key) => storage.getItem(await entryKey(key)),
+    set: async (key, entry) => {
+      const ttlMs = getFarmCacheEntryTtlMs(entry);
+      if (ttlMs === void 0) {
+        await storage.setItem(await entryKey(key), entry);
+      } else {
+        await storage.setItem(await entryKey(key), entry, { ttl: Math.ceil(ttlMs / 1e3) });
+      }
+    },
+    delete: async (key) => {
+      await storage.removeItem(await entryKey(key));
+    },
+    clear: storage.clear ? async () => {
+      await storage.clear(base);
+    } : void 0,
+    getTagVersions: async (tags) => {
+      const versions = await Promise.all(
+        tags.map(async (tag) => {
+          const value = await storage.getItem(await tagKey(tag));
+          return [tag, normalizeAdapterVersion(value)];
+        })
+      );
+      return Object.fromEntries(versions);
+    },
+    invalidateTags: async (tags) => {
+      await Promise.all(
+        tags.map(async (tag) => {
+          const key = await tagKey(tag);
+          const current = normalizeAdapterVersion(await storage.getItem(key));
+          await storage.setItem(key, Math.max(Date.now(), current + 1));
+        })
+      );
+    }
+  };
+}
+var MAX_STORAGE_KEY_SEGMENT_LENGTH = 200;
+async function encodeStorageKeySegment(value) {
+  let encoded;
+  try {
+    encoded = encodeURIComponent(value);
+  } catch (e) {
+  }
+  if (encoded !== void 0 && encoded.length <= MAX_STORAGE_KEY_SEGMENT_LENGTH) return encoded;
+  const digest = await crypto.subtle.digest(
+    "SHA-256",
+    new TextEncoder().encode(JSON.stringify(value))
+  );
+  let hex = "";
+  for (const byte of new Uint8Array(digest)) hex += byte.toString(16).padStart(2, "0");
+  return `sha256:${hex}`;
+}
+var MIN_STALE_RETENTION_MS = 6e4;
+var PPR_SHELL_ADAPTER_TTL_SECONDS = 86400;
+function getFarmCacheEntryExpiresAt(createdAt, revalidate, now = Date.now()) {
+  if (typeof revalidate !== "number") return void 0;
+  const revalidateMs = revalidate * 1e3;
+  return Math.max(createdAt + revalidateMs, now) + Math.max(revalidateMs, MIN_STALE_RETENTION_MS);
+}
+function getFarmCacheEntryTtlMs(entry, now = Date.now()) {
+  if (typeof entry.expiresAt !== "number" || !Number.isFinite(entry.expiresAt)) return void 0;
+  return Math.max(1, Math.ceil(entry.expiresAt - now));
+}
+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.config = {};
+    this.isShellCache = false;
+    this.lease = {
+      enabled: true,
+      ttlMs: 1e4,
+      waitTimeoutMs: 1e4,
+      pollIntervalMs: 25
+    };
+    this.configure(config);
+  }
+  configure(config = {}) {
+    this.config = config;
+    _optionalChain([this, 'access', _17 => _17.shells, 'optionalAccess', _18 => _18.configure, 'call', _19 => _19(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', _20 => _20.lease, 'optionalAccess', _21 => _21.ttlMs]), 1e4, "cache.lease.ttlMs"),
+      waitTimeoutMs: normalizePositiveDuration(
+        _optionalChain([config, 'access', _22 => _22.lease, 'optionalAccess', _23 => _23.waitTimeoutMs]),
+        1e4,
+        "cache.lease.waitTimeoutMs"
+      ),
+      pollIntervalMs: normalizePositiveDuration(
+        _optionalChain([config, 'access', _24 => _24.lease, 'optionalAccess', _25 => _25.pollIntervalMs]),
+        25,
+        "cache.lease.pollIntervalMs"
+      )
+    };
+  }
+  /**
+   * Where PPR shells live: the same adapter and namespace, so path and tag invalidation
+   * reaches them, but their own in-memory LRU of `maxEntries`.
+   * @internal
+   */
+  get pprShellCache() {
+    if (this.isShellCache) return this;
+    if (!this.shells) {
+      this.shells = new _FarmDataCache(this.config);
+      this.shells.isShellCache = true;
+    }
+    return this.shells;
+  }
+  get adapterName() {
+    return _optionalChain([this, 'access', _26 => _26.adapter, 'optionalAccess', _27 => _27.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', _28 => _28.getEntry, 'call', _29 => _29(key, options), 'optionalAccess', _30 => _30.value]);
+  }
+  getEntry(key, options = {}) {
+    const entry = this.entries.get(key);
+    if (!entry) {
+      _chunkEVIWKPJVcjs.emitFarmEvent.call(void 0, { type: "cache.miss", key });
+      return void 0;
+    }
+    const stale = this.isStale(entry, options.now);
+    if (stale) {
+      _chunkEVIWKPJVcjs.emitFarmEvent.call(void 0, {
+        type: "cache.stale",
+        key,
+        tags: Array.from(entry.tags),
+        revalidate: entry.revalidate
+      });
+    }
+    if (!options.allowStale && stale) {
+      _chunkEVIWKPJVcjs.emitFarmEvent.call(void 0, { type: "cache.miss", key, reason: "stale" });
+      return void 0;
+    }
+    this.touchEntry(key, entry);
+    _chunkEVIWKPJVcjs.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 || isForeignAdapterEntry(entry, key)) {
+      _chunkEVIWKPJVcjs.emitFarmEvent.call(void 0, { type: "cache.miss", key, ...entry ? { reason: "key-mismatch" } : {} });
+      return void 0;
+    }
+    assertFarmCacheEntry(entry, key);
+    if (typeof entry.expiresAt === "number" && entry.expiresAt <= (_nullishCoalesce(options.now, () => ( Date.now())))) {
+      _chunkEVIWKPJVcjs.emitFarmEvent.call(void 0, { type: "cache.miss", key, reason: "expired" });
+      try {
+        await adapter.delete(`${namespace}:entry:${key}`);
+      } catch (error) {
+        _chunkEVIWKPJVcjs.emitFarmEvent.call(void 0, { type: "cache.error", key, operation: "delete", error });
+      }
+      return void 0;
+    }
+    const stale = await this.isAdapterEntryStale(entry, options.now, adapter, namespace);
+    if (generation !== this.generation) return void 0;
+    if (stale) {
+      _chunkEVIWKPJVcjs.emitFarmEvent.call(void 0, {
+        type: "cache.stale",
+        key,
+        tags: [...entry.tags],
+        revalidate: entry.revalidate
+      });
+      if (!options.allowStale) {
+        _chunkEVIWKPJVcjs.emitFarmEvent.call(void 0, { type: "cache.miss", key, reason: "stale" });
+        return void 0;
+      }
+    }
+    _chunkEVIWKPJVcjs.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);
+    _chunkEVIWKPJVcjs.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 createdAt = _nullishCoalesce(options.createdAt, () => ( Date.now()));
+    const expiresAt = _nullishCoalesce(getFarmCacheEntryExpiresAt(createdAt, revalidate), () => ( (this.isShellCache && this.adapter ? createdAt + PPR_SHELL_ADAPTER_TTL_SECONDS * 1e3 : void 0)));
+    const entry = {
+      key,
+      value,
+      tags: Array.from(tags),
+      tagVersions: capturedVersions,
+      createdAt,
+      createdVersion: _nullishCoalesce(createdVersion, () => ( ++this.version)),
+      revalidate,
+      ...expiresAt === void 0 ? {} : { expiresAt }
+    };
+    if (this.local) {
+      this.hydrateLocalEntry(entry);
+    }
+    if (this.adapter) {
+      await this.adapter.set(this.createAdapterKey(key), entry);
+    }
+    _chunkEVIWKPJVcjs.emitFarmEvent.call(void 0, {
+      type: "cache.set",
+      key,
+      tags: [...entry.tags],
+      revalidate: entry.revalidate
+    });
+    return entry;
+  }
+  delete(key) {
+    const deleted = this.deleteLocalEntry(key);
+    _chunkEVIWKPJVcjs.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));
+    }
+    _chunkEVIWKPJVcjs.emitFarmEvent.call(void 0, { type: "cache.delete", key, deleted: this.adapter ? true : deleted });
+    return this.adapter ? true : deleted;
+  }
+  clear() {
+    const count = this.entries.size + (_nullishCoalesce(_optionalChain([this, 'access', _31 => _31.shells, 'optionalAccess', _32 => _32.resetLocal, 'call', _33 => _33()]), () => ( 0)));
+    this.resetLocal();
+    _chunkEVIWKPJVcjs.emitFarmEvent.call(void 0, { type: "cache.clear", count });
+  }
+  resetLocal() {
+    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;
+    return count;
+  }
+  async clearAsync() {
+    this.clear();
+    await _optionalChain([this, 'access', _34 => _34.adapter, 'optionalAccess', _35 => _35.clear, 'optionalCall', _36 => _36()]);
+  }
+  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) + (_nullishCoalesce(_optionalChain([this, 'access', _37 => _37.shells, 'optionalAccess', _38 => _38.invalidateTag, 'call', _39 => _39(normalized)]), () => ( 0)));
+    _chunkEVIWKPJVcjs.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) + (_nullishCoalesce(_optionalChain([this, 'access', _40 => _40.shells, 'optionalAccess', _41 => _41.invalidateTag, 'call', _42 => _42(normalized)]), () => ( 0)));
+    await _optionalChain([this, 'access', _43 => _43.adapter, 'optionalAccess', _44 => _44.invalidateTags, 'optionalCall', _45 => _45([this.createAdapterTag(normalized)])]);
+    _chunkEVIWKPJVcjs.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"]) + (_nullishCoalesce(_optionalChain([this, 'access', _46 => _46.shells, 'optionalAccess', _47 => _47.countEntriesForTags, 'call', _48 => _48([pathTag, "ppr"])]), () => ( 0)));
+    const count = this.invalidateTag(pathTag) + (_nullishCoalesce(_optionalChain([this, 'access', _49 => _49.shells, 'optionalAccess', _50 => _50.invalidateTag, 'call', _51 => _51(pathTag)]), () => ( 0)));
+    _chunkEVIWKPJVcjs.emitFarmEvent.call(void 0, { type: "cache.revalidatePath", path: normalizedPath, count });
+    if (pprCount > 0) {
+      _chunkEVIWKPJVcjs.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"]) + (_nullishCoalesce(_optionalChain([this, 'access', _52 => _52.shells, 'optionalAccess', _53 => _53.countEntriesForTags, 'call', _54 => _54([pathTag, "ppr"])]), () => ( 0)));
+    const count = this.invalidateTag(pathTag) + (_nullishCoalesce(_optionalChain([this, 'access', _55 => _55.shells, 'optionalAccess', _56 => _56.invalidateTag, 'call', _57 => _57(pathTag)]), () => ( 0)));
+    await _optionalChain([this, 'access', _58 => _58.adapter, 'optionalAccess', _59 => _59.invalidateTags, 'optionalCall', _60 => _60([this.createAdapterTag(pathTag)])]);
+    _chunkEVIWKPJVcjs.emitFarmEvent.call(void 0, { type: "cache.revalidatePath", path: normalizedPath, count });
+    if (pprCount > 0) {
+      _chunkEVIWKPJVcjs.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)) {
+      _chunkEVIWKPJVcjs.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) => {
+      _chunkEVIWKPJVcjs.emitFarmEvent.call(void 0, { type: "cache.error", key, operation: "set", error });
+      throw error;
+    }).finally(() => {
+      if (_optionalChain([this, 'access', _61 => _61.inflight, 'access', _62 => _62.get, 'call', _63 => _63(key), 'optionalAccess', _64 => _64.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', _65 => _65.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) {
+          _chunkEVIWKPJVcjs.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', _66 => _66.releaseLease])) {
+        try {
+          await adapter.releaseLease(leaseKey, leaseToken);
+        } catch (error) {
+          _chunkEVIWKPJVcjs.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 || isForeignAdapterEntry(entry, key)) {
+        _chunkEVIWKPJVcjs.emitFarmEvent.call(void 0, { type: "cache.miss", key, ...entry ? { reason: "key-mismatch" } : {} });
+        continue;
+      }
+      assertFarmCacheEntry(entry, key);
+      const stale = await this.isAdapterEntryStale(entry, Date.now(), adapter, namespace);
+      if (generation !== this.generation) return void 0;
+      if (stale) {
+        _chunkEVIWKPJVcjs.emitFarmEvent.call(void 0, {
+          type: "cache.stale",
+          key,
+          tags: [...entry.tags],
+          revalidate: entry.revalidate
+        });
+        _chunkEVIWKPJVcjs.emitFarmEvent.call(void 0, { type: "cache.miss", key, reason: "stale" });
+      } else {
+        _chunkEVIWKPJVcjs.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', _67 => _67.entriesByTag, 'access', _68 => _68.get, 'call', _69 => _69(normalizedTag), 'optionalAccess', _70 => _70.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', _71 => _71.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', _72 => _72.tagVersions, 'optionalAccess', _73 => _73[tag]]))) {
+        return true;
+      }
+    }
+    return false;
+  }
+};
+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;
+}
+function configureFarmCache(config) {
+  sharedFarmDataCache.configure(config);
+}
+function unstable_cache(fn, keyParts = [], options = {}) {
+  return async (...args) => {
+    const locale = _optionalChain([_chunkAOKXITZ6cjs.getActiveFarmI18nSnapshot.call(void 0, ), 'optionalAccess', _74 => _74.locale]);
+    const key = _chunkDXUXQP2Tcjs.createFarmCacheKey.call(void 0, [
+      "unstable_cache",
+      _chunkDXUXQP2Tcjs.getFunctionCacheIdentity.call(void 0, fn),
+      locale ? ["locale", locale] : null,
+      keyParts,
+      args
+    ]);
+    return getFarmDataCache().getOrSet(
+      key,
+      () => _chunk3BIASUGRcjs._runInSharedCacheScope.call(void 0, "unstable_cache()", () => fn(...args)),
+      options
+    );
+  };
+}
+function revalidateTag(_tag, _profile) {
+  const cache = getFarmDataCache();
+  if (cache.hasAdapter) {
+    const task = cache.revalidateTagAsync(_tag, {
+      source: "revalidateTag",
+      profile: _profile
+    }).then(() => void 0);
+    _chunkUZCMMJJTcjs.notifyFarmCacheTask.call(void 0, task);
+    return task;
+  }
+  cache.revalidateTag(_tag, {
+    source: "revalidateTag",
+    profile: _profile
+  });
+}
+function updateTag(tag) {
+  const cache = getFarmDataCache();
+  if (cache.hasAdapter) {
+    const task = cache.revalidateTagAsync(tag, { source: "updateTag" }).then(() => void 0);
+    _chunkUZCMMJJTcjs.notifyFarmCacheTask.call(void 0, task);
+    return task;
+  }
+  cache.revalidateTag(tag, { source: "updateTag" });
+}
+function revalidatePath(routePath) {
+  const cache = getFarmDataCache();
+  if (cache.hasAdapter) {
+    const task = cache.revalidatePathAsync(routePath).then(() => void 0);
+    _chunkUZCMMJJTcjs.notifyFarmCacheTask.call(void 0, task);
+    return task;
+  }
+  cache.revalidatePath(routePath);
+}
+function invalidate(key) {
+  const clientKey = _chunkDXUXQP2Tcjs.createRouteDataCacheKey.call(void 0, key);
+  const task = updateTag(createRouteDataCacheTag(key));
+  _chunkUZCMMJJTcjs.notifyFarmCacheInvalidation.call(void 0, clientKey);
+  return task;
+}
+function invalidateRouteData(key) {
+  return invalidate(key);
+}
+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(_chunkDXUXQP2Tcjs.createRouteDataCacheKey.call(void 0, target.key));
+    } else if ("path" in target) {
+      await revalidatePath(target.path);
+    } else {
+      await updateTag(target.tag);
+    }
+  }
+  return Array.from(new Set(clientKeys));
+}
+function createPathCacheTag(routePath) {
+  return `path:${normalizeRevalidatePath(routePath)}`;
+}
+function createRouteDataCacheTag(key) {
+  return `route-data:${_chunkDXUXQP2Tcjs.createRouteDataCacheKey.call(void 0, key)}`;
+}
+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 (e2) {
+  }
+  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 || "/";
+}
+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;
+}
+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;
+}
+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;
+}
+function normalizeAdapterVersion(value) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : 0;
+}
+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);
+}
+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;
+}
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+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;
+}
+function isForeignAdapterEntry(entry, expectedKey) {
+  return typeof entry === "object" && entry !== null && typeof entry.key === "string" && entry.key !== expectedKey;
+}
+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)}.`
+    );
+  }
+}
+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.");
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.createFarmCacheInvalidationStream = createFarmCacheInvalidationStream; exports.defineCacheKey = defineCacheKey; exports.storageCacheAdapter = storageCacheAdapter; exports.PPR_SHELL_ADAPTER_TTL_SECONDS = PPR_SHELL_ADAPTER_TTL_SECONDS; 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.normalizeRevalidatePath = normalizeRevalidatePath;