@farm.js/core 0.1.0-beta.3 → 0.1.0-beta.5

package/dist/server-fn.cjs

@@ -36,16 +36,36 @@ var FARM_CACHE_INVALIDATION_STATE = /* @__PURE__ */ Symbol.for("farm.cacheInvali
 var globalState = globalThis;
 function getFarmCacheInvalidationState() {
   return globalState[FARM_CACHE_INVALIDATION_STATE] ?? (globalState[FARM_CACHE_INVALIDATION_STATE] = {
-    listeners: /* @__PURE__ */ new Set()
+    listeners: /* @__PURE__ */ new Set(),
+    taskListeners: /* @__PURE__ */ new Set()
   });
 }
 __name(getFarmCacheInvalidationState, "getFarmCacheInvalidationState");
+function notifyFarmCacheInvalidation(key) {
+  if (typeof key !== "string" || key.length === 0) return;
+  for (const listener of getFarmCacheInvalidationState().listeners) {
+    listener(key);
+  }
+}
+__name(notifyFarmCacheInvalidation, "notifyFarmCacheInvalidation");
+function notifyFarmCacheTask(task) {
+  for (const listener of getFarmCacheInvalidationState().taskListeners) {
+    listener(task);
+  }
+}
+__name(notifyFarmCacheTask, "notifyFarmCacheTask");
 function subscribeFarmCacheInvalidation(listener) {
   const state = getFarmCacheInvalidationState();
   state.listeners.add(listener);
   return () => state.listeners.delete(listener);
 }
 __name(subscribeFarmCacheInvalidation, "subscribeFarmCacheInvalidation");
+function subscribeFarmCacheTask(listener) {
+  const state = getFarmCacheInvalidationState();
+  state.taskListeners.add(listener);
+  return () => state.taskListeners.delete(listener);
+}
+__name(subscribeFarmCacheTask, "subscribeFarmCacheTask");
 
 // src/server-action-security.ts
 var SERVER_ACTION_STORAGE_KEY = /* @__PURE__ */ Symbol.for("farm.serverActionStorage");
@@ -61,6 +81,9 @@ __name(getServerActionSignal, "getServerActionSignal");
 subscribeFarmCacheInvalidation((key) => {
   getServerActionExecutionContext()?.invalidations.add(key);
 });
+subscribeFarmCacheTask((task) => {
+  getServerActionExecutionContext()?.cacheTasks.add(task);
+});
 function getServerActionStorage() {
   const globalState2 = globalThis;
   if (!globalState2[SERVER_ACTION_STORAGE_KEY]) {
@@ -89,6 +112,748 @@ function _resolveCurrentRequest() {
 }
 __name(_resolveCurrentRequest, "_resolveCurrentRequest");
 
+// src/observability.ts
+var runtimeHandlers = /* @__PURE__ */ new Set();
+var observabilityState = {
+  logs: false,
+  handlers: []
+};
+function emitFarmEvent(input) {
+  const event = {
+    timestamp: Date.now(),
+    level: inferFarmEventLevel(input.type),
+    ...input
+  };
+  if (!shouldEmitFarmEvent(event)) {
+    return event;
+  }
+  if (observabilityState.logs) {
+    logFarmEvent(event);
+  }
+  for (const handler of [...observabilityState.handlers, ...runtimeHandlers]) {
+    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)}`);
+    }
+  }
+  return event;
+}
+__name(emitFarmEvent, "emitFarmEvent");
+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",
+    "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.ts
+var _FarmDataCache = class _FarmDataCache {
+  constructor(config = {}) {
+    this.entries = /* @__PURE__ */ new Map();
+    this.inflight = /* @__PURE__ */ new Map();
+    this.invalidatedTagVersions = /* @__PURE__ */ new Map();
+    this.version = 0;
+    this.namespace = "farm";
+    this.local = true;
+    this.lease = {
+      enabled: true,
+      ttlMs: 1e4,
+      waitTimeoutMs: 1e4,
+      pollIntervalMs: 25
+    };
+    this.configure(config);
+  }
+  configure(config = {}) {
+    this.adapter = config.adapter;
+    this.namespace = normalizeCacheNamespace(config.namespace || "farm");
+    this.local = !config.adapter;
+    this.lease = config.lease === false ? { ...this.lease, enabled: false } : {
+      enabled: true,
+      ttlMs: normalizePositiveDuration(config.lease?.ttlMs, 1e4, "cache.lease.ttlMs"),
+      waitTimeoutMs: normalizePositiveDuration(
+        config.lease?.waitTimeoutMs,
+        1e4,
+        "cache.lease.waitTimeoutMs"
+      ),
+      pollIntervalMs: normalizePositiveDuration(
+        config.lease?.pollIntervalMs,
+        25,
+        "cache.lease.pollIntervalMs"
+      )
+    };
+    if (!this.local) {
+      this.entries.clear();
+      this.inflight.clear();
+      this.invalidatedTagVersions.clear();
+      this.version = 0;
+    }
+  }
+  get adapterName() {
+    return this.adapter?.name || (this.adapter ? "custom" : "memory");
+  }
+  get hasAdapter() {
+    return this.adapter !== void 0;
+  }
+  get size() {
+    return this.entries.size;
+  }
+  get(key, options = {}) {
+    return this.getEntry(key, options)?.value;
+  }
+  getEntry(key, options = {}) {
+    const entry = this.entries.get(key);
+    if (!entry) {
+      emitFarmEvent({ type: "cache.miss", key });
+      return void 0;
+    }
+    const stale = this.isStale(entry, options.now);
+    if (stale) {
+      emitFarmEvent({
+        type: "cache.stale",
+        key,
+        tags: Array.from(entry.tags),
+        revalidate: entry.revalidate
+      });
+    }
+    if (!options.allowStale && stale) {
+      emitFarmEvent({ type: "cache.miss", key, reason: "stale" });
+      return void 0;
+    }
+    emitFarmEvent({
+      type: "cache.hit",
+      key,
+      tags: Array.from(entry.tags),
+      revalidate: entry.revalidate,
+      stale
+    });
+    return this.toPublicEntry(entry);
+  }
+  async getEntryAsync(key, options = {}) {
+    if (this.local) {
+      const localEntry = this.getEntry(key, options);
+      if (localEntry) return localEntry;
+    }
+    if (!this.adapter) {
+      return this.local ? void 0 : this.getEntry(key, options);
+    }
+    const entry = await this.adapter.get(this.createAdapterKey(key));
+    if (!entry) {
+      emitFarmEvent({ type: "cache.miss", key });
+      return void 0;
+    }
+    assertFarmCacheEntry(entry, key);
+    const stale = await this.isAdapterEntryStale(entry, options.now);
+    if (stale) {
+      emitFarmEvent({
+        type: "cache.stale",
+        key,
+        tags: [...entry.tags],
+        revalidate: entry.revalidate
+      });
+      if (!options.allowStale) {
+        emitFarmEvent({ type: "cache.miss", key, reason: "stale" });
+        return void 0;
+      }
+    }
+    emitFarmEvent({
+      type: "cache.hit",
+      key,
+      tags: [...entry.tags],
+      revalidate: entry.revalidate,
+      stale
+    });
+    if (this.local && !stale) {
+      this.hydrateLocalEntry(entry);
+    }
+    return { ...entry, key };
+  }
+  set(key, value, options = {}) {
+    const tags = /* @__PURE__ */ new Set();
+    for (const tag of options.tags ?? []) {
+      tags.add(normalizeCacheTag(tag));
+    }
+    for (const routePath of options.paths ?? []) {
+      tags.add(createPathCacheTag(routePath));
+    }
+    const entry = {
+      key,
+      value,
+      tags,
+      tagVersions: void 0,
+      createdAt: options.createdAt ?? Date.now(),
+      createdVersion: ++this.version,
+      revalidate: normalizeRevalidate(options.revalidate)
+    };
+    this.entries.set(key, entry);
+    emitFarmEvent({
+      type: "cache.set",
+      key,
+      tags: Array.from(tags),
+      revalidate: entry.revalidate
+    });
+    return this.toPublicEntry(entry);
+  }
+  async setAsync(key, value, options = {}, tagVersions) {
+    const tags = normalizeCacheOptionsTags(options);
+    const capturedVersions = tagVersions ?? await this.getAdapterTagVersions(Array.from(tags.values()));
+    const entry = {
+      key,
+      value,
+      tags: Array.from(tags),
+      tagVersions: capturedVersions,
+      createdAt: options.createdAt ?? Date.now(),
+      createdVersion: ++this.version,
+      revalidate: normalizeRevalidate(options.revalidate)
+    };
+    if (this.local) {
+      this.hydrateLocalEntry(entry);
+    }
+    if (this.adapter) {
+      await this.adapter.set(this.createAdapterKey(key), entry);
+    }
+    emitFarmEvent({
+      type: "cache.set",
+      key,
+      tags: [...entry.tags],
+      revalidate: entry.revalidate
+    });
+    return entry;
+  }
+  delete(key) {
+    const deleted = this.entries.delete(key);
+    emitFarmEvent({ type: "cache.delete", key, deleted });
+    return deleted;
+  }
+  async deleteAsync(key) {
+    const deleted = this.entries.delete(key);
+    if (this.adapter) {
+      await this.adapter.delete(this.createAdapterKey(key));
+    }
+    emitFarmEvent({ type: "cache.delete", key, deleted: this.adapter ? true : deleted });
+    return this.adapter ? true : deleted;
+  }
+  clear() {
+    const count = this.entries.size;
+    this.entries.clear();
+    this.inflight.clear();
+    this.invalidatedTagVersions.clear();
+    this.version = 0;
+    emitFarmEvent({ type: "cache.clear", count });
+  }
+  async clearAsync() {
+    this.clear();
+    await this.adapter?.clear?.();
+  }
+  isStale(entry, now = Date.now()) {
+    if (typeof entry.revalidate === "number" && entry.revalidate > 0 && now - entry.createdAt >= entry.revalidate * 1e3) {
+      return true;
+    }
+    for (const tag of entry.tags) {
+      const invalidatedVersion = this.invalidatedTagVersions.get(normalizeCacheTag(tag));
+      if (typeof invalidatedVersion === "number" && typeof entry.createdVersion === "number" && invalidatedVersion > entry.createdVersion) {
+        return true;
+      }
+    }
+    return false;
+  }
+  async isStaleAsync(entry, now = Date.now()) {
+    if (this.adapter) {
+      return this.isAdapterEntryStale(entry, now);
+    }
+    return this.isStale(entry, now);
+  }
+  revalidateTag(tag, options = {}) {
+    const normalized = normalizeCacheTag(tag);
+    const count = this.invalidateTag(normalized);
+    emitFarmEvent(
+      options.source === "updateTag" ? { type: "cache.updateTag", tag: normalized, count } : { type: "cache.revalidateTag", tag: normalized, profile: options.profile, count }
+    );
+    return count;
+  }
+  async revalidateTagAsync(tag, options = {}) {
+    const normalized = normalizeCacheTag(tag);
+    const count = this.invalidateTag(normalized);
+    await this.adapter?.invalidateTags?.([this.createAdapterTag(normalized)]);
+    emitFarmEvent(
+      options.source === "updateTag" ? { type: "cache.updateTag", tag: normalized, count } : { type: "cache.revalidateTag", tag: normalized, profile: options.profile, count }
+    );
+    return count;
+  }
+  revalidatePath(routePath) {
+    const normalizedPath = normalizeRevalidatePath(routePath);
+    const pathTag = createPathCacheTag(normalizedPath);
+    const pprCount = this.countEntriesForTags([pathTag, "ppr"]);
+    const count = this.invalidateTag(pathTag);
+    emitFarmEvent({ type: "cache.revalidatePath", path: normalizedPath, count });
+    if (pprCount > 0) {
+      emitFarmEvent({
+        type: "ppr.shell.invalidated",
+        route: normalizedPath,
+        reason: "revalidatePath",
+        count: pprCount
+      });
+    }
+    return count;
+  }
+  async revalidatePathAsync(routePath) {
+    const normalizedPath = normalizeRevalidatePath(routePath);
+    const pathTag = createPathCacheTag(normalizedPath);
+    const pprCount = this.countEntriesForTags([pathTag, "ppr"]);
+    const count = this.invalidateTag(pathTag);
+    await this.adapter?.invalidateTags?.([this.createAdapterTag(pathTag)]);
+    emitFarmEvent({ type: "cache.revalidatePath", path: normalizedPath, count });
+    if (pprCount > 0) {
+      emitFarmEvent({
+        type: "ppr.shell.invalidated",
+        route: normalizedPath,
+        reason: "revalidatePath",
+        count: pprCount
+      });
+    }
+    return count;
+  }
+  async getOrSet(key, producer, options = {}) {
+    const cached = await this.getEntryAsync(key);
+    if (cached) {
+      return cached.value;
+    }
+    const inflight = this.inflight.get(key);
+    if (inflight) {
+      emitFarmEvent({ type: "cache.dedupe", key });
+      return inflight;
+    }
+    const tags = Array.from(normalizeCacheOptionsTags(options));
+    const promise = this.fillCacheEntry(key, producer, options, tags).catch((error) => {
+      emitFarmEvent({ type: "cache.error", key, operation: "set", error });
+      throw error;
+    }).finally(() => {
+      this.inflight.delete(key);
+    });
+    this.inflight.set(key, promise);
+    return promise;
+  }
+  async fillCacheEntry(key, producer, options, tags) {
+    const leaseKey = `${this.namespace}:lease:${key}`;
+    let leaseToken;
+    if (this.adapter?.acquireLease && this.adapter.releaseLease && this.lease.enabled) {
+      leaseToken = await this.adapter.acquireLease(leaseKey, this.lease.ttlMs);
+      if (!leaseToken) {
+        const shared = await this.waitForAdapterEntry(key);
+        if (shared) {
+          emitFarmEvent({ type: "cache.dedupe", key });
+          return shared.value;
+        }
+        leaseToken = await this.adapter.acquireLease(leaseKey, this.lease.ttlMs);
+      }
+    }
+    try {
+      const initialTagVersions = await this.getAdapterTagVersions(tags);
+      const value = await producer();
+      await this.setAsync(key, value, options, initialTagVersions);
+      return value;
+    } finally {
+      if (leaseToken && this.adapter?.releaseLease) {
+        await this.adapter.releaseLease(leaseKey, leaseToken);
+      }
+    }
+  }
+  async waitForAdapterEntry(key) {
+    const deadline = Date.now() + this.lease.waitTimeoutMs;
+    while (Date.now() < deadline) {
+      await delay(this.lease.pollIntervalMs);
+      const entry = await this.getEntryAsync(key);
+      if (entry) return entry;
+    }
+    return void 0;
+  }
+  countEntriesForTag(tag) {
+    let count = 0;
+    for (const entry of this.entries.values()) {
+      if (entry.tags.has(tag)) {
+        count++;
+      }
+    }
+    return count;
+  }
+  countEntriesForTags(tags) {
+    let count = 0;
+    for (const entry of this.entries.values()) {
+      if (tags.every((tag) => entry.tags.has(tag))) {
+        count++;
+      }
+    }
+    return count;
+  }
+  invalidateTag(normalizedTag) {
+    this.invalidatedTagVersions.set(normalizedTag, ++this.version);
+    return this.countEntriesForTag(normalizedTag);
+  }
+  toPublicEntry(entry) {
+    return {
+      key: entry.key,
+      value: entry.value,
+      tags: Array.from(entry.tags),
+      tagVersions: entry.tagVersions,
+      createdAt: entry.createdAt,
+      createdVersion: entry.createdVersion,
+      revalidate: entry.revalidate
+    };
+  }
+  hydrateLocalEntry(entry) {
+    this.entries.set(entry.key, {
+      key: entry.key,
+      value: entry.value,
+      tags: new Set(entry.tags.map(normalizeCacheTag)),
+      tagVersions: entry.tagVersions,
+      createdAt: entry.createdAt,
+      createdVersion: entry.createdVersion ?? ++this.version,
+      revalidate: normalizeRevalidate(entry.revalidate)
+    });
+  }
+  createAdapterKey(key) {
+    return `${this.namespace}:entry:${key}`;
+  }
+  createAdapterTag(tag) {
+    return `${this.namespace}:tag:${tag}`;
+  }
+  async getAdapterTagVersions(tags) {
+    if (!this.adapter?.getTagVersions || tags.length === 0) return {};
+    const normalized = tags.map(normalizeCacheTag);
+    const physicalTags = normalized.map((tag) => this.createAdapterTag(tag));
+    const versions = await this.adapter.getTagVersions(physicalTags);
+    return Object.fromEntries(
+      normalized.map((tag, index) => [
+        tag,
+        normalizeAdapterVersion(versions[physicalTags[index]])
+      ])
+    );
+  }
+  async isAdapterEntryStale(entry, now = Date.now()) {
+    if (typeof entry.revalidate === "number" && entry.revalidate > 0 && now - entry.createdAt >= entry.revalidate * 1e3) {
+      return true;
+    }
+    const currentVersions = await this.getAdapterTagVersions(entry.tags);
+    for (const tag of entry.tags) {
+      if (normalizeAdapterVersion(currentVersions[tag]) > normalizeAdapterVersion(entry.tagVersions?.[tag])) {
+        return true;
+      }
+    }
+    return false;
+  }
+};
+__name(_FarmDataCache, "FarmDataCache");
+var FarmDataCache = _FarmDataCache;
+var FARM_DATA_CACHE_SYMBOL = /* @__PURE__ */ Symbol.for("farm.dataCache");
+var farmDataCacheGlobal = globalThis;
+var sharedFarmDataCache = farmDataCacheGlobal[FARM_DATA_CACHE_SYMBOL] ?? (farmDataCacheGlobal[FARM_DATA_CACHE_SYMBOL] = new FarmDataCache());
+var functionIds = /* @__PURE__ */ new WeakMap();
+var nextFunctionId = 0;
+function getFarmDataCache() {
+  return sharedFarmDataCache;
+}
+__name(getFarmDataCache, "getFarmDataCache");
+function updateTag(tag) {
+  const cache = getFarmDataCache();
+  if (cache.hasAdapter) {
+    const task = cache.revalidateTagAsync(tag, { source: "updateTag" }).then(() => void 0);
+    notifyFarmCacheTask(task);
+    return task;
+  }
+  cache.revalidateTag(tag, { source: "updateTag" });
+}
+__name(updateTag, "updateTag");
+function revalidatePath(routePath) {
+  const cache = getFarmDataCache();
+  if (cache.hasAdapter) {
+    const task = cache.revalidatePathAsync(routePath).then(() => void 0);
+    notifyFarmCacheTask(task);
+    return task;
+  }
+  cache.revalidatePath(routePath);
+}
+__name(revalidatePath, "revalidatePath");
+function invalidate(key) {
+  const clientKey = createRouteDataCacheKey(key);
+  const task = updateTag(createRouteDataCacheTag(key));
+  notifyFarmCacheInvalidation(clientKey);
+  return task;
+}
+__name(invalidate, "invalidate");
+async function applyFarmCacheInvalidationTargets(targets) {
+  if (!Array.isArray(targets)) {
+    throw new TypeError("Cache invalidations must resolve to an array of targets.");
+  }
+  const clientKeys = [];
+  for (const target of targets) {
+    assertFarmCacheInvalidationTarget(target);
+    if ("key" in target) {
+      await invalidate(target.key);
+      clientKeys.push(createRouteDataCacheKey(target.key));
+    } else if ("path" in target) {
+      await revalidatePath(target.path);
+    } else {
+      await updateTag(target.tag);
+    }
+  }
+  return Array.from(new Set(clientKeys));
+}
+__name(applyFarmCacheInvalidationTargets, "applyFarmCacheInvalidationTargets");
+function createPathCacheTag(routePath) {
+  return `path:${normalizeRevalidatePath(routePath)}`;
+}
+__name(createPathCacheTag, "createPathCacheTag");
+function createRouteDataCacheTag(key) {
+  return `route-data:${createRouteDataCacheKey(key)}`;
+}
+__name(createRouteDataCacheTag, "createRouteDataCacheTag");
+function createRouteDataCacheKey(key) {
+  return createFarmCacheKey(Array.isArray(key) ? key : [key]);
+}
+__name(createRouteDataCacheKey, "createRouteDataCacheKey");
+function normalizeRevalidatePath(routePath) {
+  if (typeof routePath !== "string") {
+    throw new TypeError("revalidatePath expects a path string.");
+  }
+  let normalized = routePath.trim();
+  if (!normalized) {
+    throw new Error("revalidatePath expects a non-empty path.");
+  }
+  try {
+    if (/^https?:\/\//.test(normalized)) {
+      normalized = new URL(normalized).pathname;
+    }
+  } catch {
+  }
+  normalized = normalized.split("?")[0] ?? normalized;
+  normalized = normalized.startsWith("/") ? normalized : `/${normalized}`;
+  normalized = normalized.replace(/\/{2,}/g, "/");
+  if (normalized.length > 1) {
+    normalized = normalized.replace(/\/+$/, "");
+  }
+  return normalized || "/";
+}
+__name(normalizeRevalidatePath, "normalizeRevalidatePath");
+function createFarmCacheKey(parts) {
+  return stableSerialize(parts);
+}
+__name(createFarmCacheKey, "createFarmCacheKey");
+function normalizeRevalidate(revalidate) {
+  if (revalidate === false || revalidate === void 0) {
+    return revalidate;
+  }
+  if (!Number.isFinite(revalidate) || revalidate <= 0) {
+    return void 0;
+  }
+  return revalidate;
+}
+__name(normalizeRevalidate, "normalizeRevalidate");
+function normalizeCacheTag(tag) {
+  if (typeof tag !== "string") {
+    throw new TypeError("Cache tags must be strings.");
+  }
+  const normalized = tag.trim();
+  if (!normalized) {
+    throw new Error("Cache tags cannot be empty.");
+  }
+  return normalized;
+}
+__name(normalizeCacheTag, "normalizeCacheTag");
+function normalizeCacheNamespace(namespace) {
+  if (typeof namespace !== "string") {
+    throw new TypeError("Cache namespace must be a string.");
+  }
+  const normalized = namespace.trim().replace(/:+$/g, "");
+  if (!normalized) {
+    throw new Error("Cache namespace cannot be empty.");
+  }
+  return normalized;
+}
+__name(normalizeCacheNamespace, "normalizeCacheNamespace");
+function normalizeAdapterVersion(value) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : 0;
+}
+__name(normalizeAdapterVersion, "normalizeAdapterVersion");
+function normalizePositiveDuration(value, fallback, name) {
+  if (value === void 0) return fallback;
+  if (!Number.isFinite(value) || value <= 0) {
+    throw new TypeError(`${name} must be a positive number of milliseconds.`);
+  }
+  return Math.floor(value);
+}
+__name(normalizePositiveDuration, "normalizePositiveDuration");
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+__name(delay, "delay");
+function normalizeCacheOptionsTags(options) {
+  const tags = /* @__PURE__ */ new Set();
+  for (const tag of options.tags ?? []) {
+    tags.add(normalizeCacheTag(tag));
+  }
+  for (const routePath of options.paths ?? []) {
+    tags.add(createPathCacheTag(routePath));
+  }
+  return tags;
+}
+__name(normalizeCacheOptionsTags, "normalizeCacheOptionsTags");
+function assertFarmCacheEntry(entry, expectedKey) {
+  if (!entry || typeof entry !== "object" || entry.key !== expectedKey || !Array.isArray(entry.tags) || typeof entry.createdAt !== "number") {
+    throw new TypeError(
+      `Cache adapter returned an invalid entry for ${JSON.stringify(expectedKey)}.`
+    );
+  }
+}
+__name(assertFarmCacheEntry, "assertFarmCacheEntry");
+function assertFarmCacheInvalidationTarget(target) {
+  if (!target || typeof target !== "object") {
+    throw new TypeError("Cache invalidation targets must be { key }, { path }, or { tag }.");
+  }
+  if ("key" in target) {
+    const key = target.key;
+    if (typeof key === "string" || Array.isArray(key)) return;
+  } else if ("path" in target && typeof target.path === "string") {
+    return;
+  } else if ("tag" in target && typeof target.tag === "string") {
+    return;
+  }
+  throw new TypeError("Cache invalidation targets must contain a string/array key, path, or tag.");
+}
+__name(assertFarmCacheInvalidationTarget, "assertFarmCacheInvalidationTarget");
+function getFunctionCacheIdentity(fn) {
+  if (fn.name) {
+    return `name:${fn.name}`;
+  }
+  let id = functionIds.get(fn);
+  if (!id) {
+    id = ++nextFunctionId;
+    functionIds.set(fn, id);
+  }
+  return `anonymous:${id}`;
+}
+__name(getFunctionCacheIdentity, "getFunctionCacheIdentity");
+function stableSerialize(value, seen = /* @__PURE__ */ new WeakSet()) {
+  if (value === null) return "null";
+  if (value === void 0) return "undefined";
+  const valueType = typeof value;
+  if (valueType === "string") return JSON.stringify(value);
+  if (valueType === "number" || valueType === "boolean" || valueType === "bigint") {
+    return `${valueType}:${String(value)}`;
+  }
+  if (valueType === "symbol") {
+    return `symbol:${String(value)}`;
+  }
+  if (valueType === "function") {
+    return `function:${getFunctionCacheIdentity(value)}`;
+  }
+  if (value instanceof Date) {
+    return `date:${value.toISOString()}`;
+  }
+  if (value instanceof URL) {
+    return `url:${value.toString()}`;
+  }
+  if (value instanceof RegExp) {
+    return `regexp:${value.toString()}`;
+  }
+  if (Array.isArray(value)) {
+    return `[${value.map((item) => stableSerialize(item, seen)).join(",")}]`;
+  }
+  if (value && typeof value === "object") {
+    if (seen.has(value)) {
+      return "[Circular]";
+    }
+    seen.add(value);
+    const entries = Object.entries(value).sort(
+      ([a], [b]) => a.localeCompare(b)
+    );
+    const serialized = entries.map(([key, item]) => `${JSON.stringify(key)}:${stableSerialize(item, seen)}`).join(",");
+    seen.delete(value);
+    return `{${serialized}}`;
+  }
+  return String(value);
+}
+__name(stableSerialize, "stableSerialize");
+
 // src/server-fn.ts
 var FARM_SERVER_FN_SYMBOL = /* @__PURE__ */ Symbol.for("farm.server-fn");
 var UNSAFE_FORM_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
@@ -126,8 +891,21 @@ function createServerFn(options) {
       request,
       signal
     };
-    const result = await runServerFnMiddleware(middleware, handlerContext, options.handler);
-    return _parseServerFnSchema(options.output, result, "output");
+    let resolvedContext = Object.freeze(/* @__PURE__ */ Object.create(null));
+    const result = await runServerFnMiddleware(middleware, handlerContext, async (context) => {
+      resolvedContext = context.context;
+      return options.handler(context);
+    });
+    const parsedResult = await _parseServerFnSchema(options.output, result, "output");
+    if (options.invalidates) {
+      const declaration = typeof options.invalidates === "function" ? await options.invalidates({
+        ...handlerContext,
+        context: resolvedContext,
+        result: parsedResult
+      }) : options.invalidates;
+      await applyFarmCacheInvalidationTargets(declaration);
+    }
+    return parsedResult;
   }, "serverFn");
   Object.defineProperties(serverFn, {
     [FARM_SERVER_FN_SYMBOL]: {
@@ -149,6 +927,10 @@ function createServerFn(options) {
     __farmServerFnMiddleware: {
       value: middleware,
       enumerable: false
+    },
+    __farmServerFnInvalidates: {
+      value: options.invalidates,
+      enumerable: false
     }
   });
   return serverFn;