@farm.js/core 0.1.0-beta.0

package/dist/server-query.cjs

@@ -0,0 +1,804 @@
+"use strict";
+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);
+
+// src/server-query.ts
+var server_query_exports = {};
+__export(server_query_exports, {
+  FARM_SERVER_QUERY_SYMBOL: () => FARM_SERVER_QUERY_SYMBOL,
+  createServerQuery: () => createServerQuery
+});
+module.exports = __toCommonJS(server_query_exports);
+
+// 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-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()
+  });
+}
+__name(getFarmCacheInvalidationState, "getFarmCacheInvalidationState");
+function subscribeFarmCacheInvalidation(listener) {
+  const state = getFarmCacheInvalidationState();
+  state.listeners.add(listener);
+  return () => state.listeners.delete(listener);
+}
+__name(subscribeFarmCacheInvalidation, "subscribeFarmCacheInvalidation");
+
+// src/cache.ts
+var _FarmDataCache = class _FarmDataCache {
+  constructor() {
+    this.entries = /* @__PURE__ */ new Map();
+    this.inflight = /* @__PURE__ */ new Map();
+    this.invalidatedTagVersions = /* @__PURE__ */ new Map();
+    this.version = 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);
+  }
+  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,
+      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);
+  }
+  delete(key) {
+    const deleted = this.entries.delete(key);
+    emitFarmEvent({ type: "cache.delete", key, deleted });
+    return deleted;
+  }
+  clear() {
+    const count = this.entries.size;
+    this.entries.clear();
+    this.inflight.clear();
+    this.invalidatedTagVersions.clear();
+    this.version = 0;
+    emitFarmEvent({ type: "cache.clear", count });
+  }
+  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;
+  }
+  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;
+  }
+  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 getOrSet(key, producer, options = {}) {
+    const cached = this.getEntry(key);
+    if (cached) {
+      return cached.value;
+    }
+    const inflight = this.inflight.get(key);
+    if (inflight) {
+      emitFarmEvent({ type: "cache.dedupe", key });
+      return inflight;
+    }
+    const promise = Promise.resolve().then(producer).then((value) => {
+      this.set(key, value, options);
+      return value;
+    }).catch((error) => {
+      emitFarmEvent({ type: "cache.error", key, operation: "set", error });
+      throw error;
+    }).finally(() => {
+      this.inflight.delete(key);
+    });
+    this.inflight.set(key, promise);
+    return promise;
+  }
+  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),
+      createdAt: entry.createdAt,
+      createdVersion: entry.createdVersion,
+      revalidate: entry.revalidate
+    };
+  }
+};
+__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 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 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-action-security.ts
+var import_node_async_hooks = require("async_hooks");
+var SERVER_ACTION_STORAGE_KEY = /* @__PURE__ */ Symbol.for("farm.serverActionStorage");
+var FALLBACK_ABORT_CONTROLLER_KEY = /* @__PURE__ */ Symbol.for("farm.serverActionFallbackAbortController");
+function getServerActionExecutionContext() {
+  return getServerActionStorage().getStore();
+}
+__name(getServerActionExecutionContext, "getServerActionExecutionContext");
+function getServerActionSignal() {
+  return getServerActionExecutionContext()?.signal ?? getFallbackAbortController().signal;
+}
+__name(getServerActionSignal, "getServerActionSignal");
+subscribeFarmCacheInvalidation((key) => {
+  getServerActionExecutionContext()?.invalidations.add(key);
+});
+function getServerActionStorage() {
+  const globalState2 = globalThis;
+  if (!globalState2[SERVER_ACTION_STORAGE_KEY]) {
+    globalState2[SERVER_ACTION_STORAGE_KEY] = new import_node_async_hooks.AsyncLocalStorage();
+  }
+  return globalState2[SERVER_ACTION_STORAGE_KEY];
+}
+__name(getServerActionStorage, "getServerActionStorage");
+function getFallbackAbortController() {
+  const globalState2 = globalThis;
+  if (!globalState2[FALLBACK_ABORT_CONTROLLER_KEY]) {
+    globalState2[FALLBACK_ABORT_CONTROLLER_KEY] = new AbortController();
+  }
+  return globalState2[FALLBACK_ABORT_CONTROLLER_KEY];
+}
+__name(getFallbackAbortController, "getFallbackAbortController");
+
+// src/server/request-bridge.ts
+var CURRENT_REQUEST_RESOLVER_KEY = /* @__PURE__ */ Symbol.for("farm.currentRequestResolver");
+function getGlobalState() {
+  return globalThis;
+}
+__name(getGlobalState, "getGlobalState");
+function _resolveCurrentRequest() {
+  return getGlobalState()[CURRENT_REQUEST_RESOLVER_KEY]?.();
+}
+__name(_resolveCurrentRequest, "_resolveCurrentRequest");
+
+// 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"]);
+function createServerFn(options) {
+  if (!options || typeof options.handler !== "function") {
+    throw new TypeError("createServerFn requires a handler function");
+  }
+  const middleware = resolveServerFnMiddleware(options.middleware);
+  const serverFn = /* @__PURE__ */ __name(async (value) => {
+    const formData = isFormData(value) ? value : void 0;
+    const rawInput = formData ? formDataToObject(formData) : value;
+    const input = await _parseServerFnSchema(options.input, rawInput, "input");
+    const executionContext = getServerActionExecutionContext();
+    const request = executionContext?.request ?? _resolveCurrentRequest();
+    const signal = executionContext?.signal ?? request?.signal ?? getServerActionSignal();
+    const handlerContext = {
+      input,
+      rawInput,
+      formData,
+      request,
+      signal
+    };
+    const result = await runServerFnMiddleware(middleware, handlerContext, options.handler);
+    return _parseServerFnSchema(options.output, result, "output");
+  }, "serverFn");
+  Object.defineProperties(serverFn, {
+    [FARM_SERVER_FN_SYMBOL]: {
+      value: true,
+      enumerable: false
+    },
+    __farmServerFn: {
+      value: true,
+      enumerable: false
+    },
+    __farmServerFnInput: {
+      value: options.input,
+      enumerable: false
+    },
+    __farmServerFnOutput: {
+      value: options.output,
+      enumerable: false
+    },
+    __farmServerFnMiddleware: {
+      value: middleware,
+      enumerable: false
+    }
+  });
+  return serverFn;
+}
+__name(createServerFn, "createServerFn");
+async function runServerFnMiddleware(middleware, handlerContext, handler) {
+  const dispatch = /* @__PURE__ */ __name(async (index, context) => {
+    const current = middleware[index];
+    if (!current) {
+      return handler({ ...handlerContext, context });
+    }
+    let nextCalled = false;
+    const result = await current.handler({
+      ...handlerContext,
+      context,
+      next: /* @__PURE__ */ __name(async (nextOptions) => {
+        if (nextCalled) {
+          throw new Error("Server function middleware next() can only be called once");
+        }
+        nextCalled = true;
+        return dispatch(index + 1, mergeServerFnContext(context, nextOptions?.context));
+      }, "next")
+    });
+    if (!nextCalled) {
+      throw new Error("Server function middleware must call next()");
+    }
+    return result;
+  }, "dispatch");
+  return dispatch(0, Object.freeze(/* @__PURE__ */ Object.create(null)));
+}
+__name(runServerFnMiddleware, "runServerFnMiddleware");
+function resolveServerFnMiddleware(middleware) {
+  const resolved = [];
+  const seen = /* @__PURE__ */ new Set();
+  const visiting = /* @__PURE__ */ new Set();
+  const visit = /* @__PURE__ */ __name((entry) => {
+    assertServerFnMiddleware(entry);
+    if (seen.has(entry)) return;
+    if (visiting.has(entry)) {
+      throw new Error("Server function middleware dependencies cannot contain a cycle");
+    }
+    visiting.add(entry);
+    for (const dependency of entry.middleware) {
+      visit(dependency);
+    }
+    visiting.delete(entry);
+    seen.add(entry);
+    resolved.push(entry);
+  }, "visit");
+  for (const entry of middleware ?? []) {
+    visit(entry);
+  }
+  return Object.freeze(resolved);
+}
+__name(resolveServerFnMiddleware, "resolveServerFnMiddleware");
+function assertServerFnMiddleware(value) {
+  if (!value || typeof value !== "object" || value.__farmServerFnMiddleware !== true || typeof value.handler !== "function" || !Array.isArray(value.middleware)) {
+    throw new TypeError("createServerFn middleware must be created with createServerMiddleware");
+  }
+}
+__name(assertServerFnMiddleware, "assertServerFnMiddleware");
+function mergeServerFnContext(current, added) {
+  if (added !== void 0 && (added === null || typeof added !== "object" || Array.isArray(added))) {
+    throw new TypeError("Server function middleware context must be an object");
+  }
+  return Object.freeze(Object.assign(/* @__PURE__ */ Object.create(null), current, added));
+}
+__name(mergeServerFnContext, "mergeServerFnContext");
+async function _parseServerFnSchema(schema, value, contract, owner = "createServerFn") {
+  if (!schema) return value;
+  if (typeof schema.safeParseAsync === "function") {
+    const result = await schema.safeParseAsync(value);
+    return unwrapSafeParseResult(result);
+  }
+  if (typeof schema.safeParse === "function") {
+    const result = schema.safeParse(value);
+    return unwrapSafeParseResult(await result);
+  }
+  if (typeof schema.parseAsync === "function") {
+    return schema.parseAsync(value);
+  }
+  if (typeof schema.parse === "function") {
+    return schema.parse(value);
+  }
+  throw new TypeError(`${owner} ${contract} must provide parse, parseAsync, or safeParse`);
+}
+__name(_parseServerFnSchema, "_parseServerFnSchema");
+function unwrapSafeParseResult(result) {
+  if (result && typeof result === "object" && "success" in result && result.success === false) {
+    throw result.error;
+  }
+  if (result && typeof result === "object" && "success" in result && result.success === true) {
+    return result.data;
+  }
+  return result;
+}
+__name(unwrapSafeParseResult, "unwrapSafeParseResult");
+function formDataToObject(formData) {
+  const output = /* @__PURE__ */ Object.create(null);
+  for (const [key, value] of formData.entries()) {
+    if (!isSafeFormKey(key)) continue;
+    const existing = output[key];
+    if (existing === void 0) {
+      output[key] = value;
+    } else if (Array.isArray(existing)) {
+      existing.push(value);
+    } else {
+      output[key] = [existing, value];
+    }
+  }
+  return output;
+}
+__name(formDataToObject, "formDataToObject");
+function isSafeFormKey(key) {
+  return !key.startsWith("$ACTION_") && !UNSAFE_FORM_KEYS.has(key);
+}
+__name(isSafeFormKey, "isSafeFormKey");
+function isFormData(value) {
+  if (!value || typeof value !== "object") return false;
+  if (typeof FormData !== "undefined" && value instanceof FormData) {
+    return true;
+  }
+  return Object.prototype.toString.call(value) === "[object FormData]" && typeof value.entries === "function";
+}
+__name(isFormData, "isFormData");
+
+// src/server-query-protocol.ts
+var FARM_SERVER_QUERY_RESULT_VERSION = 1;
+function createFarmServerQueryResult(data, metadata) {
+  return {
+    __farmServerQuery: {
+      version: FARM_SERVER_QUERY_RESULT_VERSION,
+      ...metadata
+    },
+    data
+  };
+}
+__name(createFarmServerQueryResult, "createFarmServerQueryResult");
+
+// src/server-query.ts
+var FARM_SERVER_QUERY_SYMBOL = /* @__PURE__ */ Symbol.for("farm.server-query");
+var requestInflight = /* @__PURE__ */ new WeakMap();
+var detachedInflight = /* @__PURE__ */ new Map();
+function createServerQuery(options) {
+  if (!options || typeof options.handler !== "function") {
+    throw new TypeError("createServerQuery requires a handler function");
+  }
+  if (typeof options.key !== "function") {
+    throw new TypeError("createServerQuery requires a key function");
+  }
+  const staleTime = normalizeServerQueryStaleTime(options.staleTime);
+  const execute = createServerFn({
+    input: options.input,
+    middleware: options.middleware,
+    handler: /* @__PURE__ */ __name(async (context) => {
+      const routeKey = await options.key(context);
+      assertServerQueryKey(routeKey);
+      const clientKey = createRouteDataCacheKey(routeKey);
+      const cacheKey = createFarmCacheKey(["route-data", routeKey]);
+      const producer = /* @__PURE__ */ __name(async () => {
+        const value = await options.handler(context);
+        return _parseServerFnSchema(options.output, value, "output", "createServerQuery");
+      }, "producer");
+      let data;
+      let updatedAt;
+      if (staleTime === 0) {
+        data = await dedupeServerQueryRequest(cacheKey, context.request, producer);
+        updatedAt = Date.now();
+      } else {
+        const cache = getFarmDataCache();
+        data = await cache.getOrSet(cacheKey, producer, {
+          tags: [createRouteDataCacheTag(routeKey)],
+          revalidate: staleTime === false ? false : Math.max(1, Math.ceil(staleTime / 1e3))
+        });
+        updatedAt = cache.getEntry(cacheKey, { allowStale: true })?.createdAt ?? Date.now();
+      }
+      return createFarmServerQueryResult(data, {
+        key: clientKey,
+        staleTime,
+        updatedAt
+      });
+    }, "handler")
+  });
+  const query = /* @__PURE__ */ __name(async (input) => {
+    const result = await execute(input);
+    return getServerActionExecutionContext() ? result : result.data;
+  }, "query");
+  Object.defineProperties(query, {
+    [FARM_SERVER_QUERY_SYMBOL]: {
+      value: true,
+      enumerable: false
+    },
+    __farmServerQuery: {
+      value: true,
+      enumerable: false
+    },
+    __farmServerQueryInput: {
+      value: options.input,
+      enumerable: false
+    },
+    __farmServerQueryOutput: {
+      value: options.output,
+      enumerable: false
+    }
+  });
+  return query;
+}
+__name(createServerQuery, "createServerQuery");
+async function dedupeServerQueryRequest(key, request, producer) {
+  let inflight;
+  if (request) {
+    inflight = requestInflight.get(request) ?? /* @__PURE__ */ new Map();
+    requestInflight.set(request, inflight);
+  } else {
+    inflight = detachedInflight;
+  }
+  const existing = inflight.get(key);
+  if (existing) return existing;
+  const promise = Promise.resolve().then(producer);
+  inflight.set(key, promise);
+  try {
+    return await promise;
+  } finally {
+    inflight.delete(key);
+  }
+}
+__name(dedupeServerQueryRequest, "dedupeServerQueryRequest");
+function normalizeServerQueryStaleTime(value) {
+  if (value === false) return false;
+  if (value === void 0) return 0;
+  if (typeof value === "number") {
+    if (!Number.isFinite(value) || value < 0) {
+      throw new TypeError("createServerQuery staleTime must be a non-negative duration");
+    }
+    return value;
+  }
+  const match = value.match(/^(\d+(?:\.\d+)?)(ms|s|m|h)$/);
+  if (!match) {
+    throw new TypeError('createServerQuery staleTime must look like "250ms", "30s", "5m", or "1h"');
+  }
+  const amount = Number(match[1]);
+  const unit = match[2];
+  const multiplier = unit === "ms" ? 1 : unit === "s" ? 1e3 : unit === "m" ? 6e4 : 36e5;
+  return amount * multiplier;
+}
+__name(normalizeServerQueryStaleTime, "normalizeServerQueryStaleTime");
+function assertServerQueryKey(key) {
+  if (typeof key === "string") {
+    if (key.trim().length > 0) return;
+  } else if (Array.isArray(key)) {
+    return;
+  }
+  throw new TypeError("createServerQuery key must return a non-empty string or an array");
+}
+__name(assertServerQueryKey, "assertServerQueryKey");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FARM_SERVER_QUERY_SYMBOL,
+  createServerQuery
+});
+//# sourceMappingURL=server-query.cjs.map