@farm.js/core 0.1.61 → 0.1.62

package/dist/chunk-5QIKR7RR.cjs

@@ -1,224 +0,0 @@
-"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

@@ -1,26 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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

@@ -1,389 +0,0 @@
-"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;