@farm.js/core 0.1.0-beta.4 → 0.1.0-beta.6

package/dist/chunk-V3XURYJO.mjs

@@ -1,756 +0,0 @@
-import {
-  getActiveFarmI18nSnapshot
-} from "./chunk-WZ5QFROO.mjs";
-import {
-  notifyFarmCacheInvalidation,
-  notifyFarmCacheTask
-} from "./chunk-RBRLLZL5.mjs";
-import {
-  emitFarmEvent
-} from "./chunk-7ZY5AIJO.mjs";
-import {
-  __name
-} from "./chunk-CGILA3WO.mjs";
-
-// 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;
-    });
-  };
-}
-__name(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__ */ __name((key) => `${base}:entry:${key}`, "entryKey");
-  const tagKey = /* @__PURE__ */ __name((tag) => `${base}:tag:${tag}`, "tagKey");
-  return {
-    name: "storage",
-    get: /* @__PURE__ */ __name((key) => storage.getItem(entryKey(key)), "get"),
-    set: /* @__PURE__ */ __name(async (key, entry) => {
-      await storage.setItem(entryKey(key), entry);
-    }, "set"),
-    delete: /* @__PURE__ */ __name(async (key) => {
-      await storage.removeItem(entryKey(key));
-    }, "delete"),
-    clear: storage.clear ? async () => {
-      await storage.clear(base);
-    } : void 0,
-    getTagVersions: /* @__PURE__ */ __name(async (tags) => {
-      const versions = await Promise.all(
-        tags.map(async (tag) => {
-          const value = await storage.getItem(tagKey(tag));
-          return [tag, normalizeAdapterVersion(value)];
-        })
-      );
-      return Object.fromEntries(versions);
-    }, "getTagVersions"),
-    invalidateTags: /* @__PURE__ */ __name(async (tags) => {
-      await Promise.all(
-        tags.map(async (tag) => {
-          const key = tagKey(tag);
-          const current = normalizeAdapterVersion(await storage.getItem(key));
-          await storage.setItem(key, Math.max(Date.now(), current + 1));
-        })
-      );
-    }, "invalidateTags")
-  };
-}
-__name(storageCacheAdapter, "storageCacheAdapter");
-var _FarmDataCache = class _FarmDataCache {
-  constructor(config = {}) {
-    this.entries = /* @__PURE__ */ new Map();
-    this.inflight = /* @__PURE__ */ new Map();
-    this.invalidatedTagVersions = /* @__PURE__ */ new Map();
-    this.version = 0;
-    this.namespace = "farm";
-    this.local = true;
-    this.lease = {
-      enabled: true,
-      ttlMs: 1e4,
-      waitTimeoutMs: 1e4,
-      pollIntervalMs: 25
-    };
-    this.configure(config);
-  }
-  configure(config = {}) {
-    this.adapter = config.adapter;
-    this.namespace = normalizeCacheNamespace(config.namespace || "farm");
-    this.local = !config.adapter;
-    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"
-      )
-    };
-    if (!this.local) {
-      this.entries.clear();
-      this.inflight.clear();
-      this.invalidatedTagVersions.clear();
-      this.version = 0;
-    }
-  }
-  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;
-    }
-    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 entry = await this.adapter.get(this.createAdapterKey(key));
-    if (!entry) {
-      emitFarmEvent({ type: "cache.miss", key });
-      return void 0;
-    }
-    assertFarmCacheEntry(entry, key);
-    const stale = await this.isAdapterEntryStale(entry, options.now);
-    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 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: normalizeRevalidate(options.revalidate)
-    };
-    this.entries.set(key, entry);
-    emitFarmEvent({
-      type: "cache.set",
-      key,
-      tags: Array.from(tags),
-      revalidate: entry.revalidate
-    });
-    return this.toPublicEntry(entry);
-  }
-  async setAsync(key, value, options = {}, tagVersions) {
-    const tags = normalizeCacheOptionsTags(options);
-    const capturedVersions = tagVersions ?? await this.getAdapterTagVersions(Array.from(tags.values()));
-    const entry = {
-      key,
-      value,
-      tags: Array.from(tags),
-      tagVersions: capturedVersions,
-      createdAt: options.createdAt ?? Date.now(),
-      createdVersion: ++this.version,
-      revalidate: normalizeRevalidate(options.revalidate)
-    };
-    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.entries.delete(key);
-    emitFarmEvent({ type: "cache.delete", key, deleted });
-    return deleted;
-  }
-  async deleteAsync(key) {
-    const deleted = this.entries.delete(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.entries.clear();
-    this.inflight.clear();
-    this.invalidatedTagVersions.clear();
-    this.version = 0;
-    emitFarmEvent({ type: "cache.clear", 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);
-    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);
-    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"]);
-    const count = this.invalidateTag(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 revalidatePathAsync(routePath) {
-    const normalizedPath = normalizeRevalidatePath(routePath);
-    const pathTag = createPathCacheTag(normalizedPath);
-    const pprCount = this.countEntriesForTags([pathTag, "ppr"]);
-    const count = this.invalidateTag(pathTag);
-    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 = {}) {
-    const cached = await this.getEntryAsync(key);
-    if (cached) {
-      return cached.value;
-    }
-    const inflight = this.inflight.get(key);
-    if (inflight) {
-      emitFarmEvent({ type: "cache.dedupe", key });
-      return inflight;
-    }
-    const tags = Array.from(normalizeCacheOptionsTags(options));
-    const promise = this.fillCacheEntry(key, producer, options, tags).catch((error) => {
-      emitFarmEvent({ type: "cache.error", key, operation: "set", error });
-      throw error;
-    }).finally(() => {
-      this.inflight.delete(key);
-    });
-    this.inflight.set(key, promise);
-    return promise;
-  }
-  async fillCacheEntry(key, producer, options, tags) {
-    const leaseKey = `${this.namespace}:lease:${key}`;
-    let leaseToken;
-    if (this.adapter?.acquireLease && this.adapter.releaseLease && this.lease.enabled) {
-      leaseToken = await this.adapter.acquireLease(leaseKey, this.lease.ttlMs);
-      if (!leaseToken) {
-        const shared = await this.waitForAdapterEntry(key);
-        if (shared) {
-          emitFarmEvent({ type: "cache.dedupe", key });
-          return shared.value;
-        }
-        leaseToken = await this.adapter.acquireLease(leaseKey, this.lease.ttlMs);
-      }
-    }
-    try {
-      const initialTagVersions = await this.getAdapterTagVersions(tags);
-      const value = await producer();
-      await this.setAsync(key, value, options, initialTagVersions);
-      return value;
-    } finally {
-      if (leaseToken && this.adapter?.releaseLease) {
-        await this.adapter.releaseLease(leaseKey, leaseToken);
-      }
-    }
-  }
-  async waitForAdapterEntry(key) {
-    const deadline = Date.now() + this.lease.waitTimeoutMs;
-    while (Date.now() < deadline) {
-      await delay(this.lease.pollIntervalMs);
-      const entry = await this.getEntryAsync(key);
-      if (entry) return entry;
-    }
-    return void 0;
-  }
-  countEntriesForTag(tag) {
-    let count = 0;
-    for (const entry of this.entries.values()) {
-      if (entry.tags.has(tag)) {
-        count++;
-      }
-    }
-    return count;
-  }
-  countEntriesForTags(tags) {
-    let count = 0;
-    for (const entry of this.entries.values()) {
-      if (tags.every((tag) => entry.tags.has(tag))) {
-        count++;
-      }
-    }
-    return count;
-  }
-  invalidateTag(normalizedTag) {
-    this.invalidatedTagVersions.set(normalizedTag, ++this.version);
-    return this.countEntriesForTag(normalizedTag);
-  }
-  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.entries.set(entry.key, {
-      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)
-    });
-  }
-  createAdapterKey(key) {
-    return `${this.namespace}:entry:${key}`;
-  }
-  createAdapterTag(tag) {
-    return `${this.namespace}:tag:${tag}`;
-  }
-  async getAdapterTagVersions(tags) {
-    if (!this.adapter?.getTagVersions || tags.length === 0) return {};
-    const normalized = tags.map(normalizeCacheTag);
-    const physicalTags = normalized.map((tag) => this.createAdapterTag(tag));
-    const versions = await this.adapter.getTagVersions(physicalTags);
-    return Object.fromEntries(
-      normalized.map((tag, index) => [
-        tag,
-        normalizeAdapterVersion(versions[physicalTags[index]])
-      ])
-    );
-  }
-  async isAdapterEntryStale(entry, now = Date.now()) {
-    if (typeof entry.revalidate === "number" && entry.revalidate > 0 && now - entry.createdAt >= entry.revalidate * 1e3) {
-      return true;
-    }
-    const currentVersions = await this.getAdapterTagVersions(entry.tags);
-    for (const tag of entry.tags) {
-      if (normalizeAdapterVersion(currentVersions[tag]) > normalizeAdapterVersion(entry.tagVersions?.[tag])) {
-        return true;
-      }
-    }
-    return false;
-  }
-};
-__name(_FarmDataCache, "FarmDataCache");
-var FarmDataCache = _FarmDataCache;
-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());
-var functionIds = /* @__PURE__ */ new WeakMap();
-var nextFunctionId = 0;
-function getFarmDataCache() {
-  return sharedFarmDataCache;
-}
-__name(getFarmDataCache, "getFarmDataCache");
-function configureFarmCache(config) {
-  sharedFarmDataCache.configure(config);
-}
-__name(configureFarmCache, "configureFarmCache");
-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, () => fn(...args), options);
-  };
-}
-__name(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);
-    notifyFarmCacheTask(task);
-    return task;
-  }
-  cache.revalidateTag(_tag, {
-    source: "revalidateTag",
-    profile: _profile
-  });
-}
-__name(revalidateTag, "revalidateTag");
-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" });
-}
-__name(updateTag, "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);
-}
-__name(revalidatePath, "revalidatePath");
-function invalidate(key) {
-  const clientKey = createRouteDataCacheKey(key);
-  const task = updateTag(createRouteDataCacheTag(key));
-  notifyFarmCacheInvalidation(clientKey);
-  return task;
-}
-__name(invalidate, "invalidate");
-function invalidateRouteData(key) {
-  return invalidate(key);
-}
-__name(invalidateRouteData, "invalidateRouteData");
-async function applyFarmCacheInvalidationTargets(targets) {
-  if (!Array.isArray(targets)) {
-    throw new TypeError("Cache invalidations must resolve to an array of targets.");
-  }
-  const clientKeys = [];
-  for (const target of targets) {
-    assertFarmCacheInvalidationTarget(target);
-    if ("key" in target) {
-      await invalidate(target.key);
-      clientKeys.push(createRouteDataCacheKey(target.key));
-    } else if ("path" in target) {
-      await revalidatePath(target.path);
-    } else {
-      await updateTag(target.tag);
-    }
-  }
-  return Array.from(new Set(clientKeys));
-}
-__name(applyFarmCacheInvalidationTargets, "applyFarmCacheInvalidationTargets");
-function createPathCacheTag(routePath) {
-  return `path:${normalizeRevalidatePath(routePath)}`;
-}
-__name(createPathCacheTag, "createPathCacheTag");
-function createRouteDataCacheTag(key) {
-  return `route-data:${createRouteDataCacheKey(key)}`;
-}
-__name(createRouteDataCacheTag, "createRouteDataCacheTag");
-function createRouteDataCacheKey(key) {
-  return createFarmCacheKey(Array.isArray(key) ? key : [key]);
-}
-__name(createRouteDataCacheKey, "createRouteDataCacheKey");
-function normalizeRevalidatePath(routePath) {
-  if (typeof routePath !== "string") {
-    throw new TypeError("revalidatePath expects a path string.");
-  }
-  let normalized = routePath.trim();
-  if (!normalized) {
-    throw new Error("revalidatePath expects a non-empty path.");
-  }
-  try {
-    if (/^https?:\/\//.test(normalized)) {
-      normalized = new URL(normalized).pathname;
-    }
-  } catch {
-  }
-  normalized = normalized.split("?")[0] ?? normalized;
-  normalized = normalized.startsWith("/") ? normalized : `/${normalized}`;
-  normalized = normalized.replace(/\/{2,}/g, "/");
-  if (normalized.length > 1) {
-    normalized = normalized.replace(/\/+$/, "");
-  }
-  return normalized || "/";
-}
-__name(normalizeRevalidatePath, "normalizeRevalidatePath");
-function createFarmCacheKey(parts) {
-  return stableSerialize(parts);
-}
-__name(createFarmCacheKey, "createFarmCacheKey");
-function normalizeRevalidate(revalidate) {
-  if (revalidate === false || revalidate === void 0) {
-    return revalidate;
-  }
-  if (!Number.isFinite(revalidate) || revalidate <= 0) {
-    return void 0;
-  }
-  return revalidate;
-}
-__name(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;
-}
-__name(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;
-}
-__name(normalizeCacheNamespace, "normalizeCacheNamespace");
-function normalizeAdapterVersion(value) {
-  return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : 0;
-}
-__name(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);
-}
-__name(normalizePositiveDuration, "normalizePositiveDuration");
-function delay(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-__name(delay, "delay");
-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;
-}
-__name(normalizeCacheOptionsTags, "normalizeCacheOptionsTags");
-function assertFarmCacheEntry(entry, expectedKey) {
-  if (!entry || typeof entry !== "object" || entry.key !== expectedKey || !Array.isArray(entry.tags) || typeof entry.createdAt !== "number") {
-    throw new TypeError(
-      `Cache adapter returned an invalid entry for ${JSON.stringify(expectedKey)}.`
-    );
-  }
-}
-__name(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.");
-}
-__name(assertFarmCacheInvalidationTarget, "assertFarmCacheInvalidationTarget");
-function getFunctionCacheIdentity(fn) {
-  if (fn.name) {
-    return `name:${fn.name}`;
-  }
-  let id = functionIds.get(fn);
-  if (!id) {
-    id = ++nextFunctionId;
-    functionIds.set(fn, id);
-  }
-  return `anonymous:${id}`;
-}
-__name(getFunctionCacheIdentity, "getFunctionCacheIdentity");
-function stableSerialize(value, seen = /* @__PURE__ */ new WeakSet()) {
-  if (value === null) return "null";
-  if (value === void 0) return "undefined";
-  const valueType = typeof value;
-  if (valueType === "string") return JSON.stringify(value);
-  if (valueType === "number" || valueType === "boolean" || valueType === "bigint") {
-    return `${valueType}:${String(value)}`;
-  }
-  if (valueType === "symbol") {
-    return `symbol:${String(value)}`;
-  }
-  if (valueType === "function") {
-    return `function:${getFunctionCacheIdentity(value)}`;
-  }
-  if (value instanceof Date) {
-    return `date:${value.toISOString()}`;
-  }
-  if (value instanceof URL) {
-    return `url:${value.toString()}`;
-  }
-  if (value instanceof RegExp) {
-    return `regexp:${value.toString()}`;
-  }
-  if (Array.isArray(value)) {
-    return `[${value.map((item) => stableSerialize(item, seen)).join(",")}]`;
-  }
-  if (value && typeof value === "object") {
-    if (seen.has(value)) {
-      return "[Circular]";
-    }
-    seen.add(value);
-    const entries = Object.entries(value).sort(
-      ([a], [b]) => a.localeCompare(b)
-    );
-    const serialized = entries.map(([key, item]) => `${JSON.stringify(key)}:${stableSerialize(item, seen)}`).join(",");
-    seen.delete(value);
-    return `{${serialized}}`;
-  }
-  return String(value);
-}
-__name(stableSerialize, "stableSerialize");
-
-export {
-  defineCacheKey,
-  storageCacheAdapter,
-  FarmDataCache,
-  getFarmDataCache,
-  configureFarmCache,
-  unstable_cache,
-  revalidateTag,
-  updateTag,
-  revalidatePath,
-  invalidate,
-  invalidateRouteData,
-  applyFarmCacheInvalidationTargets,
-  createPathCacheTag,
-  createRouteDataCacheTag,
-  createRouteDataCacheKey,
-  normalizeRevalidatePath,
-  createFarmCacheKey
-};
-//# sourceMappingURL=chunk-V3XURYJO.mjs.map