@farm.js/core 0.1.0-beta.0

package/dist/routes.cjs

@@ -0,0 +1,1213 @@
+"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/routes.ts
+var routes_exports = {};
+__export(routes_exports, {
+  PROGRAMMATIC_ROUTE_FILE_NAMES: () => PROGRAMMATIC_ROUTE_FILE_NAMES,
+  api: () => api,
+  createLayoutModuleFromProgrammaticLayout: () => createLayoutModuleFromProgrammaticLayout,
+  createProgrammaticRouteModuleId: () => createProgrammaticRouteModuleId,
+  createRoute: () => createRoute,
+  createRouteModuleFromProgrammaticPage: () => createRouteModuleFromProgrammaticPage,
+  defineRoutes: () => defineRoutes,
+  getProgrammaticRouteManifest: () => getProgrammaticRouteManifest,
+  getProgrammaticRouteSearchClientOptions: () => getProgrammaticRouteSearchClientOptions,
+  getProgrammaticRouteSearchSchema: () => getProgrammaticRouteSearchSchema,
+  isProgrammaticRouteDefinition: () => isProgrammaticRouteDefinition,
+  isProgrammaticRouteManifest: () => isProgrammaticRouteManifest,
+  isProgrammaticRoutesFileName: () => isProgrammaticRoutesFileName,
+  layout: () => layout,
+  page: () => page,
+  parseProgrammaticRouteModuleId: () => parseProgrammaticRouteModuleId,
+  parseProgrammaticRoutePath: () => parseProgrammaticRoutePath,
+  redirect: () => redirect,
+  routesBuilder: () => routesBuilder,
+  scanProgrammaticPagePaths: () => scanProgrammaticPagePaths
+});
+module.exports = __toCommonJS(routes_exports);
+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/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/route-context.ts
+var FARM_ROUTE_CONTEXT_SYMBOL = /* @__PURE__ */ Symbol.for("farm.routeContext");
+function getFarmRouteContext(props) {
+  if (!props || typeof props !== "object") {
+    return void 0;
+  }
+  return props[FARM_ROUTE_CONTEXT_SYMBOL];
+}
+__name(getFarmRouteContext, "getFarmRouteContext");
+
+// 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");
+
+// 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(path, options) {
+    return normalizeProgrammaticRoute({
+      kind: "page",
+      path,
+      ...options
+    });
+  },
+  layout(path, options) {
+    return normalizeProgrammaticRoute({
+      kind: "layout",
+      path,
+      ...options
+    });
+  },
+  api(path, options) {
+    const { render, runtime, regions, maxDuration, ...methods } = options;
+    return normalizeProgrammaticRoute({
+      kind: "api",
+      path,
+      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 getProgrammaticRouteSearchSchema(search) {
+  if (!search) return void 0;
+  if (isProgrammaticRouteSchema(search)) return search;
+  return search.schema;
+}
+__name(getProgrammaticRouteSearchSchema, "getProgrammaticRouteSearchSchema");
+function getProgrammaticRouteSearchClientOptions(search) {
+  if (!search || isProgrammaticRouteSchema(search)) return void 0;
+  const options = {};
+  if (typeof search.stripDefaults !== "undefined") options.stripDefaults = search.stripDefaults;
+  if (search.preserve?.length) options.preserve = [...search.preserve];
+  if (search.temporary?.length) options.temporary = [...search.temporary];
+  return Object.keys(options).length > 0 ? options : void 0;
+}
+__name(getProgrammaticRouteSearchClientOptions, "getProgrammaticRouteSearchClientOptions");
+function resolveProgrammaticRouteSearch(searchConfig, rawSearch, path, routePath) {
+  const schema = getProgrammaticRouteSearchSchema(searchConfig);
+  const search = parseProgrammaticSchema(schema, rawSearch, "search", routePath);
+  const options = getProgrammaticRouteSearchOptions(searchConfig);
+  const canonicalPath = resolveProgrammaticRouteCanonicalPath({
+    options,
+    schema,
+    rawSearch,
+    parsedSearch: search,
+    path
+  });
+  return { search, canonicalPath };
+}
+__name(resolveProgrammaticRouteSearch, "resolveProgrammaticRouteSearch");
+function getProgrammaticRouteSearchOptions(search) {
+  if (!search || isProgrammaticRouteSchema(search)) return void 0;
+  return search;
+}
+__name(getProgrammaticRouteSearchOptions, "getProgrammaticRouteSearchOptions");
+function isProgrammaticRouteSchema(value) {
+  return !!value && typeof value === "object" && typeof value.parse === "function";
+}
+__name(isProgrammaticRouteSchema, "isProgrammaticRouteSchema");
+function resolveProgrammaticRouteCanonicalPath(input) {
+  const options = input.options;
+  if (!options?.temporary?.length && !options?.stripDefaults) {
+    return void 0;
+  }
+  const params = createSearchParams(input.rawSearch);
+  const original = params.toString();
+  for (const key of options.temporary || []) {
+    params.delete(key);
+  }
+  if (options.stripDefaults) {
+    const defaultSearch = parseDefaultSearch(input.schema);
+    if (defaultSearch !== void 0) {
+      const keys = options.stripDefaults === true ? Array.from(new Set(Array.from(params.keys()))) : [...options.stripDefaults];
+      for (const key of keys) {
+        if (params.has(key) && searchValuesEqual(
+          readSearchValue(input.parsedSearch, key),
+          readSearchValue(defaultSearch, key)
+        )) {
+          params.delete(key);
+        }
+      }
+    }
+  }
+  const next = params.toString();
+  if (next === original) {
+    return void 0;
+  }
+  return next ? `${input.path}?${next}` : input.path;
+}
+__name(resolveProgrammaticRouteCanonicalPath, "resolveProgrammaticRouteCanonicalPath");
+function createSearchParams(value) {
+  const params = new URLSearchParams();
+  for (const [key, item] of Object.entries(value)) {
+    if (item == null) continue;
+    const values = Array.isArray(item) ? item : [item];
+    for (const entry of values) {
+      if (entry != null) params.append(key, String(entry));
+    }
+  }
+  return params;
+}
+__name(createSearchParams, "createSearchParams");
+function parseDefaultSearch(schema) {
+  if (!schema) return void 0;
+  try {
+    const value = schema.parse({});
+    return value && typeof value === "object" ? value : void 0;
+  } catch {
+    return void 0;
+  }
+}
+__name(parseDefaultSearch, "parseDefaultSearch");
+function readSearchValue(value, key) {
+  return value && typeof value === "object" ? value[key] : void 0;
+}
+__name(readSearchValue, "readSearchValue");
+function searchValuesEqual(left, right) {
+  return JSON.stringify(normalizeComparableValue(left)) === JSON.stringify(normalizeComparableValue(right));
+}
+__name(searchValuesEqual, "searchValuesEqual");
+function normalizeComparableValue(value) {
+  if (Array.isArray(value)) {
+    return value.map(normalizeComparableValue);
+  }
+  if (value && typeof value === "object") {
+    return Object.keys(value).sort().reduce((output, key) => {
+      output[key] = normalizeComparableValue(value[key]);
+      return output;
+    }, {});
+  }
+  return value;
+}
+__name(normalizeComparableValue, "normalizeComparableValue");
+function createRoute(path, options) {
+  return routesBuilder.page(path, options);
+}
+__name(createRoute, "createRoute");
+function isProgrammaticRoutesFileName(fileName) {
+  const normalized = fileName.replace(/\\/g, "/");
+  const baseName = normalized.split("/").pop() || normalized;
+  return PROGRAMMATIC_ROUTE_FILE_NAMES.includes(baseName);
+}
+__name(isProgrammaticRoutesFileName, "isProgrammaticRoutesFileName");
+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 parseProgrammaticRouteModuleId(moduleId) {
+  const queryIndex = moduleId.indexOf("?");
+  if (queryIndex === -1) {
+    return null;
+  }
+  const filePath = moduleId.slice(0, queryIndex);
+  const params = new URLSearchParams(moduleId.slice(queryIndex + 1));
+  const value = params.get("farm-route");
+  if (!value) {
+    return null;
+  }
+  const separator = value.indexOf(":");
+  if (separator === -1) {
+    return null;
+  }
+  const kind = value.slice(0, separator);
+  if (kind !== "page" && kind !== "layout" && kind !== "api") {
+    return null;
+  }
+  return {
+    filePath,
+    kind,
+    routePath: normalizeRoutePath(value.slice(separator + 1))
+  };
+}
+__name(parseProgrammaticRouteModuleId, "parseProgrammaticRouteModuleId");
+function parseProgrammaticRoutePath(routePath, type = "page") {
+  const fileName = type === "layout" ? "layout.tsx" : "page.tsx";
+  const normalized = normalizeRoutePath(routePath);
+  const filePath = normalized === "/" ? fileName : `${normalized.slice(1).replace(/\/+$/, "")}/${fileName}`;
+  return {
+    filePath,
+    type,
+    segments: normalized === "/" ? [] : normalized.slice(1).split("/").map(parseRouteSegment)
+  };
+}
+__name(parseProgrammaticRoutePath, "parseProgrammaticRoutePath");
+function createRouteModuleFromProgrammaticPage(route) {
+  const mod = {
+    default: createProgrammaticPageComponent(route),
+    ...normalizeFarmRouteRuntimeConfig(route, `Route "${route.path}"`)
+  };
+  if (route.params || route.search || route.guard || route.data) {
+    mod.__farmRouteSchemas = {
+      params: route.params,
+      search: getProgrammaticRouteSearchSchema(route.search)
+    };
+    mod.__farmRouteSearch = getProgrammaticRouteSearchClientOptions(route.search);
+    mod.__farmRouteGuard = route.guard;
+    mod.__farmRouteData = route.data;
+    mod.__farmRouteParsesProps = true;
+    mod.__farmResolveRouteProps = (props) => resolveProgrammaticRouteProps(route, props);
+    mod.__farmResolveRouteCanonicalPath = (rawSearch, path) => resolveProgrammaticRouteSearch(route.search, rawSearch, path, route.path).canonicalPath;
+  }
+  if (route.pending || route.error || route.notFound) {
+    mod.__farmRouteComponents = {
+      pending: route.pending,
+      error: route.error,
+      notFound: route.notFound
+    };
+  }
+  if (route.render === "static" || route.staticPaths) {
+    mod.ssg = true;
+    mod.dynamic = "force-static";
+  } else if (route.render === "dynamic") {
+    mod.ssg = false;
+    mod.dynamic = "force-dynamic";
+  }
+  if (typeof route.revalidate !== "undefined") {
+    mod.revalidate = route.revalidate;
+  }
+  if (route.ppr) {
+    mod.ppr = true;
+  }
+  if (route.metadata) {
+    mod.metadata = route.metadata;
+  }
+  if (route.generateMetadata) {
+    mod.generateMetadata = route.generateMetadata;
+  }
+  if (route.staticPaths) {
+    mod.getStaticPaths = async () => normalizeStaticPaths(route.path, await route.staticPaths());
+  }
+  return mod;
+}
+__name(createRouteModuleFromProgrammaticPage, "createRouteModuleFromProgrammaticPage");
+function createLayoutModuleFromProgrammaticLayout(route) {
+  return {
+    default: route.component,
+    ...normalizeFarmRouteRuntimeConfig(route, `Layout "${route.path}"`),
+    metadata: route.metadata,
+    generateMetadata: route.generateMetadata
+  };
+}
+__name(createLayoutModuleFromProgrammaticLayout, "createLayoutModuleFromProgrammaticLayout");
+function scanProgrammaticPagePaths(source) {
+  const paths = /* @__PURE__ */ new Set();
+  const callRe = /\b(?:page|createRoute)\s*\(\s*(["'`])([^"'`]+)\1/g;
+  for (const match of source.matchAll(callRe)) {
+    if (match[2]) {
+      paths.add(normalizeRoutePath(match[2]));
+    }
+  }
+  return Array.from(paths);
+}
+__name(scanProgrammaticPagePaths, "scanProgrammaticPagePaths");
+function createProgrammaticPageComponent(route) {
+  if (!route.params && !route.search && !route.guard && !route.data && !route.pending && !route.error && !route.notFound) {
+    return route.component;
+  }
+  const Component = route.component;
+  if (route.pending) {
+    const PendingComponent = route.pending;
+    const routePropsResources = /* @__PURE__ */ new WeakMap();
+    const FarmProgrammaticPageContent2 = /* @__PURE__ */ __name(function FarmProgrammaticPageContent3(props) {
+      try {
+        const resolvedProps = readProgrammaticRouteProps(route, props, routePropsResources);
+        return (0, import_react.createElement)(Component, stripProgrammaticRoutePropsMarker(resolvedProps));
+      } catch (error) {
+        if (isPromiseLike(error) || isProgrammaticRedirectSignal(error)) {
+          throw error;
+        }
+        if (isProgrammaticNotFoundSignal(error) && route.notFound) {
+          return (0, import_react.createElement)(route.notFound, createProgrammaticRouteErrorProps(error, props));
+        }
+        if (route.error) {
+          return (0, import_react.createElement)(route.error, createProgrammaticRouteErrorProps(error, props));
+        }
+        throw error;
+      }
+    }, "FarmProgrammaticPageContent");
+    const PageContent = FarmProgrammaticPageContent2;
+    const FarmProgrammaticPage = /* @__PURE__ */ __name(function FarmProgrammaticPage2(props) {
+      return (0, import_react.createElement)(
+        import_react.Suspense,
+        {
+          fallback: (0, import_react.createElement)(PendingComponent, createProgrammaticRoutePendingProps(props))
+        },
+        (0, import_react.createElement)(PageContent, props)
+      );
+    }, "FarmProgrammaticPage");
+    return FarmProgrammaticPage;
+  }
+  const FarmProgrammaticPageContent = /* @__PURE__ */ __name(async function FarmProgrammaticPageContent2(props) {
+    try {
+      const resolvedProps = isProgrammaticRoutePropsResolved(props) ? props : await resolveProgrammaticRouteProps(route, props);
+      return (0, import_react.createElement)(Component, stripProgrammaticRoutePropsMarker(resolvedProps));
+    } catch (error) {
+      if (isProgrammaticRedirectSignal(error)) {
+        throw error;
+      }
+      if (isProgrammaticNotFoundSignal(error) && route.notFound) {
+        return (0, import_react.createElement)(route.notFound, createProgrammaticRouteErrorProps(error, props));
+      }
+      if (route.error) {
+        return (0, import_react.createElement)(route.error, createProgrammaticRouteErrorProps(error, props));
+      }
+      throw error;
+    }
+  }, "FarmProgrammaticPageContent");
+  return FarmProgrammaticPageContent;
+}
+__name(createProgrammaticPageComponent, "createProgrammaticPageComponent");
+function readProgrammaticRouteProps(route, props, resources) {
+  if (isProgrammaticRoutePropsResolved(props)) {
+    return props;
+  }
+  let resource = resources.get(props);
+  if (!resource) {
+    const deferredRouteProps = props.__farmRoutePropsPromise;
+    const promise = Promise.resolve(
+      isPromiseLike(deferredRouteProps) ? deferredRouteProps : resolveProgrammaticRouteProps(route, props)
+    );
+    resource = { status: "pending", promise };
+    resources.set(props, resource);
+    promise.then(
+      (value) => resources.set(props, { status: "resolved", value }),
+      (error) => resources.set(props, { status: "rejected", error })
+    );
+  }
+  if (resource.status === "pending") throw resource.promise;
+  if (resource.status === "rejected") throw resource.error;
+  return resource.value;
+}
+__name(readProgrammaticRouteProps, "readProgrammaticRouteProps");
+function isPromiseLike(value) {
+  return Boolean(
+    value && (typeof value === "object" || typeof value === "function") && typeof value.then === "function"
+  );
+}
+__name(isPromiseLike, "isPromiseLike");
+function createProgrammaticRoutePendingProps(props) {
+  return {
+    params: props.params,
+    searchParams: props.searchParams,
+    path: props.path
+  };
+}
+__name(createProgrammaticRoutePendingProps, "createProgrammaticRoutePendingProps");
+function createProgrammaticRouteErrorProps(error, props) {
+  return {
+    error,
+    params: props.params,
+    searchParams: props.searchParams,
+    path: props.path
+  };
+}
+__name(createProgrammaticRouteErrorProps, "createProgrammaticRouteErrorProps");
+function isProgrammaticRedirectSignal(error) {
+  if (!error || typeof error !== "object") return false;
+  const digest = error.digest;
+  return typeof digest === "string" && digest.startsWith("FARM_REDIRECT;");
+}
+__name(isProgrammaticRedirectSignal, "isProgrammaticRedirectSignal");
+function isProgrammaticNotFoundSignal(error) {
+  if (!error || typeof error !== "object") return false;
+  const digest = error.digest;
+  return digest === "FARM_NOT_FOUND";
+}
+__name(isProgrammaticNotFoundSignal, "isProgrammaticNotFoundSignal");
+async function resolveProgrammaticRouteProps(route, props) {
+  const rawSearch = await props.searchParams;
+  const params = parseProgrammaticSchema(route.params, props.params, "params", route.path);
+  const { search, canonicalPath } = resolveProgrammaticRouteSearch(
+    route.search,
+    rawSearch,
+    props.path,
+    route.path
+  );
+  const routeContextValue = getFarmRouteContext(props);
+  const pluginContext = props.context;
+  const baseProps = {
+    ...props,
+    params,
+    search,
+    searchParams: Promise.resolve(search)
+  };
+  const routeContextProps = {
+    ...baseProps,
+    context: routeContextValue,
+    pluginContext
+  };
+  if (route.guard) {
+    await route.guard(routeContextProps);
+  }
+  if (!route.data) {
+    return markProgrammaticRoutePropsResolved(addCanonicalPath(baseProps, canonicalPath));
+  }
+  const before = route.data.before ? await route.data.before(routeContextProps) : void 0;
+  const dataContext = {
+    ...routeContextProps,
+    before
+  };
+  const data = await resolveProgrammaticRouteData(route, route.data, dataContext);
+  if (route.data.after) {
+    await route.data.after({
+      ...routeContextProps,
+      before,
+      data
+    });
+  }
+  return markProgrammaticRoutePropsResolved({
+    ...baseProps,
+    data,
+    ...canonicalPath ? { __farmCanonicalPath: canonicalPath } : {}
+  });
+}
+__name(resolveProgrammaticRouteProps, "resolveProgrammaticRouteProps");
+async function resolveProgrammaticRouteData(route, dataHooks, context) {
+  if (!dataHooks?.key) {
+    return dataHooks.main(context);
+  }
+  const routeDataKey = await dataHooks.key(context);
+  if (routeDataKey == null) {
+    return dataHooks.main(context);
+  }
+  const cacheKey = createFarmCacheKey(["route-data", routeDataKey]);
+  const cacheOptions = {
+    tags: [
+      createRouteDataCacheTag(routeDataKey),
+      ...await resolveProgrammaticRouteDataKeys(dataHooks.tags, context)
+    ],
+    paths: [
+      ...typeof context.path === "string" ? [context.path] : [],
+      ...await resolveProgrammaticRouteDataKeys(dataHooks.paths, context)
+    ],
+    revalidate: normalizeProgrammaticRouteStaleTime(dataHooks.staleTime)
+  };
+  return getFarmDataCache().getOrSet(cacheKey, () => dataHooks.main(context), cacheOptions);
+}
+__name(resolveProgrammaticRouteData, "resolveProgrammaticRouteData");
+async function resolveProgrammaticRouteDataKeys(input, context) {
+  if (!input) return [];
+  const value = typeof input === "function" ? await input(context) : input;
+  return value.filter((item) => typeof item === "string" && item.trim().length > 0);
+}
+__name(resolveProgrammaticRouteDataKeys, "resolveProgrammaticRouteDataKeys");
+function normalizeProgrammaticRouteStaleTime(staleTime) {
+  if (staleTime === void 0) return void 0;
+  if (staleTime === false) return false;
+  if (typeof staleTime === "number") {
+    if (!Number.isFinite(staleTime) || staleTime <= 0) return void 0;
+    return Math.max(1, Math.ceil(staleTime / 1e3));
+  }
+  const match = staleTime.match(/^(\d+(?:\.\d+)?)(ms|s|m|h)$/);
+  if (!match) return void 0;
+  const value = Number(match[1]);
+  if (!Number.isFinite(value) || value <= 0) return void 0;
+  const unit = match[2];
+  const milliseconds = unit === "ms" ? value : unit === "s" ? value * 1e3 : unit === "m" ? value * 6e4 : value * 36e5;
+  return Math.max(1, Math.ceil(milliseconds / 1e3));
+}
+__name(normalizeProgrammaticRouteStaleTime, "normalizeProgrammaticRouteStaleTime");
+function isProgrammaticRoutePropsResolved(value) {
+  return !!value && typeof value === "object" && value.__farmRoutePropsResolved === true;
+}
+__name(isProgrammaticRoutePropsResolved, "isProgrammaticRoutePropsResolved");
+function markProgrammaticRoutePropsResolved(props) {
+  return {
+    ...props,
+    __farmRoutePropsResolved: true
+  };
+}
+__name(markProgrammaticRoutePropsResolved, "markProgrammaticRoutePropsResolved");
+function addCanonicalPath(props, canonicalPath) {
+  return canonicalPath ? { ...props, __farmCanonicalPath: canonicalPath } : props;
+}
+__name(addCanonicalPath, "addCanonicalPath");
+function stripProgrammaticRoutePropsMarker(props) {
+  if (!isProgrammaticRoutePropsResolved(props)) {
+    return props;
+  }
+  const {
+    __farmRoutePropsResolved,
+    __farmCanonicalPath,
+    __farmRoutePropsPromise,
+    ...componentProps
+  } = props;
+  return componentProps;
+}
+__name(stripProgrammaticRoutePropsMarker, "stripProgrammaticRoutePropsMarker");
+function parseProgrammaticSchema(schema, value, label, routePath) {
+  if (!schema) {
+    return value;
+  }
+  try {
+    return schema.parse(value);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Invalid ${label} for route "${routePath}": ${message}`);
+  }
+}
+__name(parseProgrammaticSchema, "parseProgrammaticSchema");
+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 parseRouteSegment(segment) {
+  if (segment.startsWith("[") && segment.endsWith("]")) {
+    let name = segment.slice(1, -1);
+    let isOptional = false;
+    let isCatchAll = false;
+    if (name.startsWith("[") && name.endsWith("]")) {
+      isOptional = true;
+      name = name.slice(1, -1);
+    }
+    if (name.startsWith("...")) {
+      isCatchAll = true;
+      name = name.slice(3);
+    }
+    return {
+      segment: name,
+      isDynamic: true,
+      isOptional,
+      isCatchAll
+    };
+  }
+  return {
+    segment,
+    isDynamic: false,
+    isOptional: false,
+    isCatchAll: false
+  };
+}
+__name(parseRouteSegment, "parseRouteSegment");
+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");
+function normalizeStaticPaths(routePath, paths) {
+  const dynamicSegments = parseProgrammaticRoutePath(routePath).segments.filter(
+    (segment) => segment.isDynamic
+  );
+  return paths.map((entry) => {
+    if (typeof entry === "string" || Array.isArray(entry)) {
+      if (dynamicSegments.length !== 1) {
+        throw new Error(
+          `staticPaths for "${routePath}" must return objects when the route has ${dynamicSegments.length} dynamic params.`
+        );
+      }
+      const value = Array.isArray(entry) ? entry.join("/") : entry;
+      return { [dynamicSegments[0].segment]: String(value) };
+    }
+    return Object.fromEntries(
+      Object.entries(entry).map(([key, value]) => [
+        key,
+        Array.isArray(value) ? value.map(String).join("/") : String(value)
+      ])
+    );
+  });
+}
+__name(normalizeStaticPaths, "normalizeStaticPaths");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PROGRAMMATIC_ROUTE_FILE_NAMES,
+  api,
+  createLayoutModuleFromProgrammaticLayout,
+  createProgrammaticRouteModuleId,
+  createRoute,
+  createRouteModuleFromProgrammaticPage,
+  defineRoutes,
+  getProgrammaticRouteManifest,
+  getProgrammaticRouteSearchClientOptions,
+  getProgrammaticRouteSearchSchema,
+  isProgrammaticRouteDefinition,
+  isProgrammaticRouteManifest,
+  isProgrammaticRoutesFileName,
+  layout,
+  page,
+  parseProgrammaticRouteModuleId,
+  parseProgrammaticRoutePath,
+  redirect,
+  routesBuilder,
+  scanProgrammaticPagePaths
+});
+//# sourceMappingURL=routes.cjs.map