@farm.js/core 0.1.60 → 0.1.61

package/dist/chunk-RLEALQEN.mjs

@@ -1,998 +0,0 @@
-import {
-  emitFarmEvent
-} from "./chunk-2DA7CLY7.mjs";
-import {
-  getActiveFarmI18nSnapshot
-} from "./chunk-M25IONJP.mjs";
-import {
-  createFarmCacheKey,
-  createRouteDataCacheKey,
-  getFunctionCacheIdentity
-} from "./chunk-GLOICKDO.mjs";
-import {
-  encodeFarmCacheInvalidations,
-  notifyFarmCacheInvalidation,
-  notifyFarmCacheTask,
-  subscribeFarmCacheInvalidation
-} from "./chunk-AZQXXXDX.mjs";
-import {
-  _runInSharedCacheScope
-} from "./chunk-VIXTAVEA.mjs";
-
-// 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 > (controller.desiredSize ?? 0)) {
-      overflow();
-      return;
-    }
-    controller.enqueue(chunk);
-  };
-  const cleanup = () => {
-    unsubscribe?.();
-    unsubscribe = void 0;
-    if (heartbeat !== void 0) clearInterval(heartbeat);
-    heartbeat = void 0;
-    options.signal?.removeEventListener("abort", abort);
-    pending.clear();
-    pendingBytes = 0;
-  };
-  const stop = (closeController) => {
-    if (closed) return;
-    closed = true;
-    cleanup();
-    if (closeController) controller?.close();
-  };
-  const abort = () => stop(true);
-  const overflow = () => {
-    if (closed) return;
-    stop(false);
-    controller?.error(new Error("Farm cache invalidation stream exceeded its buffer limit."));
-  };
-  const flush = () => {
-    flushScheduled = false;
-    if (closed || pending.size === 0) return;
-    const encoded = encodeFarmCacheInvalidations([...pending]);
-    pending.clear();
-    pendingBytes = 0;
-    if (encoded !== null) enqueue(`data: ${encoded}
-
-`);
-  };
-  const stream = new ReadableStream(
-    {
-      start(nextController) {
-        controller = nextController;
-        if (options.signal?.aborted) {
-          stop(true);
-          return;
-        }
-        enqueue(`: connected
-retry: ${retryMs}
-
-`);
-        unsubscribe = subscribeFarmCacheInvalidation((key) => {
-          if (closed || options.filter?.(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);
-          }
-        });
-        options.signal?.addEventListener("abort", abort, { once: true });
-        if (heartbeatIntervalMs !== false) {
-          heartbeat = setInterval(() => {
-            if (controller?.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 {
-  }
-  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;
-    this.shells?.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(config.lease?.ttlMs, 1e4, "cache.lease.ttlMs"),
-      waitTimeoutMs: normalizePositiveDuration(
-        config.lease?.waitTimeoutMs,
-        1e4,
-        "cache.lease.waitTimeoutMs"
-      ),
-      pollIntervalMs: normalizePositiveDuration(
-        config.lease?.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 this.adapter?.name || (this.adapter ? "custom" : "memory");
-  }
-  get hasAdapter() {
-    return this.adapter !== void 0;
-  }
-  get size() {
-    return this.entries.size;
-  }
-  get(key, options = {}) {
-    return this.getEntry(key, options)?.value;
-  }
-  getEntry(key, options = {}) {
-    const entry = this.entries.get(key);
-    if (!entry) {
-      emitFarmEvent({ type: "cache.miss", key });
-      return void 0;
-    }
-    const stale = this.isStale(entry, options.now);
-    if (stale) {
-      emitFarmEvent({
-        type: "cache.stale",
-        key,
-        tags: Array.from(entry.tags),
-        revalidate: entry.revalidate
-      });
-    }
-    if (!options.allowStale && stale) {
-      emitFarmEvent({ type: "cache.miss", key, reason: "stale" });
-      return void 0;
-    }
-    this.touchEntry(key, entry);
-    emitFarmEvent({
-      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)) {
-      emitFarmEvent({ type: "cache.miss", key, ...entry ? { reason: "key-mismatch" } : {} });
-      return void 0;
-    }
-    assertFarmCacheEntry(entry, key);
-    if (typeof entry.expiresAt === "number" && entry.expiresAt <= (options.now ?? Date.now())) {
-      emitFarmEvent({ type: "cache.miss", key, reason: "expired" });
-      try {
-        await adapter.delete(`${namespace}:entry:${key}`);
-      } catch (error) {
-        emitFarmEvent({ 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) {
-      emitFarmEvent({
-        type: "cache.stale",
-        key,
-        tags: [...entry.tags],
-        revalidate: entry.revalidate
-      });
-      if (!options.allowStale) {
-        emitFarmEvent({ type: "cache.miss", key, reason: "stale" });
-        return void 0;
-      }
-    }
-    emitFarmEvent({
-      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 options.tags ?? []) {
-      tags.add(normalizeCacheTag(tag));
-    }
-    for (const routePath of options.paths ?? []) {
-      tags.add(createPathCacheTag(routePath));
-    }
-    const entry = {
-      key,
-      value,
-      tags,
-      tagVersions: void 0,
-      createdAt: options.createdAt ?? Date.now(),
-      createdVersion: ++this.version,
-      revalidate
-    };
-    this.storeLocalEntry(entry);
-    emitFarmEvent({
-      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 = tagVersions ?? await this.getAdapterTagVersions(Array.from(tags.values()));
-    const createdAt = options.createdAt ?? Date.now();
-    const expiresAt = 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: 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);
-    }
-    emitFarmEvent({
-      type: "cache.set",
-      key,
-      tags: [...entry.tags],
-      revalidate: entry.revalidate
-    });
-    return entry;
-  }
-  delete(key) {
-    const deleted = this.deleteLocalEntry(key);
-    emitFarmEvent({ 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));
-    }
-    emitFarmEvent({ type: "cache.delete", key, deleted: this.adapter ? true : deleted });
-    return this.adapter ? true : deleted;
-  }
-  clear() {
-    const count = this.entries.size + (this.shells?.resetLocal() ?? 0);
-    this.resetLocal();
-    emitFarmEvent({ 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 this.adapter?.clear?.();
-  }
-  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) + (this.shells?.invalidateTag(normalized) ?? 0);
-    emitFarmEvent(
-      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) + (this.shells?.invalidateTag(normalized) ?? 0);
-    await this.adapter?.invalidateTags?.([this.createAdapterTag(normalized)]);
-    emitFarmEvent(
-      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"]) + (this.shells?.countEntriesForTags([pathTag, "ppr"]) ?? 0);
-    const count = this.invalidateTag(pathTag) + (this.shells?.invalidateTag(pathTag) ?? 0);
-    emitFarmEvent({ type: "cache.revalidatePath", path: normalizedPath, count });
-    if (pprCount > 0) {
-      emitFarmEvent({
-        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"]) + (this.shells?.countEntriesForTags([pathTag, "ppr"]) ?? 0);
-    const count = this.invalidateTag(pathTag) + (this.shells?.invalidateTag(pathTag) ?? 0);
-    await this.adapter?.invalidateTags?.([this.createAdapterTag(pathTag)]);
-    emitFarmEvent({ type: "cache.revalidatePath", path: normalizedPath, count });
-    if (pprCount > 0) {
-      emitFarmEvent({
-        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)) {
-      emitFarmEvent({ 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) => {
-      emitFarmEvent({ type: "cache.error", key, operation: "set", error });
-      throw error;
-    }).finally(() => {
-      if (this.inflight.get(key)?.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 (adapter?.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) {
-          emitFarmEvent({ 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 && adapter?.releaseLease) {
-        try {
-          await adapter.releaseLease(leaseKey, leaseToken);
-        } catch (error) {
-          emitFarmEvent({ 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)) {
-        emitFarmEvent({ 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) {
-        emitFarmEvent({
-          type: "cache.stale",
-          key,
-          tags: [...entry.tags],
-          revalidate: entry.revalidate
-        });
-        emitFarmEvent({ type: "cache.miss", key, reason: "stale" });
-      } else {
-        emitFarmEvent({
-          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 this.entriesByTag.get(tags[0]) ?? []) {
-      if (tags.every((tag) => entry.tags.has(tag))) {
-        count++;
-      }
-    }
-    return count;
-  }
-  invalidateTag(normalizedTag) {
-    const count = this.entriesByTag.get(normalizedTag)?.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: 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 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 (!adapter?.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(entry.tagVersions?.[tag])) {
-        return true;
-      }
-    }
-    return false;
-  }
-};
-var FARM_DATA_CACHE_SYMBOL = /* @__PURE__ */ Symbol.for("farm.dataCache");
-var farmDataCacheGlobal = globalThis;
-var sharedFarmDataCache = 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 = getActiveFarmI18nSnapshot()?.locale;
-    const key = createFarmCacheKey([
-      "unstable_cache",
-      getFunctionCacheIdentity(fn),
-      locale ? ["locale", locale] : null,
-      keyParts,
-      args
-    ]);
-    return getFarmDataCache().getOrSet(
-      key,
-      () => _runInSharedCacheScope("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);
-    notifyFarmCacheTask(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);
-    notifyFarmCacheTask(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);
-    notifyFarmCacheTask(task);
-    return task;
-  }
-  cache.revalidatePath(routePath);
-}
-function invalidate(key) {
-  const clientKey = createRouteDataCacheKey(key);
-  const task = updateTag(createRouteDataCacheTag(key));
-  notifyFarmCacheInvalidation(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(createRouteDataCacheKey(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:${createRouteDataCacheKey(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 {
-  }
-  normalized = 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 options.tags ?? []) {
-    tags.add(normalizeCacheTag(tag));
-  }
-  for (const routePath of 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.");
-}
-
-export {
-  createFarmCacheInvalidationStream,
-  defineCacheKey,
-  storageCacheAdapter,
-  PPR_SHELL_ADAPTER_TTL_SECONDS,
-  FarmDataCache,
-  getFarmDataCache,
-  configureFarmCache,
-  unstable_cache,
-  revalidateTag,
-  updateTag,
-  revalidatePath,
-  invalidate,
-  invalidateRouteData,
-  applyFarmCacheInvalidationTargets,
-  createPathCacheTag,
-  createRouteDataCacheTag,
-  normalizeRevalidatePath
-};