@farm.js/core 0.1.17 → 0.1.19

package/dist/routes.cjs

@@ -1,2472 +1,53 @@
-"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);
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
 
-// 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: () => parseProgrammaticRoutePath2,
-  redirect: () => redirect,
-  routesBuilder: () => routesBuilder,
-  scanProgrammaticPagePaths: () => scanProgrammaticPagePaths
-});
-module.exports = __toCommonJS(routes_exports);
 
-// src/tracing.ts
-var import_api = require("@opentelemetry/api");
-var FARM_TRACER_NAME = "@farm.js/core";
-var ALL_SPAN_KINDS = [
-  "request",
-  "render",
-  "middleware",
-  "api",
-  "integration",
-  "storage",
-  "ppr",
-  "build",
-  "plugin"
-];
-var DEFAULT_IGNORED_PATHS = [
-  "/@vite/",
-  "/@fs/",
-  "/@id/",
-  "/@react-refresh",
-  "/node_modules/",
-  "/__vite",
-  "/.well-known/appspecific/"
-];
-var FARM_REQUEST_METHOD_CONTEXT_KEY = (0, import_api.createContextKey)("@farm.js/core/request-method");
-var TRACING_RUNTIME = /* @__PURE__ */ Symbol.for("@farm.js/core/tracing-runtime/v1");
-var runtime = globalThis;
-var tracingState = runtime[TRACING_RUNTIME] ?? (runtime[TRACING_RUNTIME] = normalizeFarmTracingConfig(false));
-function normalizeFarmTracingConfig(config) {
-  if (!config) {
-    return {
-      enabled: false,
-      spans: new Set(ALL_SPAN_KINDS),
-      recordEvents: true,
-      attributes: {},
-      ignorePaths: DEFAULT_IGNORED_PATHS
-    };
-  }
-  if (config === true) {
-    return {
-      enabled: true,
-      spans: new Set(ALL_SPAN_KINDS),
-      recordEvents: true,
-      attributes: {},
-      ignorePaths: DEFAULT_IGNORED_PATHS
-    };
-  }
-  return {
-    enabled: config.enabled ?? true,
-    spans: new Set(config.spans ?? ALL_SPAN_KINDS),
-    recordEvents: config.recordEvents ?? true,
-    attributes: { ...config.attributes },
-    ignorePaths: [...DEFAULT_IGNORED_PATHS, ...config.ignorePaths ?? []]
-  };
-}
-__name(normalizeFarmTracingConfig, "normalizeFarmTracingConfig");
-function recordFarmEventTrace(event) {
-  if (!tracingState.enabled) return void 0;
-  const activeContext = import_api.context.active();
-  const activeSpan = import_api.trace.getSpan(activeContext);
-  const traceContext = getSpanTraceContext(activeSpan);
-  if (activeSpan && traceContext) {
-    if (event.type === "route.matched") {
-      const method = activeContext.getValue(FARM_REQUEST_METHOD_CONTEXT_KEY) ?? "HTTP";
-      activeSpan.updateName(`${method} ${event.route}`);
-      activeSpan.setAttribute("http.route", event.route);
-      activeSpan.setAttribute("farm.route", event.route);
-    }
-    if (tracingState.recordEvents) {
-      activeSpan.addEvent(event.type, toEventAttributes(event), event.timestamp);
-    }
-    const error = event.type === "request.error" ? void 0 : getEventError(event);
-    if (error !== void 0) {
-      if (event.type === "render.error") {
-        recordSpanException(activeSpan, error);
-      } else {
-        recordSpanError(activeSpan, error);
-      }
-    }
-  }
-  const completedTraceContext = recordCompletedEventSpan(event, activeContext);
-  return traceContext ?? completedTraceContext;
-}
-__name(recordFarmEventTrace, "recordFarmEventTrace");
-function recordCompletedEventSpan(event, parentContext) {
-  const descriptor = getCompletedSpanDescriptor(event);
-  if (!descriptor || !tracingState.spans.has(descriptor.kind)) return void 0;
-  const tracer = import_api.trace.getTracer(FARM_TRACER_NAME);
-  const span = tracer.startSpan(
-    descriptor.name,
-    {
-      kind: import_api.SpanKind.INTERNAL,
-      startTime: event.timestamp - descriptor.durationMs,
-      attributes: {
-        ...tracingState.attributes,
-        ...toEventAttributes(event),
-        "farm.event.type": event.type
-      }
-    },
-    parentContext
-  );
-  const status = "status" in event && typeof event.status === "number" ? event.status : void 0;
-  if (status !== void 0) setResponseStatus(span, status);
-  const error = getEventError(event);
-  if (error !== void 0) recordSpanError(span, error);
-  const traceContext = getSpanTraceContext(span);
-  span.end(event.timestamp);
-  return traceContext;
-}
-__name(recordCompletedEventSpan, "recordCompletedEventSpan");
-function getCompletedSpanDescriptor(event) {
-  if (!("durationMs" in event) || typeof event.durationMs !== "number") return void 0;
-  switch (event.type) {
-    case "render.complete":
-      return { kind: "render", name: `farm.render ${event.route}`, durationMs: event.durationMs };
-    case "render.stream.shellReady":
-      return {
-        kind: "render",
-        name: `farm.render.shell ${event.route}`,
-        durationMs: event.durationMs
-      };
-    case "render.stream.complete":
-      return {
-        kind: "render",
-        name: `farm.render.stream ${event.route}`,
-        durationMs: event.durationMs
-      };
-    case "middleware.complete":
-      return {
-        kind: "middleware",
-        name: `farm.middleware ${event.name ?? event.route ?? "anonymous"}`,
-        durationMs: event.durationMs
-      };
-    case "api.request.complete":
-    case "api.error":
-      return {
-        kind: "api",
-        name: `farm.api ${event.method} ${event.route}`,
-        durationMs: event.durationMs
-      };
-    case "integration.api.call.complete":
-      return {
-        kind: "integration",
-        name: `farm.integration ${event.integration}.${event.operation}`,
-        durationMs: event.durationMs
-      };
-    case "storage.query.complete":
-      return {
-        kind: "storage",
-        name: `farm.storage ${event.operation}`,
-        durationMs: event.durationMs
-      };
-    case "ppr.refresh.complete":
-      return {
-        kind: "ppr",
-        name: `farm.ppr.refresh ${event.route}`,
-        durationMs: event.durationMs
-      };
-    case "build.complete":
-      return {
-        kind: "build",
-        name: `farm.build${event.target ? ` ${event.target}` : ""}`,
-        durationMs: event.durationMs
-      };
-    case "plugin.hook.complete":
-      return {
-        kind: "plugin",
-        name: `farm.plugin ${event.plugin}.${event.hook}`,
-        durationMs: event.durationMs
-      };
-    default:
-      return void 0;
-  }
-}
-__name(getCompletedSpanDescriptor, "getCompletedSpanDescriptor");
-function hashFarmCacheKey(value) {
-  let hash = 2166136261;
-  for (let index = 0; index < value.length; index++) {
-    hash ^= value.charCodeAt(index);
-    hash = Math.imul(hash, 16777619);
-  }
-  return (hash >>> 0).toString(16).padStart(8, "0");
-}
-__name(hashFarmCacheKey, "hashFarmCacheKey");
-function toEventAttributes(event) {
-  const attributes = {};
-  const redactKey = typeof event.type === "string" && event.type.startsWith("cache.");
-  for (const [key, value] of Object.entries(event)) {
-    if (key === "timestamp" || key === "level" || key === "error" || key === "traceId" || key === "spanId" || key === "traceSampled" || value === void 0) {
-      continue;
-    }
-    if (redactKey && key === "key" && typeof value === "string") {
-      attributes["farm.key_hash"] = hashFarmCacheKey(value);
-      continue;
-    }
-    if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
-      attributes[`farm.${key}`] = value;
-    } else if (Array.isArray(value)) {
-      if (value.every((entry) => typeof entry === "string")) {
-        attributes[`farm.${key}`] = value;
-      } else if (value.every((entry) => typeof entry === "number")) {
-        attributes[`farm.${key}`] = value;
-      } else if (value.every((entry) => typeof entry === "boolean")) {
-        attributes[`farm.${key}`] = value;
-      }
-    }
-  }
-  return attributes;
-}
-__name(toEventAttributes, "toEventAttributes");
-function getEventError(event) {
-  return "error" in event ? event.error : void 0;
-}
-__name(getEventError, "getEventError");
-function recordSpanException(span, error) {
-  const normalized = error instanceof Error ? error : new Error(String(error));
-  span.recordException(normalized);
-  return normalized;
-}
-__name(recordSpanException, "recordSpanException");
-function recordSpanError(span, error) {
-  const normalized = recordSpanException(span, error);
-  span.setStatus({ code: import_api.SpanStatusCode.ERROR, message: normalized.message });
-}
-__name(recordSpanError, "recordSpanError");
-function setResponseStatus(span, status) {
-  span.setAttribute("http.response.status_code", status);
-  if (status >= 500) {
-    span.setStatus({ code: import_api.SpanStatusCode.ERROR });
-  }
-}
-__name(setResponseStatus, "setResponseStatus");
-function getSpanTraceContext(span) {
-  if (!span) return void 0;
-  const spanContext = span.spanContext();
-  if (!(0, import_api.isSpanContextValid)(spanContext)) return void 0;
-  return {
-    traceId: spanContext.traceId,
-    spanId: spanContext.spanId,
-    traceSampled: (spanContext.traceFlags & 1) === 1
-  };
-}
-__name(getSpanTraceContext, "getSpanTraceContext");
 
-// src/observability.ts
-var OBSERVABILITY_RUNTIME = /* @__PURE__ */ Symbol.for("@farm.js/core/observability-runtime/v1");
-var runtime2 = globalThis;
-var shared = runtime2[OBSERVABILITY_RUNTIME] ?? (runtime2[OBSERVABILITY_RUNTIME] = {
-  handlers: /* @__PURE__ */ new Set(),
-  unfilteredHandlers: /* @__PURE__ */ new Set(),
-  config: { logs: false, handlers: [], tracing: normalizeFarmTracingConfig(false) }
-});
-var runtimeHandlers = shared.handlers;
-var unfilteredRuntimeHandlers = shared.unfilteredHandlers;
-var observabilityState = shared.config;
-function emitFarmEvent(input) {
-  const event = {
-    timestamp: Date.now(),
-    level: inferFarmEventLevel(input.type),
-    ...input
-  };
-  const traceContext = recordFarmEventTrace(event);
-  if (traceContext) {
-    event.traceId = traceContext.traceId;
-    event.spanId = traceContext.spanId;
-    event.traceSampled = traceContext.traceSampled;
-  }
-  notifyFarmEventHandlers(event, unfilteredRuntimeHandlers);
-  if (!shouldEmitFarmEvent(event)) return event;
-  if (observabilityState.logs) {
-    logFarmEvent(event);
-  }
-  notifyFarmEventHandlers(event, [...observabilityState.handlers, ...runtimeHandlers]);
-  return event;
-}
-__name(emitFarmEvent, "emitFarmEvent");
-function notifyFarmEventHandlers(event, handlers) {
-  for (const handler of handlers) {
-    try {
-      Promise.resolve(handler(event)).catch((error) => {
-        console.warn(`[farm:observability] event handler failed: ${formatError(error)}`);
-      });
-    } catch (error) {
-      console.warn(`[farm:observability] event handler failed: ${formatError(error)}`);
-    }
-  }
-}
-__name(notifyFarmEventHandlers, "notifyFarmEventHandlers");
-function shouldEmitFarmEvent(event) {
-  if (!observabilityState.logs && observabilityState.handlers.length === 0 && runtimeHandlers.size === 0) {
-    return false;
-  }
-  if (observabilityState.events && !observabilityState.events.has(event.type)) {
-    return false;
-  }
-  return true;
-}
-__name(shouldEmitFarmEvent, "shouldEmitFarmEvent");
-function inferFarmEventLevel(type) {
-  if (type === "error" || type.endsWith(".error") || type.endsWith(".failed")) {
-    return "error";
-  }
-  if (type.endsWith(".bypass") || type.endsWith(".invalidated") || type.endsWith(".stale") || type.endsWith(".notFound")) {
-    return "warn";
-  }
-  if (type.endsWith(".hit") || type.endsWith(".miss") || type.endsWith(".start") || type.endsWith(".shellReady")) {
-    return "debug";
-  }
-  return "info";
-}
-__name(inferFarmEventLevel, "inferFarmEventLevel");
-function logFarmEvent(event) {
-  const message = `[farm:${event.level}] ${event.type}${formatFarmEventDetails(event)}`;
-  switch (event.level) {
-    case "error":
-      console.error(message);
-      break;
-    case "warn":
-      console.warn(message);
-      break;
-    default:
-      console.log(message);
-      break;
-  }
-}
-__name(logFarmEvent, "logFarmEvent");
-function formatFarmEventDetails(event) {
-  const details = [];
-  const record = event;
-  for (const key of [
-    "route",
-    "pathname",
-    "method",
-    "status",
-    "key",
-    "tag",
-    "path",
-    "reason",
-    "durationMs",
-    "integration",
-    "server",
-    "tool",
-    "outcome",
-    "operation",
-    "plugin",
-    "hook",
-    "target",
-    "count"
-  ]) {
-    const value = record[key];
-    if (value !== void 0) {
-      details.push(`${key}=${formatDetailValue(value)}`);
-    }
-  }
-  return details.length > 0 ? ` ${details.join(" ")}` : "";
-}
-__name(formatFarmEventDetails, "formatFarmEventDetails");
-function formatDetailValue(value) {
-  if (typeof value === "string") {
-    return value;
-  }
-  if (typeof value === "number" || typeof value === "boolean") {
-    return String(value);
-  }
-  try {
-    return JSON.stringify(value);
-  } catch {
-    return String(value);
-  }
-}
-__name(formatDetailValue, "formatDetailValue");
-function formatError(error) {
-  return error instanceof Error ? error.message : String(error);
-}
-__name(formatError, "formatError");
 
-// src/cache-invalidation-stream.ts
-var MAX_BUFFERED_BYTES = 64 * 1024;
-var textEncoder = new TextEncoder();
 
-// src/cache.ts
-var _FarmDataCache = class _FarmDataCache {
-  constructor(config = {}) {
-    this.entries = /* @__PURE__ */ new Map();
-    this.inflight = /* @__PURE__ */ new Map();
-    /** Local entries by tag, so tag counts and pruning never scan unrelated entries. */
-    this.entriesByTag = /* @__PURE__ */ new Map();
-    this.invalidatedTagVersions = /* @__PURE__ */ new Map();
-    this.activeGenerations = /* @__PURE__ */ new Set();
-    this.version = 0;
-    this.generation = 0;
-    this.namespace = "farm";
-    this.local = true;
-    this.maxEntries = 1024;
-    this.lease = {
-      enabled: true,
-      ttlMs: 1e4,
-      waitTimeoutMs: 1e4,
-      pollIntervalMs: 25
-    };
-    this.configure(config);
-  }
-  configure(config = {}) {
-    this.generation++;
-    this.entries.clear();
-    this.entriesByTag.clear();
-    this.inflight.clear();
-    this.invalidatedTagVersions.clear();
-    this.activeGenerations.clear();
-    this.version = 0;
-    this.adapter = config.adapter;
-    this.namespace = normalizeCacheNamespace(config.namespace || "farm");
-    this.local = !config.adapter;
-    this.maxEntries = normalizePositiveInteger(config.maxEntries, 1024, "cache.maxEntries");
-    this.lease = config.lease === false ? { ...this.lease, enabled: false } : {
-      enabled: true,
-      ttlMs: normalizePositiveDuration(config.lease?.ttlMs, 1e4, "cache.lease.ttlMs"),
-      waitTimeoutMs: normalizePositiveDuration(
-        config.lease?.waitTimeoutMs,
-        1e4,
-        "cache.lease.waitTimeoutMs"
-      ),
-      pollIntervalMs: normalizePositiveDuration(
-        config.lease?.pollIntervalMs,
-        25,
-        "cache.lease.pollIntervalMs"
-      )
-    };
-  }
-  get adapterName() {
-    return this.adapter?.name || (this.adapter ? "custom" : "memory");
-  }
-  get hasAdapter() {
-    return this.adapter !== void 0;
-  }
-  get size() {
-    return this.entries.size;
-  }
-  get(key, options = {}) {
-    return this.getEntry(key, options)?.value;
-  }
-  getEntry(key, options = {}) {
-    const entry = this.entries.get(key);
-    if (!entry) {
-      emitFarmEvent({ type: "cache.miss", key });
-      return void 0;
-    }
-    const stale = this.isStale(entry, options.now);
-    if (stale) {
-      emitFarmEvent({
-        type: "cache.stale",
-        key,
-        tags: Array.from(entry.tags),
-        revalidate: entry.revalidate
-      });
-    }
-    if (!options.allowStale && stale) {
-      emitFarmEvent({ type: "cache.miss", key, reason: "stale" });
-      return void 0;
-    }
-    this.touchEntry(key, entry);
-    emitFarmEvent({
-      type: "cache.hit",
-      key,
-      tags: Array.from(entry.tags),
-      revalidate: entry.revalidate,
-      stale
-    });
-    return this.toPublicEntry(entry);
-  }
-  async getEntryAsync(key, options = {}) {
-    if (this.local) {
-      const localEntry = this.getEntry(key, options);
-      if (localEntry) return localEntry;
-    }
-    if (!this.adapter) {
-      return this.local ? void 0 : this.getEntry(key, options);
-    }
-    const generation = this.generation;
-    const adapter = this.adapter;
-    const namespace = this.namespace;
-    const entry = await adapter.get(`${namespace}:entry:${key}`);
-    if (generation !== this.generation) return void 0;
-    if (!entry) {
-      emitFarmEvent({ type: "cache.miss", key });
-      return void 0;
-    }
-    assertFarmCacheEntry(entry, key);
-    const stale = await this.isAdapterEntryStale(entry, options.now, adapter, namespace);
-    if (generation !== this.generation) return void 0;
-    if (stale) {
-      emitFarmEvent({
-        type: "cache.stale",
-        key,
-        tags: [...entry.tags],
-        revalidate: entry.revalidate
-      });
-      if (!options.allowStale) {
-        emitFarmEvent({ type: "cache.miss", key, reason: "stale" });
-        return void 0;
-      }
-    }
-    emitFarmEvent({
-      type: "cache.hit",
-      key,
-      tags: [...entry.tags],
-      revalidate: entry.revalidate,
-      stale
-    });
-    if (this.local && !stale) {
-      this.hydrateLocalEntry(entry);
-    }
-    return { ...entry, key };
-  }
-  set(key, value, options = {}) {
-    const revalidate = normalizeRevalidate(options.revalidate);
-    const tags = /* @__PURE__ */ new Set();
-    for (const tag of options.tags ?? []) {
-      tags.add(normalizeCacheTag(tag));
-    }
-    for (const routePath of options.paths ?? []) {
-      tags.add(createPathCacheTag(routePath));
-    }
-    const entry = {
-      key,
-      value,
-      tags,
-      tagVersions: void 0,
-      createdAt: options.createdAt ?? Date.now(),
-      createdVersion: ++this.version,
-      revalidate
-    };
-    this.storeLocalEntry(entry);
-    emitFarmEvent({
-      type: "cache.set",
-      key,
-      tags: Array.from(tags),
-      revalidate: entry.revalidate
-    });
-    return this.toPublicEntry(entry);
-  }
-  async setAsync(key, value, options = {}, tagVersions) {
-    return this.writeAsync(key, value, options, tagVersions);
-  }
-  async writeAsync(key, value, options, tagVersions, createdVersion) {
-    const revalidate = normalizeRevalidate(options.revalidate);
-    const tags = normalizeCacheOptionsTags(options);
-    const capturedVersions = tagVersions ?? await this.getAdapterTagVersions(Array.from(tags.values()));
-    const entry = {
-      key,
-      value,
-      tags: Array.from(tags),
-      tagVersions: capturedVersions,
-      createdAt: options.createdAt ?? Date.now(),
-      createdVersion: createdVersion ?? ++this.version,
-      revalidate
-    };
-    if (this.local) {
-      this.hydrateLocalEntry(entry);
-    }
-    if (this.adapter) {
-      await this.adapter.set(this.createAdapterKey(key), entry);
-    }
-    emitFarmEvent({
-      type: "cache.set",
-      key,
-      tags: [...entry.tags],
-      revalidate: entry.revalidate
-    });
-    return entry;
-  }
-  delete(key) {
-    const deleted = this.deleteLocalEntry(key);
-    emitFarmEvent({ type: "cache.delete", key, deleted });
-    return deleted;
-  }
-  async deleteAsync(key) {
-    const deleted = this.deleteLocalEntry(key);
-    if (this.adapter) {
-      await this.adapter.delete(this.createAdapterKey(key));
-    }
-    emitFarmEvent({ type: "cache.delete", key, deleted: this.adapter ? true : deleted });
-    return this.adapter ? true : deleted;
-  }
-  clear() {
-    const count = this.entries.size;
-    this.generation++;
-    this.entries.clear();
-    this.entriesByTag.clear();
-    this.inflight.clear();
-    this.invalidatedTagVersions.clear();
-    this.activeGenerations.clear();
-    this.version = 0;
-    emitFarmEvent({ type: "cache.clear", count });
-  }
-  async clearAsync() {
-    this.clear();
-    await this.adapter?.clear?.();
-  }
-  isStale(entry, now = Date.now()) {
-    if (typeof entry.revalidate === "number" && entry.revalidate >= 0 && now - entry.createdAt >= entry.revalidate * 1e3) {
-      return true;
-    }
-    for (const tag of entry.tags) {
-      const invalidatedVersion = this.invalidatedTagVersions.get(normalizeCacheTag(tag));
-      if (typeof invalidatedVersion === "number" && typeof entry.createdVersion === "number" && invalidatedVersion > entry.createdVersion) {
-        return true;
-      }
-    }
-    return false;
-  }
-  async isStaleAsync(entry, now = Date.now()) {
-    if (this.adapter) {
-      return this.isAdapterEntryStale(entry, now);
-    }
-    return this.isStale(entry, now);
-  }
-  revalidateTag(tag, options = {}) {
-    const normalized = normalizeCacheTag(tag);
-    const count = this.invalidateTag(normalized);
-    emitFarmEvent(
-      options.source === "updateTag" ? { type: "cache.updateTag", tag: normalized, count } : { type: "cache.revalidateTag", tag: normalized, profile: options.profile, count }
-    );
-    return count;
-  }
-  async revalidateTagAsync(tag, options = {}) {
-    const normalized = normalizeCacheTag(tag);
-    const count = this.invalidateTag(normalized);
-    await this.adapter?.invalidateTags?.([this.createAdapterTag(normalized)]);
-    emitFarmEvent(
-      options.source === "updateTag" ? { type: "cache.updateTag", tag: normalized, count } : { type: "cache.revalidateTag", tag: normalized, profile: options.profile, count }
-    );
-    return count;
-  }
-  revalidatePath(routePath) {
-    const normalizedPath = normalizeRevalidatePath(routePath);
-    const pathTag = createPathCacheTag(normalizedPath);
-    const pprCount = this.countEntriesForTags([pathTag, "ppr"]);
-    const count = this.invalidateTag(pathTag);
-    emitFarmEvent({ type: "cache.revalidatePath", path: normalizedPath, count });
-    if (pprCount > 0) {
-      emitFarmEvent({
-        type: "ppr.shell.invalidated",
-        route: normalizedPath,
-        reason: "revalidatePath",
-        count: pprCount
-      });
-    }
-    return count;
-  }
-  async revalidatePathAsync(routePath) {
-    const normalizedPath = normalizeRevalidatePath(routePath);
-    const pathTag = createPathCacheTag(normalizedPath);
-    const pprCount = this.countEntriesForTags([pathTag, "ppr"]);
-    const count = this.invalidateTag(pathTag);
-    await this.adapter?.invalidateTags?.([this.createAdapterTag(pathTag)]);
-    emitFarmEvent({ type: "cache.revalidatePath", path: normalizedPath, count });
-    if (pprCount > 0) {
-      emitFarmEvent({
-        type: "ppr.shell.invalidated",
-        route: normalizedPath,
-        reason: "revalidatePath",
-        count: pprCount
-      });
-    }
-    return count;
-  }
-  async getOrSet(key, producer, options = {}) {
-    normalizeRevalidate(options.revalidate);
-    const cached = await this.getEntryAsync(key);
-    if (cached) {
-      return cached.value;
-    }
-    const inflight = this.inflight.get(key);
-    if (inflight && !this.wasInvalidatedSince(inflight.tags, inflight.startVersion)) {
-      emitFarmEvent({ type: "cache.dedupe", key });
-      return inflight.promise;
-    }
-    const tags = Array.from(normalizeCacheOptionsTags(options));
-    const generation = this.generation;
-    const startVersion = this.version;
-    const promise = this.fillCacheEntry(key, producer, options, tags, generation).catch((error) => {
-      emitFarmEvent({ type: "cache.error", key, operation: "set", error });
-      throw error;
-    }).finally(() => {
-      if (this.inflight.get(key)?.promise === promise) {
-        this.inflight.delete(key);
-      }
-    });
-    this.inflight.set(key, { promise, tags, startVersion });
-    return promise;
-  }
-  /** A fill that started before one of its tags was invalidated cannot satisfy later readers. */
-  wasInvalidatedSince(tags, version) {
-    for (const tag of tags) {
-      const invalidatedVersion = this.invalidatedTagVersions.get(tag);
-      if (invalidatedVersion !== void 0 && invalidatedVersion > version) return true;
-    }
-    return false;
-  }
-  async fillCacheEntry(key, producer, options, tags, generation) {
-    const adapter = this.adapter;
-    const namespace = this.namespace;
-    const lease = { ...this.lease };
-    const leaseKey = `${namespace}:lease:${key}`;
-    let leaseToken;
-    if (adapter?.acquireLease && adapter.releaseLease && lease.enabled) {
-      leaseToken = await adapter.acquireLease(leaseKey, lease.ttlMs);
-      if (!leaseToken) {
-        const shared2 = await this.waitForAdapterEntry(
-          key,
-          adapter,
-          namespace,
-          lease,
-          generation
-        );
-        if (shared2) {
-          emitFarmEvent({ type: "cache.dedupe", key });
-          return shared2.value;
-        }
-        if (generation === this.generation) {
-          leaseToken = await adapter.acquireLease(leaseKey, lease.ttlMs);
-        }
-      }
-    }
-    const initialCreatedVersion = this.version;
-    const activeGeneration = {
-      tags: new Set(tags),
-      createdVersion: initialCreatedVersion
-    };
-    this.activeGenerations.add(activeGeneration);
-    try {
-      const initialTagVersions = await this.getAdapterTagVersions(tags, adapter, namespace);
-      const value = await producer();
-      if (generation === this.generation) {
-        await this.writeAsync(key, value, options, initialTagVersions, initialCreatedVersion);
-      }
-      return value;
-    } finally {
-      this.activeGenerations.delete(activeGeneration);
-      this.pruneInvalidatedTagVersions(activeGeneration.tags);
-      if (leaseToken && adapter?.releaseLease) {
-        try {
-          await adapter.releaseLease(leaseKey, leaseToken);
-        } catch (error) {
-          emitFarmEvent({ type: "cache.error", key, operation: "set", error });
-        }
-      }
-    }
-  }
-  async waitForAdapterEntry(key, adapter, namespace, lease, generation) {
-    const deadline = Date.now() + lease.waitTimeoutMs;
-    while (Date.now() < deadline) {
-      await delay(lease.pollIntervalMs);
-      if (generation !== this.generation) return void 0;
-      const entry = await adapter.get(`${namespace}:entry:${key}`);
-      if (generation !== this.generation) return void 0;
-      if (!entry) {
-        emitFarmEvent({ type: "cache.miss", key });
-        continue;
-      }
-      assertFarmCacheEntry(entry, key);
-      const stale = await this.isAdapterEntryStale(entry, Date.now(), adapter, namespace);
-      if (generation !== this.generation) return void 0;
-      if (stale) {
-        emitFarmEvent({
-          type: "cache.stale",
-          key,
-          tags: [...entry.tags],
-          revalidate: entry.revalidate
-        });
-        emitFarmEvent({ type: "cache.miss", key, reason: "stale" });
-      } else {
-        emitFarmEvent({
-          type: "cache.hit",
-          key,
-          tags: [...entry.tags],
-          revalidate: entry.revalidate,
-          stale: false
-        });
-        return { ...entry, key };
-      }
-    }
-    return void 0;
-  }
-  countEntriesForTags(tags) {
-    let count = 0;
-    for (const entry of this.entriesByTag.get(tags[0]) ?? []) {
-      if (tags.every((tag) => entry.tags.has(tag))) {
-        count++;
-      }
-    }
-    return count;
-  }
-  invalidateTag(normalizedTag) {
-    const count = this.entriesByTag.get(normalizedTag)?.size ?? 0;
-    this.invalidatedTagVersions.delete(normalizedTag);
-    this.invalidatedTagVersions.set(normalizedTag, ++this.version);
-    this.pruneInvalidatedTagVersions([normalizedTag]);
-    return count;
-  }
-  toPublicEntry(entry) {
-    return {
-      key: entry.key,
-      value: entry.value,
-      tags: Array.from(entry.tags),
-      tagVersions: entry.tagVersions,
-      createdAt: entry.createdAt,
-      createdVersion: entry.createdVersion,
-      revalidate: entry.revalidate
-    };
-  }
-  hydrateLocalEntry(entry) {
-    this.storeLocalEntry({
-      key: entry.key,
-      value: entry.value,
-      tags: new Set(entry.tags.map(normalizeCacheTag)),
-      tagVersions: entry.tagVersions,
-      createdAt: entry.createdAt,
-      createdVersion: entry.createdVersion ?? ++this.version,
-      revalidate: normalizeRevalidate(entry.revalidate)
-    });
-  }
-  touchEntry(key, entry) {
-    this.entries.delete(key);
-    this.entries.set(key, entry);
-  }
-  storeLocalEntry(entry) {
-    const removed = [];
-    const replaced = this.detachLocalEntry(entry.key);
-    if (replaced) removed.push(replaced);
-    this.entries.set(entry.key, entry);
-    for (const tag of entry.tags) {
-      let tagged = this.entriesByTag.get(tag);
-      if (!tagged) this.entriesByTag.set(tag, tagged = /* @__PURE__ */ new Set());
-      tagged.add(entry);
-    }
-    while (this.entries.size > this.maxEntries) {
-      const oldestKey = this.entries.keys().next().value;
-      if (oldestKey === void 0) break;
-      removed.push(this.detachLocalEntry(oldestKey));
-    }
-    for (const removedEntry of removed) this.pruneInvalidatedTagVersions(removedEntry.tags);
-  }
-  deleteLocalEntry(key) {
-    const entry = this.detachLocalEntry(key);
-    if (!entry) return false;
-    this.pruneInvalidatedTagVersions(entry.tags);
-    return true;
-  }
-  detachLocalEntry(key) {
-    const entry = this.entries.get(key);
-    if (!entry) return void 0;
-    this.entries.delete(key);
-    for (const tag of entry.tags) {
-      const tagged = this.entriesByTag.get(tag);
-      if (!tagged) continue;
-      tagged.delete(entry);
-      if (tagged.size === 0) this.entriesByTag.delete(tag);
-    }
-    return entry;
-  }
-  /**
-   * Drop invalidation versions that no local entry or active fill can be stale against.
-   * Callers pass only the tags whose dependents just changed, so the cost is bounded by
-   * the entries sharing those tags rather than by the whole cache.
-   */
-  pruneInvalidatedTagVersions(tags) {
-    tags: for (const tag of tags) {
-      const invalidatedVersion = this.invalidatedTagVersions.get(tag);
-      if (invalidatedVersion === void 0) continue;
-      for (const entry of this.entriesByTag.get(tag) ?? []) {
-        if (entry.createdVersion < invalidatedVersion) continue tags;
-      }
-      for (const generation of this.activeGenerations) {
-        if (generation.tags.has(tag) && generation.createdVersion < invalidatedVersion)
-          continue tags;
-      }
-      this.invalidatedTagVersions.delete(tag);
-    }
-  }
-  createAdapterKey(key) {
-    return `${this.namespace}:entry:${key}`;
-  }
-  createAdapterTag(tag) {
-    return `${this.namespace}:tag:${tag}`;
-  }
-  async getAdapterTagVersions(tags, adapter = this.adapter, namespace = this.namespace) {
-    if (!adapter?.getTagVersions || tags.length === 0) return {};
-    const normalized = tags.map(normalizeCacheTag);
-    const physicalTags = normalized.map((tag) => `${namespace}:tag:${tag}`);
-    const versions = await adapter.getTagVersions(physicalTags);
-    return Object.fromEntries(
-      normalized.map((tag, index) => [
-        tag,
-        normalizeAdapterVersion(versions[physicalTags[index]])
-      ])
-    );
-  }
-  async isAdapterEntryStale(entry, now = Date.now(), adapter = this.adapter, namespace = this.namespace) {
-    if (typeof entry.revalidate === "number" && entry.revalidate >= 0 && now - entry.createdAt >= entry.revalidate * 1e3) {
-      return true;
-    }
-    const currentVersions = await this.getAdapterTagVersions(entry.tags, adapter, namespace);
-    for (const tag of entry.tags) {
-      if (normalizeAdapterVersion(currentVersions[tag]) > normalizeAdapterVersion(entry.tagVersions?.[tag])) {
-        return true;
-      }
-    }
-    return false;
-  }
-};
-__name(_FarmDataCache, "FarmDataCache");
-var FarmDataCache = _FarmDataCache;
-var FARM_DATA_CACHE_SYMBOL = /* @__PURE__ */ Symbol.for("farm.dataCache");
-var farmDataCacheGlobal = globalThis;
-var sharedFarmDataCache = farmDataCacheGlobal[FARM_DATA_CACHE_SYMBOL] ?? (farmDataCacheGlobal[FARM_DATA_CACHE_SYMBOL] = new FarmDataCache());
-function 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?:\/\//i.test(normalized)) {
-      normalized = new URL(normalized).pathname;
-    }
-  } catch {
-  }
-  normalized = normalized.split(/[?#]/, 1)[0] ?? normalized;
-  normalized = normalized.startsWith("/") ? normalized : `/${normalized}`;
-  normalized = normalized.replace(/\/{2,}/g, "/");
-  normalized = new URL(normalized, "http://farm.invalid").pathname;
-  if (normalized.length > 1) {
-    normalized = normalized.replace(/\/+$/, "");
-  }
-  return normalized || "/";
-}
-__name(normalizeRevalidatePath, "normalizeRevalidatePath");
-function createFarmCacheKey(parts) {
-  return stableSerialize(parts);
-}
-__name(createFarmCacheKey, "createFarmCacheKey");
-function normalizeRevalidate(revalidate) {
-  if (revalidate === false || revalidate === void 0) {
-    return revalidate;
-  }
-  if (!Number.isFinite(revalidate) || revalidate < 0) {
-    throw new TypeError("Cache revalidate must be false or a finite, non-negative number.");
-  }
-  return revalidate;
-}
-__name(normalizeRevalidate, "normalizeRevalidate");
-function normalizeCacheTag(tag) {
-  if (typeof tag !== "string") {
-    throw new TypeError("Cache tags must be strings.");
-  }
-  const normalized = tag.trim();
-  if (!normalized) {
-    throw new Error("Cache tags cannot be empty.");
-  }
-  return normalized;
-}
-__name(normalizeCacheTag, "normalizeCacheTag");
-function normalizeCacheNamespace(namespace) {
-  if (typeof namespace !== "string") {
-    throw new TypeError("Cache namespace must be a string.");
-  }
-  const normalized = namespace.trim().replace(/:+$/g, "");
-  if (!normalized) {
-    throw new Error("Cache namespace cannot be empty.");
-  }
-  return normalized;
-}
-__name(normalizeCacheNamespace, "normalizeCacheNamespace");
-function normalizeAdapterVersion(value) {
-  return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : 0;
-}
-__name(normalizeAdapterVersion, "normalizeAdapterVersion");
-function normalizePositiveDuration(value, fallback, name) {
-  if (value === void 0) return fallback;
-  if (!Number.isFinite(value) || value <= 0) {
-    throw new TypeError(`${name} must be a positive number of milliseconds.`);
-  }
-  return Math.floor(value);
-}
-__name(normalizePositiveDuration, "normalizePositiveDuration");
-function normalizePositiveInteger(value, fallback, name) {
-  if (value === void 0) return fallback;
-  if (!Number.isSafeInteger(value) || value <= 0) {
-    throw new TypeError(`${name} must be a positive integer.`);
-  }
-  return value;
-}
-__name(normalizePositiveInteger, "normalizePositiveInteger");
-function delay(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-__name(delay, "delay");
-function normalizeCacheOptionsTags(options) {
-  const tags = /* @__PURE__ */ new Set();
-  for (const tag of options.tags ?? []) {
-    tags.add(normalizeCacheTag(tag));
-  }
-  for (const routePath of options.paths ?? []) {
-    tags.add(createPathCacheTag(routePath));
-  }
-  return tags;
-}
-__name(normalizeCacheOptionsTags, "normalizeCacheOptionsTags");
-function assertFarmCacheEntry(entry, expectedKey) {
-  if (!entry || typeof entry !== "object" || entry.key !== expectedKey || !Array.isArray(entry.tags) || typeof entry.createdAt !== "number") {
-    throw new TypeError(
-      `Cache adapter returned an invalid entry for ${JSON.stringify(expectedKey)}.`
-    );
-  }
-}
-__name(assertFarmCacheEntry, "assertFarmCacheEntry");
-function getFunctionCacheIdentity(fn) {
-  const name = fn.name || "anonymous";
-  return `${name}:${hashFunctionSource(String(fn))}`;
-}
-__name(getFunctionCacheIdentity, "getFunctionCacheIdentity");
-function hashFunctionSource(source) {
-  let hash = 2166136261;
-  for (let index = 0; index < source.length; index++) {
-    hash ^= source.charCodeAt(index);
-    hash = Math.imul(hash, 16777619);
-  }
-  return (hash >>> 0).toString(36);
-}
-__name(hashFunctionSource, "hashFunctionSource");
-function compareCodepoint(a, b) {
-  return a < b ? -1 : a > b ? 1 : 0;
-}
-__name(compareCodepoint, "compareCodepoint");
-function serializeBinaryBytes(bytes) {
-  return Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
-}
-__name(serializeBinaryBytes, "serializeBinaryBytes");
-function serializeCanonicalStringEntries(entries, seen) {
-  const valuesByKey = /* @__PURE__ */ new Map();
-  for (const [key, item] of entries) {
-    const values = valuesByKey.get(key);
-    if (values) values.push(item);
-    else valuesByKey.set(key, [item]);
-  }
-  return Array.from(valuesByKey.keys()).sort(compareCodepoint).flatMap(
-    (key) => valuesByKey.get(key).map((item) => `[${stableSerialize(key, seen)},${stableSerialize(item, seen)}]`)
-  ).join(",");
-}
-__name(serializeCanonicalStringEntries, "serializeCanonicalStringEntries");
-function isPlainCacheKeyObject(value) {
-  const prototype = Object.getPrototypeOf(value);
-  if (prototype === null) return true;
-  const constructor = Object.getOwnPropertyDescriptor(prototype, "constructor")?.value;
-  return Object.getPrototypeOf(prototype) === null && typeof constructor === "function" && constructor.name === "Object";
-}
-__name(isPlainCacheKeyObject, "isPlainCacheKeyObject");
-function getCacheKeyValueType(value) {
-  const prototype = Object.getPrototypeOf(value);
-  const constructor = prototype ? Object.getOwnPropertyDescriptor(prototype, "constructor")?.value : void 0;
-  if (typeof constructor === "function" && constructor.name) {
-    return constructor.name;
-  }
-  return Object.prototype.toString.call(value).slice(8, -1) || "object";
-}
-__name(getCacheKeyValueType, "getCacheKeyValueType");
-function stableSerialize(value, seen = /* @__PURE__ */ new WeakSet()) {
-  if (value === null) return "null";
-  if (value === void 0) return "undefined";
-  const valueType = typeof value;
-  if (valueType === "string") return JSON.stringify(value);
-  if (valueType === "number" || valueType === "boolean" || valueType === "bigint") {
-    return `${valueType}:${String(value)}`;
-  }
-  if (valueType === "symbol") {
-    return `symbol:${String(value)}`;
-  }
-  if (valueType === "function") {
-    return `function:${getFunctionCacheIdentity(value)}`;
-  }
-  if (value instanceof Date) {
-    return Number.isNaN(value.getTime()) ? "date:invalid" : `date:${value.toISOString()}`;
-  }
-  if (value instanceof URL) {
-    return `url:${value.toString()}`;
-  }
-  if (value instanceof RegExp) {
-    return `regexp:${value.toString()}`;
-  }
-  if (value instanceof ArrayBuffer) {
-    return `arraybuffer:${serializeBinaryBytes(new Uint8Array(value))}`;
-  }
-  if (typeof SharedArrayBuffer !== "undefined" && value instanceof SharedArrayBuffer) {
-    return `sharedarraybuffer:${serializeBinaryBytes(new Uint8Array(value))}`;
-  }
-  if (ArrayBuffer.isView(value)) {
-    const viewType = Object.prototype.toString.call(value).slice(8, -1);
-    const bytes = new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
-    return `binary:${viewType}:${serializeBinaryBytes(bytes)}`;
-  }
-  if (value && typeof value === "object") {
-    if (seen.has(value)) {
-      return "[Circular]";
-    }
-    seen.add(value);
-    if (Array.isArray(value)) {
-      const items = [];
-      for (let index = 0; index < value.length; index++) {
-        items.push(
-          Object.prototype.hasOwnProperty.call(value, index) ? stableSerialize(value[index], seen) : "[Hole]"
-        );
-      }
-      seen.delete(value);
-      return `[${items.join(",")}]`;
-    }
-    if (value instanceof Set) {
-      const items = Array.from(value, (item) => stableSerialize(item, seen)).sort(compareCodepoint);
-      seen.delete(value);
-      return `set:[${items.join(",")}]`;
-    }
-    if (value instanceof Map) {
-      const items = Array.from(
-        value,
-        ([key, item]) => `[${stableSerialize(key, seen)},${stableSerialize(item, seen)}]`
-      ).sort(compareCodepoint);
-      seen.delete(value);
-      return `map:[${items.join(",")}]`;
-    }
-    if (value instanceof URLSearchParams) {
-      const serialized2 = serializeCanonicalStringEntries(value, seen);
-      seen.delete(value);
-      return `urlsearchparams:[${serialized2}]`;
-    }
-    if (value instanceof Headers) {
-      const serialized2 = serializeCanonicalStringEntries(value, seen);
-      seen.delete(value);
-      return `headers:[${serialized2}]`;
-    }
-    if (!isPlainCacheKeyObject(value)) {
-      throw new TypeError(
-        `Cache keys do not support ${getCacheKeyValueType(value)} values. Convert the value to an explicit stable string or structured key before caching.`
-      );
-    }
-    const entries = Object.entries(value).sort(
-      ([a], [b]) => compareCodepoint(a, b)
-    );
-    const serialized = entries.map(([key, item]) => `${JSON.stringify(key)}:${stableSerialize(item, seen)}`).join(",");
-    seen.delete(value);
-    return `{${serialized}}`;
-  }
-  return String(value);
-}
-__name(stableSerialize, "stableSerialize");
 
-// src/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/routing/specificity.ts
-var _AmbiguousRouteError = class _AmbiguousRouteError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "AmbiguousRouteError";
-  }
-};
-__name(_AmbiguousRouteError, "AmbiguousRouteError");
-var AmbiguousRouteError = _AmbiguousRouteError;
-var _NonTerminalCatchAllRouteError = class _NonTerminalCatchAllRouteError extends TypeError {
-  constructor(message) {
-    super(message);
-    this.name = "NonTerminalCatchAllRouteError";
-  }
-};
-__name(_NonTerminalCatchAllRouteError, "NonTerminalCatchAllRouteError");
-var NonTerminalCatchAllRouteError = _NonTerminalCatchAllRouteError;
-var _DuplicateRouteParameterError = class _DuplicateRouteParameterError extends AmbiguousRouteError {
-  constructor(message) {
-    super(message);
-    this.name = "DuplicateRouteParameterError";
-  }
-};
-__name(_DuplicateRouteParameterError, "DuplicateRouteParameterError");
-var DuplicateRouteParameterError = _DuplicateRouteParameterError;
-var _ReservedRouteParameterError = class _ReservedRouteParameterError extends AmbiguousRouteError {
-  constructor(message) {
-    super(message);
-    this.name = "ReservedRouteParameterError";
-  }
-};
-__name(_ReservedRouteParameterError, "ReservedRouteParameterError");
-var ReservedRouteParameterError = _ReservedRouteParameterError;
-var _BrowserUnstableRouteError = class _BrowserUnstableRouteError extends TypeError {
-  constructor(message) {
-    super(message);
-    this.name = "BrowserUnstableRouteError";
-  }
-};
-__name(_BrowserUnstableRouteError, "BrowserUnstableRouteError");
-var BrowserUnstableRouteError = _BrowserUnstableRouteError;
-var ROUTER_PARAMETER_NAME = "[A-Za-z0-9_$-]+";
-var PAGE_PARAMETER_PATTERN = /^(?:\[\[\.\.\.(.+)\]\]|\[\.\.\.(.+)\]|\[(.+)\])$/;
-var ROUTER_PARAMETER_PATTERN = /^(?:\[\[\.\.\.([A-Za-z0-9_$-]+)\]\]|\[\.\.\.([A-Za-z0-9_$-]+)\]|\[([A-Za-z0-9_$-]+)\]|:([A-Za-z0-9_$-]+)|\*([A-Za-z0-9_$-]+)\??)$/;
-var RESERVED_PARAMETER_NAMES = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
-function assertBrowserStableRoutePath(pattern) {
-  if (pattern.includes("\\") || hasControlCharacter(pattern)) {
-    throw new BrowserUnstableRouteError(
-      `Route path "${pattern}" cannot contain backslashes or control characters.`
-    );
-  }
-  for (const segment of pattern.split("/").filter(Boolean)) {
-    if (segment.startsWith("(") && segment.endsWith(")") || segment.startsWith("[") && segment.endsWith("]")) {
-      continue;
-    }
-    let decoded = segment;
-    try {
-      decoded = decodeURIComponent(segment);
-    } catch {
-    }
-    if (decoded === "." || decoded === ".." || decoded.includes("/") || decoded.includes("\\") || hasControlCharacter(decoded)) {
-      throw new BrowserUnstableRouteError(
-        `Route path "${pattern}" contains browser-unstable segment "${segment}".`
-      );
-    }
-  }
-}
-__name(assertBrowserStableRoutePath, "assertBrowserStableRoutePath");
-function hasControlCharacter(value) {
-  return Array.from(value).some((character) => {
-    const code = character.charCodeAt(0);
-    return code <= 31 || code >= 127 && code <= 159;
-  });
-}
-__name(hasControlCharacter, "hasControlCharacter");
-function assertUniqueRouteParameters(pattern, syntax = "page") {
-  const parameterPattern = syntax === "router" ? ROUTER_PARAMETER_PATTERN : PAGE_PARAMETER_PATTERN;
-  const names = /* @__PURE__ */ new Set();
-  for (const segment of splitRoutePattern(pattern, syntax)) {
-    const match = parameterPattern.exec(segment);
-    const name = match?.slice(1).find(Boolean);
-    if (!name) continue;
-    if (RESERVED_PARAMETER_NAMES.has(name)) {
-      throw new ReservedRouteParameterError(
-        `Route parameter "${name}" in route "${pattern}" is reserved. Use a different parameter name.`
-      );
-    }
-    if (names.has(name)) {
-      throw new DuplicateRouteParameterError(
-        `Duplicate route parameter "${name}" in route "${pattern}". Each dynamic segment must use a unique name.`
-      );
-    }
-    names.add(name);
-  }
-}
-__name(assertUniqueRouteParameters, "assertUniqueRouteParameters");
-function splitRoutePattern(pattern, syntax) {
-  return pattern.replace(/\\/g, "/").split("/").filter(Boolean).filter(
-    (segment) => syntax === "api" ? true : !(segment.startsWith("(") && segment.endsWith(")"))
-  );
-}
-__name(splitRoutePattern, "splitRoutePattern");
-function assertTerminalCatchAll(pattern, syntax = "page") {
-  const segments = splitRoutePattern(pattern, syntax);
-  const parameterName = syntax === "router" ? ROUTER_PARAMETER_NAME : ".+";
-  const catchAllPattern = new RegExp(
-    syntax === "router" ? `^(?:\\[\\[\\.\\.\\.${parameterName}\\]\\]|\\[\\.\\.\\.${parameterName}\\]|\\*${parameterName}\\??)$` : `^(?:\\[\\[\\.\\.\\.${parameterName}\\]\\]|\\[\\.\\.\\.${parameterName}\\])$`
-  );
-  const catchAllIndex = segments.findIndex((segment) => catchAllPattern.test(segment));
-  if (catchAllIndex >= 0 && catchAllIndex !== segments.length - 1) {
-    throw new NonTerminalCatchAllRouteError(
-      `Catch-all segment "${segments[catchAllIndex]}" must be the final segment in route "${pattern}".`
-    );
-  }
-}
-__name(assertTerminalCatchAll, "assertTerminalCatchAll");
 
-// src/route-call-scanner.ts
-function extractProgrammaticPageCallPathLiterals(source) {
-  const results = /* @__PURE__ */ new Set();
-  const length = source.length;
-  let cursor = 0;
-  const controlParentheses = [];
-  let nextParenthesisIsControl = false;
-  let prev = "none";
-  const isWhitespace = /* @__PURE__ */ __name((char) => char === " " || char === "	" || char === "\n" || char === "\r" || char === "\f" || char === "\v", "isWhitespace");
-  const isIdentifierStart = /* @__PURE__ */ __name((char) => /[A-Za-z_$]/.test(char), "isIdentifierStart");
-  const isIdentifierPart = /* @__PURE__ */ __name((char) => /[A-Za-z0-9_$]/.test(char), "isIdentifierPart");
-  const isDigit = /* @__PURE__ */ __name((char) => char >= "0" && char <= "9", "isDigit");
-  const EXPRESSION_KEYWORDS = /* @__PURE__ */ new Set([
-    "return",
-    "typeof",
-    "delete",
-    "void",
-    "new",
-    "throw",
-    "instanceof",
-    "in",
-    "of",
-    "await",
-    "yield",
-    "else",
-    "do",
-    "case"
-  ]);
-  const VALUE_KEYWORDS = /* @__PURE__ */ new Set(["true", "false", "null", "this", "super", "undefined"]);
-  const CONTROL_PAREN_KEYWORDS = /* @__PURE__ */ new Set(["if", "for", "while", "switch", "with", "catch"]);
-  const REGEX_CONTEXT = /* @__PURE__ */ new Set([
-    "none",
-    "open",
-    "operator",
-    "keyword",
-    "spread"
-  ]);
-  function readIdentifier(start) {
-    let end = start;
-    while (end < length && isIdentifierPart(source[end])) end++;
-    return { end, text: source.slice(start, end) };
-  }
-  __name(readIdentifier, "readIdentifier");
-  function readStringLiteral(start, quote) {
-    let end = start + 1;
-    while (end < length) {
-      const char = source[end];
-      if (char === "\\") {
-        end += 2;
-        continue;
-      }
-      if (char === quote) {
-        return { end: end + 1, content: source.slice(start + 1, end) };
-      }
-      end++;
-    }
-    return null;
-  }
-  __name(readStringLiteral, "readStringLiteral");
-  function readTemplateLiteral(start) {
-    let end = start + 1;
-    let dynamic = false;
-    while (end < length) {
-      const char = source[end];
-      if (char === "\\") {
-        end += 2;
-        continue;
-      }
-      if (char === "`") {
-        return { end: end + 1, content: source.slice(start + 1, end), dynamic };
-      }
-      if (char === "$" && source[end + 1] === "{") {
-        dynamic = true;
-        const after = skipTemplateInterpolation(end + 2);
-        if (after === -1) return null;
-        end = after;
-        continue;
-      }
-      end++;
-    }
-    return null;
-  }
-  __name(readTemplateLiteral, "readTemplateLiteral");
-  function skipTemplateInterpolation(start) {
-    let end = start;
-    let depth = 1;
-    while (end < length && depth > 0) {
-      const char = source[end];
-      if (char === "\\") {
-        end += 2;
-        continue;
-      }
-      if (char === "{") {
-        depth++;
-        end++;
-        continue;
-      }
-      if (char === "}") {
-        depth--;
-        end++;
-        continue;
-      }
-      if (char === '"' || char === "'") {
-        const result = readStringLiteral(end, char);
-        if (!result) return -1;
-        end = result.end;
-        continue;
-      }
-      if (char === "`") {
-        const result = readTemplateLiteral(end);
-        if (!result) return -1;
-        end = result.end;
-        continue;
-      }
-      end++;
-    }
-    return depth === 0 ? end : -1;
-  }
-  __name(skipTemplateInterpolation, "skipTemplateInterpolation");
-  function readRegexLiteral(start) {
-    let end = start + 1;
-    let inClass = false;
-    while (end < length) {
-      const char = source[end];
-      if (char === "\\") {
-        end += 2;
-        continue;
-      }
-      if (char === "[") {
-        inClass = true;
-        end++;
-        continue;
-      }
-      if (char === "]") {
-        inClass = false;
-        end++;
-        continue;
-      }
-      if (char === "/" && !inClass) {
-        end++;
-        while (end < length && source[end] >= "a" && source[end] <= "z") end++;
-        return end;
-      }
-      if (char === "\n") return null;
-      end++;
-    }
-    return null;
-  }
-  __name(readRegexLiteral, "readRegexLiteral");
-  function skipLineComment(start) {
-    let end = start + 2;
-    while (end < length && source[end] !== "\n") end++;
-    return end;
-  }
-  __name(skipLineComment, "skipLineComment");
-  function skipBlockComment(start) {
-    let end = start + 2;
-    while (end < length) {
-      if (source[end] === "*" && source[end + 1] === "/") return end + 2;
-      end++;
-    }
-    return end;
-  }
-  __name(skipBlockComment, "skipBlockComment");
-  function readNumber(start) {
-    const first = source[start];
-    let end = start;
-    if (first === "0") {
-      const prefix = source[start + 1];
-      if (prefix === "x" || prefix === "X" || prefix === "o" || prefix === "O" || prefix === "b" || prefix === "B") {
-        end = start + 2;
-        while (end < length && /[0-9a-fA-F_]/.test(source[end])) end++;
-        if (source[end] === "n") end++;
-        return end;
-      }
-    }
-    while (end < length && (isDigit(source[end]) || source[end] === "_")) end++;
-    if (source[end] === ".") {
-      end++;
-      while (end < length && (isDigit(source[end]) || source[end] === "_")) end++;
-    }
-    if (source[end] === "e" || source[end] === "E") {
-      end++;
-      if (source[end] === "+" || source[end] === "-") end++;
-      while (end < length && (isDigit(source[end]) || source[end] === "_")) end++;
-    }
-    if (source[end] === "n") end++;
-    return end;
-  }
-  __name(readNumber, "readNumber");
-  function classifyWord(text) {
-    if (VALUE_KEYWORDS.has(text)) return "value";
-    if (EXPRESSION_KEYWORDS.has(text)) return "keyword";
-    return "identifier";
-  }
-  __name(classifyWord, "classifyWord");
-  while (cursor < length) {
-    const char = source[cursor];
-    if (isWhitespace(char)) {
-      cursor++;
-      continue;
-    }
-    if (char === "/" && source[cursor + 1] === "/") {
-      cursor = skipLineComment(cursor);
-      continue;
-    }
-    if (char === "/" && source[cursor + 1] === "*") {
-      cursor = skipBlockComment(cursor);
-      continue;
-    }
-    if (char === '"' || char === "'") {
-      const result = readStringLiteral(cursor, char);
-      prev = "value";
-      nextParenthesisIsControl = false;
-      cursor = result ? result.end : length;
-      continue;
-    }
-    if (char === "`") {
-      const result = readTemplateLiteral(cursor);
-      prev = "value";
-      nextParenthesisIsControl = false;
-      cursor = result ? result.end : length;
-      continue;
-    }
-    if (char === "/" && REGEX_CONTEXT.has(prev)) {
-      const end = readRegexLiteral(cursor);
-      if (end !== null) {
-        prev = "value";
-        nextParenthesisIsControl = false;
-        cursor = end;
-        continue;
-      }
-    }
-    if (isIdentifierStart(char)) {
-      const { end: idEnd, text } = readIdentifier(cursor);
-      const isMemberAccess = prev === "dot" || prev === "questionDot";
-      let next = idEnd;
-      while (next < length && isWhitespace(source[next])) next++;
-      if (!isMemberAccess && (text === "page" || text === "createRoute") && source[next] === "(") {
-        let argStart = next + 1;
-        while (argStart < length && isWhitespace(source[argStart])) argStart++;
-        const quote = source[argStart];
-        if (quote === '"' || quote === "'") {
-          const arg = readStringLiteral(argStart, quote);
-          if (arg) {
-            results.add(arg.content);
-            prev = "value";
-            nextParenthesisIsControl = false;
-            cursor = arg.end;
-            continue;
-          }
-        } else if (quote === "`") {
-          const arg = readTemplateLiteral(argStart);
-          if (arg) {
-            if (!arg.dynamic) results.add(arg.content);
-            prev = "value";
-            nextParenthesisIsControl = false;
-            cursor = arg.end;
-            continue;
-          }
-        }
-      }
-      prev = classifyWord(text);
-      nextParenthesisIsControl = CONTROL_PAREN_KEYWORDS.has(text);
-      cursor = idEnd;
-      continue;
-    }
-    if (isDigit(char) || char === "." && isDigit(source[cursor + 1] || "")) {
-      prev = "value";
-      nextParenthesisIsControl = false;
-      cursor = readNumber(cursor);
-      continue;
-    }
-    if (char === "?" && source[cursor + 1] === ".") {
-      prev = "questionDot";
-      nextParenthesisIsControl = false;
-      cursor += 2;
-      continue;
-    }
-    if (char === "." && source[cursor + 1] === "." && source[cursor + 2] === ".") {
-      prev = "spread";
-      nextParenthesisIsControl = false;
-      cursor += 3;
-      continue;
-    }
-    if (char === "." && source[cursor + 1] === ".") {
-      prev = "operator";
-      nextParenthesisIsControl = false;
-      cursor += 2;
-      continue;
-    }
-    if (char === ".") {
-      prev = "dot";
-      nextParenthesisIsControl = false;
-      cursor += 1;
-      continue;
-    }
-    if (char === "(") {
-      controlParentheses.push(nextParenthesisIsControl);
-      nextParenthesisIsControl = false;
-      prev = "open";
-      cursor++;
-      continue;
-    }
-    if (char === "[" || char === "{") {
-      nextParenthesisIsControl = false;
-      prev = "open";
-      cursor++;
-      continue;
-    }
-    if (char === ")") {
-      prev = controlParentheses.pop() ? "keyword" : "close";
-      nextParenthesisIsControl = false;
-      cursor++;
-      continue;
-    }
-    if (char === "]" || char === "}") {
-      prev = "close";
-      nextParenthesisIsControl = false;
-      cursor++;
-      continue;
-    }
-    prev = "operator";
-    nextParenthesisIsControl = false;
-    cursor++;
-  }
-  return results.size > 0 ? Array.from(results) : [];
-}
-__name(extractProgrammaticPageCallPathLiterals, "extractProgrammaticPageCallPathLiterals");
 
-// src/routes-shared.ts
-function parseProgrammaticRoutePath(routePath, type = "page") {
-  const fileName = type === "layout" ? "layout.tsx" : "page.tsx";
-  const normalized = normalizeProgrammaticRoutePath(routePath);
-  assertTerminalCatchAll(normalized);
-  assertUniqueRouteParameters(normalized);
-  const filePath = normalized === "/" ? fileName : `${normalized.slice(1).replace(/\/+$/, "")}/${fileName}`;
-  return {
-    filePath,
-    segments: normalized.split("/").filter(Boolean).filter((segment) => !(segment.startsWith("(") && segment.endsWith(")"))).map(parseRouteSegment),
-    type
-  };
-}
-__name(parseProgrammaticRoutePath, "parseProgrammaticRoutePath");
-function normalizeProgrammaticRoutePath(routePath) {
-  if (routePath.includes("?") || routePath.includes("#")) {
-    throw new TypeError(
-      `Programmatic route path "${routePath}" must be a pathname without a query string or hash.`
-    );
-  }
-  const withSlash = routePath.startsWith("/") ? routePath : `/${routePath}`;
-  const withoutTrailing = withSlash.length > 1 ? withSlash.replace(/\/+$/, "") : withSlash;
-  assertBrowserStableRoutePath(withoutTrailing);
-  return withoutTrailing || "/";
-}
-__name(normalizeProgrammaticRoutePath, "normalizeProgrammaticRoutePath");
-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");
 
-// 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: runtime3, regions, maxDuration, ...methods } = options;
-    return normalizeProgrammaticRoute({
-      kind: "api",
-      path,
-      render,
-      runtime: runtime3,
-      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))}&lang.js`;
-}
-__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 parseProgrammaticRoutePath2(routePath, type = "page") {
-  return parseProgrammaticRoutePath(routePath, type);
-}
-__name(parseProgrammaticRoutePath2, "parseProgrammaticRoutePath");
-function createRouteModuleFromProgrammaticPage(route, rendererRuntime) {
-  const mod = {
-    default: createProgrammaticPageComponent(route, rendererRuntime),
-    ...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();
-  for (const routePath of extractProgrammaticPageCallPathLiterals(source)) {
-    if (routePath) {
-      paths.add(normalizeRoutePath(routePath));
-    }
-  }
-  return Array.from(paths);
-}
-__name(scanProgrammaticPagePaths, "scanProgrammaticPagePaths");
-function createProgrammaticPageComponent(route, rendererRuntime) {
-  if (!route.params && !route.search && !route.guard && !route.data && !route.pending && !route.error && !route.notFound) {
-    return route.component;
-  }
-  const createElement = /* @__PURE__ */ __name((...args) => {
-    if (!rendererRuntime) {
-      throw new Error(
-        `Programmatic route "${route.path}" requires a FARMJS renderer runtime before it can render.`
-      );
-    }
-    return rendererRuntime.createElement(...args);
-  }, "createElement");
-  const markFunctionComponent = /* @__PURE__ */ __name((component) => rendererRuntime?.markFunctionComponent?.(component) ?? component, "markFunctionComponent");
-  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 createElement(Component, stripProgrammaticRoutePropsMarker(resolvedProps));
-      } catch (error) {
-        if (isPromiseLike(error) || isProgrammaticRedirectSignal(error)) {
-          throw error;
-        }
-        if (isProgrammaticNotFoundSignal(error) && route.notFound) {
-          return createElement(route.notFound, createProgrammaticRouteErrorProps(error, props));
-        }
-        if (route.error) {
-          return createElement(route.error, createProgrammaticRouteErrorProps(error, props));
-        }
-        throw error;
-      }
-    }, "FarmProgrammaticPageContent");
-    const PageContent = markFunctionComponent(
-      FarmProgrammaticPageContent2
-    );
-    const FarmProgrammaticPage = /* @__PURE__ */ __name(function FarmProgrammaticPage2(props) {
-      return createElement(
-        rendererRuntime.Suspense,
-        {
-          fallback: createElement(PendingComponent, createProgrammaticRoutePendingProps(props))
-        },
-        createElement(PageContent, props)
-      );
-    }, "FarmProgrammaticPage");
-    return markFunctionComponent(FarmProgrammaticPage);
-  }
-  const FarmProgrammaticPageContent = /* @__PURE__ */ __name(async function FarmProgrammaticPageContent2(props) {
-    try {
-      const resolvedProps = isProgrammaticRoutePropsResolved(props) ? props : await resolveProgrammaticRouteProps(route, props);
-      return createElement(Component, stripProgrammaticRoutePropsMarker(resolvedProps));
-    } catch (error) {
-      if (isProgrammaticRedirectSignal(error)) {
-        throw error;
-      }
-      if (isProgrammaticNotFoundSignal(error) && route.notFound) {
-        return createElement(route.notFound, createProgrammaticRouteErrorProps(error, props));
-      }
-      if (route.error) {
-        return createElement(route.error, createProgrammaticRouteErrorProps(error, props));
-      }
-      throw error;
-    }
-  }, "FarmProgrammaticPageContent");
-  return markFunctionComponent(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, context2) {
-  if (!dataHooks?.key) {
-    return dataHooks.main(context2);
-  }
-  const routeDataKey = await dataHooks.key(context2);
-  if (routeDataKey == null) {
-    return dataHooks.main(context2);
-  }
-  const cacheKey = createFarmCacheKey(["route-data", routeDataKey]);
-  const cacheOptions = {
-    tags: [
-      createRouteDataCacheTag(routeDataKey),
-      ...await resolveProgrammaticRouteDataKeys(dataHooks.tags, context2)
-    ],
-    paths: [
-      ...typeof context2.path === "string" ? [context2.path] : [],
-      ...await resolveProgrammaticRouteDataKeys(dataHooks.paths, context2)
-    ],
-    revalidate: normalizeProgrammaticRouteStaleTime(dataHooks.staleTime)
-  };
-  return getFarmDataCache().getOrSet(cacheKey, () => dataHooks.main(context2), cacheOptions);
-}
-__name(resolveProgrammaticRouteData, "resolveProgrammaticRouteData");
-async function resolveProgrammaticRouteDataKeys(input, context2) {
-  if (!input) return [];
-  const value = typeof input === "function" ? await input(context2) : 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)
-    };
-  }
-  const routeActions = route.kind === "page" ? normalizeProgrammaticRouteActions(route) : void 0;
-  return {
-    ...route,
-    ...routeActions,
-    ...normalizeFarmRouteRuntimeConfig(
-      route,
-      `${route.kind === "layout" ? "Layout" : "Route"} "${route.path}"`
-    ),
-    path: normalizeRoutePath(route.path)
-  };
-}
-__name(normalizeProgrammaticRoute, "normalizeProgrammaticRoute");
-function normalizeProgrammaticRouteActions(route) {
-  const entries = Object.entries(route.actions ?? {});
-  if (entries.length === 0) {
-    if (route.defaultAction !== void 0) {
-      throw new TypeError(
-        `Route "${route.path}" declares defaultAction without declaring any actions.`
-      );
-    }
-    return {};
-  }
-  for (const [name, action2] of entries) {
-    if (typeof action2 !== "function") {
-      throw new TypeError(`Route "${route.path}" action "${name}" must be a server function.`);
-    }
-  }
-  const defaultAction = route.defaultAction ?? entries[0][0];
-  const actions = Object.freeze({ ...route.actions });
-  const action = actions[defaultAction];
-  if (!action) {
-    throw new TypeError(
-      `Route "${route.path}" defaultAction "${defaultAction}" does not match a declared action.`
-    );
-  }
-  return {
-    actions,
-    defaultAction,
-    action
-  };
-}
-__name(normalizeProgrammaticRouteActions, "normalizeProgrammaticRouteActions");
-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 === "QUERY" || method === "POST" || method === "PUT" || method === "DELETE" || method === "PATCH" || method === "OPTIONS";
-}
-__name(isProgrammaticRouteMethod, "isProgrammaticRouteMethod");
-function normalizeStaticPaths(routePath, paths) {
-  const dynamicSegments = parseProgrammaticRoutePath2(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
-});
+
+
+
+
+
+
+
+
+
+var _chunkXSKZORAScjs = require('./chunk-XSKZORAS.cjs');
+require('./chunk-6QQDAAAZ.cjs');
+require('./chunk-6V4TDWEC.cjs');
+require('./chunk-MKB2EGIR.cjs');
+require('./chunk-H6G5INWM.cjs');
+require('./chunk-ZEG3OPIB.cjs');
+require('./chunk-LIUGYUX3.cjs');
+require('./chunk-E3UK5IIB.cjs');
+require('./chunk-NO3WWW3N.cjs');
+require('./chunk-S3JO3N4H.cjs');
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.PROGRAMMATIC_ROUTE_FILE_NAMES = _chunkXSKZORAScjs.PROGRAMMATIC_ROUTE_FILE_NAMES; exports.api = _chunkXSKZORAScjs.api; exports.createLayoutModuleFromProgrammaticLayout = _chunkXSKZORAScjs.createLayoutModuleFromProgrammaticLayout; exports.createProgrammaticRouteModuleId = _chunkXSKZORAScjs.createProgrammaticRouteModuleId; exports.createRoute = _chunkXSKZORAScjs.createRoute; exports.createRouteModuleFromProgrammaticPage = _chunkXSKZORAScjs.createRouteModuleFromProgrammaticPage; exports.defineRoutes = _chunkXSKZORAScjs.defineRoutes; exports.getProgrammaticRouteManifest = _chunkXSKZORAScjs.getProgrammaticRouteManifest; exports.getProgrammaticRouteSearchClientOptions = _chunkXSKZORAScjs.getProgrammaticRouteSearchClientOptions; exports.getProgrammaticRouteSearchSchema = _chunkXSKZORAScjs.getProgrammaticRouteSearchSchema; exports.isProgrammaticRouteDefinition = _chunkXSKZORAScjs.isProgrammaticRouteDefinition; exports.isProgrammaticRouteManifest = _chunkXSKZORAScjs.isProgrammaticRouteManifest; exports.isProgrammaticRoutesFileName = _chunkXSKZORAScjs.isProgrammaticRoutesFileName; exports.layout = _chunkXSKZORAScjs.layout; exports.page = _chunkXSKZORAScjs.page; exports.parseProgrammaticRouteModuleId = _chunkXSKZORAScjs.parseProgrammaticRouteModuleId; exports.parseProgrammaticRoutePath = _chunkXSKZORAScjs.parseProgrammaticRoutePath; exports.redirect = _chunkXSKZORAScjs.redirect; exports.routesBuilder = _chunkXSKZORAScjs.routesBuilder; exports.scanProgrammaticPagePaths = _chunkXSKZORAScjs.scanProgrammaticPagePaths;