@farm.js/core 0.1.47 → 0.1.49

package/dist/chunk-RLEALQEN.mjs

@@ -0,0 +1,998 @@
+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
+};