@farm.js/core 0.1.17 → 0.1.19

package/dist/server-query-client.cjs

@@ -1,1894 +1,26 @@
-"use strict";
-"use client";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});"use client";
 
-// src/server-query-client.ts
-var server_query_client_exports = {};
-__export(server_query_client_exports, {
-  beginFarmServerQueryAction: () => beginFarmServerQueryAction,
-  completeFarmServerQueryAction: () => completeFarmServerQueryAction,
-  fetchServerQuery: () => fetchServerQuery,
-  prefetchServerQuery: () => prefetchServerQuery,
-  shouldApplyFarmServerQueryActionResult: () => shouldApplyFarmServerQueryActionResult,
-  useServerQuery: () => useServerQuery
-});
-module.exports = __toCommonJS(server_query_client_exports);
-var import_react = require("react");
 
-// src/tracing.ts
-var import_api = require("@opentelemetry/api");
-var FARM_TRACER_NAME = "@farm.js/core";
-var ALL_SPAN_KINDS = [
-  "request",
-  "render",
-  "middleware",
-  "api",
-  "integration",
-  "storage",
-  "ppr",
-  "build",
-  "plugin"
-];
-var DEFAULT_IGNORED_PATHS = [
-  "/@vite/",
-  "/@fs/",
-  "/@id/",
-  "/@react-refresh",
-  "/node_modules/",
-  "/__vite",
-  "/.well-known/appspecific/"
-];
-var FARM_REQUEST_METHOD_CONTEXT_KEY = (0, import_api.createContextKey)("@farm.js/core/request-method");
-var TRACING_RUNTIME = /* @__PURE__ */ Symbol.for("@farm.js/core/tracing-runtime/v1");
-var runtime = globalThis;
-var tracingState = runtime[TRACING_RUNTIME] ?? (runtime[TRACING_RUNTIME] = normalizeFarmTracingConfig(false));
-function normalizeFarmTracingConfig(config) {
-  if (!config) {
-    return {
-      enabled: false,
-      spans: new Set(ALL_SPAN_KINDS),
-      recordEvents: true,
-      attributes: {},
-      ignorePaths: DEFAULT_IGNORED_PATHS
-    };
-  }
-  if (config === true) {
-    return {
-      enabled: true,
-      spans: new Set(ALL_SPAN_KINDS),
-      recordEvents: true,
-      attributes: {},
-      ignorePaths: DEFAULT_IGNORED_PATHS
-    };
-  }
-  return {
-    enabled: config.enabled ?? true,
-    spans: new Set(config.spans ?? ALL_SPAN_KINDS),
-    recordEvents: config.recordEvents ?? true,
-    attributes: { ...config.attributes },
-    ignorePaths: [...DEFAULT_IGNORED_PATHS, ...config.ignorePaths ?? []]
-  };
-}
-__name(normalizeFarmTracingConfig, "normalizeFarmTracingConfig");
-function recordFarmEventTrace(event) {
-  if (!tracingState.enabled) return void 0;
-  const activeContext = import_api.context.active();
-  const activeSpan = import_api.trace.getSpan(activeContext);
-  const traceContext = getSpanTraceContext(activeSpan);
-  if (activeSpan && traceContext) {
-    if (event.type === "route.matched") {
-      const method = activeContext.getValue(FARM_REQUEST_METHOD_CONTEXT_KEY) ?? "HTTP";
-      activeSpan.updateName(`${method} ${event.route}`);
-      activeSpan.setAttribute("http.route", event.route);
-      activeSpan.setAttribute("farm.route", event.route);
-    }
-    if (tracingState.recordEvents) {
-      activeSpan.addEvent(event.type, toEventAttributes(event), event.timestamp);
-    }
-    const error = event.type === "request.error" ? void 0 : getEventError(event);
-    if (error !== void 0) {
-      if (event.type === "render.error") {
-        recordSpanException(activeSpan, error);
-      } else {
-        recordSpanError(activeSpan, error);
-      }
-    }
-  }
-  const completedTraceContext = recordCompletedEventSpan(event, activeContext);
-  return traceContext ?? completedTraceContext;
-}
-__name(recordFarmEventTrace, "recordFarmEventTrace");
-function recordCompletedEventSpan(event, parentContext) {
-  const descriptor = getCompletedSpanDescriptor(event);
-  if (!descriptor || !tracingState.spans.has(descriptor.kind)) return void 0;
-  const tracer = import_api.trace.getTracer(FARM_TRACER_NAME);
-  const span = tracer.startSpan(
-    descriptor.name,
-    {
-      kind: import_api.SpanKind.INTERNAL,
-      startTime: event.timestamp - descriptor.durationMs,
-      attributes: {
-        ...tracingState.attributes,
-        ...toEventAttributes(event),
-        "farm.event.type": event.type
-      }
-    },
-    parentContext
-  );
-  const status = "status" in event && typeof event.status === "number" ? event.status : void 0;
-  if (status !== void 0) setResponseStatus(span, status);
-  const error = getEventError(event);
-  if (error !== void 0) recordSpanError(span, error);
-  const traceContext = getSpanTraceContext(span);
-  span.end(event.timestamp);
-  return traceContext;
-}
-__name(recordCompletedEventSpan, "recordCompletedEventSpan");
-function getCompletedSpanDescriptor(event) {
-  if (!("durationMs" in event) || typeof event.durationMs !== "number") return void 0;
-  switch (event.type) {
-    case "render.complete":
-      return { kind: "render", name: `farm.render ${event.route}`, durationMs: event.durationMs };
-    case "render.stream.shellReady":
-      return {
-        kind: "render",
-        name: `farm.render.shell ${event.route}`,
-        durationMs: event.durationMs
-      };
-    case "render.stream.complete":
-      return {
-        kind: "render",
-        name: `farm.render.stream ${event.route}`,
-        durationMs: event.durationMs
-      };
-    case "middleware.complete":
-      return {
-        kind: "middleware",
-        name: `farm.middleware ${event.name ?? event.route ?? "anonymous"}`,
-        durationMs: event.durationMs
-      };
-    case "api.request.complete":
-    case "api.error":
-      return {
-        kind: "api",
-        name: `farm.api ${event.method} ${event.route}`,
-        durationMs: event.durationMs
-      };
-    case "integration.api.call.complete":
-      return {
-        kind: "integration",
-        name: `farm.integration ${event.integration}.${event.operation}`,
-        durationMs: event.durationMs
-      };
-    case "storage.query.complete":
-      return {
-        kind: "storage",
-        name: `farm.storage ${event.operation}`,
-        durationMs: event.durationMs
-      };
-    case "ppr.refresh.complete":
-      return {
-        kind: "ppr",
-        name: `farm.ppr.refresh ${event.route}`,
-        durationMs: event.durationMs
-      };
-    case "build.complete":
-      return {
-        kind: "build",
-        name: `farm.build${event.target ? ` ${event.target}` : ""}`,
-        durationMs: event.durationMs
-      };
-    case "plugin.hook.complete":
-      return {
-        kind: "plugin",
-        name: `farm.plugin ${event.plugin}.${event.hook}`,
-        durationMs: event.durationMs
-      };
-    default:
-      return void 0;
-  }
-}
-__name(getCompletedSpanDescriptor, "getCompletedSpanDescriptor");
-function hashFarmCacheKey(value) {
-  let hash = 2166136261;
-  for (let index = 0; index < value.length; index++) {
-    hash ^= value.charCodeAt(index);
-    hash = Math.imul(hash, 16777619);
-  }
-  return (hash >>> 0).toString(16).padStart(8, "0");
-}
-__name(hashFarmCacheKey, "hashFarmCacheKey");
-function toEventAttributes(event) {
-  const attributes = {};
-  const redactKey = typeof event.type === "string" && event.type.startsWith("cache.");
-  for (const [key, value] of Object.entries(event)) {
-    if (key === "timestamp" || key === "level" || key === "error" || key === "traceId" || key === "spanId" || key === "traceSampled" || value === void 0) {
-      continue;
-    }
-    if (redactKey && key === "key" && typeof value === "string") {
-      attributes["farm.key_hash"] = hashFarmCacheKey(value);
-      continue;
-    }
-    if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
-      attributes[`farm.${key}`] = value;
-    } else if (Array.isArray(value)) {
-      if (value.every((entry) => typeof entry === "string")) {
-        attributes[`farm.${key}`] = value;
-      } else if (value.every((entry) => typeof entry === "number")) {
-        attributes[`farm.${key}`] = value;
-      } else if (value.every((entry) => typeof entry === "boolean")) {
-        attributes[`farm.${key}`] = value;
-      }
-    }
-  }
-  return attributes;
-}
-__name(toEventAttributes, "toEventAttributes");
-function getEventError(event) {
-  return "error" in event ? event.error : void 0;
-}
-__name(getEventError, "getEventError");
-function recordSpanException(span, error) {
-  const normalized = error instanceof Error ? error : new Error(String(error));
-  span.recordException(normalized);
-  return normalized;
-}
-__name(recordSpanException, "recordSpanException");
-function recordSpanError(span, error) {
-  const normalized = recordSpanException(span, error);
-  span.setStatus({ code: import_api.SpanStatusCode.ERROR, message: normalized.message });
-}
-__name(recordSpanError, "recordSpanError");
-function setResponseStatus(span, status) {
-  span.setAttribute("http.response.status_code", status);
-  if (status >= 500) {
-    span.setStatus({ code: import_api.SpanStatusCode.ERROR });
-  }
-}
-__name(setResponseStatus, "setResponseStatus");
-function getSpanTraceContext(span) {
-  if (!span) return void 0;
-  const spanContext = span.spanContext();
-  if (!(0, import_api.isSpanContextValid)(spanContext)) return void 0;
-  return {
-    traceId: spanContext.traceId,
-    spanId: spanContext.spanId,
-    traceSampled: (spanContext.traceFlags & 1) === 1
-  };
-}
-__name(getSpanTraceContext, "getSpanTraceContext");
+var _chunkC3VRMB6Hcjs = require('./chunk-C3VRMB6H.cjs');
 
-// src/observability.ts
-var OBSERVABILITY_RUNTIME = /* @__PURE__ */ Symbol.for("@farm.js/core/observability-runtime/v1");
-var runtime2 = globalThis;
-var shared = runtime2[OBSERVABILITY_RUNTIME] ?? (runtime2[OBSERVABILITY_RUNTIME] = {
-  handlers: /* @__PURE__ */ new Set(),
-  unfilteredHandlers: /* @__PURE__ */ new Set(),
-  config: { logs: false, handlers: [], tracing: normalizeFarmTracingConfig(false) }
-});
-var runtimeHandlers = shared.handlers;
-var unfilteredRuntimeHandlers = shared.unfilteredHandlers;
-var observabilityState = shared.config;
-function emitFarmEvent(input) {
-  const event = {
-    timestamp: Date.now(),
-    level: inferFarmEventLevel(input.type),
-    ...input
-  };
-  const traceContext = recordFarmEventTrace(event);
-  if (traceContext) {
-    event.traceId = traceContext.traceId;
-    event.spanId = traceContext.spanId;
-    event.traceSampled = traceContext.traceSampled;
-  }
-  notifyFarmEventHandlers(event, unfilteredRuntimeHandlers);
-  if (!shouldEmitFarmEvent(event)) return event;
-  if (observabilityState.logs) {
-    logFarmEvent(event);
-  }
-  notifyFarmEventHandlers(event, [...observabilityState.handlers, ...runtimeHandlers]);
-  return event;
-}
-__name(emitFarmEvent, "emitFarmEvent");
-function notifyFarmEventHandlers(event, handlers) {
-  for (const handler of handlers) {
-    try {
-      Promise.resolve(handler(event)).catch((error) => {
-        console.warn(`[farm:observability] event handler failed: ${formatError(error)}`);
-      });
-    } catch (error) {
-      console.warn(`[farm:observability] event handler failed: ${formatError(error)}`);
-    }
-  }
-}
-__name(notifyFarmEventHandlers, "notifyFarmEventHandlers");
-function shouldEmitFarmEvent(event) {
-  if (!observabilityState.logs && observabilityState.handlers.length === 0 && runtimeHandlers.size === 0) {
-    return false;
-  }
-  if (observabilityState.events && !observabilityState.events.has(event.type)) {
-    return false;
-  }
-  return true;
-}
-__name(shouldEmitFarmEvent, "shouldEmitFarmEvent");
-function inferFarmEventLevel(type) {
-  if (type === "error" || type.endsWith(".error") || type.endsWith(".failed")) {
-    return "error";
-  }
-  if (type.endsWith(".bypass") || type.endsWith(".invalidated") || type.endsWith(".stale") || type.endsWith(".notFound")) {
-    return "warn";
-  }
-  if (type.endsWith(".hit") || type.endsWith(".miss") || type.endsWith(".start") || type.endsWith(".shellReady")) {
-    return "debug";
-  }
-  return "info";
-}
-__name(inferFarmEventLevel, "inferFarmEventLevel");
-function logFarmEvent(event) {
-  const message = `[farm:${event.level}] ${event.type}${formatFarmEventDetails(event)}`;
-  switch (event.level) {
-    case "error":
-      console.error(message);
-      break;
-    case "warn":
-      console.warn(message);
-      break;
-    default:
-      console.log(message);
-      break;
-  }
-}
-__name(logFarmEvent, "logFarmEvent");
-function formatFarmEventDetails(event) {
-  const details = [];
-  const record = event;
-  for (const key of [
-    "route",
-    "pathname",
-    "method",
-    "status",
-    "key",
-    "tag",
-    "path",
-    "reason",
-    "durationMs",
-    "integration",
-    "server",
-    "tool",
-    "outcome",
-    "operation",
-    "plugin",
-    "hook",
-    "target",
-    "count"
-  ]) {
-    const value = record[key];
-    if (value !== void 0) {
-      details.push(`${key}=${formatDetailValue(value)}`);
-    }
-  }
-  return details.length > 0 ? ` ${details.join(" ")}` : "";
-}
-__name(formatFarmEventDetails, "formatFarmEventDetails");
-function formatDetailValue(value) {
-  if (typeof value === "string") {
-    return value;
-  }
-  if (typeof value === "number" || typeof value === "boolean") {
-    return String(value);
-  }
-  try {
-    return JSON.stringify(value);
-  } catch {
-    return String(value);
-  }
-}
-__name(formatDetailValue, "formatDetailValue");
-function formatError(error) {
-  return error instanceof Error ? error.message : String(error);
-}
-__name(formatError, "formatError");
 
-// src/cache-invalidation.ts
-var FARM_CACHE_INVALIDATION_STATE = /* @__PURE__ */ Symbol.for("farm.cacheInvalidationState");
-var globalState = globalThis;
-function getFarmCacheInvalidationState() {
-  return globalState[FARM_CACHE_INVALIDATION_STATE] ?? (globalState[FARM_CACHE_INVALIDATION_STATE] = {
-    listeners: /* @__PURE__ */ new Set(),
-    taskListeners: /* @__PURE__ */ new Set()
-  });
-}
-__name(getFarmCacheInvalidationState, "getFarmCacheInvalidationState");
-function subscribeFarmCacheInvalidation(listener) {
-  const state = getFarmCacheInvalidationState();
-  state.listeners.add(listener);
-  return () => state.listeners.delete(listener);
-}
-__name(subscribeFarmCacheInvalidation, "subscribeFarmCacheInvalidation");
 
-// src/cache-invalidation-stream.ts
-var MAX_BUFFERED_BYTES = 64 * 1024;
-var textEncoder = new TextEncoder();
 
-// src/cache.ts
-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.lease = {
-      enabled: true,
-      ttlMs: 1e4,
-      waitTimeoutMs: 1e4,
-      pollIntervalMs: 25
-    };
-    this.configure(config);
-  }
-  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"
-      )
-    };
-  }
-  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) {
-      emitFarmEvent({ type: "cache.miss", key });
-      return void 0;
-    }
-    assertFarmCacheEntry(entry, key);
-    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 entry = {
-      key,
-      value,
-      tags: Array.from(tags),
-      tagVersions: capturedVersions,
-      createdAt: options.createdAt ?? Date.now(),
-      createdVersion: createdVersion ?? ++this.version,
-      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.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.generation++;
-    this.entries.clear();
-    this.entriesByTag.clear();
-    this.inflight.clear();
-    this.invalidatedTagVersions.clear();
-    this.activeGenerations.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 = {}) {
-    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 shared2 = await this.waitForAdapterEntry(
-          key,
-          adapter,
-          namespace,
-          lease,
-          generation
-        );
-        if (shared2) {
-          emitFarmEvent({ type: "cache.dedupe", key });
-          return shared2.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) {
-        emitFarmEvent({ type: "cache.miss", key });
-        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;
-  }
-};
-__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());
-function createPathCacheTag(routePath) {
-  return `path:${normalizeRevalidatePath(routePath)}`;
-}
-__name(createPathCacheTag, "createPathCacheTag");
-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 || "/";
-}
-__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) {
-    throw new TypeError("Cache revalidate must be false or a finite, non-negative number.");
-  }
-  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 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;
-}
-__name(normalizePositiveInteger, "normalizePositiveInteger");
-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 getFunctionCacheIdentity(fn) {
-  const name = fn.name || "anonymous";
-  return `${name}:${hashFunctionSource(String(fn))}`;
-}
-__name(getFunctionCacheIdentity, "getFunctionCacheIdentity");
-function hashFunctionSource(source) {
-  let hash = 2166136261;
-  for (let index = 0; index < source.length; index++) {
-    hash ^= source.charCodeAt(index);
-    hash = Math.imul(hash, 16777619);
-  }
-  return (hash >>> 0).toString(36);
-}
-__name(hashFunctionSource, "hashFunctionSource");
-function compareCodepoint(a, b) {
-  return a < b ? -1 : a > b ? 1 : 0;
-}
-__name(compareCodepoint, "compareCodepoint");
-function serializeBinaryBytes(bytes) {
-  return Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
-}
-__name(serializeBinaryBytes, "serializeBinaryBytes");
-function serializeCanonicalStringEntries(entries, seen) {
-  const valuesByKey = /* @__PURE__ */ new Map();
-  for (const [key, item] of entries) {
-    const values = valuesByKey.get(key);
-    if (values) values.push(item);
-    else valuesByKey.set(key, [item]);
-  }
-  return Array.from(valuesByKey.keys()).sort(compareCodepoint).flatMap(
-    (key) => valuesByKey.get(key).map((item) => `[${stableSerialize(key, seen)},${stableSerialize(item, seen)}]`)
-  ).join(",");
-}
-__name(serializeCanonicalStringEntries, "serializeCanonicalStringEntries");
-function isPlainCacheKeyObject(value) {
-  const prototype = Object.getPrototypeOf(value);
-  if (prototype === null) return true;
-  const constructor = Object.getOwnPropertyDescriptor(prototype, "constructor")?.value;
-  return Object.getPrototypeOf(prototype) === null && typeof constructor === "function" && constructor.name === "Object";
-}
-__name(isPlainCacheKeyObject, "isPlainCacheKeyObject");
-function getCacheKeyValueType(value) {
-  const prototype = Object.getPrototypeOf(value);
-  const constructor = prototype ? Object.getOwnPropertyDescriptor(prototype, "constructor")?.value : void 0;
-  if (typeof constructor === "function" && constructor.name) {
-    return constructor.name;
-  }
-  return Object.prototype.toString.call(value).slice(8, -1) || "object";
-}
-__name(getCacheKeyValueType, "getCacheKeyValueType");
-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 Number.isNaN(value.getTime()) ? "date:invalid" : `date:${value.toISOString()}`;
-  }
-  if (value instanceof URL) {
-    return `url:${value.toString()}`;
-  }
-  if (value instanceof RegExp) {
-    return `regexp:${value.toString()}`;
-  }
-  if (value instanceof ArrayBuffer) {
-    return `arraybuffer:${serializeBinaryBytes(new Uint8Array(value))}`;
-  }
-  if (typeof SharedArrayBuffer !== "undefined" && value instanceof SharedArrayBuffer) {
-    return `sharedarraybuffer:${serializeBinaryBytes(new Uint8Array(value))}`;
-  }
-  if (ArrayBuffer.isView(value)) {
-    const viewType = Object.prototype.toString.call(value).slice(8, -1);
-    const bytes = new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
-    return `binary:${viewType}:${serializeBinaryBytes(bytes)}`;
-  }
-  if (value && typeof value === "object") {
-    if (seen.has(value)) {
-      return "[Circular]";
-    }
-    seen.add(value);
-    if (Array.isArray(value)) {
-      const items = [];
-      for (let index = 0; index < value.length; index++) {
-        items.push(
-          Object.prototype.hasOwnProperty.call(value, index) ? stableSerialize(value[index], seen) : "[Hole]"
-        );
-      }
-      seen.delete(value);
-      return `[${items.join(",")}]`;
-    }
-    if (value instanceof Set) {
-      const items = Array.from(value, (item) => stableSerialize(item, seen)).sort(compareCodepoint);
-      seen.delete(value);
-      return `set:[${items.join(",")}]`;
-    }
-    if (value instanceof Map) {
-      const items = Array.from(
-        value,
-        ([key, item]) => `[${stableSerialize(key, seen)},${stableSerialize(item, seen)}]`
-      ).sort(compareCodepoint);
-      seen.delete(value);
-      return `map:[${items.join(",")}]`;
-    }
-    if (value instanceof URLSearchParams) {
-      const serialized2 = serializeCanonicalStringEntries(value, seen);
-      seen.delete(value);
-      return `urlsearchparams:[${serialized2}]`;
-    }
-    if (value instanceof Headers) {
-      const serialized2 = serializeCanonicalStringEntries(value, seen);
-      seen.delete(value);
-      return `headers:[${serialized2}]`;
-    }
-    if (!isPlainCacheKeyObject(value)) {
-      throw new TypeError(
-        `Cache keys do not support ${getCacheKeyValueType(value)} values. Convert the value to an explicit stable string or structured key before caching.`
-      );
-    }
-    const entries = Object.entries(value).sort(
-      ([a], [b]) => compareCodepoint(a, 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");
 
-// 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);
-    }
-  };
-}
-__name(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 = 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);
-        cacheFinalizer?.register(this, unsubscribe, reference);
-        this.unsubscribeInvalidation = unsubscribe;
-      } else {
-        this.unsubscribeInvalidation = subscribeFarmCacheInvalidation(
-          (key) => this.applyInvalidation(key, Date.now(), false)
-        );
-      }
-    }
-  }
-  // This closure must only capture a weak reference, never the cache itself.
-  static subscribeWeakCache(reference) {
-    const unsubscribe = subscribeFarmCacheInvalidation((key) => {
-      const cache = reference.deref();
-      if (cache) cache.applyInvalidation(key, Date.now(), false);
-      else dispose();
-    });
-    function dispose() {
-      unsubscribe();
-      cacheFinalizer?.unregister(reference);
-    }
-    __name(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);
-      this.persistence?.onDelete(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();
-    this.persistence?.onSet(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) this.persistence?.onDelete(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();
-    this.persistence?.onClear();
-    for (const key of keys) this.emit(key);
-  }
-  dispose() {
-    this.unsubscribeInvalidation?.();
-    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 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 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 = this.invalidatedAt.get(alias) ?? aliasEntry?.invalidatedAt;
-    const resolvedInvalidatedAt = this.invalidatedAt.get(resolved);
-    if (aliasEntry && !this.entries.has(resolved)) {
-      this.entries.set(resolved, aliasEntry);
-      this.persistence?.onSet(resolved, aliasEntry);
-    }
-    if (this.entries.delete(alias)) this.persistence?.onDelete(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 (resolvedEntry?.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);
-    timer.unref?.();
-    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);
-      this.persistence?.onDelete(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 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);
-    aliases?.delete(alias);
-    if (aliases?.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 this.listeners.get(key) ?? []) {
-      try {
-        listener(event);
-      } catch (error) {
-        const detail = error instanceof Error ? error.stack ?? error.message : String(error);
-        console.warn(`[farm:client-cache] cache listener failed: ${detail}`);
-      }
-    }
-  }
-};
-__name(_FarmClientDataCache, "FarmClientDataCache");
-var FarmClientDataCache = _FarmClientDataCache;
-var FARM_CLIENT_DATA_CACHE = /* @__PURE__ */ Symbol.for("farm.clientDataCache");
-var clientCacheGlobal = globalThis;
-var sharedFarmClientDataCache = clientCacheGlobal[FARM_CLIENT_DATA_CACHE] ?? (clientCacheGlobal[FARM_CLIENT_DATA_CACHE] = new FarmClientDataCache());
-function getFarmClientDataCache() {
-  return sharedFarmClientDataCache;
-}
-__name(getFarmClientDataCache, "getFarmClientDataCache");
 
-// src/client-revalidation.ts
-function attachRevalidationListeners(refresh, options = {}) {
-  if (typeof window === "undefined") return () => {
-  };
-  const onFocus = options.refetchOnWindowFocus === false ? void 0 : refresh;
-  const onOnline = options.refetchOnReconnect === false ? void 0 : refresh;
-  if (onFocus) window.addEventListener("focus", onFocus);
-  if (onOnline) window.addEventListener("online", onOnline);
-  return () => {
-    if (onFocus) window.removeEventListener("focus", onFocus);
-    if (onOnline) window.removeEventListener("online", onOnline);
-  };
-}
-__name(attachRevalidationListeners, "attachRevalidationListeners");
+var _chunkY4YWHNKUcjs = require('./chunk-Y4YWHNKU.cjs');
+require('./chunk-I7PUUDGY.cjs');
+require('./chunk-SK35NQKK.cjs');
+require('./chunk-H6G5INWM.cjs');
+require('./chunk-ZEG3OPIB.cjs');
+require('./chunk-LIUGYUX3.cjs');
+require('./chunk-E3UK5IIB.cjs');
+require('./chunk-S3JO3N4H.cjs');
 
-// src/server-query-protocol.ts
-var FARM_SERVER_QUERY_RESULT_VERSION = 1;
-function isFarmServerQueryResult(value) {
-  if (!value || typeof value !== "object") return false;
-  const metadata = value.__farmServerQuery;
-  return metadata?.version === FARM_SERVER_QUERY_RESULT_VERSION && typeof metadata.key === "string" && (metadata.staleTime === false || typeof metadata.staleTime === "number") && typeof metadata.updatedAt === "number" && "data" in value;
-}
-__name(isFarmServerQueryResult, "isFarmServerQueryResult");
 
-// src/server-query-runtime.ts
-var FARM_SERVER_QUERY_CLIENT_STATE = /* @__PURE__ */ Symbol.for("farm.serverQueryClientState");
-var serverQueryClientGlobal = globalThis;
-var serverQueryClientState = serverQueryClientGlobal[FARM_SERVER_QUERY_CLIENT_STATE] ?? (serverQueryClientGlobal[FARM_SERVER_QUERY_CLIENT_STATE] = {
-  functionIds: /* @__PURE__ */ new WeakMap(),
-  nextFunctionId: 0,
-  active: [],
-  latestOwners: /* @__PURE__ */ new Map(),
-  owners: /* @__PURE__ */ new Set()
-});
-serverQueryClientState.latestOwners ?? (serverQueryClientState.latestOwners = /* @__PURE__ */ new Map());
-serverQueryClientState.owners ?? (serverQueryClientState.owners = /* @__PURE__ */ new Set());
-function isServerQueryOwnerSuperseded(owner, key) {
-  const cache = getFarmClientDataCache();
-  const resolved = cache.resolveKey(key);
-  for (const superseded of owner.supersededKeys ?? []) {
-    if (cache.resolveKey(superseded) === resolved) return true;
-  }
-  return false;
-}
-__name(isServerQueryOwnerSuperseded, "isServerQueryOwnerSuperseded");
-function claimServerQueryKey(owner, key) {
-  if (isServerQueryOwnerSuperseded(owner, key)) return false;
-  const resolved = getFarmClientDataCache().resolveKey(key);
-  for (const older of serverQueryClientState.owners) {
-    if (older === owner) break;
-    older.supersededKeys.add(resolved);
-  }
-  return true;
-}
-__name(claimServerQueryKey, "claimServerQueryKey");
-var RAW_SERVER_QUERY_SYMBOL = /* @__PURE__ */ Symbol.for("farm.server-query");
-function assertNotRawServerQueryInBrowser(query) {
-  if (typeof window === "undefined" || typeof document === "undefined") return;
-  if (!query?.[RAW_SERVER_QUERY_SYMBOL]) return;
-  throw new Error(
-    [
-      "useServerQuery received a raw server query implementation in the browser.",
-      "Server query handlers run only on the server. Enable the server-function transform (add @farm.js/plugin/rsc and set experimental.serverActions: true in farm.config.ts) so client imports become server references,",
-      "or call the query from server code / an API route (createAPIClient) instead."
-    ].join("\n")
-  );
-}
-__name(assertNotRawServerQueryInBrowser, "assertNotRawServerQueryInBrowser");
-function beginFarmServerQueryAction(actionId, args) {
-  const active = serverQueryClientState.active.at(-1);
-  return {
-    actionId,
-    args,
-    provisionalKey: active?.provisionalKey,
-    owner: active?.owner
-  };
-}
-__name(beginFarmServerQueryAction, "beginFarmServerQueryAction");
-function completeFarmServerQueryAction(invocation, value) {
-  if (!isFarmServerQueryResult(value)) return value;
-  const cache = getFarmClientDataCache();
-  const metadata = value.__farmServerQuery;
-  if (!shouldApplyFarmServerQueryActionResult(invocation)) {
-    return value.data;
-  }
-  if (invocation.provisionalKey) {
-    cache.alias(invocation.provisionalKey, metadata.key);
-  }
-  const owner = invocation.owner;
-  if (owner && serverQueryClientState.owners.has(owner) && !claimServerQueryKey(owner, metadata.key)) {
-    return value.data;
-  }
-  const invalidated = invocation.owner?.invalidations?.has(
-    metadata.key
-  );
-  cache.set(metadata.key, {
-    data: value.data,
-    updatedAt: metadata.updatedAt,
-    staleAt: invalidated ? 0 : metadata.staleTime === false ? Number.POSITIVE_INFINITY : metadata.updatedAt + metadata.staleTime,
-    status: "success",
-    error: null,
-    fetching: false,
-    persist: metadata.persist === true ? true : void 0
-  });
-  return value.data;
-}
-__name(completeFarmServerQueryAction, "completeFarmServerQueryAction");
-function shouldApplyFarmServerQueryActionResult(invocation) {
-  if (!invocation.provisionalKey || !invocation.owner) return true;
-  return isCurrentServerQueryOwner(invocation.provisionalKey, invocation.owner);
-}
-__name(shouldApplyFarmServerQueryActionResult, "shouldApplyFarmServerQueryActionResult");
-function isCurrentServerQueryOwner(provisionalKey, owner) {
-  return serverQueryClientState.latestOwners.get(provisionalKey) === owner && !isServerQueryOwnerSuperseded(owner, provisionalKey);
-}
-__name(isCurrentServerQueryOwner, "isCurrentServerQueryOwner");
-function createServerQueryCallKey(query, input) {
-  let id = serverQueryClientState.functionIds.get(query);
-  if (!id) {
-    id = ++serverQueryClientState.nextFunctionId;
-    serverQueryClientState.functionIds.set(query, id);
-  }
-  return createFarmCacheKey(["server-query-call", id, input]);
-}
-__name(createServerQueryCallKey, "createServerQueryCallKey");
-async function fetchServerQuery(query, input, options = {}) {
-  const cache = getFarmClientDataCache();
-  const provisionalKey = createServerQueryCallKey(query, input);
-  const entry = cache.get(provisionalKey);
-  const stale = cache.isStale(provisionalKey);
-  const inflight = cache.getInflight(provisionalKey);
-  if (!options.force && entry && stale && (entry.status !== "pending" || entry.updatedAt !== 0) && entry.status !== "error" && (options.swr ?? true)) {
-    if (!inflight) {
-      void executeServerQuery(query, input, provisionalKey, options).catch(() => void 0);
-    }
-    return entry.data;
-  }
-  if (inflight && !options.force) return inflight;
-  if (!options.force && entry && !stale && entry.status !== "error") return entry.data;
-  return executeServerQuery(query, input, provisionalKey, options);
-}
-__name(fetchServerQuery, "fetchServerQuery");
-function prefetchServerQuery(query, input, options = {}) {
-  return fetchServerQuery(query, input, options);
-}
-__name(prefetchServerQuery, "prefetchServerQuery");
-async function executeServerQuery(query, input, provisionalKey, options) {
-  assertNotRawServerQueryInBrowser(query);
-  const cache = getFarmClientDataCache();
-  const inflight = cache.getInflight(provisionalKey);
-  if (inflight && !options.force) return inflight;
-  const owner = {
-    invalidations: trackFarmClientCacheInvalidations(cache),
-    supersededKeys: /* @__PURE__ */ new Set()
-  };
-  serverQueryClientState.latestOwners.set(provisionalKey, owner);
-  serverQueryClientState.owners.add(owner);
-  claimServerQueryKey(owner, provisionalKey);
-  const previous = cache.get(provisionalKey);
-  cache.set(provisionalKey, {
-    data: previous?.data,
-    updatedAt: previous?.updatedAt ?? 0,
-    staleAt: previous?.staleAt ?? 0,
-    gcAt: previous?.gcAt,
-    invalidatedAt: previous?.invalidatedAt,
-    status: "pending",
-    error: null,
-    fetching: true
-  });
-  let promise;
-  promise = (async () => {
-    await Promise.resolve();
-    try {
-      serverQueryClientState.active.push({ provisionalKey, owner });
-      let pending;
-      try {
-        pending = query(input);
-      } finally {
-        serverQueryClientState.active.pop();
-      }
-      const data = await pending;
-      const transported = cache.get(provisionalKey);
-      if (isCurrentServerQueryOwner(provisionalKey, owner) && (!transported || transported.fetching)) {
-        const updatedAt = Date.now();
-        cache.set(provisionalKey, {
-          data,
-          updatedAt,
-          staleAt: owner.invalidations.has(provisionalKey) ? 0 : options.staleTime === false ? Number.POSITIVE_INFINITY : updatedAt + (options.staleTime ?? 0),
-          status: "success",
-          error: null,
-          fetching: false
-        });
-      }
-      return data;
-    } catch (cause) {
-      const error = normalizeServerQueryError(cause);
-      if (isCurrentServerQueryOwner(provisionalKey, owner)) {
-        const current = cache.get(provisionalKey);
-        cache.set(provisionalKey, {
-          data: current?.data,
-          updatedAt: current?.updatedAt ?? 0,
-          staleAt: current?.staleAt ?? 0,
-          gcAt: current?.gcAt,
-          invalidatedAt: current?.invalidatedAt,
-          status: "error",
-          error,
-          fetching: false
-        });
-      }
-      throw error;
-    } finally {
-      const invalidated = isCurrentServerQueryOwner(provisionalKey, owner) && owner.invalidations.has(provisionalKey);
-      owner.invalidations.dispose();
-      serverQueryClientState.owners.delete(owner);
-      owner.supersededKeys.clear();
-      if (cache.getInflight(provisionalKey) === promise) {
-        cache.deleteInflight(provisionalKey);
-      }
-      if (serverQueryClientState.latestOwners.get(provisionalKey) === owner) {
-        serverQueryClientState.latestOwners.delete(provisionalKey);
-      }
-      if (invalidated) cache.invalidate(provisionalKey);
-    }
-  })();
-  cache.setInflight(provisionalKey, promise);
-  return promise;
-}
-__name(executeServerQuery, "executeServerQuery");
-function normalizeServerQueryError(cause) {
-  if (cause instanceof Error) return cause;
-  const error = new Error(typeof cause === "string" ? cause : "Server query failed");
-  error.cause = cause;
-  return error;
-}
-__name(normalizeServerQueryError, "normalizeServerQueryError");
 
-// src/server-query-client.ts
-function useServerQuery(query, input, options = {}) {
-  const cache = getFarmClientDataCache();
-  const key = createServerQueryCallKey(query, input);
-  const inputRef = (0, import_react.useRef)(input);
-  const optionsRef = (0, import_react.useRef)(options);
-  const mountedKeyRef = (0, import_react.useRef)(void 0);
-  const pendingInvalidationRef = (0, import_react.useRef)(false);
-  inputRef.current = input;
-  optionsRef.current = options;
-  const subscribe = (0, import_react.useCallback)(
-    (listener) => cache.subscribe(key, (event) => {
-      if (event === "invalidate") pendingInvalidationRef.current = true;
-      else if (cache.get(key)?.fetching) {
-        pendingInvalidationRef.current = false;
-      }
-      listener();
-    }),
-    [cache, key]
-  );
-  const getSnapshot = (0, import_react.useCallback)(() => cache.get(key), [cache, key]);
-  const entry = (0, import_react.useSyncExternalStore)(subscribe, getSnapshot, () => void 0);
-  const run = (0, import_react.useCallback)(
-    (force = false) => {
-      pendingInvalidationRef.current = false;
-      return fetchServerQuery(query, inputRef.current, {
-        ...optionsRef.current,
-        force
-      });
-    },
-    [query]
-  );
-  (0, import_react.useEffect)(() => {
-    if (options.enabled === false) {
-      mountedKeyRef.current = void 0;
-      return;
-    }
-    const firstReadForKey = mountedKeyRef.current !== key;
-    if (firstReadForKey) mountedKeyRef.current = key;
-    if (firstReadForKey && (!entry || cache.isStale(key)) || pendingInvalidationRef.current && entry?.invalidatedAt !== void 0 && !entry.fetching) {
-      void run().catch(() => void 0);
-    }
-  }, [cache, entry, key, options.enabled, run]);
-  (0, import_react.useEffect)(() => {
-    if (options.enabled === false) return;
-    return attachRevalidationListeners(
-      () => {
-        if (cache.isStale(key)) void run().catch(() => void 0);
-      },
-      {
-        refetchOnWindowFocus: options.refetchOnWindowFocus,
-        refetchOnReconnect: options.refetchOnReconnect
-      }
-    );
-  }, [cache, key, options.enabled, options.refetchOnReconnect, options.refetchOnWindowFocus, run]);
-  const status = entry?.status ?? (entry ? "success" : "idle");
-  const fetching = entry?.fetching ?? false;
-  return {
-    data: entry?.data,
-    error: entry?.error ?? null,
-    status,
-    pending: status === "pending" && (entry?.updatedAt ?? 0) === 0,
-    fetching,
-    stale: cache.isStale(key),
-    refetch: /* @__PURE__ */ __name(() => run(true), "refetch")
-  };
-}
-__name(useServerQuery, "useServerQuery");
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  beginFarmServerQueryAction,
-  completeFarmServerQueryAction,
-  fetchServerQuery,
-  prefetchServerQuery,
-  shouldApplyFarmServerQueryActionResult,
-  useServerQuery
-});
+
+
+
+
+exports.beginFarmServerQueryAction = _chunkY4YWHNKUcjs.beginFarmServerQueryAction; exports.completeFarmServerQueryAction = _chunkY4YWHNKUcjs.completeFarmServerQueryAction; exports.fetchServerQuery = _chunkY4YWHNKUcjs.fetchServerQuery; exports.prefetchServerQuery = _chunkY4YWHNKUcjs.prefetchServerQuery; exports.shouldApplyFarmServerQueryActionResult = _chunkY4YWHNKUcjs.shouldApplyFarmServerQueryActionResult; exports.useServerQuery = _chunkC3VRMB6Hcjs.useServerQuery;