@farm.js/core 0.1.61 → 0.1.63

package/dist/chunk-YWN746US.cjs

@@ -1,1002 +0,0 @@
-"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 _chunkE3UK5IIBcjs = require('./chunk-E3UK5IIB.cjs');
-
-
-var _chunkLIUGYUX3cjs = require('./chunk-LIUGYUX3.cjs');
-
-
-
-
-var _chunkNYJMY3JAcjs = require('./chunk-NYJMY3JA.cjs');
-
-
-
-
-
-var _chunkZEG3OPIBcjs = require('./chunk-ZEG3OPIB.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, async (key) => `${base}:entry:${await encodeStorageKeySegment(key)}`, "entryKey");
-  const tagKey = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, async (tag) => `${base}:tag:${await encodeStorageKeySegment(tag)}`, "tagKey");
-  return {
-    name: "storage",
-    get: /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, async (key) => storage.getItem(await entryKey(key)), "get"),
-    set: /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, 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) });
-      }
-    }, "set"),
-    delete: /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, async (key) => {
-      await storage.removeItem(await 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(await 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 = await 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 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}`;
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, encodeStorageKeySegment, "encodeStorageKeySegment");
-var MIN_STALE_RETENTION_MS = 6e4;
-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);
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, getFarmCacheEntryExpiresAt, "getFarmCacheEntryExpiresAt");
-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));
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, getFarmCacheEntryTtlMs, "getFarmCacheEntryTtlMs");
-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 || isForeignAdapterEntry(entry, key)) {
-      _chunkE3UK5IIBcjs.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())))) {
-      _chunkE3UK5IIBcjs.emitFarmEvent.call(void 0, { type: "cache.miss", key, reason: "expired" });
-      try {
-        await adapter.delete(`${namespace}:entry:${key}`);
-      } catch (error) {
-        _chunkE3UK5IIBcjs.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) {
-      _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 createdAt = _nullishCoalesce(options.createdAt, () => ( Date.now()));
-    const expiresAt = getFarmCacheEntryExpiresAt(createdAt, revalidate);
-    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);
-    }
-    _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 || isForeignAdapterEntry(entry, key)) {
-        _chunkE3UK5IIBcjs.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) {
-        _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 = _chunkNYJMY3JAcjs.createFarmCacheKey.call(void 0, [
-      "unstable_cache",
-      _chunkNYJMY3JAcjs.getFunctionCacheIdentity.call(void 0, 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 = _chunkNYJMY3JAcjs.createRouteDataCacheKey.call(void 0, 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(_chunkNYJMY3JAcjs.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));
-}
-_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:${_chunkNYJMY3JAcjs.createRouteDataCacheKey.call(void 0, key)}`;
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, createRouteDataCacheTag, "createRouteDataCacheTag");
-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 || "/";
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, normalizeRevalidatePath, "normalizeRevalidatePath");
-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 isForeignAdapterEntry(entry, expectedKey) {
-  return typeof entry === "object" && entry !== null && typeof entry.key === "string" && entry.key !== expectedKey;
-}
-_chunkS3JO3N4Hcjs.__name.call(void 0, isForeignAdapterEntry, "isForeignAdapterEntry");
-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");
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-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.normalizeRevalidatePath = normalizeRevalidatePath;