@farm.js/core 0.1.51-beta.3 → 0.1.61

package/dist/chunk-5QIKR7RR.cjs

@@ -0,0 +1,224 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var _chunkQNPEUFHQcjs = require('./chunk-QNPEUFHQ.cjs');
+
+
+var _chunkUS2QVW3Ecjs = require('./chunk-US2QVW3E.cjs');
+
+
+
+
+var _chunkNO3WWW3Ncjs = require('./chunk-NO3WWW3N.cjs');
+
+
+var _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
+
+// src/utils.ts
+var _path = require('path'); var _path2 = _interopRequireDefault(_path);
+function parseRoutePath(filePath) {
+  const segments = [];
+  const normalizedPath = filePath.replace(/\\/g, "/");
+  const pathParts = normalizedPath.split("/").filter(Boolean);
+  const fileName = pathParts.pop() || "";
+  const fileType = getRouteType(fileName);
+  const routePath = `/${pathParts.join("/")}`;
+  _chunkNO3WWW3Ncjs.assertBrowserStableRoutePath.call(void 0, routePath);
+  _chunkNO3WWW3Ncjs.assertTerminalCatchAll.call(void 0, routePath);
+  _chunkNO3WWW3Ncjs.assertUniqueRouteParameters.call(void 0, routePath);
+  for (const part of pathParts) {
+    if (part.startsWith("(") && part.endsWith(")")) continue;
+    if (part.startsWith("[") && part.endsWith("]")) {
+      let segment = part.slice(1, -1);
+      const isDynamic = true;
+      let isOptional = false;
+      let isCatchAll = false;
+      if (segment.startsWith("[") && segment.endsWith("]")) {
+        isOptional = true;
+        segment = segment.slice(1, -1);
+        if (segment.startsWith("...")) {
+          segment = segment.slice(3);
+          isCatchAll = true;
+        }
+      } else if (segment.startsWith("...")) {
+        segment = segment.slice(3);
+        isCatchAll = true;
+      }
+      segments.push({ segment, isDynamic, isOptional, isCatchAll });
+    } else {
+      segments.push({
+        segment: part,
+        isDynamic: false,
+        isOptional: false,
+        isCatchAll: false
+      });
+    }
+  }
+  return {
+    segments,
+    filePath: normalizedPath,
+    type: fileType
+  };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, parseRoutePath, "parseRoutePath");
+function getRouteType(fileName) {
+  const baseName = fileName.replace(/\.(tsx?|jsx?|vue|svelte|mdx?|markdown)$/, "");
+  switch (baseName) {
+    case "page":
+      return "page";
+    case "layout":
+      return "layout";
+    case "loading":
+      return "loading";
+    case "error":
+      return "error";
+    case "not-found":
+      return "not-found";
+    default:
+      return "page";
+  }
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, getRouteType, "getRouteType");
+function segmentsToPattern(segments) {
+  if (segments.length === 0) return "/";
+  return "/" + segments.map((segment) => {
+    if (!segment.isDynamic) return segment.segment;
+    if (segment.isCatchAll) {
+      return segment.isOptional ? `*${segment.segment}?` : `*${segment.segment}`;
+    }
+    return `:${segment.segment}`;
+  }).join("/");
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, segmentsToPattern, "segmentsToPattern");
+function matchRoute(url, segments) {
+  return matchRouteParts(splitRoutePath(url), segments);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, matchRoute, "matchRoute");
+function splitRoutePath(url) {
+  return url.split("/").filter(Boolean).map(_chunkUS2QVW3Ecjs.decodeRouteSegment);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, splitRoutePath, "splitRoutePath");
+function matchRouteParts(urlParts, segments) {
+  const params = {};
+  if (segments.length === 0) {
+    return { params, matches: urlParts.length === 0 };
+  }
+  let urlIndex = 0;
+  let segmentIndex = 0;
+  while (segmentIndex < segments.length && urlIndex <= urlParts.length) {
+    const segment = segments[segmentIndex];
+    if (!segment.isDynamic) {
+      if (urlParts[urlIndex] !== segment.segment) {
+        return { params: {}, matches: false };
+      }
+      urlIndex++;
+      segmentIndex++;
+    } else if (segment.isCatchAll) {
+      const remainingParts = urlParts.slice(urlIndex);
+      if (remainingParts.length === 0 && !segment.isOptional) {
+        return { params: {}, matches: false };
+      }
+      params[segment.segment] = remainingParts.join("/");
+      urlIndex = urlParts.length;
+      segmentIndex++;
+    } else {
+      if (urlIndex >= urlParts.length) {
+        return { params: {}, matches: false };
+      }
+      params[segment.segment] = urlParts[urlIndex];
+      urlIndex++;
+      segmentIndex++;
+    }
+  }
+  const matches = segmentIndex === segments.length && urlIndex === urlParts.length;
+  return { params, matches };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, matchRouteParts, "matchRouteParts");
+function matchRoutePrefix(url, segments) {
+  return matchRoutePrefixParts(splitRoutePath(url), segments);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, matchRoutePrefix, "matchRoutePrefix");
+function matchRoutePrefixParts(urlParts, segments) {
+  let urlIndex = 0;
+  for (const segment of segments) {
+    if (segment.isCatchAll) {
+      return segment.isOptional || urlIndex < urlParts.length;
+    }
+    const urlPart = urlParts[urlIndex];
+    if (urlPart === void 0) return false;
+    if (!segment.isDynamic && segment.segment !== urlPart) return false;
+    urlIndex++;
+  }
+  return true;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, matchRoutePrefixParts, "matchRoutePrefixParts");
+function resolveAppPath(root, ...paths) {
+  return _path2.default.resolve(root, ...paths);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, resolveAppPath, "resolveAppPath");
+function toRootRelativeUrlPath(absolutePath, projectRoot) {
+  if (absolutePath === projectRoot) return "";
+  if (absolutePath.startsWith(`${projectRoot}/`) || absolutePath.startsWith(`${projectRoot}\\`)) {
+    return absolutePath.slice(projectRoot.length).replace(/\\/g, "/");
+  }
+  return void 0;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, toRootRelativeUrlPath, "toRootRelativeUrlPath");
+function toPosixPath(filePath) {
+  return filePath.replace(/\\/g, "/");
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, toPosixPath, "toPosixPath");
+function toViteModuleId(filePath, root) {
+  if (!_path2.default.isAbsolute(filePath)) return filePath;
+  const relativePath = _path2.default.relative(root, filePath);
+  if (relativePath && !relativePath.startsWith("..") && !_path2.default.isAbsolute(relativePath)) {
+    return `/${relativePath.split(_path2.default.sep).join("/")}`;
+  }
+  const normalizedPath = filePath.replace(/\\/g, "/");
+  return normalizedPath.startsWith("/") ? `/@fs${normalizedPath}` : `/@fs/${normalizedPath}`;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, toViteModuleId, "toViteModuleId");
+async function fileExists(filePath) {
+  try {
+    const fs = await import("fs/promises");
+    await fs.access(filePath);
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, fileExists, "fileExists");
+async function globFiles(pattern, cwd) {
+  const glob = await import("fast-glob");
+  return glob.default(pattern, { cwd, absolute: false });
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, globFiles, "globFiles");
+function parseSearchParams(searchParams) {
+  return _chunkQNPEUFHQcjs.searchParamsToObject.call(void 0, searchParams);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, parseSearchParams, "parseSearchParams");
+var logger = {
+  info: /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, (message) => console.log(`[info] ${message}`), "info"),
+  success: /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, (message) => console.log(`[success] ${message}`), "success"),
+  warn: /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, (message) => console.warn(`\u26A0\uFE0F  ${message}`), "warn"),
+  error: /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, (message) => console.error(`\u274C ${message}`), "error"),
+  ready: /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, (message) => console.log(`${message}`), "ready"),
+  event: /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, (message) => console.log(`  ${message}`), "event")
+};
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.parseRoutePath = parseRoutePath; exports.segmentsToPattern = segmentsToPattern; exports.matchRoute = matchRoute; exports.splitRoutePath = splitRoutePath; exports.matchRouteParts = matchRouteParts; exports.matchRoutePrefix = matchRoutePrefix; exports.matchRoutePrefixParts = matchRoutePrefixParts; exports.resolveAppPath = resolveAppPath; exports.toRootRelativeUrlPath = toRootRelativeUrlPath; exports.toPosixPath = toPosixPath; exports.toViteModuleId = toViteModuleId; exports.fileExists = fileExists; exports.globFiles = globFiles; exports.parseSearchParams = parseSearchParams; exports.logger = logger;

package/dist/chunk-5SJWVY6R.mjs

@@ -0,0 +1,26 @@
+import {
+  __name
+} from "./chunk-LPEX4YW6.mjs";
+
+// src/client/navigation-url.ts
+var FARM_NAVIGATION_PROTOCOLS = /* @__PURE__ */ new Set(["http:", "https:", "mailto:", "tel:"]);
+function isFarmBlockedNavigationURL(url) {
+  if (FARM_NAVIGATION_PROTOCOLS.has(url.protocol)) return false;
+  console.error(`[Farm.js] Blocked navigation to a ${url.protocol} URL as a security precaution.`);
+  return true;
+}
+__name(isFarmBlockedNavigationURL, "isFarmBlockedNavigationURL");
+function isFarmExternalNavigationURL(url, currentOrigin) {
+  return url.protocol !== "http:" && url.protocol !== "https:" || url.origin !== currentOrigin;
+}
+__name(isFarmExternalNavigationURL, "isFarmExternalNavigationURL");
+function resolveFarmNavigationURL(href, documentUrl) {
+  return new URL(href, documentUrl);
+}
+__name(resolveFarmNavigationURL, "resolveFarmNavigationURL");
+
+export {
+  isFarmBlockedNavigationURL,
+  isFarmExternalNavigationURL,
+  resolveFarmNavigationURL
+};

package/dist/chunk-5WI2S4CO.mjs

@@ -0,0 +1,20 @@
+import {
+  __name
+} from "./chunk-LPEX4YW6.mjs";
+
+// src/response-body.ts
+function omitFarmResponseBody(response) {
+  if (response.body) {
+    void response.body.cancel().catch(() => void 0);
+  }
+  return new Response(null, {
+    status: response.status,
+    statusText: response.statusText,
+    headers: response.headers
+  });
+}
+__name(omitFarmResponseBody, "omitFarmResponseBody");
+
+export {
+  omitFarmResponseBody
+};

package/dist/chunk-63H6BKXG.cjs

@@ -0,0 +1,389 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+var _chunkNYJMY3JAcjs = require('./chunk-NYJMY3JA.cjs');
+
+
+var _chunkZEG3OPIBcjs = require('./chunk-ZEG3OPIB.cjs');
+
+
+var _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
+
+// src/client-cache.ts
+var invalidationTrackers = /* @__PURE__ */ new WeakMap();
+function trackFarmClientCacheInvalidations(cache) {
+  let trackers = invalidationTrackers.get(cache);
+  if (!trackers) {
+    trackers = /* @__PURE__ */ new Set();
+    invalidationTrackers.set(cache, trackers);
+  }
+  const keys = /* @__PURE__ */ new Set();
+  trackers.add(keys);
+  return {
+    has(key) {
+      const resolved = cache.resolveKey(key);
+      for (const invalidated of keys) {
+        if (cache.resolveKey(invalidated) === resolved) return true;
+      }
+      return false;
+    },
+    dispose() {
+      if (!trackers.delete(keys)) return;
+      keys.clear();
+      if (trackers.size === 0) invalidationTrackers.delete(cache);
+    }
+  };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, trackFarmClientCacheInvalidations, "trackFarmClientCacheInvalidations");
+var cacheFinalizer = typeof FinalizationRegistry === "function" ? new FinalizationRegistry((unsubscribe) => unsubscribe()) : void 0;
+var DEFAULT_GC_SWEEP_INTERVAL_MS = 3e4;
+var _FarmClientDataCache = class _FarmClientDataCache {
+  constructor(options = {}) {
+    this.entries = /* @__PURE__ */ new Map();
+    this.aliases = /* @__PURE__ */ new Map();
+    this.aliasesByTarget = /* @__PURE__ */ new Map();
+    this.invalidatedAt = /* @__PURE__ */ new Map();
+    this.listeners = /* @__PURE__ */ new Map();
+    this.inflight = /* @__PURE__ */ new Map();
+    this.pendingMetadataSweeps = /* @__PURE__ */ new Set();
+    this.gcSweepIntervalMs = _nullishCoalesce(options.gcSweepIntervalMs, () => ( DEFAULT_GC_SWEEP_INTERVAL_MS));
+    if (options.subscribeToInvalidation !== false) {
+      if (typeof WeakRef === "function") {
+        const reference = new WeakRef(this);
+        const unsubscribe = _FarmClientDataCache.subscribeWeakCache(reference);
+        _optionalChain([cacheFinalizer, 'optionalAccess', _ => _.register, 'call', _2 => _2(this, unsubscribe, reference)]);
+        this.unsubscribeInvalidation = unsubscribe;
+      } else {
+        this.unsubscribeInvalidation = _chunkZEG3OPIBcjs.subscribeFarmCacheInvalidation.call(void 0, 
+          (key) => this.applyInvalidation(key, Date.now(), false)
+        );
+      }
+    }
+  }
+  // This closure must only capture a weak reference, never the cache itself.
+  static subscribeWeakCache(reference) {
+    const unsubscribe = _chunkZEG3OPIBcjs.subscribeFarmCacheInvalidation.call(void 0, (key) => {
+      const cache = reference.deref();
+      if (cache) cache.applyInvalidation(key, Date.now(), false);
+      else dispose();
+    });
+    function dispose() {
+      unsubscribe();
+      _optionalChain([cacheFinalizer, 'optionalAccess', _3 => _3.unregister, 'call', _4 => _4(reference)]);
+    }
+    _chunkS3JO3N4Hcjs.__name.call(void 0, dispose, "dispose");
+    return dispose;
+  }
+  get size() {
+    return this.entries.size;
+  }
+  /** @internal Attach or detach the persistence engine's observation sink. */
+  attachPersistence(sink) {
+    this.persistence = sink;
+  }
+  resolveKey(key) {
+    let resolved = key;
+    const seen = /* @__PURE__ */ new Set();
+    while (this.aliases.has(resolved) && !seen.has(resolved)) {
+      seen.add(resolved);
+      resolved = this.aliases.get(resolved);
+    }
+    return resolved;
+  }
+  get(key, now = Date.now()) {
+    const resolved = this.resolveKey(key);
+    const entry = this.entries.get(resolved);
+    if (!entry) return void 0;
+    if (entry.gcAt !== void 0 && now >= entry.gcAt) {
+      if (entry.fetching) return void 0;
+      this.entries.delete(resolved);
+      _optionalChain([this, 'access', _5 => _5.persistence, 'optionalAccess', _6 => _6.onDelete, 'call', _7 => _7(resolved)]);
+      this.sweepEntryMetadata(/* @__PURE__ */ new Set([resolved]));
+      this.emit(resolved);
+      return void 0;
+    }
+    return entry;
+  }
+  set(key, entry) {
+    const resolved = this.resolveKey(key);
+    const invalidatedAt = this.invalidatedAt.get(resolved);
+    const nextEntry = invalidatedAt !== void 0 && invalidatedAt > entry.updatedAt ? { ...entry, staleAt: 0, invalidatedAt } : { ...entry, invalidatedAt: void 0 };
+    if (invalidatedAt === void 0 || entry.updatedAt >= invalidatedAt) {
+      this.invalidatedAt.delete(resolved);
+    }
+    this.entries.set(resolved, nextEntry);
+    this.pendingMetadataSweeps.delete(resolved);
+    if (nextEntry.gcAt !== void 0) this.scheduleGcSweep();
+    _optionalChain([this, 'access', _8 => _8.persistence, 'optionalAccess', _9 => _9.onSet, 'call', _10 => _10(resolved, nextEntry)]);
+    this.emit(resolved);
+    return this;
+  }
+  delete(key) {
+    const resolved = this.resolveKey(key);
+    const deleted = this.entries.delete(resolved);
+    this.inflight.delete(resolved);
+    if (deleted) _optionalChain([this, 'access', _11 => _11.persistence, 'optionalAccess', _12 => _12.onDelete, 'call', _13 => _13(resolved)]);
+    if (deleted || this.pendingMetadataSweeps.has(resolved)) {
+      this.sweepEntryMetadata(/* @__PURE__ */ new Set([resolved]));
+    }
+    this.emit(resolved);
+    return deleted;
+  }
+  clear() {
+    const keys = /* @__PURE__ */ new Set([...this.entries.keys(), ...this.listeners.keys()]);
+    this.entries.clear();
+    this.aliases.clear();
+    this.aliasesByTarget.clear();
+    this.invalidatedAt.clear();
+    this.inflight.clear();
+    this.pendingMetadataSweeps.clear();
+    _optionalChain([this, 'access', _14 => _14.persistence, 'optionalAccess', _15 => _15.onClear, 'call', _16 => _16()]);
+    for (const key of keys) this.emit(key);
+  }
+  dispose() {
+    _optionalChain([this, 'access', _17 => _17.unsubscribeInvalidation, 'optionalCall', _18 => _18()]);
+    this.unsubscribeInvalidation = void 0;
+    if (this.gcTimer !== void 0) {
+      clearTimeout(this.gcTimer);
+      this.gcTimer = void 0;
+    }
+    this.clear();
+  }
+  isStale(key, now = Date.now()) {
+    const entry = this.get(key, now);
+    return !entry || entry.invalidatedAt !== void 0 || now >= entry.staleAt;
+  }
+  invalidate(key, now = Date.now()) {
+    this.applyInvalidation(key, now, true);
+  }
+  applyInvalidation(key, now, retainUnowned) {
+    const resolved = this.resolveKey(key);
+    for (const keys of _nullishCoalesce(invalidationTrackers.get(this), () => ( []))) keys.add(resolved);
+    const entry = this.entries.get(resolved);
+    const alreadyRetained = this.invalidatedAt.has(resolved);
+    if (retainUnowned || entry || alreadyRetained || this.hasMetadataOwner(resolved)) {
+      this.invalidatedAt.set(resolved, now);
+      if (!entry && !retainUnowned && !alreadyRetained) this.pendingMetadataSweeps.add(resolved);
+    }
+    if (entry) {
+      this.entries.set(resolved, {
+        ...entry,
+        staleAt: 0,
+        invalidatedAt: now
+      });
+    }
+    this.emit(resolved, "invalidate");
+  }
+  hasMetadataOwner(key) {
+    const related = /* @__PURE__ */ new Set([key]);
+    for (const target of related) {
+      if (this.listeners.has(target) || this.inflight.has(target)) return true;
+      for (const alias of _nullishCoalesce(this.aliasesByTarget.get(target), () => ( []))) related.add(alias);
+    }
+    return false;
+  }
+  alias(alias, key) {
+    const resolved = this.resolveKey(key);
+    if (alias === resolved) return;
+    const aliasEntry = this.entries.get(alias);
+    const aliasInvalidatedAt = _nullishCoalesce(this.invalidatedAt.get(alias), () => ( _optionalChain([aliasEntry, 'optionalAccess', _19 => _19.invalidatedAt])));
+    const resolvedInvalidatedAt = this.invalidatedAt.get(resolved);
+    if (aliasEntry && !this.entries.has(resolved)) {
+      this.entries.set(resolved, aliasEntry);
+      _optionalChain([this, 'access', _20 => _20.persistence, 'optionalAccess', _21 => _21.onSet, 'call', _22 => _22(resolved, aliasEntry)]);
+    }
+    if (this.entries.delete(alias)) _optionalChain([this, 'access', _23 => _23.persistence, 'optionalAccess', _24 => _24.onDelete, 'call', _25 => _25(alias)]);
+    this.invalidatedAt.delete(alias);
+    const invalidatedAt = [aliasInvalidatedAt, resolvedInvalidatedAt].reduce(
+      (latest, value) => value === void 0 ? latest : latest === void 0 ? value : Math.max(latest, value),
+      void 0
+    );
+    const resolvedEntry = this.entries.get(resolved);
+    if (invalidatedAt !== void 0 && (!resolvedEntry || invalidatedAt > resolvedEntry.updatedAt)) {
+      this.invalidatedAt.set(resolved, invalidatedAt);
+      if (resolvedEntry) {
+        this.entries.set(resolved, {
+          ...resolvedEntry,
+          staleAt: 0,
+          invalidatedAt
+        });
+      }
+    } else if (invalidatedAt !== void 0) {
+      this.invalidatedAt.delete(resolved);
+      if (_optionalChain([resolvedEntry, 'optionalAccess', _26 => _26.invalidatedAt]) !== void 0) {
+        this.entries.set(resolved, { ...resolvedEntry, invalidatedAt: void 0 });
+      }
+    }
+    const aliasInflight = this.inflight.get(alias);
+    if (aliasInflight && !this.inflight.has(resolved)) {
+      this.inflight.set(resolved, aliasInflight);
+    }
+    this.inflight.delete(alias);
+    if (this.pendingMetadataSweeps.delete(alias) && !this.entries.has(resolved)) {
+      this.pendingMetadataSweeps.add(resolved);
+    }
+    const previousTarget = this.aliases.get(alias);
+    if (previousTarget !== resolved) {
+      const previousResolved = previousTarget !== void 0 && this.pendingMetadataSweeps.size > 0 ? this.resolveKey(alias) : void 0;
+      this.removeAlias(alias);
+      this.aliases.set(alias, resolved);
+      let aliases = this.aliasesByTarget.get(resolved);
+      if (!aliases) this.aliasesByTarget.set(resolved, aliases = /* @__PURE__ */ new Set());
+      aliases.add(alias);
+      if (previousResolved !== void 0) this.sweepPendingEntryMetadata(previousResolved);
+    }
+    this.emit(alias);
+    this.emit(resolved, this.invalidatedAt.has(resolved) ? "invalidate" : void 0);
+  }
+  subscribe(key, listener) {
+    let listeners = this.listeners.get(key);
+    if (!listeners) {
+      listeners = /* @__PURE__ */ new Set();
+      this.listeners.set(key, listeners);
+    }
+    listeners.add(listener);
+    return () => {
+      listeners.delete(listener);
+      if (listeners.size === 0 && this.listeners.get(key) === listeners) {
+        this.listeners.delete(key);
+        this.sweepPendingEntryMetadata(key);
+      }
+    };
+  }
+  getInflight(key) {
+    return this.inflight.get(this.resolveKey(key));
+  }
+  setInflight(key, promise) {
+    this.inflight.set(this.resolveKey(key), promise);
+  }
+  deleteInflight(key) {
+    const resolved = this.resolveKey(key);
+    if (this.inflight.delete(resolved)) this.sweepPendingEntryMetadata(resolved);
+  }
+  scheduleGcSweep() {
+    if (this.gcSweepIntervalMs === false || this.gcTimer !== void 0) return;
+    const timer = setTimeout(() => {
+      this.gcTimer = void 0;
+      this.sweepExpiredEntries();
+    }, this.gcSweepIntervalMs);
+    _optionalChain([timer, 'access', _27 => _27.unref, 'optionalCall', _28 => _28()]);
+    this.gcTimer = timer;
+  }
+  sweepExpiredEntries(now = Date.now()) {
+    const watched = /* @__PURE__ */ new Set();
+    for (const key of this.listeners.keys()) watched.add(this.resolveKey(key));
+    let remaining = false;
+    const swept = /* @__PURE__ */ new Set();
+    for (const [key, entry] of this.entries) {
+      if (entry.gcAt === void 0) continue;
+      if (now < entry.gcAt || entry.fetching || this.inflight.has(key) || watched.has(key)) {
+        remaining = true;
+        continue;
+      }
+      this.entries.delete(key);
+      _optionalChain([this, 'access', _29 => _29.persistence, 'optionalAccess', _30 => _30.onDelete, 'call', _31 => _31(key)]);
+      swept.add(key);
+    }
+    if (swept.size > 0) this.sweepEntryMetadata(swept);
+    if (remaining) this.scheduleGcSweep();
+  }
+  /**
+   * Entry eviction alone leaves the per-key metadata behind. `invalidatedAt`
+   * marks and provisional aliases are created per query invocation, so with
+   * dynamic keys they accumulate for the lifetime of the page even though the
+   * entries they describe are long gone.
+   */
+  sweepEntryMetadata(swept) {
+    const protectedKeys = /* @__PURE__ */ new Set();
+    for (const key of swept) if (this.hasMetadataOwner(key)) protectedKeys.add(key);
+    for (const key of swept) {
+      if (this.entries.has(key)) {
+        this.pendingMetadataSweeps.delete(key);
+      } else if (protectedKeys.has(key)) {
+        this.pendingMetadataSweeps.add(key);
+      } else {
+        this.pendingMetadataSweeps.delete(key);
+        this.invalidatedAt.delete(key);
+      }
+    }
+    const related = /* @__PURE__ */ new Set();
+    const targets = new Set(swept);
+    for (const target of targets) {
+      for (const alias of _nullishCoalesce(this.aliasesByTarget.get(target), () => ( []))) {
+        related.add(alias);
+        targets.add(alias);
+      }
+    }
+    const removable = [];
+    for (const alias of related) {
+      if (this.entries.has(alias) || this.listeners.has(alias) || this.inflight.has(alias))
+        continue;
+      const resolved = this.resolveKey(alias);
+      if (!swept.has(resolved)) continue;
+      if (this.entries.has(resolved) || protectedKeys.has(resolved)) continue;
+      removable.push(alias);
+    }
+    for (const alias of removable) {
+      this.removeAlias(alias);
+      this.invalidatedAt.delete(alias);
+    }
+  }
+  removeAlias(alias) {
+    const target = this.aliases.get(alias);
+    if (target === void 0) return;
+    this.aliases.delete(alias);
+    const aliases = this.aliasesByTarget.get(target);
+    _optionalChain([aliases, 'optionalAccess', _32 => _32.delete, 'call', _33 => _33(alias)]);
+    if (_optionalChain([aliases, 'optionalAccess', _34 => _34.size]) === 0) this.aliasesByTarget.delete(target);
+  }
+  sweepPendingEntryMetadata(key) {
+    if (this.pendingMetadataSweeps.size === 0) return;
+    if (key !== void 0) {
+      const resolved = this.resolveKey(key);
+      if (this.pendingMetadataSweeps.has(resolved)) {
+        this.sweepEntryMetadata(/* @__PURE__ */ new Set([resolved]));
+      }
+      return;
+    }
+    this.sweepEntryMetadata(new Set(this.pendingMetadataSweeps));
+  }
+  emit(key, event) {
+    this.notifyListeners(key, event);
+    if (this.listeners.size === 0) return;
+    for (const [alias, target] of this.aliases) {
+      if (!this.listeners.has(alias)) continue;
+      if (this.resolveKey(target) === key) {
+        this.notifyListeners(alias, event);
+      }
+    }
+  }
+  notifyListeners(key, event) {
+    for (const listener of _nullishCoalesce(this.listeners.get(key), () => ( []))) {
+      try {
+        listener(event);
+      } catch (error) {
+        const detail = error instanceof Error ? _nullishCoalesce(error.stack, () => ( error.message)) : String(error);
+        console.warn(`[farm:client-cache] cache listener failed: ${detail}`);
+      }
+    }
+  }
+};
+_chunkS3JO3N4Hcjs.__name.call(void 0, _FarmClientDataCache, "FarmClientDataCache");
+var FarmClientDataCache = _FarmClientDataCache;
+var FARM_CLIENT_DATA_CACHE = /* @__PURE__ */ Symbol.for("farm.clientDataCache");
+var clientCacheGlobal = globalThis;
+var sharedFarmClientDataCache = _nullishCoalesce(clientCacheGlobal[FARM_CLIENT_DATA_CACHE], () => ( (clientCacheGlobal[FARM_CLIENT_DATA_CACHE] = new FarmClientDataCache())));
+function getFarmClientDataCache() {
+  return sharedFarmClientDataCache;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, getFarmClientDataCache, "getFarmClientDataCache");
+function normalizeFarmClientCacheKey(key) {
+  return typeof key === "string" ? key : _chunkNYJMY3JAcjs.createRouteDataCacheKey.call(void 0, key);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, normalizeFarmClientCacheKey, "normalizeFarmClientCacheKey");
+
+
+
+
+
+
+exports.trackFarmClientCacheInvalidations = trackFarmClientCacheInvalidations; exports.FarmClientDataCache = FarmClientDataCache; exports.getFarmClientDataCache = getFarmClientDataCache; exports.normalizeFarmClientCacheKey = normalizeFarmClientCacheKey;