@farm.js/core 0.1.0-beta.0

package/dist/api/route-manager.cjs

@@ -0,0 +1,1196 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/api/route-manager.ts
+var route_manager_exports = {};
+__export(route_manager_exports, {
+  APIRouteManager: () => APIRouteManager,
+  API_ROUTE_METHODS: () => API_ROUTE_METHODS,
+  invokeAPIRouteEndpoint: () => invokeAPIRouteEndpoint,
+  isWebResponse: () => isWebResponse,
+  matchAPIRoute: () => matchAPIRoute,
+  normalizeRouteResponse: () => normalizeRouteResponse
+});
+module.exports = __toCommonJS(route_manager_exports);
+var fs = __toESM(require("fs"));
+var path2 = __toESM(require("path"));
+
+// src/utils.ts
+var logger = {
+  info: /* @__PURE__ */ __name((message) => console.log(`[info] ${message}`), "info"),
+  success: /* @__PURE__ */ __name((message) => console.log(`[success] ${message}`), "success"),
+  warn: /* @__PURE__ */ __name((message) => console.warn(`\u26A0\uFE0F  ${message}`), "warn"),
+  error: /* @__PURE__ */ __name((message) => console.error(`\u274C ${message}`), "error"),
+  ready: /* @__PURE__ */ __name((message) => console.log(`${message}`), "ready"),
+  event: /* @__PURE__ */ __name((message) => console.log(`  ${message}`), "event")
+};
+
+// src/routes.ts
+var import_react = require("react");
+
+// 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/i18n/bridge.ts
+var FARM_I18N_SNAPSHOT_RESOLVER = /* @__PURE__ */ Symbol.for("farm.i18n.snapshotResolver");
+function _setFarmI18nSnapshotResolver(resolver) {
+  globalThis[FARM_I18N_SNAPSHOT_RESOLVER] = resolver;
+}
+__name(_setFarmI18nSnapshotResolver, "_setFarmI18nSnapshotResolver");
+
+// 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());
+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?:\/\//.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 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");
+
+// src/route-runtime.ts
+function normalizeFarmRouteRuntimeConfig(value, source = "Route configuration") {
+  if (!value) return {};
+  const normalized = {};
+  if (value.runtime !== void 0) {
+    if (value.runtime !== "auto" && value.runtime !== "node" && value.runtime !== "edge") {
+      throw new TypeError(`${source} runtime must be "auto", "node", or "edge"`);
+    }
+    normalized.runtime = value.runtime;
+  }
+  if (value.regions !== void 0) {
+    if (value.regions === "auto") {
+      normalized.regions = "auto";
+    } else {
+      if (!Array.isArray(value.regions) || value.regions.length === 0) {
+        throw new TypeError(`${source} regions must be "auto" or a non-empty string array`);
+      }
+      const regions = Array.from(
+        new Set(
+          value.regions.map((region) => {
+            if (typeof region !== "string" || !region.trim() || /[\u0000-\u001f\u007f]/.test(region)) {
+              throw new TypeError(`${source} regions must contain non-empty region identifiers`);
+            }
+            return region.trim();
+          })
+        )
+      );
+      normalized.regions = regions;
+    }
+  }
+  if (value.maxDuration !== void 0) {
+    if (value.maxDuration === "auto") {
+      normalized.maxDuration = "auto";
+    } else if (typeof value.maxDuration !== "number" || !Number.isInteger(value.maxDuration) || value.maxDuration <= 0) {
+      throw new TypeError(`${source} maxDuration must be "auto" or a positive integer in seconds`);
+    } else {
+      normalized.maxDuration = value.maxDuration;
+    }
+  }
+  return normalized;
+}
+__name(normalizeFarmRouteRuntimeConfig, "normalizeFarmRouteRuntimeConfig");
+function getFarmRouteRuntimeConfig(value) {
+  if (!value || typeof value !== "object") return {};
+  const route = value;
+  return {
+    ...route.runtime !== void 0 ? { runtime: route.runtime } : {},
+    ...route.regions !== void 0 ? { regions: route.regions } : {},
+    ...route.maxDuration !== void 0 ? { maxDuration: route.maxDuration } : {}
+  };
+}
+__name(getFarmRouteRuntimeConfig, "getFarmRouteRuntimeConfig");
+
+// src/routes.ts
+var FARM_ROUTES_BRAND = /* @__PURE__ */ Symbol.for("farm.routes");
+var PROGRAMMATIC_ROUTE_FILE_NAMES = [
+  "farm.route.ts",
+  "farm.route.tsx",
+  "farm.route.js",
+  "farm.route.jsx",
+  "farm.routes.ts",
+  "farm.routes.tsx",
+  "farm.routes.js",
+  "farm.routes.jsx",
+  "routes.ts",
+  "routes.tsx",
+  "routes.js",
+  "routes.jsx"
+];
+function defineRoutes(input) {
+  const routes = typeof input === "function" ? input(routesBuilder) : input;
+  const manifest = {
+    __farmRoutes: true,
+    routes: routes.map(normalizeProgrammaticRoute)
+  };
+  Object.defineProperty(manifest, FARM_ROUTES_BRAND, {
+    value: true,
+    enumerable: false
+  });
+  return manifest;
+}
+__name(defineRoutes, "defineRoutes");
+var routesBuilder = {
+  page(path3, options) {
+    return normalizeProgrammaticRoute({
+      kind: "page",
+      path: path3,
+      ...options
+    });
+  },
+  layout(path3, options) {
+    return normalizeProgrammaticRoute({
+      kind: "layout",
+      path: path3,
+      ...options
+    });
+  },
+  api(path3, options) {
+    const { render, runtime, regions, maxDuration, ...methods } = options;
+    return normalizeProgrammaticRoute({
+      kind: "api",
+      path: path3,
+      render,
+      runtime,
+      regions,
+      maxDuration,
+      methods: normalizeApiMethods(methods)
+    });
+  },
+  redirect(source, destination, options = {}) {
+    return normalizeProgrammaticRoute({
+      kind: "redirect",
+      source,
+      destination,
+      ...options
+    });
+  }
+};
+var page = routesBuilder.page;
+var layout = routesBuilder.layout;
+var api = routesBuilder.api;
+var redirect = routesBuilder.redirect;
+function getProgrammaticRouteManifest(mod) {
+  if (!mod) return null;
+  const candidates = [mod.default, mod.routes, mod.Route];
+  for (const candidate of candidates) {
+    if (isProgrammaticRouteManifest(candidate)) {
+      return candidate;
+    }
+    if (isProgrammaticRouteDefinition(candidate)) {
+      return defineRoutes([candidate]);
+    }
+    if (Array.isArray(candidate)) {
+      return defineRoutes(candidate);
+    }
+  }
+  const routeDefinitions = Object.values(mod).filter(isProgrammaticRouteDefinition);
+  if (routeDefinitions.length > 0) {
+    return defineRoutes(routeDefinitions);
+  }
+  return null;
+}
+__name(getProgrammaticRouteManifest, "getProgrammaticRouteManifest");
+function isProgrammaticRouteManifest(value) {
+  return !!value && typeof value === "object" && value.__farmRoutes === true && Array.isArray(value.routes);
+}
+__name(isProgrammaticRouteManifest, "isProgrammaticRouteManifest");
+function isProgrammaticRouteDefinition(value) {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const kind = value.kind;
+  return kind === "page" || kind === "layout" || kind === "api" || kind === "redirect";
+}
+__name(isProgrammaticRouteDefinition, "isProgrammaticRouteDefinition");
+function createProgrammaticRouteModuleId(filePath, kind, routePath) {
+  return `${filePath}?farm-route=${kind}:${encodeURIComponent(normalizeRoutePath(routePath))}`;
+}
+__name(createProgrammaticRouteModuleId, "createProgrammaticRouteModuleId");
+function normalizeProgrammaticRoute(route) {
+  if (route.kind === "redirect") {
+    return {
+      ...route,
+      source: normalizeRoutePath(route.source)
+    };
+  }
+  if (route.kind === "api") {
+    return {
+      ...route,
+      ...normalizeFarmRouteRuntimeConfig(route, `API route "${route.path}"`),
+      path: normalizeRoutePath(route.path),
+      methods: normalizeApiMethods(route.methods)
+    };
+  }
+  return {
+    ...route,
+    ...normalizeFarmRouteRuntimeConfig(
+      route,
+      `${route.kind === "layout" ? "Layout" : "Route"} "${route.path}"`
+    ),
+    path: normalizeRoutePath(route.path)
+  };
+}
+__name(normalizeProgrammaticRoute, "normalizeProgrammaticRoute");
+function normalizeRoutePath(routePath) {
+  const withSlash = routePath.startsWith("/") ? routePath : `/${routePath}`;
+  const withoutTrailing = withSlash.length > 1 ? withSlash.replace(/\/+$/, "") : withSlash;
+  return withoutTrailing || "/";
+}
+__name(normalizeRoutePath, "normalizeRoutePath");
+function normalizeApiMethods(methods) {
+  const normalized = {};
+  for (const [method, handler] of Object.entries(methods)) {
+    const normalizedMethod = method.toUpperCase();
+    if (handler && isProgrammaticRouteMethod(normalizedMethod)) {
+      normalized[normalizedMethod] = handler;
+    }
+  }
+  return normalized;
+}
+__name(normalizeApiMethods, "normalizeApiMethods");
+function isProgrammaticRouteMethod(method) {
+  return method === "GET" || method === "HEAD" || method === "POST" || method === "PUT" || method === "DELETE" || method === "PATCH" || method === "OPTIONS";
+}
+__name(isProgrammaticRouteMethod, "isProgrammaticRouteMethod");
+
+// src/routes.server.ts
+var import_fs = require("fs");
+var import_path = require("path");
+function findProgrammaticRouteFilesInDir(srcRoot) {
+  const files = [];
+  for (const fileName of PROGRAMMATIC_ROUTE_FILE_NAMES) {
+    const filePath = (0, import_path.join)(srcRoot, fileName);
+    if ((0, import_fs.existsSync)(filePath)) {
+      files.push(filePath);
+    }
+  }
+  return files;
+}
+__name(findProgrammaticRouteFilesInDir, "findProgrammaticRouteFilesInDir");
+
+// src/i18n/server.ts
+var import_node_async_hooks = require("async_hooks");
+
+// src/i18n/runtime.ts
+var import_intl_messageformat = __toESM(require("intl-messageformat"));
+
+// src/i18n/catalog.ts
+var import_promises = require("fs/promises");
+var import_icu_messageformat_parser = require("@formatjs/icu-messageformat-parser");
+
+// src/i18n/config.ts
+var import_node_path = __toESM(require("path"));
+var DEFAULT_FARM_I18N_COOKIE_MAX_AGE = 60 * 60 * 24 * 365;
+
+// src/i18n/server.ts
+var FARM_I18N_REQUEST_STORE = /* @__PURE__ */ Symbol.for("farm.i18n.requestStore");
+function getRequestStore() {
+  const state = globalThis;
+  return state[FARM_I18N_REQUEST_STORE] ?? (state[FARM_I18N_REQUEST_STORE] = new import_node_async_hooks.AsyncLocalStorage());
+}
+__name(getRequestStore, "getRequestStore");
+function getState() {
+  const state = getRequestStore().getStore();
+  if (!state) {
+    throw new Error(
+      "No Farm i18n request context is active. Use this API while rendering, inside an API route, or use createTranslator(locale)."
+    );
+  }
+  return state;
+}
+__name(getState, "getState");
+async function _runWithFarmI18nRequest(runtime, request, fn, options = {}) {
+  const resolution = runtime.resolveRequest(request, options);
+  const state = {
+    runtime,
+    resolution,
+    snapshot: runtime.getClientSnapshot(resolution)
+  };
+  return getRequestStore().run(state, () => fn(resolution));
+}
+__name(_runWithFarmI18nRequest, "_runWithFarmI18nRequest");
+var t = createTranslatorFromState(() => getState());
+function getFarmI18nClientSnapshot() {
+  return getRequestStore().getStore()?.snapshot;
+}
+__name(getFarmI18nClientSnapshot, "getFarmI18nClientSnapshot");
+function createTranslatorFromState(resolveState) {
+  const translator = /* @__PURE__ */ __name(((key, values) => {
+    const state = resolveState();
+    return state.runtime.translate(state.resolution.locale, key, values);
+  }), "translator");
+  translator.rich = (key, values) => {
+    const state = resolveState();
+    return state.runtime.translateRich(state.resolution.locale, key, values);
+  };
+  translator.raw = (key) => {
+    const state = resolveState();
+    return state.runtime.getRawMessage(state.resolution.locale, key);
+  };
+  translator.has = (key) => {
+    const state = resolveState();
+    return state.runtime.hasMessage(state.resolution.locale, key);
+  };
+  return translator;
+}
+__name(createTranslatorFromState, "createTranslatorFromState");
+_setFarmI18nSnapshotResolver(() => getFarmI18nClientSnapshot());
+
+// src/server/request.ts
+var import_node_async_hooks2 = require("async_hooks");
+
+// src/server/request-bridge.ts
+var CURRENT_REQUEST_RESOLVER_KEY = /* @__PURE__ */ Symbol.for("farm.currentRequestResolver");
+function getGlobalState() {
+  return globalThis;
+}
+__name(getGlobalState, "getGlobalState");
+function _setCurrentRequestResolver(resolver) {
+  getGlobalState()[CURRENT_REQUEST_RESOLVER_KEY] = resolver;
+}
+__name(_setCurrentRequestResolver, "_setCurrentRequestResolver");
+
+// src/server/request.ts
+var REQUEST_STORAGE_KEY = /* @__PURE__ */ Symbol.for("@farm.js/core/request-storage");
+function getRequestStore2() {
+  const runtime = globalThis;
+  const existing = runtime[REQUEST_STORAGE_KEY];
+  if (existing instanceof import_node_async_hooks2.AsyncLocalStorage) {
+    return existing;
+  }
+  const storage = new import_node_async_hooks2.AsyncLocalStorage();
+  runtime[REQUEST_STORAGE_KEY] = storage;
+  return storage;
+}
+__name(getRequestStore2, "getRequestStore");
+var requestStore = getRequestStore2();
+_setCurrentRequestResolver(() => requestStore.getStore());
+async function _runWithCurrentRequest(request, fn) {
+  return requestStore.run(request, fn);
+}
+__name(_runWithCurrentRequest, "_runWithCurrentRequest");
+
+// src/api/runtime.ts
+function matchAPIRoute(routes, pathname) {
+  const exactRoute = routes.get(pathname);
+  if (exactRoute) {
+    return { route: exactRoute, params: {} };
+  }
+  const normalizedPathname = normalizePathname(pathname);
+  if (normalizedPathname !== pathname) {
+    const normalizedRoute = routes.get(normalizedPathname);
+    if (normalizedRoute) {
+      return { route: normalizedRoute, params: {} };
+    }
+  }
+  for (const route of routes.values()) {
+    const params = matchRoutePath(route.path, pathname);
+    if (params) {
+      return { route, params };
+    }
+  }
+  return null;
+}
+__name(matchAPIRoute, "matchAPIRoute");
+async function invokeAPIRouteEndpoint(endpoint, request, params = {}) {
+  return _runWithCurrentRequest(
+    request,
+    () => invokeAPIRouteEndpointInContext(endpoint, request, params)
+  );
+}
+__name(invokeAPIRouteEndpoint, "invokeAPIRouteEndpoint");
+async function invokeAPIRouteEndpointInContext(endpoint, request, params) {
+  const farmHandler = endpoint.__handler || (isFarmContextHandler(endpoint) ? endpoint : null);
+  if (!farmHandler) {
+    const result2 = await endpoint(request, {
+      params: Promise.resolve(params)
+    });
+    return normalizeRouteResponse(result2);
+  }
+  const url = new URL(request.url);
+  const query = {};
+  url.searchParams.forEach((value, key) => {
+    query[key] = value;
+  });
+  let body = void 0;
+  if (request.method.toUpperCase() !== "GET" && request.method.toUpperCase() !== "HEAD") {
+    body = await readJSONBody(request);
+  }
+  const headers = Object.fromEntries(request.headers.entries());
+  const types = endpoint.__types || {};
+  const queryValidation = validateInput(types.query, query, "Invalid query parameters");
+  if (queryValidation instanceof Response) {
+    return queryValidation;
+  }
+  const bodyValidation = validateInput(types.body, body, "Invalid request body");
+  if (bodyValidation instanceof Response) {
+    return bodyValidation;
+  }
+  const headersValidation = validateInput(types.headers, headers, "Invalid request headers");
+  if (headersValidation instanceof Response) {
+    return headersValidation;
+  }
+  const result = await farmHandler({
+    query: queryValidation,
+    body: bodyValidation,
+    headers: headersValidation,
+    request,
+    context: {},
+    params
+  });
+  return normalizeRouteResponse(result);
+}
+__name(invokeAPIRouteEndpointInContext, "invokeAPIRouteEndpointInContext");
+function normalizeRouteResponse(result) {
+  if (isWebResponse(result)) {
+    return result;
+  }
+  if (result === void 0) {
+    return new Response(null, { status: 204 });
+  }
+  return new Response(JSON.stringify(result), {
+    status: 200,
+    headers: { "Content-Type": "application/json" }
+  });
+}
+__name(normalizeRouteResponse, "normalizeRouteResponse");
+function isWebResponse(value) {
+  return value instanceof Response || typeof value === "object" && value !== null && "headers" in value && "status" in value && typeof value.arrayBuffer === "function";
+}
+__name(isWebResponse, "isWebResponse");
+function isFarmContextHandler(endpoint) {
+  if (typeof endpoint !== "function") {
+    return false;
+  }
+  const source = Function.prototype.toString.call(endpoint).trim();
+  const arrowMatch = source.match(/^(?:async\s*)?(?:\(([^)]*)\)|([A-Za-z_$][\w$]*))\s*=>/);
+  const functionMatch = source.match(/^(?:async\s*)?function[^(]*\(([^)]*)\)/);
+  const firstParameter = (arrowMatch?.[1] || arrowMatch?.[2] || functionMatch?.[1] || "").split(",")[0].trim();
+  return firstParameter === "ctx" || firstParameter === "context" || firstParameter.startsWith("{");
+}
+__name(isFarmContextHandler, "isFarmContextHandler");
+async function readJSONBody(request) {
+  try {
+    const text = await request.clone().text();
+    if (text) {
+      return JSON.parse(text);
+    }
+  } catch {
+  }
+  return void 0;
+}
+__name(readJSONBody, "readJSONBody");
+function validateInput(schema, value, error) {
+  if (!schema || typeof schema.parse !== "function") {
+    return value;
+  }
+  try {
+    return schema.parse(value);
+  } catch (validationError) {
+    return new Response(
+      JSON.stringify({
+        error,
+        details: validationError.errors || validationError.issues || validationError.message
+      }),
+      {
+        status: 400,
+        headers: { "Content-Type": "application/json" }
+      }
+    );
+  }
+}
+__name(validateInput, "validateInput");
+function matchRoutePath(routePath, pathname) {
+  const routeSegments = getPathSegments(routePath);
+  const pathnameSegments = getPathSegments(pathname);
+  const params = {};
+  let pathIndex = 0;
+  for (const routeSegment of routeSegments) {
+    const dynamicSegment = parseDynamicSegment(routeSegment);
+    if (dynamicSegment?.catchAll) {
+      const remainingSegments = pathnameSegments.slice(pathIndex).map(decodePathSegment);
+      if (remainingSegments.length === 0 && !dynamicSegment.optional) {
+        return null;
+      }
+      if (remainingSegments.length > 0) {
+        params[dynamicSegment.name] = remainingSegments;
+      }
+      pathIndex = pathnameSegments.length;
+      continue;
+    }
+    const pathnameSegment = pathnameSegments[pathIndex];
+    if (pathnameSegment === void 0) {
+      return null;
+    }
+    if (dynamicSegment) {
+      params[dynamicSegment.name] = decodePathSegment(pathnameSegment);
+      pathIndex++;
+      continue;
+    }
+    if (routeSegment !== pathnameSegment) {
+      return null;
+    }
+    pathIndex++;
+  }
+  return pathIndex === pathnameSegments.length ? params : null;
+}
+__name(matchRoutePath, "matchRoutePath");
+function getPathSegments(pathname) {
+  return normalizePathname(pathname).split("/").filter((segment) => segment.length > 0);
+}
+__name(getPathSegments, "getPathSegments");
+function normalizePathname(pathname) {
+  if (pathname.length > 1 && pathname.endsWith("/")) {
+    return pathname.replace(/\/+$/, "");
+  }
+  return pathname;
+}
+__name(normalizePathname, "normalizePathname");
+function parseDynamicSegment(segment) {
+  const optionalCatchAll = segment.match(/^\[\[\.\.\.(.+)\]\]$/);
+  if (optionalCatchAll?.[1]) {
+    return { name: optionalCatchAll[1], catchAll: true, optional: true };
+  }
+  const catchAll = segment.match(/^\[\.\.\.(.+)\]$/);
+  if (catchAll?.[1]) {
+    return { name: catchAll[1], catchAll: true, optional: false };
+  }
+  const dynamic = segment.match(/^\[(.+)\]$/);
+  if (dynamic?.[1]) {
+    return { name: dynamic[1], catchAll: false, optional: false };
+  }
+  return null;
+}
+__name(parseDynamicSegment, "parseDynamicSegment");
+function decodePathSegment(segment) {
+  try {
+    return decodeURIComponent(segment);
+  } catch {
+    return segment;
+  }
+}
+__name(decodePathSegment, "decodePathSegment");
+
+// src/api/route-manager.ts
+var API_ROUTE_METHODS = [
+  "GET",
+  "HEAD",
+  "POST",
+  "PUT",
+  "DELETE",
+  "PATCH",
+  "OPTIONS"
+];
+var _APIRouteManager = class _APIRouteManager {
+  constructor(appDir, viteServer, options = {}) {
+    this.routes = /* @__PURE__ */ new Map();
+    this.appDirs = Array.isArray(appDir) ? [...appDir] : [appDir];
+    this.viteServer = viteServer;
+    this.throwOnLoadError = options.throwOnLoadError === true;
+    this.i18n = options.i18n;
+  }
+  /**
+   * Discover route.ts files in /app/api and explicit endpoints in root routes.ts
+   */
+  async discoverRoutes() {
+    this.routes.clear();
+    for (const appDir of this.appDirs) {
+      const apiDir = path2.join(appDir, "api");
+      let routeFiles = [];
+      if (fs.existsSync(apiDir)) {
+        routeFiles = this.findRouteFiles(apiDir);
+      }
+      for (const filePath of routeFiles) {
+        await this.loadRoute(filePath, appDir);
+      }
+      await this.loadRootRoutes(appDir);
+      await this.loadProgrammaticApiRoutes(appDir);
+    }
+    if (process.env.FARM_VERBOSE) {
+      logger.success(`Discovered ${this.routes.size} API routes`);
+      for (const [routePath, route] of this.routes) {
+        logger.info(`  ${route.methods.join(", ")} ${routePath}`);
+      }
+    }
+  }
+  /**
+   * Recursively find all route.ts files
+   */
+  findRouteFiles(dir) {
+    const files = [];
+    if (!fs.existsSync(dir)) {
+      return files;
+    }
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path2.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        files.push(...this.findRouteFiles(fullPath));
+      } else if (entry.name === "route.ts" || entry.name === "route.tsx" || entry.name === "route.js") {
+        files.push(fullPath);
+      }
+    }
+    return files;
+  }
+  /**
+   * Load a route.ts file and extract HTTP method exports
+   */
+  async loadRoute(filePath, appDir) {
+    try {
+      const apiDir = path2.join(appDir, "api");
+      const relativePath = path2.relative(apiDir, path2.dirname(filePath));
+      const routePath = "/api/" + (relativePath === "." ? "" : relativePath.replace(/\\/g, "/"));
+      const routeModule = await this.loadModule(filePath);
+      const endpoints = {};
+      const availableMethods = [];
+      for (const method of API_ROUTE_METHODS) {
+        if (routeModule[method]) {
+          endpoints[method] = routeModule[method];
+          availableMethods.push(method);
+        }
+      }
+      if (availableMethods.length > 0) {
+        const runtimeConfig = normalizeFarmRouteRuntimeConfig(
+          getFarmRouteRuntimeConfig(routeModule),
+          `API route "${routePath}"`
+        );
+        this.routes.set(routePath, {
+          path: routePath,
+          filePath,
+          methods: availableMethods,
+          endpoints,
+          ...runtimeConfig
+        });
+      }
+    } catch (error) {
+      this.handleLoadError(`Error loading route ${filePath}`, error);
+    }
+  }
+  /**
+   * Load explicit-path endpoints from src/routes.ts-style files.
+   */
+  async loadRootRoutes(appDir) {
+    const routesFile = this.findRootRoutesFile(appDir);
+    if (!routesFile) {
+      return;
+    }
+    try {
+      const routesModule = await this.loadModule(routesFile);
+      for (const exportValue of Object.values(routesModule)) {
+        const endpoint = exportValue;
+        if (!endpoint?.__path) {
+          continue;
+        }
+        const method = String(endpoint.__method || "GET").toUpperCase();
+        this.addEndpoint(endpoint.__path, routesFile, method, endpoint);
+      }
+    } catch (error) {
+      this.handleLoadError(`Error loading root API routes ${routesFile}`, error);
+    }
+  }
+  async loadProgrammaticApiRoutes(appDir) {
+    const candidateRoots = [path2.dirname(appDir), appDir];
+    const routeFiles = Array.from(
+      new Set(candidateRoots.flatMap((srcRoot) => findProgrammaticRouteFilesInDir(srcRoot)))
+    );
+    for (const routeFile of routeFiles) {
+      try {
+        const routesModule = await this.loadModule(routeFile);
+        const manifest = getProgrammaticRouteManifest(routesModule);
+        if (!manifest) continue;
+        for (const definition of manifest.routes) {
+          if (definition.kind !== "api") continue;
+          this.addProgrammaticApiRoute(routeFile, definition);
+        }
+      } catch (error) {
+        this.handleLoadError(`Error loading programmatic API routes ${routeFile}`, error);
+      }
+    }
+  }
+  handleLoadError(message, error) {
+    logger.error(`${message}: ${error}`);
+    if (this.throwOnLoadError) {
+      throw error;
+    }
+  }
+  findRootRoutesFile(appDir) {
+    const routeNames = ["routes.ts", "routes.tsx", "routes.js"];
+    const candidateDirs = [path2.dirname(appDir), appDir];
+    const seen = /* @__PURE__ */ new Set();
+    for (const dir of candidateDirs) {
+      for (const routeName of routeNames) {
+        const routesFile = path2.join(dir, routeName);
+        if (seen.has(routesFile)) {
+          continue;
+        }
+        seen.add(routesFile);
+        if (fs.existsSync(routesFile)) {
+          return routesFile;
+        }
+      }
+    }
+    return null;
+  }
+  async loadModule(filePath) {
+    if (this.viteServer) {
+      return await this.viteServer.ssrLoadModule(filePath);
+    }
+    const fileUrl = `file://${filePath}`;
+    return await import(
+      /* @vite-ignore */
+      fileUrl
+    );
+  }
+  addEndpoint(routePath, filePath, method, endpoint, runtimeConfig = {}) {
+    const normalizedMethod = method.toUpperCase();
+    const existingRoute = this.routes.get(routePath);
+    if (existingRoute) {
+      if (!existingRoute.methods.includes(normalizedMethod)) {
+        existingRoute.methods.push(normalizedMethod);
+      }
+      existingRoute.endpoints[normalizedMethod] = endpoint;
+      Object.assign(existingRoute, runtimeConfig);
+      return;
+    }
+    this.routes.set(routePath, {
+      path: routePath,
+      filePath,
+      methods: [normalizedMethod],
+      endpoints: { [normalizedMethod]: endpoint },
+      ...runtimeConfig
+    });
+  }
+  addProgrammaticApiRoute(filePath, route) {
+    const modulePath = createProgrammaticRouteModuleId(filePath, "api", route.path);
+    const runtimeConfig = normalizeFarmRouteRuntimeConfig(route, `API route "${route.path}"`);
+    for (const [method, endpoint] of Object.entries(route.methods)) {
+      if (endpoint) {
+        this.addEndpoint(route.path, modulePath, method, endpoint, runtimeConfig);
+      }
+    }
+  }
+  /**
+   * Get the handler that directly invokes endpoint handlers
+   */
+  getHandler() {
+    if (this.routes.size === 0) {
+      return null;
+    }
+    return async (request) => {
+      const url = new URL(request.url);
+      const pathname = url.pathname;
+      const method = request.method.toUpperCase();
+      const match = matchAPIRoute(this.routes, pathname);
+      if (!match) {
+        return new Response(JSON.stringify({ error: "Not Found" }), {
+          status: 404,
+          headers: { "Content-Type": "application/json" }
+        });
+      }
+      const { route, params } = match;
+      const endpoint = route.endpoints[method];
+      if (!endpoint) {
+        return new Response(JSON.stringify({ error: "Method Not Allowed" }), {
+          status: 405,
+          headers: { "Content-Type": "application/json" }
+        });
+      }
+      const invoke = /* @__PURE__ */ __name(async () => {
+        try {
+          return await invokeAPIRouteEndpoint(endpoint, request, params);
+        } catch (error) {
+          console.error(`[API Error] ${pathname}:`, error);
+          return new Response(JSON.stringify({ error: "Internal Server Error" }), {
+            status: 500,
+            headers: { "Content-Type": "application/json" }
+          });
+        }
+      }, "invoke");
+      return this.i18n?.config.enabled ? _runWithFarmI18nRequest(this.i18n, request, invoke, {
+        redirect: false
+      }) : invoke();
+    };
+  }
+  /**
+   * Check if a path is an API route
+   */
+  isAPIRoute(pathname) {
+    return Boolean(this.matchRoute(pathname));
+  }
+  matchRoute(pathname) {
+    return matchAPIRoute(this.routes, pathname);
+  }
+  /**
+   * Get all routes for client type generation
+   */
+  getRoutes() {
+    return this.routes;
+  }
+};
+__name(_APIRouteManager, "APIRouteManager");
+var APIRouteManager = _APIRouteManager;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  APIRouteManager,
+  API_ROUTE_METHODS,
+  invokeAPIRouteEndpoint,
+  isWebResponse,
+  matchAPIRoute,
+  normalizeRouteResponse
+});
+//# sourceMappingURL=route-manager.cjs.map